From 84de32b2d726d40abb38ed44930ae950cfba4556 Mon Sep 17 00:00:00 2001
From: omer-ayhan <om.ayhan247@gmail.com>
Date: Wed, 31 Jul 2024 11:08:30 -0700
Subject: [PATCH] =?UTF-8?q?chore:=20=E2=98=82=EF=B8=8F=20Migrate=20BundleH?=
 =?UTF-8?q?ermesCTaskTest.kt=20to=20AssertJ=20(#45806)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Summary:
Issue: https://github.com/facebook/react-native/issues/45596

## Changelog:
[INTERNAL] [CHANGED] - Migrate `BundleHermesCTaskTest.kt` to AssertJ testing library

<!-- Help reviewers and the release process by writing your own changelog entry.

Pick one each for the category and type tags:

[ANDROID|GENERAL|IOS|INTERNAL] [BREAKING|ADDED|CHANGED|DEPRECATED|REMOVED|FIXED|SECURITY] - Message

For more details, see:
https://reactnative.dev/contributing/changelogs-in-pull-requests

Pull Request resolved: https://github.com/facebook/react-native/pull/45806

Test Plan: Run `./gradlew -p packages/gradle-plugin test`

Reviewed By: mdvacca

Differential Revision: D60522760

Pulled By: cortinico

fbshipit-source-id: f7847143d182b29e1bbbba738a0ddae9bf3ee59c
---
 .../react/tasks/BundleHermesCTaskTest.kt      | 269 +++++++++---------
 1 file changed, 133 insertions(+), 136 deletions(-)

diff --git a/packages/gradle-plugin/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/BundleHermesCTaskTest.kt b/packages/gradle-plugin/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/BundleHermesCTaskTest.kt
index f7feb2b1173..2fd83a282e8 100644
--- a/packages/gradle-plugin/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/BundleHermesCTaskTest.kt
+++ b/packages/gradle-plugin/react-native-gradle-plugin/src/test/kotlin/com/facebook/react/tasks/BundleHermesCTaskTest.kt
@@ -12,7 +12,7 @@ import com.facebook.react.tests.OsRule
 import com.facebook.react.tests.WithOs
 import com.facebook.react.tests.createTestTask
 import java.io.File
-import org.junit.Assert.*
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
@@ -26,7 +26,7 @@ class BundleHermesCTaskTest {
   @Test
   fun bundleTask_groupIsSetCorrectly() {
     val task = createTestTask<BundleHermesCTask> {}
-    assertEquals("react", task.group)
+    assertThat(task.group).isEqualTo("react")
   }
 
   @Test
@@ -41,14 +41,13 @@ class BundleHermesCTaskTest {
 
     val task = createTestTask<BundleHermesCTask> { it.root.set(rootDir) }
 
-    assertEquals(4, task.sources.files.size)
-    assertEquals(
-        setOf(
+    assertThat(task.sources.files.size).isEqualTo(4)
+    assertThat(task.sources.files)
+        .containsExactlyInAnyOrder(
             File(rootDir, "file.js"),
             File(rootDir, "file.jsx"),
             File(rootDir, "file.ts"),
-            File(rootDir, "file.tsx")),
-        task.sources.files)
+            File(rootDir, "file.tsx"))
   }
 
   @Test
@@ -70,16 +69,11 @@ class BundleHermesCTaskTest {
 
     val task = createTestTask<BundleHermesCTask> { it.root.set(rootDir) }
 
-    assertEquals(
-        setOf(
-            "**/android/**/*",
-            "**/ios/**/*",
-            "**/build/**/*",
-            "**/node_modules/**/*",
-        ),
-        task.sources.excludes)
-    assertEquals(1, task.sources.files.size)
-    assertEquals(setOf(File(rootDir, "afolder/includedfile.js")), task.sources.files)
+    assertThat(task.sources.excludes)
+        .containsExactlyInAnyOrder(
+            "**/android/**/*", "**/ios/**/*", "**/build/**/*", "**/node_modules/**/*")
+    assertThat(task.sources.files.size).isEqualTo(1)
+    assertThat(task.sources.files).containsExactly(File(rootDir, "afolder/includedfile.js"))
   }
 
   @Test
@@ -97,15 +91,15 @@ class BundleHermesCTaskTest {
           it.hermesFlags.set(listOf("flag1", "flag2"))
         }
 
-    assertEquals(listOf("node", "arg1", "arg2"), task.nodeExecutableAndArgs.get())
-    assertEquals("bundle", task.bundleCommand.get())
-    assertEquals("myassetname", task.bundleAssetName.get())
-    assertTrue(task.minifyEnabled.get())
-    assertTrue(task.hermesEnabled.get())
-    assertTrue(task.devEnabled.get())
-    assertEquals(listOf("extra", "arg"), task.extraPackagerArgs.get())
-    assertEquals("./my-hermesc", task.hermesCommand.get())
-    assertEquals(listOf("flag1", "flag2"), task.hermesFlags.get())
+    assertThat(task.nodeExecutableAndArgs.get()).isEqualTo(listOf("node", "arg1", "arg2"))
+    assertThat(task.bundleCommand.get()).isEqualTo("bundle")
+    assertThat(task.bundleAssetName.get()).isEqualTo("myassetname")
+    assertThat(task.minifyEnabled.get()).isTrue()
+    assertThat(task.hermesEnabled.get()).isTrue()
+    assertThat(task.devEnabled.get()).isTrue()
+    assertThat(task.extraPackagerArgs.get()).isEqualTo(listOf("extra", "arg"))
+    assertThat(task.hermesCommand.get()).isEqualTo("./my-hermesc")
+    assertThat(task.hermesFlags.get()).isEqualTo(listOf("flag1", "flag2"))
   }
 
   @Test
@@ -131,14 +125,14 @@ class BundleHermesCTaskTest {
           it.reactNativeDir.set(reactNativeDir)
         }
 
-    assertEquals(entryFile, task.entryFile.get().asFile)
-    assertEquals(cliFile, task.cliFile.get().asFile)
-    assertEquals(jsBundleDir, task.jsBundleDir.get().asFile)
-    assertEquals(resourcesDir, task.resourcesDir.get().asFile)
-    assertEquals(jsIntermediateSourceMapsDir, task.jsIntermediateSourceMapsDir.get().asFile)
-    assertEquals(jsSourceMapsDir, task.jsSourceMapsDir.get().asFile)
-    assertEquals(bundleConfig, task.bundleConfig.get().asFile)
-    assertEquals(reactNativeDir, task.reactNativeDir.get().asFile)
+    assertThat(task.entryFile.get().asFile).isEqualTo(entryFile)
+    assertThat(task.cliFile.get().asFile).isEqualTo(cliFile)
+    assertThat(task.jsBundleDir.get().asFile).isEqualTo(jsBundleDir)
+    assertThat(task.resourcesDir.get().asFile).isEqualTo(resourcesDir)
+    assertThat(task.jsIntermediateSourceMapsDir.get().asFile).isEqualTo(jsIntermediateSourceMapsDir)
+    assertThat(task.jsSourceMapsDir.get().asFile).isEqualTo(jsSourceMapsDir)
+    assertThat(task.bundleConfig.get().asFile).isEqualTo(bundleConfig)
+    assertThat(task.reactNativeDir.get().asFile).isEqualTo(reactNativeDir)
   }
 
   @Test
