graphql 0.2.0 → 0.3.0

data/spec/graph_ql/static_validation/{arguments_are_defined_spec.rb → rules/arguments_are_defined_spec.rb}

@@ -13,7 +13,7 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
   let(:errors) { validator.validate(document) }
 
   it 'finds undefined arguments to fields and directives' do

data/spec/graph_ql/static_validation/{directives_are_defined_spec.rb → rules/directives_are_defined_spec.rb}

@@ -13,7 +13,7 @@ describe GraphQL::StaticValidation::DirectivesAreDefined do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::DirectivesAreDefined]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreDefined]) }
   let(:errors) { validator.validate(document) }
 
   describe 'non-existent directives' do

data/spec/graph_ql/static_validation/{fields_are_defined_on_type_spec.rb → rules/fields_are_defined_on_type_spec.rb}

@@ -11,7 +11,7 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
     fragment cheeseFields on Cheese { fatContent, hogwashField }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
   let(:errors) { validator.validate(GraphQL.parse(query_string)) }
   let(:error_messages) { errors.map { |e| e["message" ] }}
 

data/spec/graph_ql/static_validation/{fields_have_appropriate_selections_spec.rb → rules/fields_have_appropriate_selections_spec.rb}

@@ -9,7 +9,7 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
   let(:errors) { validator.validate(document) }
 
   it 'adds errors for selections on scalars' do

data/spec/graph_ql/static_validation/{fields_will_merge_spec.rb → rules/fields_will_merge_spec.rb}

@@ -29,7 +29,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsWillMerge]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsWillMerge]) }
   let(:errors) { validator.validate(document) }
   let(:error_messages) { errors.map { |e| e["message" ] }}
 

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
+  let(:document) { GraphQL.parse(%|
+    query getCheese {
+      cheese(id: 1) {
+        ... milkFields
+        ... cheeseFields
+        ... on Milk { fatContent }
+        ... on AnimalProduct { source }
+        ... on DairyProduct {
+          fatContent
+          ... on Edible { fatContent }
+        }
+      }
+    }
+
+    fragment milkFields on Milk { fatContent }
+    fragment cheeseFields on Cheese {
+      fatContent
+      ... milkFields
+    }
+  |)}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentSpreadsArePossible]) }
+  let(:errors) { validator.validate(document) }
+
+  it "doesnt allow spreads where they'll never apply" do
+    # TODO: more negative, abstract examples here, add stuff to the schema
+    expected = [
+      {
+        "message"=>"Fragment on Milk can't be spread inside Cheese",
+        "locations"=>[{"line"=>6, "column"=>9}]
+      },
+      {
+        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
+        "locations"=>[{"line"=>4, "column"=>9}]
+      },
+      {
+        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
+        "locations"=>[{"line"=>18, "column"=>7}]
+      }
+    ]
+    assert_equal(expected, errors)
+  end
+end

data/spec/graph_ql/static_validation/{fragment_types_exist_spec.rb → rules/fragment_types_exist_spec.rb}

