fix: remove required parameter from directives and implement a few unit tests for AbstractDirective

Author: WipeAir

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/AbstractDirective.kt

@@ -9,7 +9,6 @@ import graphql.schema.GraphQLType
 
 abstract class AbstractDirective(
     override val name: String,
-    override val required: Boolean
 ) : Directive {
     /**
      * Will check if the given [directive] will match against the reference ([reference]).

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/Directive.kt

@@ -13,11 +13,6 @@ interface Directive {
      */
     val name: String
 
-    /**
-     * If the directive MUST be present on the schema.
-     */
-    val required: Boolean
-
     /**
      * The reference [GraphQLDirective], which is represented here.
      */

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/DirectiveFacade.kt

@@ -33,21 +33,12 @@ object DirectiveFacade {
 
     /**
      * Will check if the given [directive] exists on the given [schema] (using [Directive.name]).
-     * Additional it will return the [GraphQLDirective] if it available on the schema
+     * Additional it will return the [GraphQLDirective] if it's available on the schema
      *
      * @throws DirectiveValidationException If the directive is required but is not present on the [schema].
      */
     private fun getDirectiveDefinition(directive: Directive, schema: GraphQLSchema): GraphQLDirective? {
-        val schemaDirective = schema.getDirective(directive.name)
-
-        // Throw exception if the schema is required but not given on the schema.
-        if (schemaDirective == null && directive.required)
-            throw DirectiveValidationException(
-                directive,
-                "Not present on the schema, but is required. Consider adding it."
-            )
-
-        return schemaDirective
+        return schema.getDirective(directive.name)
     }
 
     /**

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/DoubleNullDirective.kt

@@ -4,7 +4,7 @@ import com.auritylab.graphql.kotlin.toolkit.common.directive.AbstractDirective
 import graphql.introspection.Introspection
 import graphql.schema.GraphQLDirective
 
-object DoubleNullDirective : AbstractDirective("kDoubleNull", false) {
+object DoubleNullDirective : AbstractDirective("kDoubleNull") {
     override val reference: GraphQLDirective =
         GraphQLDirective.newDirective()
             .name(name)

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/GenerateDirective.kt

@@ -4,7 +4,7 @@ import com.auritylab.graphql.kotlin.toolkit.common.directive.AbstractDirective
 import graphql.introspection.Introspection
 import graphql.schema.GraphQLDirective
 
-object GenerateDirective : AbstractDirective("kGenerate", false) {
+object GenerateDirective : AbstractDirective("kGenerate") {
     override val reference: GraphQLDirective =
         GraphQLDirective.newDirective()
             .name(name)

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/PaginationDirective.kt

@@ -4,7 +4,7 @@ import com.auritylab.graphql.kotlin.toolkit.common.directive.AbstractDirective
 import graphql.introspection.Introspection
 import graphql.schema.GraphQLDirective
 
-object PaginationDirective : AbstractDirective("kPagination", false) {
+object PaginationDirective : AbstractDirective("kPagination") {
     override val reference: GraphQLDirective =
         GraphQLDirective.newDirective()
             .name(name)

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/RepresentationDirective.kt

@@ -10,7 +10,7 @@ import graphql.schema.GraphQLList
 import graphql.schema.GraphQLNonNull
 
 object RepresentationDirective :
-    AbstractDirective("kRepresentation", false),
+    AbstractDirective("kRepresentation"),
     HasArgumentsDirective<RepresentationDirective.Model> {
 
     override val reference: GraphQLDirective =

graphql-kotlin-toolkit-common/src/main/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/implementation/ResolverDirective.kt

@@ -4,7 +4,7 @@ import com.auritylab.graphql.kotlin.toolkit.common.directive.AbstractDirective
 import graphql.introspection.Introspection
 import graphql.schema.GraphQLDirective
 
-object ResolverDirective : AbstractDirective("kResolver", false) {
+object ResolverDirective : AbstractDirective("kResolver") {
     override val reference: GraphQLDirective =
         GraphQLDirective.newDirective()
             .name(name)

graphql-kotlin-toolkit-common/src/test/kotlin/com/auritylab/graphql/kotlin/toolkit/common/directive/AbstractDirectiveTest.kt

@@ -1,7 +1,99 @@
 package com.auritylab.graphql.kotlin.toolkit.common.directive
 
-import org.junit.jupiter.api.Assertions.*
+import com.auritylab.graphql.kotlin.toolkit.common.directive.exception.DirectiveValidationException
+import graphql.Scalars
+import graphql.introspection.Introspection
+import graphql.schema.GraphQLArgument
+import graphql.schema.GraphQLDirective
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
 
 internal class AbstractDirectiveTest {
+    @Nested
+    inner class ValidateDefinition {
+        @Test
+        fun shouldThrowExceptionOnMissingArgument() {
+            assertThrows<DirectiveValidationException> {
+                // _directiveOne defines exactly one argument which is expected to be not available on _directiveEmpty,
+                // because it does not define any argument.
+                toInternal(_directiveOne).validateDefinition(_directiveEmpty)
+            }
+        }
 
+        @Test
+        fun shouldIgnoreTooManyArguments() {
+            assertDoesNotThrow {
+                // As a reference we have a directive with no arguments. We validate against a directive which defines
+                // exactly one argument. Because additional directives do not matter here, we just assert that it does
+                //  not throw.
+                toInternal(_directiveEmpty).validateDefinition(_directiveOne)
+            }
+        }
+
+        @Test
+        fun shouldThrowExceptionOnMissingLocation() {
+            assertThrows<DirectiveValidationException> {
+                // _directiveTwo defines one valid location which is expected to be not available on _directiveEmpty.
+                // Therefore, we assert that an exception will be thrown.
+                toInternal(_directiveTwo).validateDefinition(_directiveEmpty)
+            }
+        }
+
+        @Test
+        fun shouldIgnoreTooManyLocations() {
+            assertDoesNotThrow {
+                // As a reference we have a directive with no valid locations. We validate against a directive which
+                // defines exactly one valid location. Because additional locations do not matter here, we assert that
+                // it does not throw any exception.
+                toInternal(_directiveEmpty).validateDefinition(_directiveTwo)
+            }
+        }
+
+        @Test
+        fun shouldThrowExceptionOnDifferingArgumentTypes () {
+            assertThrows<DirectiveValidationException> {
+                // As a reference we have a directive with exactly one argument named 'name' of type 'String'. We try
+                // to validate against a directive which also defines exactly one argument named 'name' but with a
+                // differing type 'boolean'. Because those types differ we assert that an exception will be thrown.
+                toInternal(_directiveOne).validateDefinition(_directiveThree)
+            }
+        }
+    }
+
+    private val _directiveEmpty = GraphQLDirective.newDirective()
+        .name("DirectiveEmpty").build()
+
+    private val _directiveOne = GraphQLDirective.newDirective()
+        .name("Directive")
+        .argument(
+            GraphQLArgument.newArgument()
+                .name("name")
+                .type(Scalars.GraphQLString)
+        ).build()
+
+    private val _directiveTwo = GraphQLDirective.newDirective()
+        .name("DirectiveTwo")
+        .validLocations(Introspection.DirectiveLocation.FIELD)
+        .build()
+
+    private val _directiveThree = GraphQLDirective.newDirective()
+        .name("DirectiveThree")
+        .argument(GraphQLArgument.newArgument().name("name").type(Scalars.GraphQLBoolean))
+        .build()
+
+    /**
+     * Creates a new [AbstractDirective] based on the given input parameters. The [input] will be used
+     * as [AbstractDirective.reference]. All other parameters are optional and define default values.
+     */
+    private fun toInternal(
+        input: GraphQLDirective,
+        name: String = "Test",
+        required: Boolean = false
+    ): AbstractDirective {
+        return object : AbstractDirective(name) {
+            override val reference: GraphQLDirective = input
+        }
+    }
 }