@callstack/react-native-brownfield 5.1.0 → 5.2.0

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/artifacts/RncTransitiveDependencyDiscovererTest.kt

@@ -0,0 +1,171 @@
+package com.callstack.react.brownfield.artifacts
+
+import com.callstack.react.brownfield.shared.DependencyInfo
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class RncTransitiveDependencyDiscovererTest {
+    private fun defaultArtifacts(root: org.gradle.api.Project) =
+        listOf(
+            UnresolvedArtifactInfo(
+                moduleGroup = root.name,
+                moduleName = "react-native-fake-module",
+                moduleVersion = "unspecified",
+                file = null,
+                isExpoPublishDependency = false,
+            ),
+        )
+
+    @Test
+    fun `a dynamic consumer-declared version never becomes a mediation candidate`() {
+        // Module-side versions are validated by collectPublishableGradleDependencies; the
+        // consumer side must be validated too, or `1.+` can win mediation and be published.
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.dependencies.add("implementation", "androidx.appcompat:appcompat:1.0.0")
+
+        consumer.configurations.create("implementation")
+        consumer.dependencies.add("implementation", "androidx.appcompat:appcompat:1.+")
+
+        val result = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root))
+
+        val appcompat = result.dependencies.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.0.0", appcompat.version, "the dynamic consumer version must not win mediation")
+        assertFalse(result.dependencies.any { it.version == "1.+" }, "'1.+' must never reach the published set")
+    }
+
+    @Test
+    fun `a versionless consumer declaration still supersedes, so the coordinate is not duplicated`() {
+        // Declared via BOM/platform, so `.version` is null. A version-only lookup returns null
+        // here, never marks the coordinate superseded, and leaves two entries for it in the POM.
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.dependencies.add("implementation", "androidx.appcompat:appcompat:1.7.1")
+
+        consumer.configurations.create("implementation")
+        consumer.dependencies.add("implementation", "androidx.appcompat:appcompat")
+
+        val result = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root))
+
+        assertTrue(
+            result.supersededCoordinates.contains("androidx.appcompat" to "appcompat"),
+            "a declared-but-versionless coordinate must still be superseded",
+        )
+        assertEquals("1.7.1", result.dependencies.first { it.groupId == "androidx.appcompat" }.version)
+    }
+
+    @Test
+    fun `discovers a module's direct external dependencies, skipping project deps and non-publishable coordinates`() {
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+        val siblingProject = ProjectBuilder.builder().withParent(root).withName("some-other-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.configurations.create("api")
+        embeddedModule.configurations.create("runtimeOnly")
+
+        embeddedModule.dependencies.add("implementation", "androidx.appcompat:appcompat:1.7.1")
+        embeddedModule.dependencies.add("implementation", "com.facebook.react:react-native:+")
+        embeddedModule.dependencies.add("runtimeOnly", "androidx.annotation:annotation:1.9.1")
+        embeddedModule.dependencies.add(
+            "implementation",
+            embeddedModule.dependencies.project(mapOf("path" to siblingProject.path)),
+        )
+
+        consumer.configurations.create("api")
+
+        val result = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root))
+        val discovered = result.dependencies
+
+        assertEquals(2, discovered.size)
+        assertTrue(
+            discovered.contains(
+                DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false),
+            ),
+        )
+        assertTrue(
+            discovered.contains(
+                DependencyInfo("androidx.annotation", "annotation", "1.9.1", "runtime", false),
+            ),
+        )
+        assertFalse(discovered.contains(DependencyInfo("com.facebook.react", "react-native", "+", "compile", false)))
+        assertFalse(discovered.contains(DependencyInfo(root.name, "some-other-module", "unspecified", "compile", false)))
+        assertTrue(result.supersededCoordinates.isEmpty())
+    }
+
+    @Test
+    fun `publishes a runtimeOnly dependency under Maven runtime scope, not compile`() {
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.configurations.create("api")
+        embeddedModule.configurations.create("runtimeOnly")
+        embeddedModule.dependencies.add("runtimeOnly", "androidx.annotation:annotation:1.9.1")
+
+        val discovered = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root)).dependencies
+
+        val annotationDep = discovered.first { it.groupId == "androidx.annotation" }
+        assertEquals("runtime", annotationDep.scope)
+    }
+
+    @Test
+    fun `a module's higher version requirement wins over, and supersedes, the consumer's own lower declaration`() {
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.configurations.create("api")
+        embeddedModule.configurations.create("runtimeOnly")
+        embeddedModule.dependencies.add("implementation", "androidx.appcompat:appcompat:1.7.1")
+
+        consumer.configurations.create("api")
+        consumer.dependencies.add("api", "androidx.appcompat:appcompat:1.6.0")
+
+        val result = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root))
+
+        val appcompatDep = result.dependencies.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.7.1", appcompatDep.version, "the module's higher requirement must win mediation")
+        assertTrue(
+            result.supersededCoordinates.contains("androidx.appcompat" to "appcompat"),
+            "the consumer's stale lower-version entry must be marked for replacement",
+        )
+    }
+
+    @Test
+    fun `does not regress or supersede when the consumer's own version already satisfies the module`() {
+        val root = ProjectBuilder.builder().build()
+        val consumer = ProjectBuilder.builder().withParent(root).withName("BrownfieldLib").build()
+        val embeddedModule = ProjectBuilder.builder().withParent(root).withName("react-native-fake-module").build()
+
+        embeddedModule.configurations.create("implementation")
+        embeddedModule.configurations.create("api")
+        embeddedModule.configurations.create("runtimeOnly")
+        embeddedModule.dependencies.add("implementation", "androidx.appcompat:appcompat:1.6.0")
+
+        consumer.configurations.create("api")
+        consumer.dependencies.add("api", "androidx.appcompat:appcompat:1.7.1")
+
+        val result = RncTransitiveDependencyDiscoverer(consumer).discover(defaultArtifacts(root))
+
+        val appcompatDep = result.dependencies.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.7.1", appcompatDep.version, "the consumer's already-higher version must be preserved, not downgraded")
+        assertTrue(
+            result.supersededCoordinates.contains("androidx.appcompat" to "appcompat"),
+            "still marked superseded so the injector re-declares it at the mediated (unchanged) version instead of duplicating it",
+        )
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/expo/ExpoPublishingHelperGradleFallbackTest.kt

@@ -0,0 +1,47 @@
+package com.callstack.react.brownfield.expo
+
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import org.gradle.api.Project
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ExpoPublishingHelperGradleFallbackTest {
+    @Test
+    fun `Gradle-fallback discovery picks up runtimeOnly dependencies`() {
+        val root = ProjectBuilder.builder().build()
+        val expoPkgProject = ProjectBuilder.builder().withParent(root).withName("expo-fake-module").build()
+
+        expoPkgProject.configurations.create("implementation")
+        expoPkgProject.configurations.create("api")
+        expoPkgProject.configurations.create("runtimeOnly")
+        expoPkgProject.dependencies.add("runtimeOnly", "androidx.annotation:annotation:1.9.1")
+
+        val helper =
+            object : ExpoPublishingHelper(brownfieldAppProject = root) {
+                fun exposedAppend(
+                    pkgProject: Project,
+                    deps: VersionMediatingDependencySet,
+                ) {
+                    appendExpoTransitiveDependenciesFromGradle(pkgProject, deps)
+                }
+            }
+
+        val discovered = VersionMediatingDependencySet()
+        helper.exposedAppend(expoPkgProject, discovered)
+
+        // Coordinate-only check: VersionMediatingDependencySet keys on groupId/artifactId, so
+        // passing a scope here would be inert and would read as contradicting the scope
+        // assertion below.
+        assertTrue(
+            discovered.any { it.groupId == "androidx.annotation" && it.artifactId == "annotation" },
+            "expected the runtimeOnly dependency to be discovered via the Gradle fallback path",
+        )
+        assertEquals(
+            "runtime",
+            discovered.first { it.groupId == "androidx.annotation" }.scope,
+            "runtimeOnly dependencies should be published under Maven's runtime scope, not compile",
+        )
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/AgpCompatibilityMatrixTest.kt

@@ -0,0 +1,155 @@
+package com.callstack.react.brownfield.plugin
+
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.jupiter.api.Assumptions.assumeTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import java.io.File
+import kotlin.test.assertTrue
+
+/**
+ * Configures a minimal android library against every AGP version in the matrix declared in
+ * `build.gradle.kts`.
+ *
+ * The plugin compiles against the OLDEST supported AGP, which is what stops it from reaching for an
+ * API newer AGP added. That leaves the opposite direction uncovered: an API the floor has but a
+ * newer AGP removed, renamed or narrowed compiles cleanly and only breaks at the consumer. This
+ * test is the coverage for that direction, so the newest entry in the matrix is the one earning its
+ * keep here.
+ *
+ * Skipped without an Android SDK, since the plugin requires `com.android.library`.
+ */
+class AgpCompatibilityMatrixTest {
+    @ParameterizedTest(name = "configures cleanly on AGP {0}")
+    @MethodSource("agpVersions")
+    fun `the plugin configures an android library on every supported AGP`(
+        agpVersion: String,
+        @TempDir projectDir: File,
+    ) {
+        val androidSdk = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
+        assumeTrue(
+            androidSdk != null && File(androidSdk).isDirectory,
+            "no Android SDK available (ANDROID_HOME/ANDROID_SDK_ROOT); skipping AGP-dependent test",
+        )
+
+        writeFixture(projectDir, androidSdk!!)
+
+        // `--dry-run` still runs configuration in full — variant callbacks, source set wiring, task
+        // graph construction — which is where every AGP API the plugin touches is exercised. It just
+        // skips the task actions, which would need a real RN app to produce anything meaningful.
+        GradleRunner.create()
+            .withProjectDir(projectDir)
+            .withPluginClasspath(pluginClasspathFor(agpVersion))
+            .withArguments("assembleDebug", "--dry-run", "--stacktrace")
+            .forwardOutput()
+            .build()
+    }
+
+    @Test
+    fun `the apply-time gate rejects AGP older than the floor`(
+        @TempDir projectDir: File,
+    ) {
+        val androidSdk = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
+        assumeTrue(
+            androidSdk != null && File(androidSdk).isDirectory,
+            "no Android SDK available (ANDROID_HOME/ANDROID_SDK_ROOT); skipping AGP-dependent test",
+        )
+
+        writeFixture(projectDir, androidSdk!!)
+
+        val belowFloor = requireNotNull(System.getProperty("agp.belowFloor.version"))
+        val result =
+            GradleRunner.create()
+                .withProjectDir(projectDir)
+                .withPluginClasspath(pluginClasspathFor(belowFloor))
+                .withArguments("tasks")
+                .buildAndFail()
+
+        assertTrue(
+            result.output.contains("requires Android Gradle Plugin"),
+            "expected the plugin's own AGP gate to reject AGP $belowFloor, but the build failed " +
+                "for some other reason:\n${result.output}",
+        )
+    }
+
+    private fun pluginClasspathFor(agpVersion: String): List<File> {
+        val raw =
+            requireNotNull(System.getProperty("agp.classpath.$agpVersion")) {
+                "no TestKit classpath was injected for AGP $agpVersion; check the agpMatrix wiring in build.gradle.kts"
+            }
+        return raw.split(File.pathSeparator).filter { it.isNotBlank() }.map(::File)
+    }
+
+    private fun writeFixture(
+        projectDir: File,
+        androidSdk: String,
+    ) {
+        File(projectDir, "settings.gradle.kts").writeText(
+            """
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "agp-matrix-consumer"
+            include(":app")
+            include(":brownfieldlib")
+            """.trimIndent(),
+        )
+        File(projectDir, "local.properties").writeText("sdk.dir=$androidSdk\n")
+        // Stands in for the RN app project. It has to be a real `com.android.application` because
+        // the brownfield plugin wires into AGP's own app-side tasks; the extra registrations cover
+        // the tasks the React Native Gradle plugin would otherwise contribute. Empty registrations
+        // are enough: this test is about AGP API compatibility, not about what those tasks produce.
+        File(projectDir, "app").mkdirs()
+        File(projectDir, "app/build.gradle.kts").writeText(
+            """
+            plugins {
+                id("com.android.application")
+            }
+
+            android {
+                namespace = "com.example.agpmatrix.app"
+                compileSdk = 34
+            }
+
+            listOf(
+                "generateAutolinkingPackageList",
+                "createBundleDebugJsAndAssets",
+                "createBundleReleaseJsAndAssets",
+            ).forEach { name -> tasks.register(name) }
+            """.trimIndent(),
+        )
+
+        File(projectDir, "brownfieldlib").mkdirs()
+        File(projectDir, "brownfieldlib/build.gradle.kts").writeText(
+            """
+            plugins {
+                id("com.android.library")
+                id("com.callstack.react.brownfield")
+                `maven-publish`
+            }
+
+            android {
+                namespace = "com.example.agpmatrix"
+                compileSdk = 34
+            }
+
+            // Contributed by the React Native Gradle plugin in a real consumer; stubbed here for the
+            // same reason as the app-side tasks above.
+            tasks.register("generateCodegenSchemaFromJavaScript")
+            """.trimIndent(),
+        )
+    }
+
+    private companion object {
+        @JvmStatic
+        fun agpVersions(): List<String> =
+            requireNotNull(System.getProperty("agp.matrix.versions")) {
+                "agp.matrix.versions was not injected; check the agpMatrix wiring in build.gradle.kts"
+            }.split(",").filter { it.isNotBlank() }
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/LegacyConsumerConfigurationTest.kt

@@ -0,0 +1,110 @@
+package com.callstack.react.brownfield.plugin
+
+import com.callstack.react.brownfield.shared.Constants
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.jupiter.api.Assumptions.assumeTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertFalse
+
+/**
+ * Guards the pre-migration consumer shape no in-repo app has any more: one that still hand-registers
+ * `removeDependenciesFromModuleFile` as the setup docs instruct. If the plugin ever claims that name
+ * again, configuration fails outright for every consumer who hasn't migrated.
+ *
+ * Skipped without an Android SDK, since the plugin requires `com.android.library`.
+ */
+class LegacyConsumerConfigurationTest {
+    @Test
+    fun `a project still registering the documented legacy task configures successfully`(
+        @TempDir projectDir: File,
+    ) {
+        val androidSdk = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
+        assumeTrue(
+            androidSdk != null && File(androidSdk).isDirectory,
+            "no Android SDK available (ANDROID_HOME/ANDROID_SDK_ROOT); skipping AGP-dependent test",
+        )
+
+        writeLegacyConsumerFixture(projectDir, androidSdk!!)
+
+        val result =
+            GradleRunner.create()
+                .withProjectDir(projectDir)
+                .withPluginClasspath()
+                .withArguments("tasks", "--stacktrace")
+                .forwardOutput()
+                .build()
+
+        // build() already failed above on any unrelated fixture breakage; this narrows a failure
+        // here to the duplicate-task-name case specifically.
+        assertFalse(
+            result.output.contains("as a task with that name already exists"),
+            "build output reports a duplicate task name; the plugin most likely claimed " +
+                "'${Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME}', which the setup docs " +
+                "reserve for consumers",
+        )
+    }
+
+    private fun writeLegacyConsumerFixture(
+        projectDir: File,
+        androidSdk: String,
+    ) {
+        File(projectDir, "settings.gradle.kts").writeText(
+            """
+            dependencyResolutionManagement {
+                repositories {
+                    google()
+                    mavenCentral()
+                }
+            }
+            rootProject.name = "legacy-consumer"
+            include(":app")
+            include(":brownfieldlib")
+            """.trimIndent(),
+        )
+        File(projectDir, "local.properties").writeText("sdk.dir=$androidSdk\n")
+        // ArtifactsResolver looks for an `app` project; an empty stub is enough, this test is about
+        // the task container, not discovery.
+        File(projectDir, "app").mkdirs()
+        File(projectDir, "app/build.gradle.kts").writeText("")
+
+        // The `tasks.register("removeDependenciesFromModuleFile")` block below is verbatim from
+        // the published setup docs. Do not "modernize" it — its whole purpose is to reproduce
+        // what a not-yet-migrated consumer actually has in their build script.
+        File(projectDir, "brownfieldlib").mkdirs()
+        File(projectDir, "brownfieldlib/build.gradle.kts").writeText(
+            """
+            import groovy.json.JsonOutput
+            import groovy.json.JsonSlurper
+
+            plugins {
+                id("com.android.library")
+                id("com.callstack.react.brownfield")
+                `maven-publish`
+            }
+
+            android {
+                namespace = "com.example.legacyconsumer"
+                compileSdk = 34
+            }
+
+            val moduleBuildDir: Directory = layout.buildDirectory.get()
+
+            tasks.register("removeDependenciesFromModuleFile") {
+                doLast {
+                    file("${'$'}moduleBuildDir/publications/mavenAar/module.json").run {
+                        val json = inputStream().use { JsonSlurper().parse(it) as Map<String, Any> }
+                        (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
+                            (variant["dependencies"] as? MutableList<Map<String, Any>>)?.removeAll {
+                                it["group"] == rootProject.name
+                            }
+                        }
+                        writer().use { it.write(JsonOutput.prettyPrint(JsonOutput.toJson(json))) }
+                    }
+                }
+            }
+            """.trimIndent(),
+        )
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/DependencyPublishabilityTest.kt

@@ -0,0 +1,67 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DependencyPublishabilityTest {
+    @Test
+    fun `rejects a fully dynamic version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-native", "+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a partially dynamic version`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "1.+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a null version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", null, "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a blank version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", "  ", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `accepts a normal pinned version`() {
+        val dep = DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)
+        assertTrue(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_release`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.release", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_integration`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.integration", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a closed Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0]", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a half-open Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects an unbounded Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+}