@granite-js/screen 1.0.0

package/gradle-plugin/src/test/kotlin/run/granite/gradle/GraniteExtensionTest.kt

@@ -0,0 +1,191 @@
+package run.granite.gradle
+
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Unit tests for GraniteExtension.
+ */
+class GraniteExtensionTest {
+
+  @TempDir
+  lateinit var testProjectDir: File
+
+  private lateinit var project: org.gradle.api.Project
+  private lateinit var extension: GraniteExtension
+
+  @BeforeEach
+  fun setup() {
+    project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    // Apply plugins to create extension
+    project.pluginManager.apply("com.android.library")
+    project.pluginManager.apply(GranitePlugin::class.java)
+
+    extension = project.extensions.getByType(GraniteExtension::class.java)
+  }
+
+  @Test
+  fun `extension has correct default values`() {
+    // Then
+    assertEquals("src/main/js/index.js", extension.entryFile.get())
+    assertEquals("index.android.bundle", extension.bundleAssetName.get())
+    assertTrue(extension.bundleCompressionEnabled.get())
+    assertEquals(4, extension.nativeArchitectures.get().size)
+    assertTrue(extension.nativeArchitectures.get().contains("arm64-v8a"))
+    assertTrue(extension.nativeArchitectures.get().contains("armeabi-v7a"))
+  }
+
+  @Test
+  fun `extension allows customization of properties`() {
+    // When
+    extension.entryFile.set("custom/entry.js")
+    extension.bundleAssetName.set("custom.bundle")
+    extension.bundleCompressionEnabled.set(false)
+    extension.nativeArchitectures.set(listOf("arm64-v8a"))
+
+    // Then
+    assertEquals("custom/entry.js", extension.entryFile.get())
+    assertEquals("custom.bundle", extension.bundleAssetName.get())
+    assertEquals(false, extension.bundleCompressionEnabled.get())
+    assertEquals(1, extension.nativeArchitectures.get().size)
+  }
+
+  // Test removed: entryFile validation moved to BundleTask execution time
+
+  @Test
+  fun `validate succeeds when all required files exist`() {
+    // Given
+    setupValidProject()
+
+    // When/Then - Should not throw
+    extension.validate()
+  }
+
+  @Test
+  fun `validate succeeds even without entry file`() {
+    // Given - Only React Native directory setup, no entry file
+    val nodeModules = File(testProjectDir, "node_modules")
+    val reactNativeDir = File(nodeModules, "react-native")
+    reactNativeDir.mkdirs()
+
+    val packageJson = File(reactNativeDir, "package.json")
+    packageJson.writeText("""{"version":"0.81.6"}""")
+
+    extension.reactNativeDir.set(reactNativeDir)
+    extension.nodeModulesDir.set(nodeModules)
+
+    // When/Then - Should not throw (entryFile validation deferred to BundleTask)
+    extension.validate()
+  }
+
+  @Test
+  fun `validate fails when React Native directory does not exist`() {
+    // Given - React Native dir not created
+
+    // When/Then
+    assertThrows<IllegalStateException> {
+      extension.validate()
+    }
+  }
+
+  // Test removed: Hermes is now always enabled, cannot be disabled
+
+  @Test
+  fun `validate fails with invalid ABI`() {
+    // Given
+    setupValidProject()
+    extension.nativeArchitectures.set(listOf("invalid-abi"))
+
+    // When/Then
+    val exception = assertThrows<IllegalStateException> {
+      extension.validate()
+    }
+
+    assertTrue(exception.message?.contains("Invalid") == true)
+    assertTrue(exception.message?.contains("ABI") == true)
+  }
+
+  @Test
+  fun `validate accepts all valid ABIs`() {
+    // Given
+    setupValidProject()
+    val validAbis = listOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
+    extension.nativeArchitectures.set(validAbis)
+
+    // When/Then - Should not throw
+    extension.validate()
+  }
+
+  @Test
+  fun `getEntryFileResolved returns correct file`() {
+    // Given
+    extension.entryFile.set("custom/entry.js")
+
+    // When
+    val resolved = extension.getEntryFileResolved()
+
+    // Then - Use canonical paths to handle symlinks (e.g., /var vs /private/var on macOS)
+    assertEquals(
+      File(testProjectDir, "custom/entry.js").canonicalPath,
+      resolved.canonicalPath,
+    )
+  }
+
+  @Test
+  fun `getReactNativeDirResolved returns correct directory`() {
+    // Given
+    val customRnDir = File(testProjectDir, "custom/react-native")
+    extension.reactNativeDir.set(customRnDir)
+
+    // When
+    val resolved = extension.getReactNativeDirResolved()
+
+    // Then - Use canonical paths to handle symlinks
+    assertEquals(customRnDir.canonicalPath, resolved.canonicalPath)
+  }
+
+  @Test
+  fun `getNodeModulesDirResolved returns correct directory`() {
+    // Given
+    val customNodeModules = File(testProjectDir, "custom/node_modules")
+    extension.nodeModulesDir.set(customNodeModules)
+
+    // When
+    val resolved = extension.getNodeModulesDirResolved()
+
+    // Then - Use canonical paths to handle symlinks
+    assertEquals(customNodeModules.canonicalPath, resolved.canonicalPath)
+  }
+
+  /**
+   * Sets up a valid project structure for testing.
+   */
+  private fun setupValidProject() {
+    // Create entry file
+    val entryFile = File(testProjectDir, "src/main/js/index.js")
+    entryFile.parentFile.mkdirs()
+    entryFile.writeText("// Entry file")
+
+    // Create React Native directory structure
+    val nodeModules = File(testProjectDir, "node_modules")
+    val reactNativeDir = File(nodeModules, "react-native")
+    reactNativeDir.mkdirs()
+
+    // Create package.json
+    val packageJson = File(reactNativeDir, "package.json")
+    packageJson.writeText("""{"version":"0.81.6"}""")
+
+    // Update extension to point to test directories
+    extension.reactNativeDir.set(reactNativeDir)
+    extension.nodeModulesDir.set(nodeModules)
+  }
+}

