test(android): Add GradleTestKit tests for sentry.gradle.kts asset tasks

CHANGELOG.md

@@ -12,6 +12,8 @@
 
 - Declare optional peer dependencies so imports resolve under strict and Plug'n'Play package managers ([#6729](https://github.com/getsentry/sentry-react-native/pull/6729))
 - Honor `shutdownTimeout` on iOS ([#6749](https://github.com/getsentry/sentry-react-native/pull/6749))
+- Android Gradle plugin no longer writes generated `sentry.options.json` into your source tree during builds ([#6751](https://github.com/getsentry/sentry-react-native/pull/6751))
+- Android Gradle plugin no longer writes generated `modules.json` into your source tree during release builds ([#6753](https://github.com/getsentry/sentry-react-native/pull/6753))
 - Fix Mac Catalyst linking the wrong `Sentry.xcframework` slice ([#6758](https://github.com/getsentry/sentry-react-native/pull/6758))
 
 ### Internal

packages/core/RNSentryAndroidTester/app/build.gradle

@@ -34,6 +34,14 @@ 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
+        // AGP version and compileSdk the fixtures should use, taken from THIS host build so they track
+        // it instead of pinning a stale AGP/SDK that silently diverges when the host is bumped.
+        systemProperty 'sentry.android.agpVersion', com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+        systemProperty 'sentry.android.compileSdk', android.compileSdk.toString()
     }
 }
 
@@ -48,6 +56,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'

packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/gradle/BaseSentryGradleTest.kt

@@ -0,0 +1,80 @@
+package io.sentry.react.gradle
+
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Shared GradleTestKit scaffolding for the `sentry.gradle.kts` script-plugin functional tests.
+ *
+ * Both concrete tests stand up a minimal `com.android.application` fixture in a temp dir, apply the
+ * real script, and drive tasks through GradleTestKit. The parts that don't vary between them live
+ * here: the system properties injected by the host build (`app/build.gradle`), the invariant fixture
+ * files (settings, local.properties, stub manifest), path escaping, and a runner with the host
+ * `SENTRY_*` environment scrubbed for determinism.
+ *
+ * The AGP version and `compileSdk` come from the host build too (not hardcoded), so the fixtures track
+ * whatever the host is on instead of pinning a stale toolchain that silently diverges on a bump.
+ */
+abstract class BaseSentryGradleTest {
+    @get:Rule
+    val tempFolder = TemporaryFolder()
+
+    protected val scriptPath: String =
+        System.getProperty("sentry.gradle.script") ?: error("sentry.gradle.script system property not set")
+    protected val sdkDir: String =
+        System.getProperty("sentry.android.sdkDir") ?: error("sentry.android.sdkDir system property not set")
+    protected val agpVersion: String =
+        System.getProperty("sentry.android.agpVersion") ?: error("sentry.android.agpVersion system property not set")
+    protected val compileSdk: String =
+        System.getProperty("sentry.android.compileSdk") ?: error("sentry.android.compileSdk system property not set")
+
+    protected lateinit var projectDir: File
+
+    /** Escape Windows path separators so an absolute path is safe inside a Groovy string literal. */
+    protected fun String.esc(): String = replace("\\", "\\\\")
+
+    /** Write the fixture files that are identical across every test: settings, local.properties, manifest. */
+    protected fun writeCommonFixture() {
+        File(projectDir, "settings.gradle").writeText(
+            """
+            pluginManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                    gradlePluginPortal()
+                }
+            }
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "fixture"
+            """.trimIndent(),
+        )
+
+        File(projectDir, "local.properties").writeText("sdk.dir=${sdkDir.esc()}")
+
+        val manifestDir = File(projectDir, "src/main")
+        manifestDir.mkdirs()
+        File(manifestDir, "AndroidManifest.xml").writeText("<manifest />")
+    }
+
+    /**
+     * A [GradleRunner] for [projectDir] with the host `SENTRY_*` variables scrubbed (the script reads
+     * several at configuration time), plus any [extraEnv] a specific test needs.
+     */
+    protected fun baseRunner(
+        vararg args: String,
+        extraEnv: Map<String, String> = emptyMap(),
+    ): GradleRunner =
+        GradleRunner
+            .create()
+            .withProjectDir(projectDir)
+            .withArguments(*args, "--stacktrace")
+            .withEnvironment(System.getenv().filterKeys { !it.startsWith("SENTRY_") } + extraEnv)
+            .forwardOutput()
+}