@@ -152,9 +146,8 @@ class BundleHermesCTaskTest {
           it.bundleAssetName.set(bundleAssetName)
         }
 
-    assertEquals(
-        File(jsIntermediateSourceMapsDir, "myassetname.packager.map"),
-        task.resolvePackagerSourceMapFile(bundleAssetName))
+    assertThat(task.resolvePackagerSourceMapFile(bundleAssetName))
+        .isEqualTo(File(jsIntermediateSourceMapsDir, "myassetname.packager.map"))
   }
 
   @Test
@@ -167,9 +160,8 @@ class BundleHermesCTaskTest {
           it.hermesEnabled.set(false)
         }
 
-    assertEquals(
-        File(jsSourceMapsDir, "myassetname.map"),
-        task.resolvePackagerSourceMapFile(bundleAssetName))
+    assertThat(task.resolvePackagerSourceMapFile(bundleAssetName))
+        .isEqualTo(File(jsSourceMapsDir, "myassetname.map"))
   }
 
   @Test
@@ -178,8 +170,8 @@ class BundleHermesCTaskTest {
     val bundleAssetName = "myassetname"
     val task = createTestTask<BundleHermesCTask> { it.jsSourceMapsDir.set(jsSourceMapsDir) }
 
-    assertEquals(
-        File(jsSourceMapsDir, "myassetname.map"), task.resolveOutputSourceMap(bundleAssetName))
+    assertThat(task.resolveOutputSourceMap(bundleAssetName))
+        .isEqualTo(File(jsSourceMapsDir, "myassetname.map"))
   }
 
   @Test
