graphql 0.1.0 → 0.2.0

data/spec/graph_ql/parser/transform_spec.rb

@@ -53,12 +53,20 @@ describe GraphQL::Transform do
     assert_equal("someInfo", res.name)
     assert_equal(3, res.selections.length)
 
-    res = get_result("mutation changeThings($var: Float = 4.5, $arr: [Int]!) @flag, @skip(if: 1) { changeThings(var: $var) { a,b,c }}", parse: :operation_definition)
+    res = get_result(
+    "mutation changeThings(
+        $var: Float = 4.5E+6,
+        $arr: [Int]!
+      ) @flag, @skip(if: 1) {
+        changeThings(var: $var) { a,b,c }
+      }", parse: :operation_definition)
     assert_equal("mutation", res.operation_type)
     assert_equal("var", res.variables.first.name)
     assert_equal("Float", res.variables.first.type.name)
-    assert_equal(4.5, res.variables.first.default_value)
+    assert_equal(4_500_000.0, res.variables.first.default_value)
     assert_equal("arr", res.variables.last.name)
+    assert_equal(3, res.variables.last.line)
+    assert_equal(10, res.variables.last.col)
     assert_equal("Int", res.variables.last.type.of_type.of_type.name)
     assert_equal(2, res.directives.length)
   end
@@ -80,6 +88,8 @@ describe GraphQL::Transform do
   it 'transforms fields' do
     res = get_result(%|best_pals: friends(first: 3, coolnessLevel: SO_COOL, query: {nice: {very: true}})|, parse: :field)
     assert_equal(GraphQL::Nodes::Field, res.class)
+    assert_equal(1, res.line)
+    assert_equal(1, res.col)
     assert_equal("friends", res.name)
     assert_equal("best_pals", res.alias)
     assert_equal("first", res.arguments[0].name)

data/spec/graph_ql/parser/visitor_spec.rb

@@ -9,13 +9,13 @@ describe GraphQL::Visitor do
 
   let(:visitor) do
     v = GraphQL::Visitor.new
-    v[GraphQL::Nodes::Field] << -> (node) { counts[:fields_entered] += 1 }
+    v[GraphQL::Nodes::Field] << -> (node, parent) { counts[:fields_entered] += 1 }
     # two ways to set up enter hooks:
-    v[GraphQL::Nodes::Argument] <<       -> (node) { counts[:argument_names] << node.name }
-    v[GraphQL::Nodes::Argument].enter << -> (node) { counts[:arguments_entered] += 1}
-    v[GraphQL::Nodes::Argument].leave << -> (node) { counts[:arguments_left] += 1 }
+    v[GraphQL::Nodes::Argument] <<       -> (node, parent) { counts[:argument_names] << node.name }
+    v[GraphQL::Nodes::Argument].enter << -> (node, parent) { counts[:arguments_entered] += 1}
+    v[GraphQL::Nodes::Argument].leave << -> (node, parent) { counts[:arguments_left] += 1 }
 
-    v[GraphQL::Nodes::Document].leave << -> (node) { counts[:finished] = true }
+    v[GraphQL::Nodes::Document].leave << -> (node, parent) { counts[:finished] = true }
     v
   end
 
@@ -28,4 +28,12 @@ describe GraphQL::Visitor do
     assert_equal(["id", "first"], counts[:argument_names])
     assert(counts[:finished])
   end
+
+  describe 'Visitor::SKIP' do
+    it 'skips the rest of the node' do
+      visitor[GraphQL::Nodes::Document] << -> (node, parent) { GraphQL::Visitor::SKIP }
+      visitor.visit(document)
+      assert_equal(0, counts[:fields_entered])
+    end
+  end
 end

data/spec/graph_ql/query_spec.rb

@@ -4,14 +4,14 @@ describe GraphQL::Query do
   describe '#execute' do
     let(:query_string) { %|
       query getFlavor($cheeseId: Int!) {
-        brie: cheese(id: 1)   { ...cheeseFields, ... meatFields, taste: flavor },
+        brie: cheese(id: 1)   { ...cheeseFields, ... milkFields, taste: flavor },
         cheese(id: $cheeseId)  {
           __typename,
           id,
           ...cheeseFields,
           ... edibleFields,
           ... on Cheese { cheeseKind: flavor },
-          ... on Meat { cut }
+          ... on Milk { source }
         }
         fromSource(source: COW) { id }
         firstSheep: searchDairy(product: {source: SHEEP}) { ... dairyFields }
@@ -19,27 +19,29 @@ describe GraphQL::Query do
       }
       fragment cheeseFields on Cheese { flavor }
       fragment edibleFields on Edible { fatContent }
-      fragment meatFields on Meat { cut }
-      fragment dairyFields on DairyProduct {
+      fragment milkFields on Milk { source }
+      fragment dairyFields on AnimalProduct {
          ... on Cheese { flavor }
          ... on Milk   { source }
       }
     |}
-    let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, params: {"cheeseId" => 2})}
+    let(:debug) { false }
+    let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, params: {"cheeseId" => 2}, debug: debug)}
     let(:result) { query.result }
