graphql 1.1.0 → 1.2.0

data/spec/graphql/argument_spec.rb

@@ -22,4 +22,22 @@ describe GraphQL::Argument do
     argument = GraphQL::Argument.define(name: :favoriteFood, type: -> { GraphQL::STRING_TYPE })
     assert_equal GraphQL::STRING_TYPE, argument.type
   end
+
+  it "accepts a default_value" do
+    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: 'Default')
+    assert_equal 'Default', argument.default_value
+    assert argument.default_value?
+  end
+
+  it "accepts a default_value of nil" do
+    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: nil)
+    assert argument.default_value.nil?
+    assert argument.default_value?
+  end
+
+  it "default_value is optional" do
+    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
+    assert argument.default_value.nil?
+    assert !argument.default_value?
+  end
 end

data/spec/graphql/define/assign_argument_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe GraphQL::Define::AssignArgument do
+  it "it accepts default_value" do
+    arg = define_argument(:a, GraphQL::STRING_TYPE, default_value: 'Default')
+
+    assert_equal "Default", arg.default_value
+    assert arg.default_value?
+  end
+
+  it "default_value is optional" do
+    arg = define_argument(:a, GraphQL::STRING_TYPE)
+
+    assert arg.default_value.nil?
+    assert !arg.default_value?
+  end
+
+  it "default_value can be explicitly set to nil" do
+    arg = define_argument(:a, GraphQL::STRING_TYPE, default_value: nil)
+
+    assert arg.default_value.nil?
+    assert arg.default_value?
+  end
+
+  it "passing unknown keyword arguments will raise" do
+    err = assert_raises ArgumentError do
+      define_argument(:a, GraphQL::STRING_TYPE, blah: nil)
+    end
+
+    assert_equal 'unknown keyword: blah', err.message
+
+    err = assert_raises ArgumentError do
+      define_argument(:a, GraphQL::STRING_TYPE, blah: nil, blah2: nil)
+    end
+
+    assert_equal 'unknown keywords: blah, blah2', err.message
+  end
+
+  def define_argument(*args)
+    type = GraphQL::ObjectType.define do
+      field :a, types.String do
+        argument(*args)
+      end
+    end
+
+    type.fields['a'].arguments[args.first.to_s]
+  end
+end

data/spec/graphql/define/instance_definable_spec.rb

@@ -11,11 +11,13 @@ module Garden
 
   class Vegetable
     include GraphQL::Define::InstanceDefinable
-    lazy_defined_attr_accessor :name, :start_planting_on, :end_planting_on
+    attr_accessor :name, :start_planting_on, :end_planting_on
+    ensure_defined(:name, :start_planting_on, :end_planting_on)
     accepts_definitions :name, plant_between: DefinePlantBetween, color: GraphQL::Define.assign_metadata_key(:color)
 
     # definition added later:
-    lazy_defined_attr_accessor :height
+    attr_accessor :height
+    ensure_defined(:height)
   end
 end
 

data/spec/graphql/execution_error_spec.rb

@@ -44,6 +44,7 @@ describe GraphQL::ExecutionError do
         }
       }
       executionError
+      valueWithExecutionError
     }
 
     fragment similarCheeseFields on Cheese {
@@ -90,6 +91,7 @@ describe GraphQL::ExecutionError do
               ]
             },
             "executionError" => nil,
+            "valueWithExecutionError" => 0
           },
           "errors"=>[
             {
@@ -127,6 +129,11 @@ describe GraphQL::ExecutionError do
               "locations"=>[{"line"=>41, "column"=>7}],
               "path"=>["executionError"]
             },
+            {
+              "message"=>"Could not fetch latest value",
+              "locations"=>[{"line"=>42, "column"=>7}],
+              "path"=>["valueWithExecutionError"]
+            },
           ]
         }
       assert_equal(expected_result, result)
@@ -185,4 +192,63 @@ describe GraphQL::ExecutionError do
       assert_equal(expected_result, result)
     end
   end
