add test for SchemaValidator

andimarek · andimarek · commit 08882b074047 · 2017-05-14T12:30:28.000+02:00
diff --git a/src/main/java/graphql/schema/validation/SchemaValidator.java b/src/main/java/graphql/schema/validation/SchemaValidator.java
@@ -1,5 +1,6 @@
 package graphql.schema.validation;
 
+import graphql.Internal;
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLFieldsContainer;
 import graphql.schema.GraphQLOutputType;
@@ -11,22 +12,30 @@
 import java.util.List;
 import java.util.Set;
 
+@Internal
 public class SchemaValidator {
 
     private final Set<GraphQLOutputType> processed = new HashSet<>();
 
-    public Set<SchemaValidationError> validateSchema(GraphQLSchema schema) {
-        SchemaValidationErrorCollector validationErrorCollector = new SchemaValidationErrorCollector();
-        List<SchemaValidationRule> rules = new ArrayList<>();
+    private List<SchemaValidationRule> rules = new ArrayList<>();
+
+    public SchemaValidator() {
         rules.add(new NoUnbrokenInputCycles());
         rules.add(new ObjectsImplementInterfaces());
+    }
 
-        List<GraphQLType> types = schema.getAllTypesAsList();
-        types.forEach(type -> {
-            for (SchemaValidationRule rule : rules) {
-                rule.check(type, validationErrorCollector);
-            }
-        });
+    SchemaValidator(List<SchemaValidationRule> rules) {
+        this.rules = rules;
+    }
+
+    public List<SchemaValidationRule> getRules() {
+        return rules;
+    }
+
+    public Set<SchemaValidationError> validateSchema(GraphQLSchema schema) {
+        SchemaValidationErrorCollector validationErrorCollector = new SchemaValidationErrorCollector();
+
+        checkTypes(schema, validationErrorCollector);
 
         traverse(schema.getQueryType(), rules, validationErrorCollector);
         if (schema.isSupportingMutations()) {
@@ -38,6 +47,15 @@ public Set<SchemaValidationError> validateSchema(GraphQLSchema schema) {
         return validationErrorCollector.getErrors();
     }
 
+    private void checkTypes(GraphQLSchema schema, SchemaValidationErrorCollector validationErrorCollector) {
+        List<GraphQLType> types = schema.getAllTypesAsList();
+        types.forEach(type -> {
+            for (SchemaValidationRule rule : rules) {
+                rule.check(type, validationErrorCollector);
+            }
+        });
+    }
+
     private void traverse(GraphQLOutputType root, List<SchemaValidationRule> rules, SchemaValidationErrorCollector validationErrorCollector) {
         if (processed.contains(root)) {
             return;
diff --git a/src/test/groovy/graphql/schema/validation/SchemaValidatorTest.groovy b/src/test/groovy/graphql/schema/validation/SchemaValidatorTest.groovy
@@ -0,0 +1,109 @@
+package graphql.schema.validation
+
+import graphql.Scalars
+import graphql.schema.GraphQLFieldDefinition
+import graphql.schema.GraphQLObjectType
+import graphql.schema.GraphQLSchema
+import spock.lang.Specification
+
+class SchemaValidatorTest extends Specification {
+
+
+    def "check used rules"() {
+        when:
+        def validator = new SchemaValidator()
+        def rules = validator.rules
+        then:
+        rules.size() == 2
+        rules[0] instanceof NoUnbrokenInputCycles
+        rules[1] instanceof ObjectsImplementInterfaces
+    }
+
+    def "rules are used"() {
+        def queryType = GraphQLObjectType.newObject()
+                .name("query")
+                .build()
+        def schema = GraphQLSchema.newSchema()
+                .query(queryType)
+                .build()
+        def dummyRule = Mock(SchemaValidationRule)
+        when:
+        def validator = new SchemaValidator([dummyRule])
+        validator.validateSchema(schema);
+
+        then:
+        1 * dummyRule.check(queryType, _ as SchemaValidationErrorCollector)
+    }
+
+    def "query fields are checked"() {
+        def field = GraphQLFieldDefinition.newFieldDefinition()
+                .name("field")
+                .type(Scalars.GraphQLString)
+                .build()
+        def queryType = GraphQLObjectType.newObject()
+                .name("query")
+                .field(field)
+                .build()
+        def schema = GraphQLSchema.newSchema()
+                .query(queryType)
+                .build()
+        def dummyRule = Mock(SchemaValidationRule)
+        when:
+        def validator = new SchemaValidator([dummyRule])
+        validator.validateSchema(schema);
+
+        then:
+        1 * dummyRule.check(field, _ as SchemaValidationErrorCollector)
+    }
+
+    def "mutation fields are checked"() {
+        def dummyRule = Mock(SchemaValidationRule)
+        def field = GraphQLFieldDefinition.newFieldDefinition()
+                .name("field")
+                .type(Scalars.GraphQLString)
+                .build()
+        def mutation = GraphQLObjectType.newObject()
+                .name("mutation")
+                .field(field)
+                .build()
+        def queryType = GraphQLObjectType.newObject()
+                .name("query")
+                .build()
+        def schema = GraphQLSchema.newSchema()
+                .query(queryType)
+                .mutation(mutation)
+                .build()
+        when:
+        def validator = new SchemaValidator([dummyRule])
+        validator.validateSchema(schema);
+
+        then:
+        1 * dummyRule.check(field, _ as SchemaValidationErrorCollector)
+    }
+
+    def "subscription fields are checked"() {
+        def dummyRule = Mock(SchemaValidationRule)
+        def field = GraphQLFieldDefinition.newFieldDefinition()
+                .name("field")
+                .type(Scalars.GraphQLString)
+                .build()
+        def mutation = GraphQLObjectType.newObject()
+                .name("subscription")
+                .field(field)
+                .build()
+        def queryType = GraphQLObjectType.newObject()
+                .name("query")
+                .build()
+        def schema = GraphQLSchema.newSchema()
+                .query(queryType)
+                .subscription(mutation)
+                .build()
+        when:
+        def validator = new SchemaValidator([dummyRule])
+        validator.validateSchema(schema);
+
+        then:
+        1 * dummyRule.check(field, _ as SchemaValidationErrorCollector)
+    }
+
+}
