Hactoberfest2023 : Multiple Directive Coexist validation

Author: vkarthikeya

src/main/java/com/intuit/graphql/orchestrator/authorization/ValidateMultipleDirectivesCoexist.java

@@ -10,21 +10,24 @@
 
 public class ValidateMultipleDirectivesCoexist {
 
+        public ValidateMultipleDirectivesCoexist() {
+        }
+
         public void validate(List<Directive> directives) {
             List<String> directiveNames = directives.stream()
                     .map(d -> d.getDefinition().getName())
                     .collect(Collectors.toList());
 
             if (CollectionUtils.containsAll(directiveNames, Arrays.asList("resolver", "external"))) {
-                throw new InvalidDirectivePairingException("resolver", "external");
+                throw new InvalidDirectivePairingException(Arrays.asList("resolver", "external"));
             }
 
             if (CollectionUtils.containsAll(directiveNames, Arrays.asList("resolver", "provides"))) {
-                throw new InvalidDirectivePairingException("resolver", "provides");
+                throw new InvalidDirectivePairingException(Arrays.asList("resolver", "external"));
             }
 
             if (CollectionUtils.containsAll(directiveNames, Arrays.asList("resolver", "requires"))) {
-                throw new InvalidDirectivePairingException("resolver", "requires");
+                throw new InvalidDirectivePairingException(Arrays.asList("resolver", "external"));
             }
 
         }

src/main/java/com/intuit/graphql/orchestrator/stitching/InvalidDirectivePairingException.java

@@ -1,12 +1,14 @@
 package com.intuit.graphql.orchestrator.stitching;
 
 
+import java.util.List;
+
 public class InvalidDirectivePairingException extends StitchingException {
 
   private static final String ERR_MSG = "Field %s in container type %s with resolver directive not allowed "
       + "to have argument definitions.";
 
-  public InvalidDirectivePairingException(String fieldName, String containerName) {
-    super(String.format(ERR_MSG, fieldName, containerName));
+  public InvalidDirectivePairingException(List<String> directiveNames) {
+    super(String.format(ERR_MSG, directiveNames.get(0), directiveNames.get(1)));
   }
 }

src/test/groovy/com/intuit/graphql/orchestrator/authorization/ValidateMultipleDirectiveCoexistSpec.groovy

@@ -0,0 +1,99 @@
+package com.intuit.graphql.orchestrator.authorization
+
+import com.intuit.graphql.orchestrator.stitching.InvalidDirectivePairingException
+import spock.lang.Specification;
+import com.intuit.graphql.graphQL.Directive
+
+import com.intuit.graphql.graphQL.DirectiveDefinition
+import static com.intuit.graphql.orchestrator.XtextObjectCreationUtil.buildDirective
+import static com.intuit.graphql.orchestrator.XtextObjectCreationUtil.buildDirectiveDefinition;
+
+class ValidateMultipleDirectiveCoexistSpec extends Specification {
+    private Directive resolverDirective
+
+    private Directive providesDirective
+
+    private Directive externalDirective
+
+    private Directive requiresDirective
+
+    private Directive skipDirective
+
+    private Directive includesDirective
+
+
+
+    def setup() {
+        DirectiveDefinition resolverDirectiveDefinition = buildDirectiveDefinition("resolver")
+        DirectiveDefinition externalDirectiveDefinition = buildDirectiveDefinition("external")
+        DirectiveDefinition requiresDirectiveDefinition = buildDirectiveDefinition("requires")
+        DirectiveDefinition providesDirectiveDefinition = buildDirectiveDefinition("provides")
+        DirectiveDefinition skipDirectiveDefinition = buildDirectiveDefinition("skip")
+        DirectiveDefinition includesDirectiveDefinition = buildDirectiveDefinition("include")
+        resolverDirective = buildDirective(resolverDirectiveDefinition, Collections.emptyList())
+        providesDirective = buildDirective(providesDirectiveDefinition, Collections.emptyList())
+        externalDirective = buildDirective(externalDirectiveDefinition, Collections.emptyList())
+        requiresDirective = buildDirective(requiresDirectiveDefinition, Collections.emptyList())
+        skipDirective = buildDirective(skipDirectiveDefinition, Collections.emptyList())
+        includesDirective = buildDirective(includesDirectiveDefinition, Collections.emptyList())
+    }
+
+    def "should throw exception for invalid directive pairing: resolver and external"() {
+        given:
+        def directives = [
+                resolverDirective,
+                externalDirective
+        ]
+
+        when:
+        new ValidateMultipleDirectivesCoexist().validate(directives)
+
+        then:
+        thrown InvalidDirectivePairingException.class
+    }
+
+    def "should throw exception for invalid directive pairing: resolver and provides"() {
+        given:
+        def directives = [
+                resolverDirective,
+                providesDirective
+        ]
+
+        when:
+        new ValidateMultipleDirectivesCoexist().validate(directives)
+
+        then:
+        thrown InvalidDirectivePairingException.class
+    }
+
+    def "should throw exception for invalid directive pairing: resolver and requires"() {
+        given:
+        def directives = [
+                resolverDirective,
+                requiresDirective
+        ]
+
+        when:
+        new ValidateMultipleDirectivesCoexist().validate(directives)
+
+        then:
+        thrown InvalidDirectivePairingException.class
+    }
+
+    def "should not throw exception for valid directives"() {
+        given:
+        def directives = [
+                requiresDirective,
+                skipDirective,
+                includesDirective
+        ]
+
+        when:
+        new ValidateMultipleDirectivesCoexist().validate(directives)
+
+        then:
+        noExceptionThrown()
+    }
+}
+
+