simplify validation harness by extracting union types

Replicates graphql/graphql-js@2490f44

Author: Cito

tests/validation/harness.py

@@ -15,20 +15,16 @@
 
 test_schema = build_schema(
     """
-    interface Being {
-      name(surname: Boolean): String
-    }
-
-    interface Mammal {
+   interface Mammal {
       mother: Mammal
       father: Mammal
     }
 
-    interface Pet implements Being {
+    interface Pet {
       name(surname: Boolean): String
     }
 
-    interface Canine implements Mammal & Being {
+    interface Canine implements Mammal {
       name(surname: Boolean): String
       mother: Canine
       father: Canine
@@ -40,7 +36,7 @@
       DOWN
     }
 
-    type Dog implements Being & Pet & Mammal & Canine {
+    type Dog implements Pet & Mammal & Canine {
       name(surname: Boolean): String
       nickname: String
       barkVolume: Int
@@ -52,7 +48,7 @@
       father: Dog
     }
 
-    type Cat implements Being & Pet {
+    type Cat implements Pet {
       name(surname: Boolean): String
       nickname: String
       meows: Boolean
@@ -62,27 +58,12 @@
 
     union CatOrDog = Cat | Dog
 
-    interface Intelligent {
-      iq: Int
-    }
-
-    type Human implements Being & Intelligent {
+    type Human {
       name(surname: Boolean): String
       pets: [Pet]
       relatives: [Human]
-      iq: Int
     }
 
-    type Alien implements Being & Intelligent {
-      name(surname: Boolean): String
-      numEyes: Int
-      iq: Int
-    }
-
-    union DogOrHuman = Dog | Human
-
-    union HumanOrAlien = Human | Alien
-
     enum FurColor {
       BROWN
       BLACK
@@ -123,13 +104,10 @@
 
     type QueryRoot {
       human(id: ID): Human
-      alien: Alien
       dog: Dog
       cat: Cat
       pet: Pet
       catOrDog: CatOrDog
-      dogOrHuman: DogOrHuman
-      humanOrAlien: HumanOrAlien
       complicatedArgs: ComplicatedArgs
     }
 

tests/validation/test_fields_on_correct_type.py

@@ -7,7 +7,41 @@
 
 from .harness import assert_validation_errors
 
-assert_errors = partial(assert_validation_errors, FieldsOnCorrectTypeRule)
+test_schema = build_schema(
+    """
+    interface Pet {
+      name: String
+    }
+
+    type Dog implements Pet {
+      name: String
+      nickname: String
+      barkVolume: Int
+    }
+
+    type Cat implements Pet {
+      name: String
+      nickname: String
+      meowVolume: Int
+    }
+
+    union CatOrDog = Cat | Dog
+
+    type Human {
+      name: String
+      pets: [Pet]
+    }
+
+    type Query {
+      human: Human
+    }
+    """
+)
+
+
+assert_errors = partial(
+    assert_validation_errors, FieldsOnCorrectTypeRule, schema=test_schema
+)
 
 assert_valid = partial(assert_errors, errors=[])
 
@@ -259,7 +293,7 @@ def defined_on_implementors_queried_on_union():
                 {
                     "message": "Cannot query field 'name' on type 'CatOrDog'."
                     " Did you mean to use an inline fragment"
-                    " on 'Being', 'Pet', 'Canine', 'Cat', or 'Dog'?",
+                    " on 'Pet', 'Cat', or 'Dog'?",
                     "locations": [(3, 15)],
                 },
             ],
@@ -355,7 +389,7 @@ def only_shows_one_set_of_suggestions_at_a_time_preferring_types():
         )
 
     def sort_type_suggestions_based_on_inheritance_order():
-        schema = build_schema(
+        interface_schema = build_schema(
             """
             interface T { bar: String }
             type Query { t: T }
@@ -377,11 +411,33 @@ def sort_type_suggestions_based_on_inheritance_order():
             """
         )
 
-        assert _error_message(schema, "{ t { foo } }") == (
+        assert _error_message(interface_schema, "{ t { foo } }") == (
             "Cannot query field 'foo' on type 'T'."
             " Did you mean to use an inline fragment on 'Z', 'Y', or 'X'?"
         )
 
+        union_schema = build_schema(
+            """
+            interface Animal { name: String }
+            interface Mammal implements Animal { name: String }
+
+            interface Canine implements Animal & Mammal { name: String }
+            type Dog implements Animal & Mammal & Canine { name: String }
+
+            interface Feline implements Animal & Mammal { name: String }
+            type Cat implements Animal & Mammal & Feline { name: String }
+
+            union CatOrDog = Cat | Dog
+            type Query { catOrDog: CatOrDog }
+            """
+        )
+
+        assert _error_message(union_schema, "{ catOrDog { name } }") == (
+            "Cannot query field 'name' on type 'CatOrDog'."
+            " Did you mean to use an inline fragment"
+            " on 'Animal', 'Mammal', 'Canine', 'Dog', or 'Feline'?"
+        )
+
     def limits_lots_of_type_suggestions():
         schema = build_schema(
             """

tests/validation/test_possible_fragment_spreads.py

@@ -1,10 +1,63 @@
 from functools import partial
 
+from graphql.utilities import build_schema
 from graphql.validation import PossibleFragmentSpreadsRule
 
 from .harness import assert_validation_errors
 
-assert_errors = partial(assert_validation_errors, PossibleFragmentSpreadsRule)
+test_schema = build_schema(
+    """
+    interface Being {
+      name: String
+    }
+
+    interface Pet implements Being {
+      name: String
+    }
+
+    type Dog implements Being & Pet {
+      name: String
+      barkVolume: Int
+    }
+
+    type Cat implements Being & Pet {
+      name: String
+      meowVolume: Int
+    }
+
+    union CatOrDog = Cat | Dog
+
+    interface Intelligent {
+      iq: Int
+    }
+
+    type Human implements Being & Intelligent {
+      name: String
+      pets: [Pet]
+      iq: Int
+    }
+
+    type Alien implements Being & Intelligent {
+      name: String
+      iq: Int
+    }
+
+    union DogOrHuman = Dog | Human
+
+    union HumanOrAlien = Human | Alien
+
+    type Query {
+      catOrDog: CatOrDog
+      dogOrHuman: DogOrHuman
+      humanOrAlien: HumanOrAlien
+    }
+    """
+)
+
+
+assert_errors = partial(
+    assert_validation_errors, PossibleFragmentSpreadsRule, schema=test_schema
+)
 
 assert_valid = partial(assert_errors, errors=[])
 

tests/validation/test_validation.py

@@ -49,12 +49,14 @@ def validates_queries():
         doc = parse(
             """
             query {
-              catOrDog {
-                ... on Cat {
-                  furColor
-                }
-                ... on Dog {
-                  isHouseTrained
+              human {
+                pets {
+                  ... on Cat {
+                    meowsVolume
+                  }
+                  ... on Dog {
+                    barkVolume
+                  }
                 }
               }
             }
@@ -85,12 +87,14 @@ def deprecated_validates_using_a_custom_type_info():
         doc = parse(
             """
             query {
-              catOrDog {
-                ... on Cat {
-                  furColor
-                }
-                ... on Dog {
-                  isHouseTrained
+              human {
+                pets {
+                  ... on Cat {
+                    meowsVolume
+                  }
+                  ... on Dog {
+                    barkVolume
+                  }
                 }
               }
             }
@@ -100,11 +104,11 @@ def deprecated_validates_using_a_custom_type_info():
         errors = validate(test_schema, doc, None, None, type_info)
 
         assert [error.message for error in errors] == [
-            "Cannot query field 'catOrDog' on type 'QueryRoot'."
-            " Did you mean 'catOrDog'?",
-            "Cannot query field 'furColor' on type 'Cat'. Did you mean 'furColor'?",
-            "Cannot query field 'isHouseTrained' on type 'Dog'."
-            " Did you mean 'isHouseTrained'?",
+            "Cannot query field 'human' on type 'QueryRoot'. Did you mean 'human'?",
+            "Cannot query field 'meowsVolume' on type 'Cat'."
+            " Did you mean 'meowsVolume'?",
+            "Cannot query field 'barkVolume' on type 'Dog'."
+            " Did you mean 'barkVolume'?",
         ]
 
     def validates_using_a_custom_rule():