Update after review

Author: ia-vzhang

gradle-module-plugin/build.gradle.kts

@@ -20,7 +20,7 @@ repositories {
 }
 
 group = "io.ia.sdk"
-version = "0.4.1"
+version = "0.5.0-SNAPSHOT"
 
 configurations {
     val functionalTestImplementation by registering {
@@ -61,7 +61,6 @@ dependencies {
     implementation(libs.kotlinXmlBuilder)
     api(libs.moduleSigner)
     testImplementation(libs.kotlinTestJunit)
-    testImplementation(libs.junit.jupiter.api)
     testImplementation("io.ia.sdk.tools.module.gen:generator-core")
 }
 

gradle-module-plugin/gradle/libs.versions.toml

@@ -1,15 +1,13 @@
 [versions]
 kotlin = "1.7.10"
 moshi = "1.9.3"
-junit-jupiter = "5.11.4"
 
 [libraries]
 # Dependencies referencable in buildscripts.  Note that dashes are replaced by periods in the buildscript reference.
 guava = { module = "com.google.guava:guava", version = "30.1.1-jre" }
 kotlinTest = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 kotlinTestJunit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
 kotlinXmlBuilder = { module = "org.redundent:kotlin-xml-builder", version = "1.7.2" }
-junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit-jupiter" }
 moshi = { module = "com.squareup.moshi:moshi-kotlin", version.ref = "moshi" }
 moshiCodegen = { module = "com.squareup.moshi:moshi-kotlin-codegen", version.ref = "moshi" }
 moduleSigner = { module = "com.inductiveautomation.ignitionsdk:module-signer", version = "0.0.1.ia" }

gradle-module-plugin/src/functionalTest/kotlin/io/ia/sdk/gradle/modl/task/ZipModuleTests.kt

@@ -7,55 +7,61 @@ import org.gradle.api.Project
 import org.gradle.api.internal.project.DefaultProject
 import org.gradle.api.tasks.TaskExecutionException
 import org.gradle.testfixtures.ProjectBuilder
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.Assertions.assertTrue
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.io.TempDir
+import kotlin.io.path.createTempDirectory
+import kotlin.test.BeforeTest
+import kotlin.test.AfterTest
+import kotlin.test.Test
+import kotlin.test.assertTrue
+import kotlin.test.assertFailsWith
 import java.io.File
 
 class ZipModuleTests : BaseTest() {
 
-    @TempDir
-    lateinit var testProjectDir: File
+    private lateinit var tempDir: File
     private lateinit var project: Project
     private lateinit var task: ZipModule
 
-    @BeforeEach
+    @BeforeTest
     fun setup() {
-        project = ProjectBuilder.builder().withProjectDir(testProjectDir).build() as DefaultProject
+        tempDir = createTempDirectory().toFile()
+        project = ProjectBuilder.builder().withProjectDir(tempDir).build() as DefaultProject
         task = project.tasks.create("testTask", ZipModule::class.java)
 
-        // Set up the task properties with the test directory
-        task.content.set(project.objects.directoryProperty().fileValue(File(testProjectDir, "content")))
-        task.unsignedModule.set(project.objects.fileProperty().fileValue(File(testProjectDir, "output.modl")))
+        // Set up the task properties with the temp directory
+        task.content.set(project.objects.directoryProperty().fileValue(File(tempDir, "content")))
+        task.unsignedModule.set(project.objects.fileProperty().fileValue(File(tempDir, "output.modl")))
+    }
+
+    @AfterTest
+    fun cleanup() {
+        tempDir.deleteRecursively()
     }
 
     @Test
     fun `task succeeds when no duplicate jars exist`() {
         // Arrange
-        val contentDir = File(testProjectDir, "content").apply { mkdirs() }
+        val contentDir = task.content.asFile.get().apply { mkdirs() }
         File(contentDir, "my-lib-1.0.jar").createNewFile()
         File(contentDir, "another-lib-2.0.jar").createNewFile()
 
-        // Act & Assert: The task should not throw an exception
+        // Act: The task should not throw an exception
         task.execute()
     }
 
     @Test
     fun `task fails when duplicate jars with different versions exist`() {
         // Arrange
-        val contentDir = File(testProjectDir, "content").apply { mkdirs() }
+        val contentDir = task.content.asFile.get().apply { mkdirs() }
         File(contentDir, "my-lib-1.0.jar").createNewFile()
         File(contentDir, "my-lib-2.0.jar").createNewFile() // This is the duplicate
 
-        // Act & Assert: The task should throw a TaskExecutionException
-        val exception = assertThrows(TaskExecutionException::class.java) {
+        // Act & Assert: The task should throw a IllegalArgumentException
+        val exception = assertFailsWith<IllegalArgumentException>{
             task.execute()
         }
 
         // Verify the exception message
-        val expectedMessage = "Jar with 'my-lib' has multiple versions presented"
+        val expectedMessage = "Library 'my-lib' exists in multiple versions"
         assertTrue(exception.message!!.contains(expectedMessage))
     }
 

gradle-module-plugin/src/main/kotlin/io/ia/sdk/gradle/modl/task/ZipModule.kt

@@ -58,33 +58,26 @@ open class ZipModule @Inject constructor(objects: ObjectFactory) : DefaultTask()
     }
 
     /**
-     * Try to detect jars in contentDir with the same name but have multiple
-     * versions existed.  Fail the build when it's found.
+     * Fail the build when jars in the contentDir with the same name has
+     * multiple versions detected.
      **/
     fun checkDuplicateJars(contentDir: File) {
         project.logger.info("Parsing file name in: ${contentDir.absolutePath}")
 
-        val fileMap = mutableMapOf<String, String>()
-        val regex = "^(.+?)-(\\d+.*)(?:\\.jar)".toRegex()
+        val fileSet = mutableSetOf<String>()
+        val regex = "^(.+?)-(?:\\d+.*)(?:\\.jar)".toRegex()
 
         contentDir.walk().filter { it.isFile }.forEach { file ->
             val matchResult = regex.find(file.name) // Match all the jar files
 
             if (matchResult != null) {
                 val name = matchResult.groupValues[1]
-                val version = matchResult.groupValues[2]
 
-                if (fileMap.containsKey(name)) {
-                    throw TaskExecutionException(
-                        this,
-                        IllegalArgumentException(
-                            """Jar with '$name' has multiple versions presented in ${contentDir.absolutePath}
-                            Please ensure only one version exist (preferably the highest) and update lib.version.toml file if needed.
-                            """.trimIndent()
-                        )
-                    )
+                if (fileSet.contains(name)) {
+                    throw IllegalArgumentException(
+                            "Library '$name' exists in multiple versions in ${contentDir.absolutePath}")
                 } else {
-                    fileMap[name] = version
+                    fileSet.add(name)
                 }
             }
         }