package/gradle-plugin/src/test/kotlin/run/granite/gradle/GranitePluginTest.kt

@@ -0,0 +1,156 @@
+package run.granite.gradle
+
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * Unit tests for GranitePlugin.
+ */
+class GranitePluginTest {
+
+  @TempDir
+  lateinit var testProjectDir: File
+
+  private lateinit var buildFile: File
+  private lateinit var settingsFile: File
+
+  @BeforeEach
+  fun setup() {
+    buildFile = File(testProjectDir, "build.gradle.kts")
+    settingsFile = File(testProjectDir, "settings.gradle.kts")
+  }
+
+  @Test
+  fun `plugin applies successfully to library project`() {
+    // Given
+    val project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    // When
+    project.pluginManager.apply("com.android.library")
+    project.pluginManager.apply(GranitePlugin::class.java)
+
+    // Then
+    assertTrue(project.plugins.hasPlugin(GranitePlugin::class.java))
+    assertNotNull(project.extensions.findByName("granite"))
+  }
+
+  @Test
+  fun `plugin creates granite extension with correct type`() {
+    // Given
+    val project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    // When
+    project.pluginManager.apply("com.android.library")
+    project.pluginManager.apply(GranitePlugin::class.java)
+
+    // Then
+    val extension = project.extensions.findByName("granite")
+    assertNotNull(extension)
+    assertTrue(extension is GraniteExtension)
+  }
+
+  @Test
+  fun `plugin registers autolinking task`() {
+    // Given
+    val project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    setupMinimalProject(project)
+
+    // When
+    project.pluginManager.apply("com.android.library")
+    project.pluginManager.apply(GranitePlugin::class.java)
+
+    // Force evaluation of afterEvaluate blocks by accessing the task container
+    // Note: This is a simplified test. Full task registration should be tested with GradleRunner.
+    // For now, we just verify the plugin applies without errors
+    assertTrue(project.plugins.hasPlugin(GranitePlugin::class.java))
+  }
+
+  @Test
+  fun `plugin registers codegen tasks`() {
+    // Given
+    val project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    setupMinimalProject(project)
+
+    // When
+    project.pluginManager.apply("com.android.library")
+    project.pluginManager.apply(GranitePlugin::class.java)
+
+    // Note: Task registration happens in afterEvaluate, which doesn't execute with ProjectBuilder.
+    // Full task registration should be tested with GradleRunner integration tests.
+    // For now, we verify the plugin and extension are configured correctly
+    val extension = project.extensions.findByName("granite")
+    assertNotNull(extension)
+    assertTrue(extension is GraniteExtension)
+  }
+
+  @Test
+  fun `plugin fails when applied to application project`() {
+    // Given
+    val project = ProjectBuilder.builder()
+      .withProjectDir(testProjectDir)
+      .build()
+
+    // When/Then
+    project.pluginManager.apply("com.android.application")
+
+    // Gradle wraps exceptions in PluginApplicationException
+    val exception = assertThrows<org.gradle.api.internal.plugins.PluginApplicationException> {
+      project.pluginManager.apply(GranitePlugin::class.java)
+    }
+
+    // Verify the cause is our expected IllegalStateException
+    assertTrue(exception.cause is IllegalStateException)
+  }
+
+  @Test
+  fun `plugin constants are correct`() {
+    assertEquals("run.granite.library", GranitePlugin.PLUGIN_ID)
+    assertEquals("granite", GranitePlugin.EXTENSION_NAME)
+    assertEquals("granite", GranitePlugin.PLUGIN_GROUP)
+  }
+
+  /**
+   * Sets up minimal project structure for testing.
+   */
+  private fun setupMinimalProject(project: org.gradle.api.Project) {
+    // Create minimal required directories
+    File(testProjectDir, "src/main/js").mkdirs()
+    File(testProjectDir, "src/main/java").mkdirs()
+
+    // Create minimal entry file
+    val entryFile = File(testProjectDir, "src/main/js/index.js")
+    entryFile.parentFile.mkdirs()
+    entryFile.writeText("// Empty entry file")
+
+    // Create fake node_modules structure
+    val nodeModules = File(testProjectDir, "node_modules")
+    val reactNativeDir = File(nodeModules, "react-native")
+    val androidDir = File(reactNativeDir, "android")
+    androidDir.mkdirs()
+
+    // Create package.json
+    val packageJson = File(reactNativeDir, "package.json")
+    packageJson.writeText("""{"version":"0.81.6"}""")
+
+    // Create cli.js
+    val cliJs = File(reactNativeDir, "cli.js")
+    cliJs.writeText("// Mock CLI")
+  }
+}