+
+  describe "fragment query when returned from a field" do
+    let(:query_string) {%|
+    query MilkQuery {
+      dairy {
+        ...Dairy
+      }
+    }
+
+    fragment Dairy on Dairy {
+      milks {
+        source
+        executionError
+        allDairy {
+          __typename
+          ...Milk
+        }
+      }
+    }
+
+    fragment Milk on Milk {
+      origin
+      executionError
+    }
+    |}
+    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
+      expected_result = {
+        "data"=>{
+            "dairy" => {
+              "milks" => [
+                {
+                  "source" => "COW",
+                  "executionError" => nil,
+                  "allDairy" => [
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
+                  ]
+                }
+              ]
+            }
+          },
+          "errors"=>[
+            {
+              "message"=>"There was an execution error",
+              "locations"=>[{"line"=>11, "column"=>9}],
+              "path"=>["dairy", "milks", 0, "executionError"]
+            },
+            {
+              "message"=>"There was an execution error",
+              "locations"=>[{"line"=>21, "column"=>7}],
+              "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
+            }
+          ]
+        }
+      assert_equal(expected_result, result)
+    end
+  end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -29,6 +29,32 @@ describe GraphQL::InputObjectType do
       end
     end
 
+    describe "validate_input with null" do
+      let(:schema) { GraphQL::Schema.from_definition(%|
+        type Query {
+          a: Int
+        }
+
+        input ExampleInputObject {
+          a: String
+          b: Int!
+        }
+      |) }
+      let(:input_type) { schema.types['ExampleInputObject'] }
+
+      it "returns an invalid result when value is null for non-null argument" do
+        invalid_input = MinimumInputObject.new({"a" => "Test", "b" => nil})
+        result = input_type.validate_input(invalid_input, PermissiveWarden)
+        assert(!result.valid?)
+      end
+
+      it "returns valid result when value is null for nullable argument" do
+        invalid_input = MinimumInputObject.new({"a" => nil, "b" => 1})
+        result = input_type.validate_input(invalid_input, PermissiveWarden)
+        assert(result.valid?)
+      end
+    end
+
     describe "validate_input with enumerable input" do
       describe "with good input" do
         let(:input) do
@@ -115,6 +141,61 @@ describe GraphQL::InputObjectType do
     end
   end
 
+  describe "coerce_result" do
+    it "omits unspecified arguments" do
+      result = input_object.coerce_result(fatContent: 0.3)
+      assert_equal ["fatContent"], result.keys
+      assert_equal 0.3, result["fatContent"]
+    end
+  end
+
+  describe "coercion of null inputs" do
+    let(:schema) { GraphQL::Schema.from_definition(%|
+      type Query {
+        a: Int
+      }
+
+      input ExampleInputObject {
+        a: String
+        b: Int!
+        c: String = "Default"
+      }
+    |) }
+    let(:input_type) { schema.types['ExampleInputObject'] }
+
+    it "null values are returned in coerced input" do
+      input = MinimumInputObject.new({"a" => "Test", "b" => nil,"c" => "Test"})
+      result = input_type.coerce_input(input)
+
+      assert_equal 'Test', result['a']
+
+      assert result.key?('b')
+      assert_equal nil, result['b']
+
+      assert_equal "Test", result['c']
+    end
+
+    it "null values are preserved when argument has a default value" do
+      input = MinimumInputObject.new({"a" => "Test", "b" => 1, "c" => nil})
+      result = input_type.coerce_input(input)
+
+      assert_equal 'Test', result['a']
+      assert_equal 1, result['b']
+
+      assert result.key?('c')
+      assert_equal nil, result['c']
+    end
+
+    it "omitted arguments are not returned" do
+      input = MinimumInputObject.new({"b" => 1, "c" => "Test"})
+      result = input_type.coerce_input(input)
+
+      assert !result.key?('a')
+      assert_equal 1, result['b']
+      assert_equal 'Test', result['c']
+    end
+  end
+
   describe "when sent into a query" do
     let(:variables) { {} }
     let(:result) { DummySchema.execute(query_string, variables: variables) }

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -19,19 +19,21 @@ describe GraphQL::InternalRepresentation::Rewrite do
       }
     }
     |}
+
     it "produces a tree of nodes" do
       op_node = rewrite_result["getCheeses"]
 