@@ -191,9 +183,8 @@ class BundleHermesCTaskTest {
           it.jsIntermediateSourceMapsDir.set(jsIntermediateSourceMapsDir)
         }
 
-    assertEquals(
-        File(jsIntermediateSourceMapsDir, "myassetname.compiler.map"),
-        task.resolveCompilerSourceMap(bundleAssetName))
+    assertThat(task.resolveCompilerSourceMap(bundleAssetName))
+        .isEqualTo(File(jsIntermediateSourceMapsDir, "myassetname.compiler.map"))
   }
 
   @Test
@@ -220,31 +211,32 @@ class BundleHermesCTaskTest {
 
     val bundleCommand = task.getBundleCommand(bundleFile, sourceMapFile)
 
-    assertEquals("node", bundleCommand[0])
-    assertEquals("arg1", bundleCommand[1])
-    assertEquals("arg2", bundleCommand[2])
-    assertEquals(cliFile.absolutePath, bundleCommand[3])
-    assertEquals("bundle", bundleCommand[4])
-    assertEquals("--platform", bundleCommand[5])
-    assertEquals("android", bundleCommand[6])
-    assertEquals("--dev", bundleCommand[7])
-    assertEquals("true", bundleCommand[8])
-    assertEquals("--reset-cache", bundleCommand[9])
-    assertEquals("--entry-file", bundleCommand[10])
-    assertEquals(entryFile.absolutePath, bundleCommand[11])
-    assertEquals("--bundle-output", bundleCommand[12])
-    assertEquals(bundleFile.absolutePath, bundleCommand[13])
-    assertEquals("--assets-dest", bundleCommand[14])
-    assertEquals(resourcesDir.absolutePath, bundleCommand[15])
-    assertEquals("--sourcemap-output", bundleCommand[16])
-    assertEquals(sourceMapFile.absolutePath, bundleCommand[17])
-    assertEquals("--config", bundleCommand[18])
-    assertEquals(bundleConfig.absolutePath, bundleCommand[19])
-    assertEquals("--minify", bundleCommand[20])
-    assertEquals("true", bundleCommand[21])
-    assertEquals("--read-global-cache", bundleCommand[22])
-    assertEquals("--verbose", bundleCommand[23])
-    assertEquals(24, bundleCommand.size)
+    assertThat(bundleCommand)
+        .containsExactly(
+            "node",
+            "arg1",
+            "arg2",
+            cliFile.absolutePath,
+            "bundle",
+            "--platform",
+            "android",
+            "--dev",
+            "true",
+            "--reset-cache",
+            "--entry-file",
+            entryFile.absolutePath,
+            "--bundle-output",
+            bundleFile.absolutePath,
+            "--assets-dest",
+            resourcesDir.absolutePath,
+            "--sourcemap-output",
+            sourceMapFile.absolutePath,
+            "--config",
+            bundleConfig.absolutePath,
+            "--minify",
+            "true",
+            "--read-global-cache",
+            "--verbose")
   }
 
   @Test