package/gradle-plugin/src/test/kotlin/run/granite/gradle/GraniteRootProjectPluginTest.kt

@@ -0,0 +1,87 @@
+package run.granite.gradle
+
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * Unit tests for GraniteRootProjectPlugin.
+ */
+class GraniteRootProjectPluginTest {
+
+  @Test
+  fun `plugin constants are correct`() {
+    assertEquals("run.granite.rootproject", GraniteRootProjectPlugin.PLUGIN_ID)
+    assertEquals("graniteRoot", GraniteRootProjectPlugin.EXTENSION_NAME)
+  }
+
+  @Test
+  fun `plugin applies successfully to root project`() {
+    // Given
+    val project = ProjectBuilder.builder().build()
+
+    // When
+    project.pluginManager.apply(GraniteRootProjectPlugin::class.java)
+
+    // Then
+    assertTrue(project.plugins.hasPlugin(GraniteRootProjectPlugin::class.java))
+  }
+
+  @Test
+  fun `plugin creates graniteRoot extension`() {
+    // Given
+    val project = ProjectBuilder.builder().build()
+
+    // When
+    project.pluginManager.apply(GraniteRootProjectPlugin::class.java)
+
+    // Then
+    val extension = project.extensions.findByName("graniteRoot")
+    assertNotNull(extension)
+    assertTrue(extension is GraniteRootExtension)
+  }
+
+  @Test
+  fun `extension has correct default values`() {
+    // Given
+    val project = ProjectBuilder.builder().build()
+    project.pluginManager.apply(GraniteRootProjectPlugin::class.java)
+
+    // When
+    val extension = project.extensions.getByType(GraniteRootExtension::class.java)
+
+    // Then
+    assertEquals("com.facebook.react", extension.reactGroup.get())
+    assertEquals("com.facebook.hermes", extension.hermesGroup.get())
+    assertEquals(project.file("node_modules"), extension.nodeModulesDir.get())
+    // reactNativeVersion and hermesVersion should not have conventions (are not present)
+    assertTrue(!extension.reactNativeVersion.isPresent)
+    assertTrue(!extension.hermesVersion.isPresent)
+  }
+
+  @Test
+  fun `plugin fails when applied to non-root project`() {
+    // Given
+    val rootProject = ProjectBuilder.builder()
+      .withName("root")
+      .build()
+    val subProject = ProjectBuilder.builder()
+      .withName("sub")
+      .withParent(rootProject)
+      .build()
+
+    // When/Then
+    // Gradle wraps exceptions in PluginApplicationException
+    val exception = assertThrows<org.gradle.api.internal.plugins.PluginApplicationException> {
+      subProject.pluginManager.apply(GraniteRootProjectPlugin::class.java)
+    }
+
+    // Verify the cause is our expected IllegalStateException
+    assertTrue(exception.cause is IllegalStateException)
+    assertTrue(exception.cause!!.message!!.contains("can only be applied to the root project"))
+    assertTrue(exception.cause!!.message!!.contains("Current project: :sub"))
+  }
+}