@@ -19,7 +19,7 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FragmentTypesExist]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentTypesExist]) }
   let(:errors) { validator.validate(document) }
 
   it 'finds non-existent types on fragments' do

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::FragmentsAreFinite do
+  let(:document) { GraphQL.parse(%|
+    query getCheese {
+      cheese(id: 1) {
+        ... idField
+        ... sourceField
+        ... flavorField
+      }
+    }
+
+    fragment sourceField on Cheese {
+      source,
+      ... flavorField
+      ... idField
+    }
+    fragment flavorField on Cheese {
+      flavor,
+      ... sourceField
+    }
+    fragment idField on Cheese {
+      id
+    }
+  |)}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreFinite]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'doesnt allow infinite loops' do
+    expected = [
+      {
+        "message"=>"Fragment sourceField contains an infinite loop",
+        "locations"=>[{"line"=>10, "column"=>5}]
+      },
+      {
+        "message"=>"Fragment flavorField contains an infinite loop",
+        "locations"=>[{"line"=>15, "column"=>5}]
+      }
+    ]
+    assert_equal(expected, errors)
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
+  let(:document) { GraphQL.parse(%|
+    query getCheese {
+      cheese(id: 1) {
+        ... on Cheese {
+          source
+          ... on Boolean {
+            something
+          }
+        }
+        ... intFields
+        ... on DairyProduct {
+          name
+        }
+        ... on DairyProductInput {
+          something
+        }
+      }
+    }
+
+    fragment intFields on Int {
+      something
+    }
+  |)}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreOnCompositeTypes]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'requires Object/Union/Interface fragment types' do
+    expected = [
+      {
+        "message"=>"Invalid fragment on type Boolean (must be Union, Interface or Object)",
+        "locations"=>[{"line"=>6, "column"=>11}]
+      },
+      {
+        "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
+        "locations"=>[{"line"=>14, "column"=>9}],
+      },
+      {
+        "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
+        "locations"=>[{"line"=>20, "column"=>5}]
+      },
+    ]
+    assert_equal(expected, errors)
+  end
+end

data/spec/graph_ql/static_validation/{fragments_are_used_spec.rb → rules/fragments_are_used_spec.rb}

@@ -11,7 +11,7 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     fragment unusedFields on Cheese { is, not, used }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FragmentsAreUsed]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreUsed]) }
   let(:errors) { validator.validate(document) }
 
   it 'adds errors for unused fragment definitions' do

data/spec/graph_ql/static_validation/{required_arguments_are_present_spec.rb → rules/required_arguments_are_present_spec.rb}