+
     it 'returns fields on objects' do
       expected = {"data"=> { "getFlavor" => {
           "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
           "cheese" => {
             "__typename" => "Cheese",
             "id" => 2,
-            "fatContent" => 0.3,
             "flavor" => "Gouda",
+            "fatContent" => 0.3,
             "cheeseKind" => "Gouda",
           },
           "fromSource" => [{ "id" => 1 }, {"id" => 2}],
           "firstSheep" => { "flavor" => "Manchego" },
-          "favoriteEdible"=>{"__typename"=>"Edible", "fatContent"=>0.04},
+          "favoriteEdible"=>{"__typename"=>"Milk", "fatContent"=>0.04},
       }}}
       assert_equal(expected, result)
     end
@@ -49,12 +51,22 @@ describe GraphQL::Query do
     end
 
     describe 'runtime errors' do
-      let(:query_string) {%| query noMilk { milk(id: 1000) { name } }|}
-      it 'turns into error messages' do
-        expected = {"errors"=>[
-          {"message"=>"Something went wrong during query execution: No field found on Query 'Query' for 'milk'"}
-        ]}
-        assert_equal(expected, result)
+      let(:query_string) {%| query noMilk { error }|}
+      describe 'if debug: false' do
+        let(:debug) { false }
+        it 'turns into error messages' do
+          expected = {"errors"=>[
+            {"message"=>"Something went wrong during query execution: This error was raised on purpose"}
+          ]}
+          assert_equal(expected, result)
+        end
+      end
+
+      describe 'if debug: true' do
+        let(:debug) { true }
+        it 'raises error' do
+          assert_raises(RuntimeError) { result }
+        end
       end
     end
 

data/spec/graph_ql/schema/field_validator_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe GraphQL::Schema::FieldValidator do
+  let(:field_defn) {{
+    name: "Field",
+    description: "Invalid field",
+    deprecation_reason: nil,
+    arguments: {symbol_arg: nil},
+    type: DairyAnimalEnum,
+  }}
+  let(:field) {
+    f = OpenStruct.new(field_defn)
+    def f.to_s; f.name; end
+    f
+  }
+  let(:errors) { e = []; GraphQL::Schema::FieldValidator.new.validate(field, e); e }
+  it "requires argument names to be strings" do
+    expected = ["Field.arguments keys must be Strings, but some aren't: symbol_arg"]
+    assert_equal(expected, errors)
+  end
+end

data/spec/graph_ql/schema/type_reducer_spec.rb

@@ -9,9 +9,9 @@ describe GraphQL::Schema::TypeReducer do
       "String" => GraphQL::STRING_TYPE,
       "DairyAnimal" => DairyAnimalEnum,
       "Float" => GraphQL::FLOAT_TYPE,
-      "Edible" => Edible,
+      "Edible" => EdibleInterface,
       "Milk" => MilkType,
-      "AnimalProduct" => AnimalProduct,
+      "AnimalProduct" => AnimalProductInterface,
     }
     assert_equal(expected.keys, reducer.result.keys)
     assert_equal(expected, reducer.result)

data/spec/graph_ql/schema/type_validator_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe GraphQL::Schema::TypeValidator do
+  let(:base_type_defn) {
+    {
+      name: "InvalidType",
+      description: "...",
+      deprecation_reason: nil,
+      kind: GraphQL::TypeKinds::OBJECT,
+      interfaces: [],
+      fields: {},
+    }
+  }
+  let(:object) {
+    o = OpenStruct.new(type_defn)
+    def o.to_s; "InvalidType"; end
+    o
+  }
+  let(:validator) { GraphQL::Schema::TypeValidator.new }
+  let(:errors) { e = []; validator.validate(object, e); e;}
+  describe 'when name isnt defined' do
+    let(:type_defn) { base_type_defn.delete_if {|k,v| k == :name }}
+    it 'requires name' do
+      assert_equal(
+        ["InvalidType must respond to #name() to be a Type"],
+        errors
+      )
+    end
+  end
+
+  describe "when a field name isnt a string" do
+    let(:type_defn) { base_type_defn.merge(fields: {symbol_field: (GraphQL::Field.new {|f|}) }) }
+    it "requires string names" do
+      assert_equal(
+        ["InvalidType.fields keys must be Strings, but some aren't: symbol_field"],
+        errors
+      )
+    end
+  end
+
+  describe "when a Union isnt valid" do
+    let(:object) {
+      GraphQL::Union.new("Something", "some union", [DairyProductInputType])
+    }
+    let(:errors) { e = []; GraphQL::Schema::TypeValidator.new.validate(object, e); e;}
+    it 'must be 2+ types, must be only object types' do
+      expected = [
+        "Something.possible_types must be objects, but some aren't: <GraphQL::InputObjectType DairyProductInput>",
+        "Union Something must be defined with 2 or more types, not 1",
+      ]
+      assert_equal(expected, errors)
+    end
+  end
+end