package/gradle-plugin/src/test/kotlin/run/granite/gradle/config/BuildConfigConfiguratorTest.kt

@@ -0,0 +1,115 @@
+package run.granite.gradle.config
+
+import com.android.build.gradle.LibraryExtension
+import org.gradle.api.Project
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import run.granite.gradle.GraniteExtension
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * Unit tests for BuildConfigConfigurator.
+ *
+ * Tests the configuration of Android BuildConfig field generation for
+ * feature flags and React Native configuration.
+ */
+class BuildConfigConfiguratorTest {
+
+  private lateinit var project: Project
+  private lateinit var extension: GraniteExtension
+  private lateinit var androidExtension: LibraryExtension
+  private lateinit var configurator: BuildConfigConfigurator
+
+  @BeforeEach
+  fun setup() {
+    project = ProjectBuilder.builder().build()
+    project.pluginManager.apply("com.android.library")
+
+    extension = project.extensions.create("granite", GraniteExtension::class.java, project)
+    androidExtension = project.extensions.getByType(LibraryExtension::class.java)
+
+    configurator = BuildConfigConfigurator(project, extension)
+  }
+
+  @Test
+  fun `configurator is created successfully`() {
+    assertNotNull(configurator, "BuildConfigConfigurator should be created")
+  }
+
+  @Test
+  fun `configure method executes without errors`() {
+    // Hermes is always enabled
+    extension.reactNativeVersion.set("0.81.0")
+    extension.bundleAssetName.set("index.android")
+
+    // Should not throw
+    configurator.configure(androidExtension)
+  }
+
+  @Test
+  fun `buildConfig feature is enabled`() {
+    // Hermes is always enabled
+    extension.reactNativeVersion.set("0.81.0")
+    extension.bundleAssetName.set("index.android")
+
+    configurator.configure(androidExtension)
+
+    // Verify BuildConfig is enabled
+    assertTrue(
+      androidExtension.buildFeatures.buildConfig == true,
+      "BuildConfig feature should be enabled",
+    )
+  }
+
+  @Test
+  fun `configure works with default extension values`() {
+    // Should not throw with default values
+    configurator.configure(androidExtension)
+
+    assertTrue(
+      androidExtension.buildFeatures.buildConfig == true,
+      "BuildConfig feature should be enabled even with defaults",
+    )
+  }
+
+  // Test removed: Hermes is now always enabled, cannot be disabled
+
+  @Test
+  fun `configure works with new architecture enabled`() {
+    // Both Hermes and New Architecture are always enabled
+    extension.reactNativeVersion.set("0.81.0")
+    extension.bundleAssetName.set("index.android")
+
+    // Should not throw
+    configurator.configure(androidExtension)
+  }
+
+  @Test
+  fun `configure can be called multiple times`() {
+    // Hermes is always enabled
+    extension.reactNativeVersion.set("0.81.0")
+    extension.bundleAssetName.set("index.android")
+
+    // Should not throw when called multiple times
+    configurator.configure(androidExtension)
+    configurator.configure(androidExtension)
+  }
+
+  @Test
+  fun `configure with different react native versions`() {
+    extension.reactNativeVersion.set("0.82.0")
+
+    // Should not throw
+    configurator.configure(androidExtension)
+  }
+
+  @Test
+  fun `configure with custom bundle asset name`() {
+    extension.bundleAssetName.set("custom.bundle")
+
+    // Should not throw
+    configurator.configure(androidExtension)
+  }
+}