-      assert_equal 2, op_node.children.length
+      root_children = op_node.typed_children[DairyAppQueryType]
+      assert_equal 2, root_children.length
       assert_equal DairyAppQueryType, op_node.return_type
-      first_field = op_node.children.values.first
-      assert_equal 3, first_field.children.length
-      assert_equal [DairyAppQueryType], first_field.definitions.keys
+      first_field = root_children.values.first
+      assert_equal 3, first_field.typed_children[CheeseType].length
+      assert_equal DairyAppQueryType, first_field.owner_type
       assert_equal CheeseType, first_field.return_type
 
-      second_field = op_node.children.values.last
-      assert_equal 1, second_field.children.length
-      assert_equal [DairyAppQueryType], second_field.definitions.keys
+      second_field = root_children.values.last
+      assert_equal 1, second_field.typed_children[CheeseType].length
+      assert_equal DairyAppQueryType.get_field("cheese"), second_field.definition
       assert_equal CheeseType, second_field.return_type
       assert second_field.inspect.is_a?(String)
     end
@@ -47,9 +49,9 @@ describe GraphQL::InternalRepresentation::Rewrite do
     |}
 
     it "gets dynamic field definitions" do
-      cheese_field = rewrite_result[nil].children["cheese"]
-      typename_field = cheese_field.children["typename"]
-      assert_equal "__typename", typename_field.definitions.values.first.name
+      cheese_field = rewrite_result[nil].typed_children[DairyAppQueryType]["cheese"]
+      typename_field = cheese_field.typed_children[CheeseType]["typename"]
+      assert_equal "__typename", typename_field.definition.name
       assert_equal "__typename", typename_field.definition_name
     end
   end
@@ -125,22 +127,103 @@ describe GraphQL::InternalRepresentation::Rewrite do
     it "puts all fragment members as children" do
       op_node = rewrite_result[nil]
 
-      cheese_field = op_node.children["cheese"]
-      assert_equal ["id1", "id2", "fatContent", "origin", "similarCow", "flavor"], cheese_field.children.keys
+      cheese_field = op_node.typed_children[DairyAppQueryType]["cheese"]
+      assert_equal ["id1", "id2", "fatContent", "similarCow", "flavor"], cheese_field.typed_children[CheeseType].keys
+      assert_equal ["fatContent", "origin"], cheese_field.typed_children[EdibleInterface].keys
       # Merge:
-      similar_cow_field = cheese_field.children["similarCow"]
-      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.children.keys
+      similar_cow_field = cheese_field.typed_children[CheeseType]["similarCow"]
+      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.typed_children[CheeseType].keys
       # Deep merge:
-      similar_sheep_field = similar_cow_field.children["similarCheese"]
-      assert_equal ["flavor", "source"], similar_sheep_field.children.keys
+      similar_sheep_field = similar_cow_field.typed_children[CheeseType]["similarCheese"]
+      assert_equal ["flavor", "source"], similar_sheep_field.typed_children[CheeseType].keys
+
+      edible_origin_node = cheese_field.typed_children[EdibleInterface]["origin"]
+      assert_equal EdibleInterface.get_field("origin"), edible_origin_node.definition
+      assert_equal EdibleInterface, edible_origin_node.owner_type
+
+      edible_fat_content_node = cheese_field.typed_children[EdibleInterface]["fatContent"]
+      assert_equal EdibleInterface.get_field("fatContent"), edible_fat_content_node.definition
+      assert_equal EdibleInterface, edible_fat_content_node.owner_type
+
+      cheese_fat_content_node = cheese_field.typed_children[CheeseType]["fatContent"]
+      assert_equal CheeseType.get_field("fatContent"), cheese_fat_content_node.definition
+      assert_equal CheeseType, cheese_fat_content_node.owner_type
+
+      cheese_flavor_node = cheese_field.typed_children[CheeseType]["flavor"]
+      assert_equal CheeseType.get_field("flavor"), cheese_flavor_node.definition
+      assert_equal CheeseType, cheese_flavor_node.owner_type
 
