diff --git a/packages/core/RNSentryAndroidTester/app/build.gradle b/packages/core/RNSentryAndroidTester/app/build.gradle
index 9a1ba87087..5d3d6c6c79 100644
--- a/packages/core/RNSentryAndroidTester/app/build.gradle
+++ b/packages/core/RNSentryAndroidTester/app/build.gradle
@@ -34,6 +34,10 @@ android {
         testLogging {
             events 'passed', 'skipped', 'failed', 'standardOut', 'standardError'
         }
+        // Absolute path to the script plugin under test and the Android SDK, so the GradleTestKit
+        // functional tests can apply the real sentry.gradle.kts and point a fixture build at the SDK.
+        systemProperty 'sentry.gradle.script', new File(rootDir, '../sentry.gradle.kts').absolutePath
+        systemProperty 'sentry.android.sdkDir', android.sdkDirectory.absolutePath
     }
 }
 
@@ -48,6 +52,7 @@ dependencies {
     implementation 'com.google.android.material:material:1.5.0'
     implementation 'androidx.test:core-ktx:1.6.1'
     testImplementation 'junit:junit:4.13.2'
+    testImplementation gradleTestKit()
     testImplementation 'org.mockito:mockito-core:5.10.0'
     testImplementation 'org.mockito.kotlin:mockito-kotlin:5.2.1'
     testImplementation 'org.robolectric:robolectric:4.14.1'
diff --git a/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryModulesTaskTest.kt b/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryModulesTaskTest.kt
new file mode 100644
index 0000000000..eda8d0e72f
--- /dev/null
+++ b/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryModulesTaskTest.kt
@@ -0,0 +1,202 @@
+package io.sentry.react.gradle
+
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Functional tests for the `CollectModulesTask` wiring declared in `sentry.gradle.kts` (issue #6750 /
+ * PR #6753): `modules.json` must be generated into the build folder and registered as a generated
+ * assets source, never written into the version-controlled `src/main/assets` tree.
+ *
+ * Unlike the options task, the modules task lives inside `processVariant`, which requires a React
+ * Native bundle task (`createBundle<Variant>JsAndAssets`) that exposes an extractable
+ * `--sourcemap-output`. The fixture stubs that bundle task with a tiny shell script that writes a
+ * source map, and points `collectModulesScript` at a fake node script so no real JS bundle is needed.
+ */
+class SentryModulesTaskTest {
+    @get:Rule
+    val tempFolder = TemporaryFolder()
+
+    private val scriptPath: String =
+        System.getProperty("sentry.gradle.script") ?: error("sentry.gradle.script system property not set")
+    private val sdkDir: String =
+        System.getProperty("sentry.android.sdkDir") ?: error("sentry.android.sdkDir system property not set")
+
+    private lateinit var projectDir: File
+
+    private val modulesTaskPath = ":createBundleReleaseJsAndAssets_SentryCollectModules"
+
+    /** All generated `modules.json` files under the build tree (AGP relocates the task output dir). */
+    private fun generatedModules(): List<File> = File(projectDir, "build").walkTopDown().filter { it.name == "modules.json" }.toList()
+
+    private fun srcAssetsModules(): File = File(projectDir, "src/main/assets/modules.json")
+
+    private fun writeFixture(
+        skipCollectModules: Boolean = false,
+        produceSourcemap: Boolean = true,
+    ) {
+        projectDir = tempFolder.newFolder("android")
+
+        // Shell stub for the RN bundle task: parses `--sourcemap-output <path>` out of its args and
+        // writes a minimal source map there, mimicking the real bundle task's observable output.
+        val makeSourcemap = File(projectDir, "make-sourcemap.sh")
+        makeSourcemap.writeText(
+            """
+            #!/bin/sh
+            out=""
+            while [ ${'$'}# -gt 0 ]; do
+              if [ "${'$'}1" = "--sourcemap-output" ]; then out="${'$'}2"; fi
+              shift
+            done
+            if [ -n "${'$'}out" ]; then
+              mkdir -p "${'$'}(dirname "${'$'}out")"
+              printf '{"version":3,"sources":[]}' > "${'$'}out"
+            fi
+            """.trimIndent(),
+        )
+
+        // Fake collectModules script: `node <script> <sourcemap> <dest> <modulesPaths>` → writes dest.
+        val fakeCollect = File(projectDir, "fake-collect-modules.js")
+        fakeCollect.writeText(
+            """
+            const fs = require('fs');
+            const dest = process.argv[3];
+            fs.mkdirSync(require('path').dirname(dest), { recursive: true });
+            fs.writeFileSync(dest, JSON.stringify({ 'fake-module': '1.0.0' }));
+            """.trimIndent(),
+        )
+
+        val bundleFile = File(projectDir, "build/generated/assets/react/release/index.android.bundle")
+        val sourcemapFile = File(projectDir, "build/generated/sourcemaps/react/release/index.android.bundle.map")
+
+        File(projectDir, "settings.gradle").writeText(
+            """
+            pluginManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                    gradlePluginPortal()
+                }
+            }
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "fixture"
+            """.trimIndent(),
+        )
+
+        val bundleTaskBlock =
+            if (produceSourcemap) {
+                """
+                tasks.register("createBundleReleaseJsAndAssets", Exec) {
+                    workingDir projectDir
+                    executable 'sh'
+                    args '${makeSourcemap.absolutePath.esc()}', '--bundle-output', '${bundleFile.absolutePath.esc()}', '--sourcemap-output', '${sourcemapFile.absolutePath.esc()}'
+                }
+                """
+            } else {
+                // Bundle task exists (so processVariant proceeds) but produces no source map.
+                """
+                tasks.register("createBundleReleaseJsAndAssets", Exec) {
+                    workingDir projectDir
+                    executable 'sh'
+                    args '-c', 'true', '--bundle-output', '${bundleFile.absolutePath.esc()}', '--sourcemap-output', '${sourcemapFile.absolutePath.esc()}'
+                }
+                """
+            }
+
+        File(projectDir, "build.gradle").writeText(
+            """
+            plugins {
+                id 'com.android.application' version '8.3.2'
+            }
+            project.ext.sentryCli = [
+                collectModulesScript: '${fakeCollect.absolutePath.esc()}',
+                modulesPaths        : ['node_modules'],
+                skipCollectModules  : $skipCollectModules,
+            ]
+            android {
+                namespace 'io.sentry.fixture'
+                compileSdk 34
+                defaultConfig {
+                    minSdk 21
+                    versionCode 1
+                    versionName '1.0'
+                }
+            }
+            $bundleTaskBlock
+            apply from: '${scriptPath.esc()}'
+            """.trimIndent(),
+        )
+
+        File(projectDir, "local.properties").writeText("sdk.dir=${sdkDir.esc()}")
+
+        val manifestDir = File(projectDir, "src/main")
+        manifestDir.mkdirs()
+        File(manifestDir, "AndroidManifest.xml").writeText("<manifest />")
+    }
+
+    private fun String.esc(): String = replace("\\", "\\\\")
+
+    private fun run(vararg args: String) =
+        GradleRunner
+            .create()
+            .withProjectDir(projectDir)
+            .withArguments(*args, "--stacktrace")
+            // Disable the sourcemap-upload finalizer of the bundle task: it shells out to sentry-cli
+            // scripts we don't ship in the fixture and is unrelated to what these tests cover.
+            .withEnvironment(System.getenv() + mapOf("SENTRY_DISABLE_AUTO_UPLOAD" to "true"))
+            .forwardOutput()
+            .build()
+
+    @Test
+    fun `modules json is generated into build folder and never into src assets`() {
+        writeFixture()
+
+        val result = run(modulesTaskPath)
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(modulesTaskPath)?.outcome)
+        val generated = generatedModules()
+        assertTrue("modules.json should be generated under build/", generated.isNotEmpty())
+        assertEquals("""{"fake-module":"1.0.0"}""", generated.first().readText())
+        assertFalse("modules.json must never be written into src/main/assets", srcAssetsModules().exists())
+    }
+
+    @Test
+    fun `second run is up-to-date`() {
+        writeFixture()
+
+        assertEquals(TaskOutcome.SUCCESS, run(modulesTaskPath).task(modulesTaskPath)?.outcome)
+        assertEquals(TaskOutcome.UP_TO_DATE, run(modulesTaskPath).task(modulesTaskPath)?.outcome)
+    }
+
+    @Test
+    fun `skipCollectModules leaves output empty`() {
+        writeFixture(skipCollectModules = true)
+
+        val result = run(modulesTaskPath)
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(modulesTaskPath)?.outcome)
+        assertTrue("no modules.json when collection is skipped", generatedModules().isEmpty())
+    }
+
+    @Test
+    fun `missing source map leaves output empty without failing`() {
+        writeFixture(produceSourcemap = false)
+
+        val result = run(modulesTaskPath)
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(modulesTaskPath)?.outcome)
+        assertTrue("no modules.json when source map is absent", generatedModules().isEmpty())
+    }
+}
diff --git a/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryOptionsTaskTest.kt b/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryOptionsTaskTest.kt
new file mode 100644
index 0000000000..3ebc815235
--- /dev/null
+++ b/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/SentryOptionsTaskTest.kt
@@ -0,0 +1,150 @@
+package io.sentry.react.gradle
+
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Functional tests for the `generateSentryOptions` task declared in `sentry.gradle.kts`.
+ *
+ * The script is a Gradle *script plugin* (`apply from:`), so its task classes cannot be imported into
+ * a JUnit test. Instead we stand up a minimal `com.android.application` fixture build in a temp dir,
+ * apply the real script into it, and drive the task through GradleTestKit — exercising the actual AGP
+ * wiring, not just the pure action logic.
+ */
+class SentryOptionsTaskTest {
+    @get:Rule
+    val tempFolder = TemporaryFolder()
+
+    private val scriptPath: String =
+        System.getProperty("sentry.gradle.script") ?: error("sentry.gradle.script system property not set")
+    private val sdkDir: String =
+        System.getProperty("sentry.android.sdkDir") ?: error("sentry.android.sdkDir system property not set")
+
+    private lateinit var projectDir: File
+
+    /**
+     * Locate the generated `sentry.options.json`. When the AGP Variant API wiring succeeds, AGP
+     * relocates the task's output under `build/generated/assets/<taskName>/`, so we search the whole
+     * build tree rather than hard-coding the script's requested `outputDir` (which AGP overrides).
+     */
+    private fun generatedOptionsOrNull(): File? = File(projectDir, "build").walkTopDown().firstOrNull { it.name == "sentry.options.json" }
+
+    private fun writeFixture(sourceOptions: String?) {
+        projectDir = tempFolder.newFolder("android")
+
+        File(projectDir, "settings.gradle").writeText(
+            """
+            pluginManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                    gradlePluginPortal()
+                }
+            }
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "fixture"
+            """.trimIndent(),
+        )
+
+        File(projectDir, "build.gradle").writeText(
+            """
+            plugins {
+                id 'com.android.application' version '8.3.2'
+            }
+            project.ext.sentryCli = [
+                collectModulesScript: 'nonexistent',
+                modulesPaths        : ['node_modules'],
+                skipCollectModules  : true,
+            ]
+            android {
+                namespace 'io.sentry.fixture'
+                compileSdk 34
+                defaultConfig { minSdk 21 }
+            }
+            apply from: '${scriptPath.replace("\\", "\\\\")}'
+            """.trimIndent(),
+        )
+
+        File(projectDir, "local.properties").writeText("sdk.dir=${sdkDir.replace("\\", "\\\\")}")
+
+        val manifestDir = File(projectDir, "src/main")
+        manifestDir.mkdirs()
+        File(manifestDir, "AndroidManifest.xml").writeText("<manifest />")
+
+        // The script reads the source `sentry.options.json` from the app root's parent (the RN project
+        // root), i.e. one level above the Gradle rootDir.
+        if (sourceOptions != null) {
+            File(projectDir.parentFile, "sentry.options.json").writeText(sourceOptions)
+        }
+    }
+
+    private fun run(
+        vararg args: String,
+        env: Map<String, String> = emptyMap(),
+    ) = GradleRunner
+        .create()
+        .withProjectDir(projectDir)
+        .withArguments(*args, "--stacktrace")
+        .withEnvironment(System.getenv() + env)
+        .forwardOutput()
+        .build()
+
+    @Test
+    fun `plain copy - no overrides copies source verbatim into build folder`() {
+        val source = """{"dsn":"https://examplePublicKey@o0.ingest.sentry.io/0","debug":true}"""
+        writeFixture(source)
+
+        val result = run("generateSentryOptions")
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(":generateSentryOptions")?.outcome)
+        val generated = generatedOptionsOrNull()
+        assertNotNull("generated file should exist in build/", generated)
+        assertEquals(source, generated!!.readText())
+    }
+
+    @Test
+    fun `SENTRY_RELEASE override rewrites release key and preserves others`() {
+        writeFixture("""{"dsn":"https://k@o0.ingest.sentry.io/0","environment":"prod"}""")
+
+        val result = run("generateSentryOptions", env = mapOf("SENTRY_RELEASE" to "1.2.3"))
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(":generateSentryOptions")?.outcome)
+        val generated = generatedOptionsOrNull()
+        assertNotNull("generated file should exist in build/", generated)
+        val json = groovy.json.JsonSlurper().parseText(generated!!.readText()) as Map<*, *>
+        assertEquals("1.2.3", json["release"])
+        assertEquals("prod", json["environment"])
+    }
+
+    @Test
+    fun `opt-out via SENTRY_COPY_OPTIONS_FILE=false leaves output empty`() {
+        writeFixture("""{"dsn":"https://k@o0.ingest.sentry.io/0"}""")
+
+        val result = run("generateSentryOptions", env = mapOf("SENTRY_COPY_OPTIONS_FILE" to "false"))
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(":generateSentryOptions")?.outcome)
+        assertNull("output must be empty when opted out", generatedOptionsOrNull())
+    }
+
+    @Test
+    fun `missing source file leaves output empty without failing`() {
+        writeFixture(sourceOptions = null)
+
+        val result = run("generateSentryOptions")
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(":generateSentryOptions")?.outcome)
+        assertNull(generatedOptionsOrNull())
+    }
+}