@react-native/gradle-plugin 0.74.85 → 0.74.86

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/internal/PrepareJSCTaskTest.kt

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tasks.internal
+
+import com.facebook.react.tests.createProject
+import com.facebook.react.tests.createTestTask
+import com.facebook.react.tests.zipFiles
+import java.io.*
+import org.junit.Assert.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class PrepareJSCTaskTest {
+
+  @get:Rule val tempFolder = TemporaryFolder()
+
+  @Test(expected = IllegalStateException::class)
+  fun prepareJSCTask_withMissingPackage_fails() {
+    val task = createTestTask<PrepareJSCTask>()
+
+    task.taskAction()
+  }
+
+  @Test(expected = IllegalStateException::class)
+  fun prepareJSCTask_withNullPackage_fails() {
+    val task = createTestTask<PrepareJSCTask> { it.jscPackagePath.set(null as String?) }
+
+    task.taskAction()
+  }
+
+  @Test(expected = IllegalStateException::class)
+  fun prepareJSCTask_withMissingDistFolder_fails() {
+    val task =
+        createTestTask<PrepareJSCTask> { it.jscPackagePath.set(tempFolder.root.absolutePath) }
+
+    task.taskAction()
+  }
+
+  @Test
+  fun prepareJSCTask_ignoresEmptyDirs() {
+    prepareInputFolder()
+    val output = tempFolder.newFolder("output")
+    File(tempFolder.root, "dist/just/an/empty/folders/").apply { mkdirs() }
+
+    val task =
+        createTestTask<PrepareJSCTask> {
+          it.jscPackagePath.set(tempFolder.root.absolutePath)
+          it.outputDir.set(output)
+        }
+
+    task.taskAction()
+
+    assertFalse(File(output, "just/an/empty/folders/").exists())
+  }
+
+  @Test
+  fun prepareJSCTask_copiesSoFiles() {
+    val soFile = tempFolder.newFile("libsomething.so")
+    prepareInputFolder(aarContent = listOf(soFile))
+    val output = tempFolder.newFolder("output")
+
+    val task =
+        createTestTask<PrepareJSCTask> {
+          it.jscPackagePath.set(tempFolder.root.absolutePath)
+          it.outputDir.set(output)
+        }
+
+    task.taskAction()
+
+    assertEquals("libsomething.so", output.listFiles()?.first()?.name)
+  }
+
+  @Test
+  fun prepareJSCTask_copiesHeaderFilesToCorrectFolder() {
+    prepareInputFolder()
+    File(tempFolder.root, "dist/include/justaheader.h").apply {
+      parentFile.mkdirs()
+      createNewFile()
+    }
+    val output = tempFolder.newFolder("output")
+
+    val task =
+        createTestTask<PrepareJSCTask> {
+          it.jscPackagePath.set(tempFolder.root.absolutePath)
+          it.outputDir.set(output)
+        }
+
+    task.taskAction()
+
+    assertTrue(File(output, "JavaScriptCore/justaheader.h").exists())
+  }
+
+  @Test
+  fun prepareJSCTask_copiesCMakefile() {
+    val project = createProject()
+    prepareInputFolder()
+    File(project.projectDir, "src/main/jni/third-party/jsc/CMakeLists.txt").apply {
+      parentFile.mkdirs()
+      createNewFile()
+    }
+    val output = tempFolder.newFolder("output")
+
+    val task =
+        createTestTask<PrepareJSCTask>(project = project) {
+          it.jscPackagePath.set(tempFolder.root.absolutePath)
+          it.outputDir.set(output)
+        }
+
+    task.taskAction()
+
+    assertTrue(File(output, "CMakeLists.txt").exists())
+  }
+
+  private fun prepareInputFolder(aarContent: List<File> = listOf(tempFolder.newFile())) {
+    val dist = tempFolder.newFolder("dist")
+    File(dist, "android-jsc/android-library.aar").apply {
+      parentFile.mkdirs()
+      createNewFile()
+    }
+    zipFiles(File(dist, "android-jsc/android-library.aar"), aarContent)
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/internal/PreparePrefabHeadersTaskTest.kt

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tasks.internal
+
+import com.facebook.react.tasks.internal.utils.PrefabPreprocessingEntry
+import com.facebook.react.tests.createProject
+import com.facebook.react.tests.createTestTask
+import java.io.*
+import org.junit.Assert.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class PreparePrefabHeadersTaskTest {
+
+  @get:Rule val tempFolder = TemporaryFolder()
+
+  @Test
+  fun preparePrefabHeadersTask_withMissingConfiguration_doesNothing() {
+    val task = createTestTask<PreparePrefabHeadersTask>()
+
+    task.taskAction()
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withSingleEntry_copiesHeaderFile() {
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/hello.h").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(listOf(PrefabPreprocessingEntry("sample_library", "input/" to "")))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "sample_library/hello.h").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withSingleEntry_respectsPrefix() {
+    val expectedPrefix = "react/render/something/"
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/hello.h").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(
+              listOf(PrefabPreprocessingEntry("sample_library", "input/" to expectedPrefix)))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "sample_library/${expectedPrefix}hello.h").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_ignoresUnnecessaryFiles() {
+    val expectedPrefix = "react/render/something/"
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/hello.hpp").createNewPathAndFile()
+    File(tempFolder.root, "input/hello.cpp").createNewPathAndFile()
+    File(tempFolder.root, "input/CMakeLists.txt").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(
+              listOf(PrefabPreprocessingEntry("sample_library", "input/" to expectedPrefix)))
+        }
+
+    task.taskAction()
+
+    assertFalse(File(outputDir, "sample_library/hello.hpp").exists())
+    assertFalse(File(outputDir, "sample_library/hello.cpp").exists())
+    assertFalse(File(outputDir, "sample_library/CMakeLists.txt").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withMultiplePaths_copiesHeaderFiles() {
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/component1/hello1.h").createNewPathAndFile()
+    File(tempFolder.root, "input/component2/debug/hello2.h").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(
+              listOf(
+                  PrefabPreprocessingEntry(
+                      "sample_library",
+                      listOf("input/component1/" to "", "input/component2/" to "")),
+              ))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "sample_library/hello1.h").exists())
+    assertTrue(File(outputDir, "sample_library/debug/hello2.h").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withMultipleEntries_copiesHeaderFiles() {
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/lib1/hello1.h").createNewPathAndFile()
+    File(tempFolder.root, "input/lib2/hello2.h").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(
+              listOf(
+                  PrefabPreprocessingEntry("libraryone", "input/lib1/" to ""),
+                  PrefabPreprocessingEntry("librarytwo", "input/lib2/" to "")))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "libraryone/hello1.h").exists())
+    assertTrue(File(outputDir, "librarytwo/hello2.h").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withReusedHeaders_copiesHeadersTwice() {
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "input/lib1/hello1.h").createNewPathAndFile()
+    File(tempFolder.root, "input/lib2/hello2.h").createNewPathAndFile()
+    File(tempFolder.root, "input/shared/sharedheader.h").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(
+              listOf(
+                  PrefabPreprocessingEntry(
+                      "libraryone", listOf("input/lib1/" to "", "input/shared/" to "shared/")),
+                  PrefabPreprocessingEntry(
+                      "librarytwo", listOf("input/lib2/" to "", "input/shared/" to "shared/")),
+              ))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "libraryone/hello1.h").exists())
+    assertTrue(File(outputDir, "libraryone/shared/sharedheader.h").exists())
+    assertTrue(File(outputDir, "librarytwo/hello2.h").exists())
+    assertTrue(File(outputDir, "librarytwo/shared/sharedheader.h").exists())
+  }
+
+  @Test
+  fun preparePrefabHeadersTask_withBoostHeaders_filtersThemCorrectly() {
+    val outputDir = tempFolder.newFolder("output")
+    File(tempFolder.root, "boost/boost/config.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/operators.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/config/default/default.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/core/core.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/detail/workaround.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/preprocessor/preprocessor.hpp").createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/preprocessor/detail/preprocessor_detail.hpp")
+        .createNewPathAndFile()
+    File(tempFolder.root, "boost/boost/anothermodule/wedontuse.hpp").createNewPathAndFile()
+
+    val project = createProject(projectDir = tempFolder.root)
+    val task =
+        createTestTask<PreparePrefabHeadersTask>(project = project) {
+          it.outputDir.set(outputDir)
+          it.input.set(listOf(PrefabPreprocessingEntry("sample_library", "boost/" to "")))
+        }
+
+    task.taskAction()
+
+    assertTrue(File(outputDir, "sample_library/boost/config.hpp").exists())
+    assertTrue(File(outputDir, "sample_library/boost/operators.hpp").exists())
+    assertTrue(File(outputDir, "sample_library/boost/config/default/default.hpp").exists())
+    assertTrue(File(outputDir, "sample_library/boost/core/core.hpp").exists())
+    assertTrue(File(outputDir, "sample_library/boost/detail/workaround.hpp").exists())
+    assertTrue(File(outputDir, "sample_library/boost/preprocessor/preprocessor.hpp").exists())
+    assertTrue(
+        File(outputDir, "sample_library/boost/preprocessor/detail/preprocessor_detail.hpp")
+            .exists())
+    assertFalse(File(outputDir, "sample_library/boost/anothermodule/wedontuse.hpp").exists())
+  }
+
+  private fun File.createNewPathAndFile() {
+    parentFile.mkdirs()
+    createNewFile()
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/internal/utils/PrefabPreprocessingEntryTest.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tasks.internal.utils
+
+import groovy.test.GroovyTestCase.assertEquals
+import org.junit.Test
+
+class PrefabPreprocessingEntryTest {
+
+  @Test
+  fun secondaryConstructor_createsAList() {
+    val sampleEntry =
+        PrefabPreprocessingEntry(
+            libraryName = "justALibrary", pathToPrefixCouple = "aPath" to "andAPrefix")
+
+    assertEquals(1, sampleEntry.pathToPrefixCouples.size)
+    assertEquals("aPath", sampleEntry.pathToPrefixCouples[0].first)
+    assertEquals("andAPrefix", sampleEntry.pathToPrefixCouples[0].second)
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tests/OsRule.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tests
+
+import org.junit.rules.TestRule
+import org.junit.runner.Description
+import org.junit.runners.model.Statement
+
+/**
+ * A JUnit [TestRule] to override values of [System.getProperties] with the support of the [WithOs]
+ * annotation.
+ */
+class OsRule : TestRule {
+
+  private var retainOs: String? = null
+  private var retainArch: String? = null
+
+  override fun apply(statement: Statement, description: Description): Statement {
+    return object : Statement() {
+      override fun evaluate() {
+        val annotation = description.annotations.filterIsInstance<WithOs>().firstOrNull()
+
+        annotation?.os?.propertyName?.let {
+          retainOs = System.getProperty(OS_NAME_KEY)
+          System.setProperty(OS_NAME_KEY, it)
+        }
+        annotation?.arch?.let {
+          if (it.isNotBlank()) {
+            retainArch = System.getProperty(OS_ARCH_KEY)
+            System.setProperty(OS_ARCH_KEY, it)
+          }
+        }
+        try {
+          statement.evaluate()
+        } finally {
+          retainOs?.let { System.setProperty(OS_NAME_KEY, it) }
+          retainArch?.let { System.setProperty(OS_ARCH_KEY, it) }
+        }
+      }
+    }
+  }
+
+  companion object {
+    const val OS_NAME_KEY = "os.name"
+    const val OS_ARCH_KEY = "os.arch"
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tests/TaskTestUtils.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tests
+
+import java.io.*
+import java.net.URI
+import java.nio.file.FileSystems
+import java.nio.file.Files
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.testfixtures.ProjectBuilder
+
+internal fun createProject(projectDir: File? = null): Project {
+  val project =
+      ProjectBuilder.builder()
+          .apply {
+            if (projectDir != null) {
+              withProjectDir(projectDir)
+            }
+          }
+          .build()
+
+  project.plugins.apply("com.android.library")
+  project.plugins.apply("com.facebook.react")
+  return project
+}
+
+internal inline fun <reified T : Task> createTestTask(
+    project: Project = createProject(),
+    taskName: String = T::class.java.simpleName,
+    crossinline block: (T) -> Unit = {}
+): T = project.tasks.register(taskName, T::class.java) { block(it) }.get()
+
+/** A util function to zip a list of files from [contents] inside the zipfile at [destination]. */
+internal fun zipFiles(destination: File, contents: List<File>) {
+  ZipOutputStream(BufferedOutputStream(FileOutputStream(destination.absolutePath))).use { out ->
+    for (file in contents) {
+      FileInputStream(file).use { fi ->
+        BufferedInputStream(fi).use { origin ->
+          val entry = ZipEntry(file.name)
+          out.putNextEntry(entry)
+          origin.copyTo(out, 1024)
+        }
+      }
+    }
+  }
+}
+
+/** A util function to create a zip given a list of dummy files path. */
+internal fun createZip(dest: File, paths: List<String>) {
+  val env = mapOf("create" to "true")
+  val uri = URI.create("jar:file:$dest")
+
+  FileSystems.newFileSystem(uri, env).use { zipfs ->
+    paths.forEach {
+      val zipEntryPath = zipfs.getPath(it)
+      val zipEntryFolder = zipEntryPath.subpath(0, zipEntryPath.nameCount - 1)
+      Files.createDirectories(zipEntryFolder)
+      Files.createFile(zipEntryPath)
+    }
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tests/WithOs.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tests
+
+/** Annotation to specify an Operating System to override the "os.name" System Property. */
+@Retention(AnnotationRetention.RUNTIME) annotation class WithOs(val os: OS, val arch: String = "")
+
+enum class OS(val propertyName: String) {
+  WIN("Windows"),
+  MAC("MacOs"),
+  LINUX("Linux")
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/utils/AgpConfiguratorUtilsTest.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import java.io.File
+import org.junit.Assert.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class AgpConfiguratorUtilsTest {
+
+  @get:Rule val tempFolder = TemporaryFolder()
+
+  @Test
+  fun getPackageNameFromManifest_withEmptyFile_returnsNull() {
+    val mainFolder = tempFolder.newFolder("awesome-module/src/main/")
+    val manifest = File(mainFolder, "AndroidManifest.xml").apply { writeText("") }
+
+    val actual = getPackageNameFromManifest(manifest)
+    assertNull(actual)
+  }
+
+  @Test
+  fun getPackageNameFromManifest_withMissingPackage_returnsNull() {
+    val mainFolder = tempFolder.newFolder("awesome-module/src/main/")
+    val manifest =
+        File(mainFolder, "AndroidManifest.xml").apply {
+          writeText(
+              // language=xml
+              """
+          <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+          </manifest>
+          """
+                  .trimIndent())
+        }
+
+    val actual = getPackageNameFromManifest(manifest)
+    assertNull(actual)
+  }
+
+  @Test
+  fun getPackageNameFromManifest_withPackage_returnsPackage() {
+    val mainFolder = tempFolder.newFolder("awesome-module/src/main/")
+    val manifest =
+        File(mainFolder, "AndroidManifest.xml").apply {
+          writeText(
+              // language=xml
+              """
+          <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.facebook.react" >
+          </manifest>
+          """
+                  .trimIndent())
+        }
+
+    val actual = getPackageNameFromManifest(manifest)
+    assertNotNull(actual)
+    assertEquals("com.facebook.react", actual)
+  }
+}

package/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/utils/BackwardCompatUtilsTest.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.facebook.react.tests.createProject
+import com.facebook.react.utils.BackwardCompatUtils.configureBackwardCompatibilityReactMap
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class BackwardCompatUtilsTest {
+
+  @get:Rule val tempFolder = TemporaryFolder()
+
+  @Test
+  fun configureBackwardCompatibilityReactMap_addsEmptyReactMap() {
+    val project = createProject()
+
+    configureBackwardCompatibilityReactMap(project)
+
+    assertTrue(project.extensions.extraProperties.has("react"))
+    @Suppress("UNCHECKED_CAST")
+    assertTrue((project.extensions.extraProperties.get("react") as Map<String, Any?>).isEmpty())
+  }
+
+  @Test
+  fun configureBackwardCompatibilityReactMap_withExistingMapSetByUser_wipesTheMap() {
+    val project = createProject()
+    project.extensions.extraProperties.set("react", mapOf("enableHermes" to true))
+
+    configureBackwardCompatibilityReactMap(project)
+
+    assertTrue(project.extensions.extraProperties.has("react"))
+    @Suppress("UNCHECKED_CAST")
+    assertTrue((project.extensions.extraProperties.get("react") as Map<String, Any?>).isEmpty())
+  }
+}