feat: add jacoco reports with tests (#61)

Author: smyrick

pom.xml

@@ -71,7 +71,7 @@
 
     <properties>
         <reflections.version>0.9.11</reflections.version>
-        <kotlin.version>1.2.70</kotlin.version>
+        <kotlin.version>1.2.71</kotlin.version>
         <kotlin-ktlint.version>0.29.0</kotlin-ktlint.version>
         <kotlin-detekt.version>1.0.0.RC8</kotlin-detekt.version>
         <junit.version>4.12</junit.version>
@@ -179,6 +179,25 @@
                     </dependency>
                 </dependencies>
             </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.2</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>test</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

src/main/kotlin/com/expedia/graphql/schema/extensions/annotationExtensions.kt

@@ -4,15 +4,13 @@ import com.expedia.graphql.annotations.GraphQLDescription
 import com.expedia.graphql.annotations.GraphQLID
 import com.expedia.graphql.annotations.GraphQLIgnore
 import com.expedia.graphql.schema.exceptions.CouldNotGetNameOfAnnotationException
-import com.expedia.graphql.schema.generator.isNotBlackListed
 import com.expedia.graphql.schema.generator.types.defaultGraphQLScalars
 import com.google.common.base.CaseFormat
 import graphql.schema.GraphQLArgument
 import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLInputType
 import kotlin.reflect.KAnnotatedElement
 import kotlin.reflect.KClass
-import kotlin.reflect.full.declaredMemberFunctions
 import kotlin.reflect.full.findAnnotation
 import com.expedia.graphql.annotations.GraphQLDirective as DirectiveAnnotation
 
@@ -71,8 +69,6 @@ internal fun KAnnotatedElement.isGraphQLID() = this.findAnnotation<GraphQLID>()
 internal fun Annotation.getDirectiveInfo(): DirectiveAnnotation? =
     this.annotationClass.annotations.find { it is DirectiveAnnotation } as? DirectiveAnnotation
 
-internal fun KClass<out Annotation>.properties() = this.declaredMemberFunctions.filter(isNotBlackListed)
-
 internal fun KAnnotatedElement.directives() =
     this.annotations.asSequence()
         .mapNotNull { it.getDirectiveInfo() }
@@ -94,11 +90,11 @@ private fun DirectiveAnnotation.getGraphQLDirective(): GraphQLDirective {
         .validLocations(*this.locations)
         .description(this.description)
 
-    kClass.properties().forEach { prop ->
-        val propertyName = prop.name
-        val value = prop.call(kClass)
+    kClass.getValidFunctions().forEach { kFunction ->
+        val propertyName = kFunction.name
+        val value = kFunction.call(kClass)
         @Suppress("Detekt.UnsafeCast")
-        val type = defaultGraphQLScalars(prop.returnType) as GraphQLInputType
+        val type = defaultGraphQLScalars(kFunction.returnType) as GraphQLInputType
         builder.argument(GraphQLArgument.newArgument().name(propertyName).value(value).type(type).build())
     }
 

src/main/kotlin/com/expedia/graphql/schema/extensions/kClassExtensions.kt

@@ -7,12 +7,12 @@ import kotlin.reflect.KClass
 import kotlin.reflect.full.declaredMemberFunctions
 import kotlin.reflect.full.declaredMemberProperties
 
-internal fun KClass<*>.getValidProperties(hooks: SchemaGeneratorHooks) = this.declaredMemberProperties
-    .filter { hooks.isValidProperty(it) }
+internal fun KClass<*>.getValidProperties(hooks: SchemaGeneratorHooks? = null) = this.declaredMemberProperties
+    .filter { hooks?.isValidProperty(it) ?: true }
     .filter { prop -> propertyFilters.all { it.invoke(prop) } }
 
-internal fun KClass<*>.getValidFunctions(hooks: SchemaGeneratorHooks) = this.declaredMemberFunctions
-    .filter { hooks.isValidFunction(it) }
+internal fun KClass<*>.getValidFunctions(hooks: SchemaGeneratorHooks? = null) = this.declaredMemberFunctions
+    .filter { hooks?.isValidFunction(it) ?: true }
     .filter { func -> functionFilters.all { it.invoke(func) } }
 
 internal fun KClass<*>.canBeGraphQLInterface(): Boolean = this.java.isInterface

src/main/kotlin/com/expedia/graphql/schema/generator/schemaFilters.kt

@@ -7,19 +7,19 @@ import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
 import kotlin.reflect.KVisibility
 
-private val blackListFunctions: List<String> = listOf("annotationType", "toString", "copy", "equals", "hashCode")
-private val componentFunctionRegex = Regex("component([0-9]+)")
-
 private typealias CallableFilter = (KCallable<*>) -> Boolean
 private typealias AnnotatedElementFilter = (KAnnotatedElement) -> Boolean
-
-private val isPublic: CallableFilter = { it.visibility == KVisibility.PUBLIC }
-private val isNotGraphQLIgnored: AnnotatedElementFilter = { it.isGraphQLIgnored().not() }
-
 private typealias PropertyFilter = (KProperty<*>) -> Boolean
 private typealias FunctionFilter = (KFunction<*>) -> Boolean
 
-internal val isNotBlackListed: FunctionFilter = { (blackListFunctions.contains(it.name) || it.name.matches(componentFunctionRegex)).not() }
+private val blackListFunctions: List<String> = listOf("annotationType", "toString", "copy", "equals", "hashCode")
+private val componentFunctionRegex = Regex("component([0-9]+)")
+
+private val isPublic: CallableFilter = { it.visibility == KVisibility.PUBLIC }
+private val isNotGraphQLIgnored: AnnotatedElementFilter = { it.isGraphQLIgnored().not() }
+private val isBlacklistedFunction: FunctionFilter = { blackListFunctions.contains(it.name) }
+private val isComponentFunction: FunctionFilter = { it.name.matches(componentFunctionRegex) }
+private val isNotBlackListed: FunctionFilter = { (isBlacklistedFunction(it) || isComponentFunction(it)).not() }
 
 internal val propertyFilters: List<PropertyFilter> = listOf(isPublic, isNotGraphQLIgnored)
 internal val functionFilters: List<FunctionFilter> = listOf(isPublic, isNotGraphQLIgnored, isNotBlackListed)

src/test/kotlin/com/expedia/graphql/schema/extensions/KClassExtensionsTest.kt

@@ -31,7 +31,7 @@ class KClassExtensionsTest {
 
     @Test
     fun `test getting valid properties with no hooks`() {
-        val properties = MyTestClass::class.getValidProperties(NoopSchemaGeneratorHooks())
+        val properties = MyTestClass::class.getValidProperties()
         assertEquals(listOf("filteredProperty", "publicProperty"), properties.map { it.name })
     }
 
@@ -43,7 +43,7 @@ class KClassExtensionsTest {
 
     @Test
     fun `test getting valid functions with no hooks`() {
-        val properties = MyTestClass::class.getValidFunctions(NoopSchemaGeneratorHooks())
+        val properties = MyTestClass::class.getValidFunctions()
         assertEquals(listOf("filteredFunction", "publicFunction"), properties.map { it.name })
     }
 

src/test/kotlin/com/expedia/graphql/schema/generator/SchenaFiltersTest.kt

@@ -0,0 +1,58 @@
+package com.expedia.graphql.schema.generator
+
+import com.expedia.graphql.annotations.GraphQLIgnore
+import kotlin.reflect.KFunction
+import kotlin.reflect.KProperty
+import kotlin.reflect.full.declaredMemberFunctions
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class SchenaFiltersTest {
+
+    private data class MyDataClass(val id: Int = 0)
+
+    private class MyClass {
+
+        val publicProperty: Int = 0
+
+        internal val nonPublicProperty: Int = 0
+
+        @GraphQLIgnore
+        internal val ignoredProperty: Int = 0
+
+        fun publicFunction() = privateFunction()
+
+        @GraphQLIgnore
+        fun ignoredFunction() = privateFunction()
+
+        internal fun privateFunction() = nonPublicProperty
+    }
+
+    @Test
+    fun `test function filters`() {
+        assertTrue(testFunction(MyClass::publicFunction))
+        assertFalse(testFunction(MyClass::ignoredFunction))
+        assertFalse(testFunction(MyClass::privateFunction))
+    }
+
+    @Test
+    fun `test generated function filters`() {
+        val functions = MyDataClass::class.declaredMemberFunctions
+        val size = functions.filter { func -> functionFilters.all { it(func) } }.size
+        assertEquals(expected = 0, actual = size)
+    }
+
+    @Test
+    fun `test property filters`() {
+        assertTrue(testProperty(MyClass::publicProperty))
+        assertFalse(testProperty(MyClass::nonPublicProperty))
+        assertFalse(testProperty(MyClass::ignoredProperty))
+        assertTrue(testProperty(MyDataClass::id))
+    }
+
+    private fun testFunction(function: KFunction<*>): Boolean = functionFilters.all { it(function) }
+
+    private fun testProperty(property: KProperty<*>): Boolean = propertyFilters.all { it(property) }
+}

src/test/kotlin/com/expedia/graphql/schema/generator/TypesCacheTest.kt

@@ -4,14 +4,15 @@ import com.expedia.graphql.schema.models.KGraphQLType
 import graphql.schema.GraphQLType
 import org.junit.jupiter.api.Test
 import kotlin.reflect.full.starProjectedType
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 class TypesCacheTest {
 
-    data class MyType(val id: Int = 0)
+    internal data class MyType(val id: Int = 0)
 
     private val graphQLType: GraphQLType = GraphQLType { "MyType" }
     private val secondGraphQLType: GraphQLType = GraphQLType { "MySecondType" }
@@ -26,7 +27,9 @@ class TypesCacheTest {
 
         cache.put(cacheKey, cacheValue)
 
-        assertNotNull(cache.get(cacheKey))
+        val cacheHit = cache.get(cacheKey)
+        assertNotNull(cacheHit)
+        assertEquals(expected = cacheValue.graphQLType, actual = cacheHit)
     }
 
     @Test

src/test/kotlin/com/expedia/graphql/schema/models/KGraphQLTypeTest.kt

@@ -0,0 +1,18 @@
+package com.expedia.graphql.schema.models
+
+import graphql.schema.GraphQLType
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+internal class KGraphQLTypeTest {
+
+    private data class MyType(val id: Int = 0)
+    private val graphQLType = GraphQLType { "MyType" }
+
+    @Test
+    fun `properties are set`() {
+        val kGraphQLType = KGraphQLType(MyType::class, graphQLType)
+        assertEquals(expected = MyType::class, actual = kGraphQLType.kClass)
+        assertEquals(expected = graphQLType, actual = kGraphQLType.graphQLType)
+    }
+}