@@ -14,7 +14,7 @@ describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
     }
   ")}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::RequiredArgumentsArePresent]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::RequiredArgumentsArePresent]) }
   let(:errors) { validator.validate(document) }
 
   it 'finds undefined arguments to fields and directives' do

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
+  let(:document) { GraphQL.parse('
+    query getCheese(
+      $id:        Int = 1,
+      $bool:      Boolean = 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 }
+    }
+  ')}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped]) }
+  let(:errors) { validator.validate(document) }
+
+  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"=>8}]
+      },
+      {
+        "message"=>"Default value for $badInt doesn't match type Int",
+        "locations"=>[{"line"=>7, "column"=>8}]
+      },
+      {
+        "message"=>"Default value for $badInput doesn't match type DairyProductInput",
+        "locations"=>[{"line"=>9, "column"=>8}]
+      },
+      {
+        "message"=>"Non-null variable $nonNull can't have a default value",
+        "locations"=>[{"line"=>10, "column"=>8}]
+      }
+    ]
+    assert_equal(expected, errors)
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
+  let(:document) { GraphQL.parse('
+    query getCheese(
+        $goodInt: Int = 1,
+        $okInt: Int!,
+        $badInt: Int,
+        $badStr: String!,
+        $goodAnimals: [DairyAnimal!]!,
+        $badAnimals: [DairyAnimal]!,
+    ) {
+      goodCheese:   cheese(id: $goodInt)  { source }
+      okCheese:     cheese(id: $okInt)    { source }
+      badCheese:    cheese(id: $badInt)   { source }
+      badStrCheese: cheese(id: $badStr)   { source }
+      cheese(id: 1) {
+        similarCheeses(source: $goodAnimals)
+        other: similarCheeses(source: $badAnimals)
+      }
+    }
+  ')}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableUsagesAreAllowed]) }
+  let(:errors) { validator.validate(document) }
+
+  it "finds variables used as arguments but don't match the argument's type" do
+    assert_equal(3, errors.length)
+    expected = [
+      {
+        "message"=>"Type mismatch on variable $badInt and argument id (Int / Int!)",
+        "locations"=>[{"line"=>12, "column"=>28}]
+      },
+      {
+        "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
+        "locations"=>[{"line"=>13, "column"=>28}]
+      },
+      {
+        "message"=>"Type mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
+        "locations"=>[{"line"=>16, "column"=>31}]
+      }
+    ]
+    assert_equal(expected, errors)
+  end
+end

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

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

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
+  let(:document) { GraphQL.parse('
+    query getCheese($id: Int, $str: String, $notUsedVar: Float, $bool: Boolean) {
+      cheese(id: $id) {
+        source(str: $str)
+        whatever(undefined: $undefinedVar)
+        ... on Cheese {
+          something(bool: $bool)
+        }
+      }
+    }
+
+    fragment outerCheeseFields on Cheese {
+      ... innerCheeseFields
+    }
+
+    fragment innerCheeseFields on Cheese {
+      source(notDefined: $notDefinedVar)
+    }
+  ')}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariablesAreUsedAndDefined]) }
+  let(:errors) { validator.validate(document) }
+
+  it "finds variables which are used-but-not-defined or defined-but-not-used" do
+    expected = [
+      {
+        "message"=>"Variable $undefinedVar is used but not declared",
+        "locations"=>[{"line"=>5, "column"=>30}]
+      },
+      {
+        "message"=>"Variable $notUsedVar is declared but not used",
+        "locations"=>[{"line"=>2, "column"=>5}]
+      },
+      {
+        "message"=>"Variable $notDefinedVar is used but not declared",
+        "locations"=>[{"line"=>17, "column"=>27}]
+      },
+    ]
+    assert_equal(expected, errors)
+  end
+end

data/spec/graph_ql/static_validation/type_stack_spec.rb

@@ -18,10 +18,10 @@ describe GraphQL::StaticValidation::TypeStack do
     query getCheese {
       cheese(id: 1) { id, ... edibleFields }
     }
-    fragment edibleFields on Edible { fatContent }
+    fragment edibleFields on Edible { fatContent @skip(if: false)}
   |}
   let(:document) { GraphQL.parse(query_string) }
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [TypeCheckValidator]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [TypeCheckValidator]) }
 
   it 'stores up types' do
     validator.validate(document)

data/spec/graph_ql/static_validation/validator_spec.rb

@@ -14,15 +14,54 @@ class DocumentErrorValidator
 end
 
 describe GraphQL::StaticValidation::Validator do
-  let(:document)  { OpenStruct.new(name: "This is not a document", children: []) }
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: "This is not a schema", validators: [SchemaErrorValidator, DocumentErrorValidator]) }
-
-  it 'uses validators' do
-    errors = validator.validate(document)
+  let(:document)  { OpenStruct.new(name: "This is not a document", children: [], parts: []) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: "This is not a schema", rules: [SchemaErrorValidator, DocumentErrorValidator]) }
+  let(:errors) { validator.validate(document) }
+  it 'uses rules' do
     expected_errors = [
       {"message" => "Something is wrong: This is not a schema", "locations" => [{"line" => 100, "column" => 4}]},
       {"message" => "Something is wrong: This is not a document", "locations" => [{"line" => 1, "column" => 1}]}
     ]
     assert_equal(expected_errors, errors)
   end
+
+  describe 'validation order' do
+    let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
+    let(:document) { GraphQL.parse(query_string)}
+
+    describe 'fields & arguments' do
+      let(:query_string) { %|
+        query getCheese {
+          cheese(id: 1) {
+            source,
+            nonsenseField,
+            id(nonsenseArg: 1)
+            bogusField(bogusArg: true)
+          }
+        }
+      |}
+
+      it 'handles args on invalid fields' do
+        assert_equal(3, errors.length)
+      end
+    end
+
+    describe 'infinite fragments' do
+      let(:query_string) { %|
+        query getCheese {
+          cheese(id: 1) {
+            ... cheeseFields
+          }
+        }
+        fragment cheeseFields on Cheese {
+          id, ... cheeseFields
+        }
+      |}
+
+      it 'handles infinite fragment spreads' do
+        p errors
+        assert_equal(1, errors.length)
+      end
+    end
+  end
 end