@@ -272,33 +264,34 @@ class BundleHermesCTaskTest {
 
     val bundleCommand = task.getBundleCommand(bundleFile, sourceMapFile)
 
-    assertEquals("cmd", bundleCommand[0])
-    assertEquals("/c", bundleCommand[1])
-    assertEquals("node", bundleCommand[2])
-    assertEquals("arg1", bundleCommand[3])
-    assertEquals("arg2", bundleCommand[4])
-    assertEquals(cliFile.relativeTo(tempFolder.root).path, bundleCommand[5])
-    assertEquals("bundle", bundleCommand[6])
-    assertEquals("--platform", bundleCommand[7])
-    assertEquals("android", bundleCommand[8])
-    assertEquals("--dev", bundleCommand[9])
-    assertEquals("true", bundleCommand[10])
-    assertEquals("--reset-cache", bundleCommand[11])
-    assertEquals("--entry-file", bundleCommand[12])
-    assertEquals(entryFile.relativeTo(tempFolder.root).path, bundleCommand[13])
-    assertEquals("--bundle-output", bundleCommand[14])
-    assertEquals(bundleFile.relativeTo(tempFolder.root).path, bundleCommand[15])
-    assertEquals("--assets-dest", bundleCommand[16])
-    assertEquals(resourcesDir.relativeTo(tempFolder.root).path, bundleCommand[17])
-    assertEquals("--sourcemap-output", bundleCommand[18])
-    assertEquals(sourceMapFile.relativeTo(tempFolder.root).path, bundleCommand[19])
-    assertEquals("--config", bundleCommand[20])
-    assertEquals(bundleConfig.relativeTo(tempFolder.root).path, bundleCommand[21])
-    assertEquals("--minify", bundleCommand[22])
-    assertEquals("true", bundleCommand[23])
-    assertEquals("--read-global-cache", bundleCommand[24])
-    assertEquals("--verbose", bundleCommand[25])
-    assertEquals(26, bundleCommand.size)
+    assertThat(bundleCommand)
+        .containsExactly(
+            "cmd",
+            "/c",
+            "node",
+            "arg1",
+            "arg2",
+            cliFile.relativeTo(tempFolder.root).path,
+            "bundle",
+            "--platform",
+            "android",
+            "--dev",
+            "true",
+            "--reset-cache",
+            "--entry-file",
+            entryFile.relativeTo(tempFolder.root).path,
+            "--bundle-output",
+            bundleFile.relativeTo(tempFolder.root).path,
+            "--assets-dest",
+            resourcesDir.relativeTo(tempFolder.root).path,
+            "--sourcemap-output",
+            sourceMapFile.relativeTo(tempFolder.root).path,
+            "--config",
+            bundleConfig.relativeTo(tempFolder.root).path,
+            "--minify",
+            "true",
+            "--read-global-cache",
+            "--verbose")
   }
 
   @Test
@@ -323,7 +316,7 @@ class BundleHermesCTaskTest {
 
     val bundleCommand = task.getBundleCommand(bundleFile, sourceMapFile)
 
-    assertTrue("--config" !in bundleCommand)
+    assertThat(bundleCommand).doesNotContain("--config")
   }
 
   @Test
@@ -339,14 +332,15 @@ class BundleHermesCTaskTest {
 
     val hermesCommand = task.getHermescCommand(customHermesc, bytecodeFile, bundleFile)
 
-    assertEquals(customHermesc, hermesCommand[0])
-    assertEquals("-emit-binary", hermesCommand[1])
-    assertEquals("-max-diagnostic-width=80", hermesCommand[2])
-    assertEquals("-out", hermesCommand[3])
-    assertEquals(bytecodeFile.absolutePath, hermesCommand[4])
-    assertEquals(bundleFile.absolutePath, hermesCommand[5])
-    assertEquals("my-custom-hermes-flag", hermesCommand[6])
-    assertEquals(7, hermesCommand.size)
+    assertThat(hermesCommand)
+        .containsExactly(
+            customHermesc,
+            "-emit-binary",
+            "-max-diagnostic-width=80",
+            "-out",
+            bytecodeFile.absolutePath,
+            bundleFile.absolutePath,
+            "my-custom-hermes-flag")
   }
 
   @Test