data/spec/graph_ql/static_validation/argument_literals_are_compatible_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
+  let(:document) { GraphQL.parse(%|
+    query getCheese {
+      cheese(id: "aasdlkfj") { source }
+      cheese(id: 1) { source @skip(if: {id: 1})}
+      yakSource: searchDairy(product: {source: YAK, fatContent: 1.1}) { source }
+      badSource: searchDairy(product: {source: 1.1}) { source }
+    }
+
+    fragment cheeseFields on Cheese {
+      similarCheeses(source: 4.5)
+    }
+  |)}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::ArgumentLiteralsAreCompatible]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'finds undefined arguments to fields and directives' do
+    assert_equal(3, errors.length)
+
+    query_root_error = {
+      "message"=>"id on Field 'cheese' has an invalid value",
+      "locations"=>[{"line"=>3, "column"=>7}]
+    }
+    assert_includes(errors, query_root_error)
+
+    input_object_error = {
+      "message"=>"product on Field 'searchDairy' has an invalid value",
+      "locations"=>[{"line"=>6, "column"=>7}]
+    }
+    assert_includes(errors, input_object_error)
+
+    fragment_error = {
+      "message"=>"source on Field 'similarCheeses' has an invalid value",
+      "locations"=>[{"line"=>10, "column"=>7}]
+    }
+    assert_includes(errors, fragment_error)
+  end
+end

