Testing improvements

.github/workflows/build.yml

@@ -38,6 +38,9 @@ jobs:
       - name: Build
         run: ./gradlew build
 
+      - name: Coverage Report
+        run: ./gradlew testCodeCoverageReport
+
       - name: Sonar
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
     alias(libs.plugins.kotlin.multiplatform) apply false
     alias(libs.plugins.sonarqube)
     alias(libs.plugins.jreleaser)
+    id("jacoco-report-aggregation")
 }
 
 allprojects {
@@ -14,6 +15,10 @@ allprojects {
     description = "Kotlin compiler plugin for generating object mappers"
 }
 
+dependencies {
+    jacocoAggregation(project(":compiler-plugin"))
+}
+
 val branch = ByteArrayOutputStream()
 
 exec {
@@ -28,6 +33,10 @@ sonar {
         property("sonar.host.url", "https://sonarcloud.io")
         property("sonar.qualitygate.wait", "true")
         property("sonar.branch.name", branch.toString(Charsets.UTF_8))
+        property("sonar.coverage.jacoco.xmlReportPaths", layout.buildDirectory
+                .file("reports/jacoco/testCodeCoverageReport/testCodeCoverageReport.xml")
+                .get().asFile.absolutePath
+        )
     }
 }
 
@@ -80,4 +89,4 @@ jreleaser {
             }
         }
     }
-}
+}

compiler-plugin/build.gradle.kts

@@ -2,16 +2,23 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     alias(libs.plugins.kotlin.jvm)
+    id("java-test-fixtures")
     id("maven-publish")
+    id("jacoco")
 }
 
 dependencies {
     compileOnly(libs.kotlin.compiler.embeddable)
 
     implementation(project(":mappie-api"))
 
+    testFixturesImplementation(libs.classgraph)
+    testFixturesImplementation(libs.okio)
+
+    testImplementation(kotlin("reflect"))
     testImplementation(kotlin("test"))
     testImplementation(libs.kotlin.compiler.embeddable)
+    testImplementation(project(":mappie-api"))
 }
 
 java {
@@ -23,7 +30,11 @@ publishing {
     publications {
         create<MavenPublication>("kotlin") {
             artifactId = "mappie-compiler-plugin"
-            from(components["java"])
+
+            from((components["java"] as AdhocComponentWithVariants).apply {
+                withVariantsFromConfiguration(configurations["testFixturesApiElements"]) { skip() }
+                withVariantsFromConfiguration(configurations["testFixturesRuntimeElements"]) { skip() }
+            })
 
             pom {
                 name = "tech.mappie:compiler-plugin"
@@ -67,10 +78,12 @@ publishing {
 
 tasks.withType<Test> {
     useJUnitPlatform()
+    finalizedBy(tasks.jacocoTestReport)
 }
 
 tasks.withType<KotlinCompile>().configureEach {
-    compilerOptions.freeCompilerArgs.add(
-        "-opt-in=org.jetbrains.kotlin.ir.symbols.UnsafeDuringIrConstructionAPI"
+    compilerOptions.freeCompilerArgs.addAll(
+        "-opt-in=org.jetbrains.kotlin.ir.symbols.UnsafeDuringIrConstructionAPI",
+        "-opt-in=org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi"
     )
-}
+}

compiler-plugin/src/main/kotlin/tech/mappie/resolving/classes/ObjectMappingBodyCollector.kt

@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.ir.IrFileEntry
 import org.jetbrains.kotlin.ir.backend.js.utils.valueArguments
 import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
+import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.createExpressionBody
-import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionExpressionImpl
@@ -140,7 +140,7 @@ private class MapperReferenceCollector : BaseVisitor<IrFunctionExpression, Unit>
 
         return when (val name = expression.symbol.owner.name) {
             getterName(ObjectMappie<*, *>::forList.name) -> {
-                val mapper = expression.symbol.owner.parent as IrClassImpl
+                val mapper = expression.symbol.owner.parent as IrClass
 
                 val function = mapper.functions
                     .filter { it.name == IDENTIFIER_MAP_LIST }
@@ -149,7 +149,7 @@ private class MapperReferenceCollector : BaseVisitor<IrFunctionExpression, Unit>
                 function.symbol.wrap(expression.dispatchReceiver!!)
             }
             getterName(ObjectMappie<*, *>::forSet.name) -> {
-                val mapper = expression.symbol.owner.parent as IrClassImpl
+                val mapper = expression.symbol.owner.parent as IrClass
 
                 val function = mapper.functions
                     .filter { it.name == IDENTIFIER_MAP_SET }

compiler-plugin/src/test/kotlin/tech/mappie/testing/enums/TwoEnumsWithSameEntriesTest.kt

@@ -0,0 +1,50 @@
+package tech.mappie.testing.enums
+
+import org.junit.jupiter.api.io.TempDir
+import tech.mappie.testing.compilation.KotlinCompilation
+import tech.mappie.testing.compilation.KotlinCompilation.ExitCode
+import tech.mappie.testing.compilation.SourceFile.Companion.kotlin
+import tech.mappie.testing.loadEnumMappieClass
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TwoEnumsWithSameEntriesTest {
+
+    enum class Input { SOME, OTHER }
+    enum class Output { SOME, OTHER }
+
+    @TempDir
+    private lateinit var directory: File
+
+    @Test
+    fun `map two enums with the same entries should succeed`() {
+        KotlinCompilation(directory).apply {
+            sources = buildList {
+                add(
+                    kotlin("Test.kt",
+                        """
+                        import tech.mappie.api.EnumMappie
+                        import tech.mappie.testing.enums.TwoEnumsWithSameEntriesTest.*
+
+                        class Mapper : EnumMappie<Input, Output>()
+                        """
+                    )
+                )
+            }
+        }.compile {
+            assertEquals(ExitCode.OK, exitCode)
+            assertEquals("", messages)
+
+            val mapper = classLoader
+                .loadEnumMappieClass<Input, Output>("Mapper")
+                .constructors
+                .first()
+                .call()
+
+            Input.entries.forEach { entry ->
+                assertEquals(Output.valueOf(entry.name), mapper.map(entry))
+            }
+        }
+    }
+}

compiler-plugin/src/testFixtures/kotlin/tech/mappie/testing/ClassLoading.kt

@@ -0,0 +1,8 @@
+package tech.mappie.testing
+
+import tech.mappie.api.EnumMappie
+import java.net.URLClassLoader
+import kotlin.reflect.KClass
+
+fun <FROM : Enum<*>, TO : Enum<*>> URLClassLoader.loadEnumMappieClass(name: String) =
+    loadClass(name).kotlin as KClass<EnumMappie<FROM, TO>>