@@ -363,16 +357,17 @@ class BundleHermesCTaskTest {
 
     val hermesCommand = task.getHermescCommand(customHermesc, bytecodeFile, bundleFile)
 
-    assertEquals("cmd", hermesCommand[0])
-    assertEquals("/c", hermesCommand[1])
-    assertEquals(customHermesc, hermesCommand[2])
-    assertEquals("-emit-binary", hermesCommand[3])
-    assertEquals("-max-diagnostic-width=80", hermesCommand[4])
-    assertEquals("-out", hermesCommand[5])
-    assertEquals(bytecodeFile.relativeTo(tempFolder.root).path, hermesCommand[6])
-    assertEquals(bundleFile.relativeTo(tempFolder.root).path, hermesCommand[7])
-    assertEquals("my-custom-hermes-flag", hermesCommand[8])
-    assertEquals(9, hermesCommand.size)
+    assertThat(hermesCommand)
+        .containsExactly(
+            "cmd",
+            "/c",
+            customHermesc,
+            "-emit-binary",
+            "-max-diagnostic-width=80",
+            "-out",
+            bytecodeFile.relativeTo(tempFolder.root).path,
+            bundleFile.relativeTo(tempFolder.root).path,
+            "my-custom-hermes-flag")
   }
 
   @Test
@@ -391,15 +386,16 @@ class BundleHermesCTaskTest {
     val composeSourcemapCommand =
         task.getComposeSourceMapsCommand(composeSourceMapsFile, packagerMap, compilerMap, outputMap)
 
-    assertEquals("node", composeSourcemapCommand[0])
-    assertEquals("arg1", composeSourcemapCommand[1])
-    assertEquals("arg2", composeSourcemapCommand[2])
-    assertEquals(composeSourceMapsFile.absolutePath, composeSourcemapCommand[3])
-    assertEquals(packagerMap.absolutePath, composeSourcemapCommand[4])
-    assertEquals(compilerMap.absolutePath, composeSourcemapCommand[5])
-    assertEquals("-o", composeSourcemapCommand[6])
-    assertEquals(outputMap.absolutePath, composeSourcemapCommand[7])
-    assertEquals(8, composeSourcemapCommand.size)
+    assertThat(composeSourcemapCommand)
+        .containsExactly(
+            "node",
+            "arg1",
+            "arg2",
+            composeSourceMapsFile.absolutePath,
+            packagerMap.absolutePath,
+            compilerMap.absolutePath,
+            "-o",
+            outputMap.absolutePath)
   }
 
   @Test
@@ -419,16 +415,17 @@ class BundleHermesCTaskTest {
     val composeSourcemapCommand =
         task.getComposeSourceMapsCommand(composeSourceMapsFile, packagerMap, compilerMap, outputMap)
 
-    assertEquals("cmd", composeSourcemapCommand[0])
-    assertEquals("/c", composeSourcemapCommand[1])
-    assertEquals("node", composeSourcemapCommand[2])
-    assertEquals("arg1", composeSourcemapCommand[3])
-    assertEquals("arg2", composeSourcemapCommand[4])
-    assertEquals(composeSourceMapsFile.relativeTo(tempFolder.root).path, composeSourcemapCommand[5])
-    assertEquals(packagerMap.relativeTo(tempFolder.root).path, composeSourcemapCommand[6])
-    assertEquals(compilerMap.relativeTo(tempFolder.root).path, composeSourcemapCommand[7])
-    assertEquals("-o", composeSourcemapCommand[8])
-    assertEquals(outputMap.relativeTo(tempFolder.root).path, composeSourcemapCommand[9])
-    assertEquals(10, composeSourcemapCommand.size)
+    assertThat(composeSourcemapCommand)
+        .containsExactly(
+            "cmd",
+            "/c",
+            "node",
+            "arg1",
+            "arg2",
+            composeSourceMapsFile.relativeTo(tempFolder.root).path,
+            packagerMap.relativeTo(tempFolder.root).path,
+            compilerMap.relativeTo(tempFolder.root).path,
+            "-o",
+            outputMap.relativeTo(tempFolder.root).path)
   }
 }