data/spec/graph_ql/static_validation/arguments_are_defined_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::ArgumentsAreDefined do
+  let(:document) { GraphQL.parse("
+    query getCheese {
+      cheese(id: 1) { source }
+      cheese(silly: false) { source }
+    }
+
+    fragment cheeseFields on Cheese {
+      similarCheeses(source: SHEEP, nonsense: 1)
+      id @skip(something: 3.4)
+    }
+  ")}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'finds undefined arguments to fields and directives' do
+    assert_equal(3, errors.length)
+
+    query_root_error = {
+      "message"=>"Field 'cheese' doesn't accept argument silly",
+      "locations"=>[{"line"=>4, "column"=>7}]
+    }
+    assert_includes(errors, query_root_error)
+
+    fragment_error = {
+      "message"=>"Field 'similarCheeses' doesn't accept argument nonsense",
+      "locations"=>[{"line"=>8, "column"=>7}]
+    }
+    assert_includes(errors, fragment_error)
+
+    directive_error = {
+      "message"=>"Directive 'skip' doesn't accept argument something",
+      "locations"=>[{"line"=>9, "column"=>11}]
+    }
+    assert_includes(errors, directive_error)
+  end
+end

data/spec/graph_ql/static_validation/directives_are_defined_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::DirectivesAreDefined do
+  let(:document) { GraphQL.parse("
+    query getCheese {
+      okCheese: cheese(id: 1) {
+        id @skip(if: true),
+        source @nonsense(if: false)
+        ... on Cheese {
+          flavor @moreNonsense
+        }
+      }
+    }
+  ")}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::DirectivesAreDefined]) }
+  let(:errors) { validator.validate(document) }
+
+  describe 'non-existent directives' do
+    it 'makes errors for them' do
+      expected = [
+        {
+          "message"=>"Directive @nonsense is not defined",
+          "locations"=>[{"line"=>5, "column"=>17}]
+        }, {
+          "message"=>"Directive @moreNonsense is not defined",
+          "locations"=>[{"line"=>7, "column"=>19}]
+        }
+      ]
+      assert_equal(expected, errors)
+    end
+  end
+end

data/spec/graph_ql/static_validation/fields_are_defined_on_type_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
+  let(:query_string) { "
+    query getCheese($sourceVar: DairyAnimal!) {
+      notDefinedField { name }
+      cheese(id: 1) { nonsenseField, flavor }
+      fromSource(source: COW) { bogusField }
+    }
+
+    fragment cheeseFields on Cheese { fatContent, hogwashField }
+  "}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
+  let(:errors) { validator.validate(GraphQL.parse(query_string)) }
+  let(:error_messages) { errors.map { |e| e["message" ] }}
+
+  it "finds fields that are requested on types that don't have that field" do
+    expected_errors = [
+      "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
+      "Field 'nonsenseField' doesn't exist on type 'Cheese'",   # from another field
+      "Field 'bogusField' doesn't exist on type 'Cheese'",      # from a list
+      "Field 'hogwashField' doesn't exist on type 'Cheese'",    # from a fragment
+    ]
+    assert_equal(expected_errors, error_messages)
+  end
+
+  describe 'on interfaces' do
+    let(:query_string) { "query getStuff { favoriteEdible { amountThatILikeIt } }"}
+
+    it 'finds invalid fields' do
+      expected_errors = [
+        {"message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'", "locations"=>[{"line"=>1, "column"=>18}]}
+      ]
+      assert_equal(expected_errors, errors)
+    end
+  end
+
+  describe 'on unions' do
+    let(:query_string) { "
+      query notOnUnion { favoriteEdible { ...dpFields } }
+      fragment dbFields on DairyProduct { source }
+      fragment dbIndirectFields on DairyProduct { ... on Cheese { source } }
+    "}
+
+
+    it 'doesnt allow selections on unions' do
+      expected_errors = [
+        {
+          "message"=>"Selections can't be made directly on unions (see selections on DairyProduct)",
+          "locations"=>[
+            {"line"=>3, "column"=>7}
+          ]
+        }
+      ]
+      assert_equal(expected_errors, errors)
+    end
+  end
+end

data/spec/graph_ql/static_validation/fields_have_appropriate_selections_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
+  let(:document) { GraphQL.parse("
+    query getCheese {
+      okCheese: cheese(id: 1) { fatContent, similarCheeses(source: YAK) { source } }
+      missingFieldsCheese: cheese(id: 1)
+      illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
+    }
+  ")}
+
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'adds errors for selections on scalars' do
+    assert_equal(2, errors.length)
+
+    illegal_selection_error = {
+      "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
+      "locations"=>[{"line"=>5, "column"=>47}]
+    }
+    assert_includes(errors, illegal_selection_error, 'finds illegal selections on scalarss')
+
+    selection_required_error = {
+      "message"=>"Objects must have selections (field 'cheese' returns Cheese but has no selections)",
+      "locations"=>[{"line"=>4, "column"=>7}]
+    }
+    assert_includes(errors, selection_required_error, 'finds objects without selections')
+  end
+end

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

@@ -1,40 +1,47 @@
 require 'spec_helper'
 
-describe GraphQL::Validations::FieldsWillMerge do
+describe GraphQL::StaticValidation::FieldsWillMerge do
   let(:document) { GraphQL.parse("
     query getCheese($sourceVar: DairyAnimal!) {
-      id
-      nickname: name,
-      nickname: fatContent,
-      fatContent
+      cheese(id: 1) {
+        id,
+        nickname: name,
+        nickname: fatContent,
+        fatContent
+        differentLevel: fatContent
+        similarCheeses(source: $sourceVar)
 
-      similarCheeses(source: $sourceVar)
-
-      origin { originName: id },
-      ...cheeseFields
-      ... on Cheese {
-        fatContent: name
-        similarCheeses(source: SHEEP)
+        similarCow: similarCheeses(source: COW) {
+          similarCowSource: source,
+          differentLevel: fatContent
+        }
+        ...cheeseFields
+        ... on Cheese {
+          fatContent: name
+          similarCheeses(source: SHEEP)
+        }
       }
     }
     fragment cheeseFields on Cheese {
       fatContent,
-      origin { originName: name }
+      similarCow: similarCheeses(source: COW) { similarCowSource: id, id }
       id @someFlag
     }
   ")}
 
-  let(:validator) { GraphQL::Validator.new(schema: nil, validators: [GraphQL::Validations::FieldsWillMerge]) }
+  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, validators: [GraphQL::StaticValidation::FieldsWillMerge]) }
   let(:errors) { validator.validate(document) }
+  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 'originName' has a field conflict: id or name?",                   # nested conflict
       "Field 'id' has a directive conflict: [] or [someFlag]?",                 # different directives
       "Field 'id' has a directive argument conflict: [] or [{}]?",              # not sure this is a great way to handle it but here we are!
+      "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 'similarCheeses' has an argument conflict: {\"source\":\"sourceVar\"} or {\"source\":\"SHEEP\"}?", # different arguments
+      "Field 'similarCowSource' has a field conflict: source or id?",           # nested conflict
     ]
-    assert_equal(expected_errors, errors)
+    assert_equal(expected_errors, error_messages)
   end
 end