@granite-js/screen 1.0.0

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

@@ -0,0 +1,318 @@
+package run.granite.gradle.tasks
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import run.granite.gradle.utils.createTestFile
+import run.granite.gradle.utils.createTestTask
+import run.granite.gradle.utils.readFileContent
+import java.io.File
+import java.util.zip.GZIPInputStream
+
+/**
+ * Unit tests for AssetPackagingTask.
+ *
+ * Tests asset packaging and compression logic by executing the actual task.
+ */
+class AssetPackagingTaskTest {
+
+  @TempDir
+  lateinit var tempDir: File
+
+  @Test
+  fun `task is cacheable`() {
+    val annotations = AssetPackagingTask::class.annotations
+    assertThat(annotations)
+      .anyMatch { it.annotationClass.simpleName == "CacheableTask" }
+  }
+
+  @Test
+  fun `task has correct group and description`() {
+    val task = createTestTask<AssetPackagingTask>()
+
+    assertThat(task.group).isEqualTo("granite")
+    assertThat(task.description).isEqualTo("Packages React Native assets and bundles")
+  }
+
+  @Test
+  fun `packageBundle copies uncompressed bundle when compression disabled`() {
+    // Create test bundle file
+    val bundleContent = "// React Native bundle\nvar __BUNDLE_START_TIME__=Date.now();"
+    val bundleFile = createTestFile(tempDir, "index.android.bundle", bundleContent)
+
+    val outputDir = File(tempDir, "output/assets")
+    val outputFile = File(outputDir, "index.android.bundle")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.outputAssetsDir.set(outputDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify uncompressed bundle was copied
+    assertThat(outputFile).exists()
+    assertThat(readFileContent(outputFile)).isEqualTo(bundleContent)
+
+    // Verify no gzipped file was created
+    assertThat(File(outputDir, "index.android.bundle.gz")).doesNotExist()
+  }
+
+  @Test
+  fun `packageBundle creates gzipped bundle when compression enabled`() {
+    // Create test bundle file
+    val bundleContent = "// React Native bundle\nvar __BUNDLE_START_TIME__=Date.now();"
+    val bundleFile = createTestFile(tempDir, "index.android.hbc", bundleContent)
+
+    val outputDir = File(tempDir, "output/assets")
+    val compressedFile = File(outputDir, "index.android.hbc.gz")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.outputAssetsDir.set(outputDir)
+      it.bundleAssetName.set("index.android.hbc")
+      it.compressionEnabled.set(true)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify gzipped bundle was created
+    assertThat(compressedFile).exists()
+
+    // Verify content can be decompressed
+    val decompressed = GZIPInputStream(compressedFile.inputStream()).use {
+      it.readBytes().toString(Charsets.UTF_8)
+    }
+    assertThat(decompressed).isEqualTo(bundleContent)
+  }
+
+  @Test
+  fun `packageBundle handles Hermes bytecode files`() {
+    // Create test Hermes bytecode file (simulated)
+    val hbcContent = ByteArray(100) { it.toByte() } // Fake bytecode
+    val bundleFile = File(tempDir, "index.android.hbc")
+    bundleFile.writeBytes(hbcContent)
+
+    val outputDir = File(tempDir, "output/assets")
+    val outputFile = File(outputDir, "index.android.hbc")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.outputAssetsDir.set(outputDir)
+      it.bundleAssetName.set("index.android.hbc")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    assertThat(outputFile).exists()
+    assertThat(outputFile.readBytes()).isEqualTo(hbcContent)
+  }
+
+  @Test
+  fun `packageDrawableAssets copies single drawable directory`() {
+    // Create drawable assets
+    val assetsDir = File(tempDir, "assets")
+    val drawableMdpi = File(assetsDir, "drawable-mdpi")
+    createTestFile(drawableMdpi, "icon.png", "fake png content")
+
+    val outputResDir = File(tempDir, "output/res")
+    val bundleFile = createTestFile(tempDir, "bundle.js", "fake")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.assetsDir.set(assetsDir)
+      it.outputAssetsDir.set(File(tempDir, "output/assets"))
+      it.outputResDir.set(outputResDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify drawable was copied
+    val copiedDrawable = File(outputResDir, "drawable-mdpi/icon.png")
+    assertThat(copiedDrawable).exists()
+    assertThat(readFileContent(copiedDrawable)).isEqualTo("fake png content")
+  }
+
+  @Test
+  fun `packageDrawableAssets copies multiple drawable densities`() {
+    // Create multiple drawable density directories
+    val assetsDir = File(tempDir, "assets")
+    val densities = listOf("mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi")
+
+    for (density in densities) {
+      val drawableDir = File(assetsDir, "drawable-$density")
+      createTestFile(drawableDir, "icon.png", "icon for $density")
+      createTestFile(drawableDir, "logo.png", "logo for $density")
+    }
+
+    val outputResDir = File(tempDir, "output/res")
+    val bundleFile = createTestFile(tempDir, "bundle.js", "fake")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.assetsDir.set(assetsDir)
+      it.outputAssetsDir.set(File(tempDir, "output/assets"))
+      it.outputResDir.set(outputResDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify all densities were copied
+    for (density in densities) {
+      val iconFile = File(outputResDir, "drawable-$density/icon.png")
+      val logoFile = File(outputResDir, "drawable-$density/logo.png")
+
+      assertThat(iconFile).exists()
+      assertThat(logoFile).exists()
+      assertThat(readFileContent(iconFile)).isEqualTo("icon for $density")
+      assertThat(readFileContent(logoFile)).isEqualTo("logo for $density")
+    }
+  }
+
+  @Test
+  fun `packageDrawableAssets handles nested subdirectories`() {
+    // Create drawable with nested structure
+    val assetsDir = File(tempDir, "assets")
+    val drawableXhdpi = File(assetsDir, "drawable-xhdpi")
+    createTestFile(File(drawableXhdpi, "icons"), "app_icon.png", "nested icon")
+
+    val outputResDir = File(tempDir, "output/res")
+    val bundleFile = createTestFile(tempDir, "bundle.js", "fake")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.assetsDir.set(assetsDir)
+      it.outputAssetsDir.set(File(tempDir, "output/assets"))
+      it.outputResDir.set(outputResDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify nested file was copied with same structure
+    val copiedNestedFile = File(outputResDir, "drawable-xhdpi/icons/app_icon.png")
+    assertThat(copiedNestedFile).exists()
+    assertThat(readFileContent(copiedNestedFile)).isEqualTo("nested icon")
+  }
+
+  @Test
+  fun `packageDrawableAssets handles no assets directory`() {
+    // Don't set assetsDir (optional)
+    val outputAssetsDir = File(tempDir, "output/assets")
+    val bundleFile = createTestFile(tempDir, "bundle.js", "fake")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      // assetsDir not set
+      it.outputAssetsDir.set(outputAssetsDir)
+      // outputResDir not set
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    // Should not throw
+    task.execute()
+
+    // Only bundle should be packaged
+    assertThat(File(outputAssetsDir, "index.android.bundle")).exists()
+  }
+
+  @Test
+  fun `packageDrawableAssets handles empty assets directory`() {
+    // Create empty assets directory
+    val assetsDir = File(tempDir, "assets")
+    assetsDir.mkdirs()
+
+    val outputResDir = File(tempDir, "output/res")
+    val bundleFile = createTestFile(tempDir, "bundle.js", "fake")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.assetsDir.set(assetsDir)
+      it.outputAssetsDir.set(File(tempDir, "output/assets"))
+      it.outputResDir.set(outputResDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    // Should not throw
+    task.execute()
+
+    // res directory may be created but empty
+    if (outputResDir.exists()) {
+      assertThat(outputResDir.listFiles()).isEmpty()
+    }
+  }
+
+  @Test
+  fun `task packages both bundle and drawables together`() {
+    // Create bundle and drawables
+    val bundleContent = "// React Native bundle"
+    val bundleFile = createTestFile(tempDir, "index.android.bundle", bundleContent)
+
+    val assetsDir = File(tempDir, "assets")
+    createTestFile(File(assetsDir, "drawable-mdpi"), "icon.png", "mdpi icon")
+    createTestFile(File(assetsDir, "drawable-hdpi"), "icon.png", "hdpi icon")
+
+    val outputAssetsDir = File(tempDir, "output/assets")
+    val outputResDir = File(tempDir, "output/res")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.assetsDir.set(assetsDir)
+      it.outputAssetsDir.set(outputAssetsDir)
+      it.outputResDir.set(outputResDir)
+      it.bundleAssetName.set("index.android.bundle")
+      it.compressionEnabled.set(false)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    // Verify both bundle and drawables were packaged
+    assertThat(File(outputAssetsDir, "index.android.bundle")).exists()
+    assertThat(File(outputResDir, "drawable-mdpi/icon.png")).exists()
+    assertThat(File(outputResDir, "drawable-hdpi/icon.png")).exists()
+  }
+
+  @Test
+  fun `gzip compression actually reduces file size for text bundles`() {
+    // Create large repetitive text bundle (compresses well)
+    val bundleContent = "var x = 'test';\n".repeat(1000)
+    val bundleFile = createTestFile(tempDir, "large.bundle", bundleContent)
+
+    val outputDir = File(tempDir, "output/assets")
+
+    val task = createTestTask<AssetPackagingTask> {
+      it.bundleFile.set(bundleFile)
+      it.outputAssetsDir.set(outputDir)
+      it.bundleAssetName.set("large.bundle")
+      it.compressionEnabled.set(true)
+      it.variantName.set("release")
+    }
+
+    task.execute()
+
+    val compressedFile = File(outputDir, "large.bundle.gz")
+    assertThat(compressedFile).exists()
+
+    // Compressed file should be smaller than original
+    assertThat(compressedFile.length()).isLessThan(bundleFile.length())
+  }
+}

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

@@ -0,0 +1,89 @@
+package run.granite.gradle.tasks
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import run.granite.gradle.fixtures.NativeModuleFixtures
+import run.granite.gradle.generators.CppAutolinkingGenerator
+
+/**
+ * Unit tests for AutolinkingTask.
+ *
+ * Tests PackageList.kt generation logic and configuration.
+ *
+ * Note: Full integration testing (actual CLI execution) requires Node.js and
+ * React Native CLI, so is done separately. These tests focus on task structure validation.
+ */
+class AutolinkingTaskTest {
+
+  @Test
+  fun `task is cacheable`() {
+    val annotations = AutolinkingTask::class.annotations
+    assertThat(annotations)
+      .anyMatch { it.annotationClass.simpleName == "CacheableTask" }
+  }
+
+  @Test
+  fun `task has all required properties`() {
+    val propertyNames = AutolinkingTask::class.members
+      .filter {
+        it.name.endsWith("File") || it.name.endsWith("Dir") ||
+          it.name == "packageName"
+      }
+      .map { it.name }
+      .toSet()
+
+    assertThat(propertyNames).contains("reactNativeDir")
+    assertThat(propertyNames).contains("nodeModulesDir")
+    assertThat(propertyNames).contains("projectDir")
+    assertThat(propertyNames).contains("outputDir")
+    assertThat(propertyNames).contains("packageListFile")
+    assertThat(propertyNames).contains("packageName")
+  }
+
+  @Test
+  fun `task has execute method`() {
+    val executeMethods = AutolinkingTask::class.members
+      .filter { it.name == "execute" }
+
+    assertThat(executeMethods).isNotEmpty
+  }
+
+  @Test
+  fun `task class is abstract`() {
+    assertThat(AutolinkingTask::class.isAbstract).isTrue
+  }
+
+  @Test
+  fun `autolinking filters modules by includesGeneratedCode flag`() {
+    // Create mixed modules: one standard, one with custom codegen
+    val modules = NativeModuleFixtures.createMixedModules()
+
+    // Simulate the filtering logic from AutolinkingTask
+    val filteredModules = modules.filter { !it.includesGeneratedCode }
+
+    // Standard module should be included
+    assertThat(filteredModules).anyMatch { it.name == "react-native-example" }
+
+    // Custom codegen module should be excluded
+    assertThat(filteredModules).noneMatch { it.name == "custom-codegen-module" }
+
+    assertThat(filteredModules).hasSize(1)
+  }
+
+  @Test
+  fun `generated autolinking excludes modules with includesGeneratedCode flag`() {
+    // Filtering by includesGeneratedCode is the caller's responsibility (AutolinkingTask),
+    // not the generator's. Test that pre-filtered input produces correct output.
+    val allModules = NativeModuleFixtures.createMixedModules()
+    val filteredModules = allModules.filter { !it.includesGeneratedCode }
+
+    val generatedCpp = CppAutolinkingGenerator.generate(filteredModules)
+
+    // Custom codegen module should be excluded after filtering
+    assertThat(generatedCpp).doesNotContain("CustomCodegenSpec_ModuleProvider")
+    assertThat(generatedCpp).doesNotContain("custom_codegen_module")
+
+    // Standard module should still be included
+    assertThat(generatedCpp).contains("ExampleSpec_ModuleProvider")
+  }
+}

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

@@ -0,0 +1,68 @@
+package run.granite.gradle.tasks
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+/**
+ * Unit tests for BundleTask.
+ *
+ * Tests JavaScript bundling and Hermes compilation logic structure.
+ *
+ * Note: Full integration testing (actual Metro/Hermes execution) requires
+ * Node.js, React Native CLI, and Hermes compiler, so is done separately.
+ * These tests focus on task structure validation.
+ */
+class BundleTaskTest {
+
+  @Test
+  fun `task is cacheable`() {
+    val annotations = BundleTask::class.annotations
+    assertThat(annotations)
+      .anyMatch { it.annotationClass.simpleName == "CacheableTask" }
+  }
+
+  @Test
+  fun `task has all required properties`() {
+    val propertyNames = BundleTask::class.members
+      .filter {
+        it.name.endsWith("File") || it.name.endsWith("Dir") ||
+          it.name == "devMode" ||
+          it.name == "bundleAssetName" || it.name == "variantName"
+      }
+      .map { it.name }
+      .toSet()
+
+    assertThat(propertyNames).contains("entryFile")
+    assertThat(propertyNames).contains("reactNativeDir")
+    assertThat(propertyNames).contains("nodeModulesDir")
+    assertThat(propertyNames).contains("projectDir")
+    assertThat(propertyNames).contains("bundleFile")
+    assertThat(propertyNames).contains("sourceMapFile")
+    assertThat(propertyNames).contains("bundleAssetName")
+    assertThat(propertyNames).contains("devMode")
+    assertThat(propertyNames).contains("variantName")
+  }
+
+  @Test
+  fun `task has execute method`() {
+    val executeMethods = BundleTask::class.members
+      .filter { it.name == "execute" }
+
+    assertThat(executeMethods).isNotEmpty
+  }
+
+  @Test
+  fun `task class is abstract`() {
+    assertThat(BundleTask::class.isAbstract).isTrue
+  }
+
+  @Test
+  fun `task has private helper methods`() {
+    val privateMembers = BundleTask::class.members
+      .map { it.name }
+      .toSet()
+
+    // Execute method orchestrates the bundling process
+    assertThat(privateMembers).contains("execute")
+  }
+}