test(codegen): add testes for the enum generator and refactored AbstractCompilationTest

Author: WipeAir

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/_test/AbstractCompilationTest.kt

@@ -22,7 +22,7 @@ abstract class AbstractCompilationTest(
      * Will compile the given [main] and the given [dependencies]. This function will return the runtime reflection
      * reference to the [main] class. The [dependencies] will just be added to the compilation.
      */
-    private fun internalCompile(main: FileSpec, vararg dependencies: FileSpec): KClass<*> {
+    private fun internalCompile(main: FileSpec, vararg dependencies: FileSpec): Result {
         // Generate source files for the given file specs.
         val mainSource = buildSourceFile(main, 0)
         val dependencySources = dependencies.mapIndexed() { index, dep -> buildSourceFile(dep, index + 1) }
@@ -39,7 +39,7 @@ abstract class AbstractCompilationTest(
             throw IllegalStateException("Kotlin compilation not successful!")
 
         // Load the given main class using the ClassLoader.
-        return result.classLoader.loadClass(main.packageName + "." + main.name).kotlin
+        return Result(result.classLoader.loadClass(main.packageName + "." + main.name).kotlin, result.classLoader)
     }
 
     /**
@@ -80,4 +80,9 @@ abstract class AbstractCompilationTest(
                         .build()
                 }).build()
     }
+
+    data class Result(
+        val main: KClass<*>,
+        val classLoader: ClassLoader
+    )
 }

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/_test/AbstractMockCompilationTest.kt

@@ -24,7 +24,7 @@ internal class ArgumentCodeBlockGeneratorTest : AbstractCompilationTest() {
         val resolver = generator.buildResolver("argument", Scalars.GraphQLString, null)
 
         // Wrap the resolver and compile the code.
-        val compiled = compile(getWrapperClass(resolver))
+        val compiled = compile(getWrapperClass(resolver)).main
 
         // There has to be exactly one function.
         Assertions.assertEquals(1, compiled.declaredFunctions.size)

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/codeblock/ArgumentCodeBlockGeneratorTest.kt

@@ -2,20 +2,30 @@ package com.auritylab.graphql.kotlin.toolkit.codegen.generator
 
 import com.auritylab.graphql.kotlin.toolkit.codegen._test.AbstractCompilationTest
 import com.auritylab.graphql.kotlin.toolkit.codegen._test.TestObject
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.TypeSpec
+import graphql.Scalars
+import graphql.schema.GraphQLArgument
+import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLEnumType
+import java.lang.reflect.InvocationTargetException
+import kotlin.reflect.full.companionObject
+import kotlin.reflect.full.companionObjectInstance
+import kotlin.reflect.full.declaredMemberFunctions
+import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.isSubclassOf
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 
 internal class EnumGeneratorTest : AbstractCompilationTest() {
     @Test
     @Suppress("UNCHECKED_CAST")
-    fun shouldGenerateCompilableCode() {
+    fun `should generate compilable code`() {
         val generator =
             EnumGenerator(testEnum, TestObject.options, TestObject.kotlinTypeMapper, TestObject.generatedMapper)
 
         // Compile the generator output.
-        val generatedClass = compile(generator)
+        val generatedClass = compile(generator).main
 
         // Assert that the generated class is of type enum.
         Assertions.assertTrue(generatedClass.isSubclassOf(Enum::class))
@@ -30,6 +40,71 @@ internal class EnumGeneratorTest : AbstractCompilationTest() {
             Assertions.assertEquals(definition.name, enumConstants[i].name)
         }
     }
+
+    @Test
+    fun `should build enum with representation correctly`() {
+        val generator = EnumGenerator(
+            testEnumWithRepresentation,
+            TestObject.options,
+            TestObject.kotlinTypeMapper,
+            TestObject.generatedMapper
+        )
+
+        // Compile the generator output and add the TestEnum file as dependency.
+        val compileResult = compile(generator.generate(), testEnumFileSpec)
+        val generatedClass = compileResult.main
+        val testEnumConstants = compileResult.classLoader.loadClass("graphql.TestEnum").enumConstants
+
+        // Assert that the generated class is of type enum.
+        Assertions.assertTrue(generatedClass.isSubclassOf(Enum::class))
+
+        // ... Not necessary to assert against the constants -> see test above.
+        val constants = generatedClass.java.enumConstants
+
+        // Load the "representation" property reference.
+        val representationProperty = generatedClass.declaredMemberProperties
+            .firstOrNull { it.name == "representation" }
+
+        // The property has to be present.
+        Assertions.assertNotNull(representationProperty)
+        representationProperty!!
+
+        // The second and the first constant can be mapped correctly.
+        Assertions.assertNotNull(representationProperty.call(constants[0]))
+        Assertions.assertNotNull(representationProperty.call(constants[1]))
+
+        // The 'invalid' enum value has to throw an exception.
+        Assertions.assertThrows(NoSuchElementException::class.java) {
+            try {
+                representationProperty.call(constants[2])
+            } catch (ex: InvocationTargetException) {
+                throw ex.targetException
+            }
+        }
+
+        // Load the "of" function reference.
+        val ofFunction = generatedClass.companionObject?.declaredMemberFunctions
+            ?.firstOrNull { it.name == "of" }
+
+        // The function has to be present.
+        Assertions.assertNotNull(ofFunction)
+        ofFunction!!
+
+        val companionInstance = generatedClass.companionObjectInstance!!
+
+        // The first and the second constant can be mapped correctly.
+        Assertions.assertNotNull(ofFunction.call(companionInstance, testEnumConstants[0]))
+        Assertions.assertNotNull(ofFunction.call(companionInstance, testEnumConstants[1]))
+
+        // The 'internalInvalid' enum value has to throw an exception.
+        Assertions.assertThrows(NoSuchElementException::class.java) {
+            try {
+                representationProperty.call(constants[2])
+            } catch (ex: InvocationTargetException) {
+                throw ex.targetException
+            }
+        }
+    }
 }
 
 private val testEnum = GraphQLEnumType.newEnum()
@@ -39,3 +114,30 @@ private val testEnum = GraphQLEnumType.newEnum()
     .value("third")
     .value("fourth")
     .build()
+
+private val testEnumWithRepresentation = GraphQLEnumType.newEnum()
+    .name("ETestEnum")
+    .value("first")
+    .value("second")
+    .value("invalid")
+    .withDirective(
+        GraphQLDirective.newDirective()
+            .name("kRepresentation")
+            .argument(
+                GraphQLArgument.newArgument()
+                    .type(Scalars.GraphQLString)
+                    .name("class")
+                    .value("graphql.TestEnum")
+            )
+    )
+    .build()
+
+private val testEnumFileSpec = FileSpec.builder("graphql", "TestEnum")
+    .addType(
+        TypeSpec.enumBuilder("TestEnum")
+            .addEnumConstant("first")
+            .addEnumConstant("second")
+            .addEnumConstant("internalInvalid")
+            .build()
+    )
+    .build()

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/generator/EnumGeneratorTest.kt

@@ -31,7 +31,7 @@ internal class InputObjectGeneratorTest : AbstractCompilationTest() {
     @BeforeAll
     fun compileCode() {
         // Compile the code of the generator
-        generatedClass = compile(generator)
+        generatedClass = compile(generator).main
     }
 
     @Test

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/generator/InputObjectGeneratorTest.kt

@@ -26,7 +26,7 @@ internal class ObjectTypeGeneratorTest : AbstractCompilationTest() {
     @BeforeAll
     fun compileCode() {
         // Compile the code of the generator
-        generatedClass = compile(generator)
+        generatedClass = compile(generator).main
     }
 
     @Test

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/generator/ObjectTypeGeneratorTest.kt

@@ -15,7 +15,7 @@ internal class ValueWrapperGeneratorTest : AbstractCompilationTest() {
             ValueWrapperGenerator(TestObject.options, TestObject.kotlinTypeMapper, TestObject.generatedMapper)
 
         // Compile the generated code.
-        val generatedClass = compile(generator)
+        val generatedClass = compile(generator).main
 
         // Assert against the member properties.
         val memberProperties = generatedClass.memberProperties

graphql-kotlin-toolkit-codegen/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/codegen/generator/ValueWrapperGeneratorTest.kt

@@ -45,7 +45,7 @@ internal class FieldResolverGeneratorTest : AbstractCompilationTest(true) {
         @BeforeAll
         fun compileCode() {
             // Compile the code of the generator
-            generatedClass = compile(generator)
+            generatedClass = compile(generator).main
         }
 
         @Test
@@ -142,7 +142,7 @@ internal class FieldResolverGeneratorTest : AbstractCompilationTest(true) {
         @BeforeAll
         fun compileCode() {
             // Compile the code of the generator
-            generatedClass = compile(generator)
+            generatedClass = compile(generator).main
         }
 
         @Test
@@ -194,7 +194,7 @@ internal class FieldResolverGeneratorTest : AbstractCompilationTest(true) {
         @BeforeAll
         fun compileCode() {
             // Compile the code of the generator
-            generatedClass = compile(generator)
+            generatedClass = compile(generator).main
         }
 
         @Test