graphql 0.18.15 → 0.19.0

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -1,15 +1,17 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsWillMerge do
+  include StaticValidationHelpers
+
   let(:query_string) {"
-    query getCheese($sourceVar: DairyAnimal!) {
+    query getCheese($sourceVar: [DairyAnimal!] = [YAK]) {
       cheese(id: 1) {
         id,
-        nickname: name,
+        nickname: flavor,
         nickname: fatContent,
         fatContent
         differentLevel: fatContent
-        similarCheese(source: $sourceVar)
+        similarCheese(source: $sourceVar) { __typename }
 
         similarCow: similarCheese(source: COW) {
           similarCowSource: source,
@@ -17,27 +19,22 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
         }
         ...cheeseFields
         ... on Cheese {
-          fatContent: name
-          similarCheese(source: SHEEP)
+          fatContent: flavor
+          similarCheese(source: SHEEP) { __typename }
         }
       }
     }
     fragment cheeseFields on Cheese {
       fatContent,
       similarCow: similarCheese(source: COW) { similarCowSource: id, id }
-      id @someFlag
+      id @skip(if: true)
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsWillMerge]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-  let(:error_messages) { errors.map { |e| e["message" ] }}
-
   it "finds field naming conflicts" do
     expected_errors = [
-      "Field 'nickname' has a field conflict: name or fatContent?",             # alias conflict in query
-      "Field 'fatContent' has a field conflict: fatContent or name?",           # alias/name conflict in query and fragment
+      "Field 'nickname' has a field conflict: flavor or fatContent?",             # alias conflict in query
+      "Field 'fatContent' has a field conflict: fatContent or flavor?",           # alias/name conflict in query and fragment
       "Field 'similarCheese' has an argument conflict: {\"source\":\"sourceVar\"} or {\"source\":\"SHEEP\"}?", # different arguments
       "Field 'similarCowSource' has a field conflict: source or id?",           # nested conflict
     ]

data/spec/graphql/static_validation/rules/fragment_spreads_are_possible_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
@@ -9,7 +11,7 @@ describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
         ... on Milk { fatContent }
         ... on AnimalProduct { source }
         ... on DairyProduct {
-          fatContent
+          ... on Cheese { fatContent }
           ... on Edible { fatContent }
         }
       }
@@ -22,10 +24,6 @@ describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
     }
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentSpreadsArePossible]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "doesnt allow spreads where they'll never apply" do
     # TODO: more negative, abstract examples here, add stuff to the schema
     expected = [

data/spec/graphql/static_validation/rules/fragment_types_exist_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentTypesExist do
+  include StaticValidationHelpers
+
   let(:query_string) {"
     query getCheese {
       cheese(id: 1) {
@@ -19,10 +21,6 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentTypesExist]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds non-existent types on fragments" do
     assert_equal(2, errors.length)
     inline_fragment_error =  {

data/spec/graphql/static_validation/rules/fragments_are_finite_spec.rb

@@ -1,12 +1,14 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentsAreFinite do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
         ... idField
         ... sourceField
-        similarCheese {
+        similarCheese(source: SHEEP) {
           ... flavorField
         }
       }
@@ -19,7 +21,7 @@ describe GraphQL::StaticValidation::FragmentsAreFinite do
     }
     fragment flavorField on Cheese {
       flavor,
-      similarCheese {
+      similarCheese(source: SHEEP) {
         ... on Cheese {
           ... sourceField
         }
@@ -30,10 +32,6 @@ describe GraphQL::StaticValidation::FragmentsAreFinite do
     }
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreFinite]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "doesnt allow infinite loops" do
     expected = [
       {

data/spec/graphql/static_validation/rules/fragments_are_named_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentTypesExist do
+  include StaticValidationHelpers
+
   let(:query_string) {"
     fragment on Cheese {
       id
@@ -8,10 +10,6 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreNamed]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds non-existent types on fragments" do
     assert_equal(1, errors.length)
     fragment_def_error = {

data/spec/graphql/static_validation/rules/fragments_are_on_composite_types_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     query getCheese {
       cheese(id: 1) {
@@ -12,7 +14,9 @@ describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
         }
         ... intFields
         ... on DairyProduct {
-          name
+          ... on Cheese {
+            flavor
+          }
         }
         ... on DairyProductInput {
           something
@@ -25,10 +29,6 @@ describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
     }
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreOnCompositeTypes]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "requires Object/Union/Interface fragment types" do
     expected = [
       {
@@ -38,12 +38,12 @@ describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
       },
       {
         "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>14, "column"=>9}],
+        "locations"=>[{"line"=>16, "column"=>9}],
         "fields"=>["query getCheese", "cheese", "... on DairyProductInput"],
       },
       {
         "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>20, "column"=>5}],
+        "locations"=>[{"line"=>22, "column"=>5}],
         "fields"=>["fragment intFields"],
       },
     ]

data/spec/graphql/static_validation/rules/fragments_are_used_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FragmentsAreUsed do
+  include StaticValidationHelpers
   let(:query_string) {"
     query getCheese {
       name,
@@ -11,10 +12,6 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     fragment unusedFields on Cheese { is, not, used }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreUsed]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "adds errors for unused fragment definitions" do
     assert_includes(errors, {
       "message"=>"Fragment unusedFields was defined, but not used",

data/spec/graphql/static_validation/rules/mutation_root_exists_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::MutationRootExists do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     mutation addBagel {
       introduceShip(input: {shipName: "Bagel"}) {
@@ -23,10 +25,6 @@ describe GraphQL::StaticValidation::MutationRootExists do
     end
   }
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: schema, rules: [GraphQL::StaticValidation::MutationRootExists]) }
-  let(:query) { GraphQL::Query.new(schema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "errors when a mutation is performed on a schema without a mutation root" do
     assert_equal(1, errors.length)
     missing_mutation_root_error = {

data/spec/graphql/static_validation/rules/required_arguments_are_present_spec.rb

@@ -1,23 +1,20 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
+  include StaticValidationHelpers
   let(:query_string) {"
     query getCheese {
-      cheese(id: 1) { source }
+      okCheese: cheese(id: 1) { ...cheeseFields }
       cheese { source }
     }
 
     fragment cheeseFields on Cheese {
-      similarCheese(id: 1)
+      similarCheese() { __typename }
       flavor @include(if: true)
       id @skip
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::RequiredArgumentsArePresent]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds undefined arguments to fields and directives" do
     assert_equal(3, errors.length)
 

data/spec/graphql/static_validation/rules/subscription_root_exists_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::SubscriptionRootExists do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     subscription {
       test
@@ -18,10 +20,6 @@ describe GraphQL::StaticValidation::SubscriptionRootExists do
     end
   }
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: schema, rules: [GraphQL::StaticValidation::SubscriptionRootExists]) }
-  let(:query) { GraphQL::Query.new(schema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "errors when a subscription is performed on a schema without a subscription root" do
     assert_equal(1, errors.length)
     missing_subscription_root_error = {

data/spec/graphql/static_validation/rules/variable_default_values_are_correctly_typed_spec.rb

@@ -1,45 +1,43 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     query getCheese(
       $id:        Int = 1,
       $int:       Int = 3.4e24, # can be coerced
       $str:       String!,
-      $badFloat:  Float = true,
       $badInt:    Int = "abc",
       $input:     DairyProductInput = {source: YAK, fatContent: 1},
       $badInput:  DairyProductInput = {source: YAK, fatContent: true},
       $nonNull:  Int! = 1,
     ) {
-      cheese(id: $id) { source }
+      cheese1: cheese(id: $id) { source }
+      cheese4: cheese(id: $int) { source }
+      cheese2: cheese(id: $badInt) { source }
+      cheese3: cheese(id: $nonNull) { source }
+      search1: searchDairy(product: [$input]) { __typename }
+      search2: searchDairy(product: [$badInput]) { __typename }
+      __type(name: $str) { name }
     }
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds default values that don't match their types" do
     expected = [
-      {
-        "message"=>"Default value for $badFloat doesn't match type Float",
-        "locations"=>[{"line"=>6, "column"=>7}],
-        "fields"=>["query getCheese"],
-      },
       {
         "message"=>"Default value for $badInt doesn't match type Int",
-        "locations"=>[{"line"=>7, "column"=>7}],
+        "locations"=>[{"line"=>6, "column"=>7}],
         "fields"=>["query getCheese"],
       },
       {
         "message"=>"Default value for $badInput doesn't match type DairyProductInput",
-        "locations"=>[{"line"=>9, "column"=>7}],
+        "locations"=>[{"line"=>8, "column"=>7}],
         "fields"=>["query getCheese"],
       },
       {
         "message"=>"Non-null variable $nonNull can't have a default value",
-        "locations"=>[{"line"=>10, "column"=>7}],
+        "locations"=>[{"line"=>9, "column"=>7}],
         "fields"=>["query getCheese"],
       }
     ]

data/spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
+  include StaticValidationHelpers
+
   let(:query_string) {'
     query getCheese(
         $goodInt: Int = 1,
@@ -17,11 +19,11 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
       badCheese:    cheese(id: $badInt)   { source }
       badStrCheese: cheese(id: $badStr)   { source }
       cheese(id: 1) {
-        similarCheese(source: $goodAnimals)
-        other: similarCheese(source: $badAnimals)
-        tooDeep: similarCheese(source: $deepAnimals)
-        nullableCheese(source: $goodAnimals)
-        deeplyNullableCheese(source: $deepAnimals)
+        similarCheese(source: $goodAnimals) { source }
+        other: similarCheese(source: $badAnimals) { source }
+        tooDeep: similarCheese(source: $deepAnimals) { source }
+        nullableCheese(source: $goodAnimals) { source }
+        deeplyNullableCheese(source: $deepAnimals) { source }
       }
 
       milk(id: 1) {
@@ -34,10 +36,6 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
     }
   '}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableUsagesAreAllowed]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds variables used as arguments but don't match the argument's type" do
     assert_equal(4, errors.length)
     expected = [

data/spec/graphql/static_validation/rules/variables_are_input_types_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::VariablesAreInputTypes do
+  include StaticValidationHelpers
+
   let(:query_string) {'
     query getCheese(
       $id:        Int = 1,
@@ -10,31 +12,27 @@ describe GraphQL::StaticValidation::VariablesAreInputTypes do
       $objects:   [Cheese]!,
     ) {
       cheese(id: $id) { source }
+      __type(name: $str) { name }
     }
   '}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariablesAreInputTypes]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds variables whose types are invalid" do
-    expected = [
-      {
-        "message"=>"AnimalProduct isn't a valid input type (on $interface)",
-        "locations"=>[{"line"=>5, "column"=>7}],
-        "fields"=>["query getCheese"],
-      },
-      {
-        "message"=>"Milk isn't a valid input type (on $object)",
-        "locations"=>[{"line"=>6, "column"=>7}],
-        "fields"=>["query getCheese"],
-      },
-      {
-        "message"=>"Cheese isn't a valid input type (on $objects)",
-        "locations"=>[{"line"=>7, "column"=>7}],
-        "fields"=>["query getCheese"],
-      }
-    ]
-    assert_equal(expected, errors)
+    assert_includes(errors, {
+      "message"=>"AnimalProduct isn't a valid input type (on $interface)",
+      "locations"=>[{"line"=>5, "column"=>7}],
+      "fields"=>["query getCheese"],
+    })
+
+    assert_includes(errors, {
+      "message"=>"Milk isn't a valid input type (on $object)",
+      "locations"=>[{"line"=>6, "column"=>7}],
+      "fields"=>["query getCheese"],
+    })
+
+    assert_includes(errors, {
+      "message"=>"Cheese isn't a valid input type (on $objects)",
+      "locations"=>[{"line"=>7, "column"=>7}],
+      "fields"=>["query getCheese"],
+    })
   end
 end

data/spec/graphql/static_validation/rules/variables_are_used_and_defined_spec.rb

@@ -1,38 +1,41 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
+  include StaticValidationHelpers
+
   let(:query_string) {'
     query getCheese(
-      $usedVar: Int,
-      $usedInnerVar: String,
-      $usedInlineFragmentVar: Boolean,
-      $usedFragmentVar: Int,
-      $notUsedVar: Float,
+      $usedVar: Int!,
+      $usedInnerVar: [DairyAnimal!]!,
+      $usedInlineFragmentVar: Int!,
+      $usedFragmentVar: Int!,
+      $notUsedVar: Int!,
     ) {
-      cheese(id: $usedVar) {
-        source(str: $usedInnerVar)
-        whatever(undefined: $undefinedVar)
-        ... on Cheese {
-          something(bool: $usedInlineFragmentVar)
+      c1: cheese(id: $usedVar) {
+        __typename
+      }
+      ... on Query {
+        c2: cheese(id: $usedInlineFragmentVar) {
+          similarCheese(source: $usedInnerVar) { __typename }
         }
-        ... outerCheeseFields
+
       }
+
+      c3: cheese(id: $undefinedVar) { __typename }
+
+      ... outerCheeseFields
     }
 
-    fragment outerCheeseFields on Cheese {
+    fragment outerCheeseFields on Query {
       ... innerCheeseFields
     }
 
-    fragment innerCheeseFields on Cheese {
-      source(notDefined: $undefinedFragmentVar)
-      someField(someArg: $usedFragmentVar)
+    fragment innerCheeseFields on Query {
+      c4: cheese(id: $undefinedFragmentVar) { __typename }
+      c5: cheese(id: $usedFragmentVar) { __typename }
     }
   '}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariablesAreUsedAndDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds variables which are used-but-not-defined or defined-but-not-used" do
     expected = [
       {
@@ -42,15 +45,16 @@ describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
       },
       {
         "message"=>"Variable $undefinedVar is used by getCheese but not declared",
-        "locations"=>[{"line"=>11, "column"=>29}],
-        "fields"=>["query getCheese", "cheese", "whatever", "undefined"],
+        "locations"=>[{"line"=>19, "column"=>22}],
+        "fields"=>["query getCheese", "c3", "id"],
       },
       {
         "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
-        "locations"=>[{"line"=>24, "column"=>26}],
-        "fields"=>["fragment innerCheeseFields", "source", "notDefined"],
+        "locations"=>[{"line"=>29, "column"=>22}],
+        "fields"=>["fragment innerCheeseFields", "c4", "id"],
       },
     ]
+
     assert_equal(expected, errors)
   end
 end