-      assert_equal [EdibleInterface], cheese_field.children["origin"].definitions.keys
-      assert_equal [CheeseType, EdibleInterface], cheese_field.children["fatContent"].definitions.keys
-      assert_equal [CheeseType], cheese_field.children["flavor"].definitions.keys
 
       # nested spread inside fragment definition:
-      cheese_2_field = op_node.children["cheese2"].children["similarCheese"]
-      assert_equal ["id", "fatContent"], cheese_2_field.children.keys
+      cheese_2_field = op_node.typed_children[DairyAppQueryType]["cheese2"].typed_children[CheeseType]["similarCheese"]
+      assert_equal ["id", "fatContent"], cheese_2_field.typed_children[CheeseType].keys
+    end
+  end
+
+  describe "nested fields on typed fragments" do
+    let(:result) { DummySchema.execute(query_string) }
+    let(:query_string) {%|
+    {
+      allDairy {
+        __typename
+
+        ... on Milk {
+          selfAsEdible {
+            milkInlineOrigin: origin
+          }
+        }
+
+        ... on Cheese {
+          selfAsEdible {
+            cheeseInlineOrigin: origin
+          }
+        }
+
+        ... on Edible {
+          selfAsEdible {
+            edibleInlineOrigin: origin
+          }
+        }
+
+        ... {
+          ... on Edible {
+            selfAsEdible {
+              untypedInlineOrigin: origin
+            }
+          }
+        }
+        ...milkFields
+        ...cheeseFields
+      }
+    }
+
+    fragment cheeseFields on Cheese {
+      selfAsEdible {
+        cheeseFragmentOrigin: origin
+      }
+    }
+    fragment milkFields on Milk {
+      selfAsEdible {
+        milkFragmentOrigin: origin
+      }
+    }
+    |}
+
+    it "distinguishes between nested fields with the same name on different typed fragments" do
+      all_dairy = result["data"]["allDairy"]
+      cheeses = all_dairy.select { |d| d["__typename"] == "Cheese" }
+      milks = all_dairy.select { |d| d["__typename"] == "Milk" }
+
+      # Make sure all the data is there:
+      assert_equal 3, cheeses.length
+      assert_equal 1, milks.length
+
+      cheeses.each do |cheese|
+        assert_equal ["cheeseInlineOrigin", "cheeseFragmentOrigin", "edibleInlineOrigin", "untypedInlineOrigin"], cheese["selfAsEdible"].keys
+      end
+      milks.each do |milk|
+        assert_equal ["milkInlineOrigin", "milkFragmentOrigin", "edibleInlineOrigin", "untypedInlineOrigin"], milk["selfAsEdible"].keys
+      end
     end
   end
 end

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -5,19 +5,19 @@ describe GraphQL::Introspection::InputValueType do
   let(:query_string) {%|
      {
        __type(name: "DairyProductInput") {
-         name,
-         description,
-         kind,
+         name
+         description
+         kind
          inputFields {
-           name,
-           type { kind, name },
+           name
+           type { kind, name }
            defaultValue
            description
          }
        }
      }
   |}
-  let(:result) { DummySchema.execute(query_string)}
+  let(:result) { DummySchema.execute(query_string) }
 
   it "exposes metadata about input objects, giving extra quotes for strings" do
     expected = { "data" => {
@@ -62,4 +62,41 @@ describe GraphQL::Introspection::InputValueType do
 
     assert_equal('["COW"]', arg['defaultValue'])
   end
+
+  it "supports null default values" do
+    schema = GraphQL::Schema.from_definition(%|
+      type Query {
+        hello(person: Person): String
+      }
+
+      input Person {
+        firstName: String!
+        lastName: String = null
+      }
+    |)
+
+    result = schema.execute(%|
+      {
+        __type(name: "Person") {
+          inputFields {
+            name
+            defaultValue
+          }
+        }
+      }
+    |)
+
+    expected = {
+      "data" => {
+        "__type" => {
+          "inputFields" => [
+            { "name" => "firstName", "defaultValue" => nil},
+            { "name" => "lastName", "defaultValue" => "null"}
+          ]
+        }
+      }
+    }
+
+    assert_equal expected, result
+  end
 end