graphql 1.8.7 → 1.9.0

data/spec/graphql/execution_error_spec.rb

@@ -3,8 +3,9 @@ require "spec_helper"
 
 describe GraphQL::ExecutionError do
   let(:result) { Dummy::Schema.execute(query_string) }
-  describe "when returned from a field" do
-    let(:query_string) {%|
+  if TESTING_RESCUE_FROM
+    describe "when returned from a field" do
+      let(:query_string) {%|
     {
       cheese(id: 1) {
         id
@@ -51,93 +52,94 @@ describe GraphQL::ExecutionError do
     fragment similarCheeseFields on Cheese {
       id, flavor
     }
-    |}
-    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-      expected_result = {
-        "data"=>{
-          "cheese"=>{
-            "id" => 1,
-            "error1"=> nil,
-            "error2"=> nil,
-            "nonError"=> {
-              "id" => 3,
-              "flavor" => "Manchego",
-            },
-            "flavor" => "Brie",
+      |}
+      it "the error is inserted into the errors key and the rest of the query is fulfilled" do
+        expected_result = {
+          "data"=>{
+            "cheese"=>{
+              "id" => 1,
+              "error1"=> nil,
+              "error2"=> nil,
+              "nonError"=> {
+                "id" => 3,
+                "flavor" => "Manchego",
+              },
+              "flavor" => "Brie",
+              },
+              "allDairy" => [
+                { "flavor" => "Brie" },
+                { "flavor" => "Gouda" },
+                { "flavor" => "Manchego" },
+                { "source" => "COW", "executionError" => nil }
+              ],
+              "dairyErrors" => [
+                { "__typename" => "Cheese" },
+                nil,
+                { "__typename" => "Cheese" },
+                { "__typename" => "Milk" }
+              ],
+              "dairy" => {
+                "milks" => [
+                  {
+                    "source" => "COW",
+                    "executionError" => nil,
+                    "allDairy" => [
+                      { "__typename" => "Cheese" },
+                      { "__typename" => "Cheese" },
+                      { "__typename" => "Cheese" },
+                      { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
+                    ]
+                  }
+                ]
+              },
+              "executionError" => nil,
+              "valueWithExecutionError" => 0
             },
-            "allDairy" => [
-              { "flavor" => "Brie" },
-              { "flavor" => "Gouda" },
-              { "flavor" => "Manchego" },
-              { "source" => "COW", "executionError" => nil }
-            ],
-            "dairyErrors" => [
-              { "__typename" => "Cheese" },
-              nil,
-              { "__typename" => "Cheese" },
-              { "__typename" => "Milk" }
-            ],
-            "dairy" => {
-              "milks" => [
-                {
-                  "source" => "COW",
-                  "executionError" => nil,
-                  "allDairy" => [
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
-                  ]
-                }
-              ]
-            },
-            "executionError" => nil,
-            "valueWithExecutionError" => 0
-          },
-          "errors"=>[
-            {
-              "message"=>"No cheeses are made from Yak milk!",
-              "locations"=>[{"line"=>5, "column"=>9}],
-              "path"=>["cheese", "error1"]
-            },
-            {
-              "message"=>"No cheeses are made from Yak milk!",
-              "locations"=>[{"line"=>8, "column"=>9}],
-              "path"=>["cheese", "error2"]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>22, "column"=>11}],
-              "path"=>["allDairy", 3, "executionError"]
-            },
-            {
-              "message"=>"missing dairy",
-              "locations"=>[{"line"=>25, "column"=>7}],
-              "path"=>["dairyErrors", 1]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>31, "column"=>11}],
-              "path"=>["dairy", "milks", 0, "executionError"]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>36, "column"=>15}],
-              "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
-            },
-            {
-              "message"=>"There was an execution error",
-              "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.to_h)
+            "errors"=>[
+              {
+                "message"=>"No cheeses are made from Yak milk!",
+                "locations"=>[{"line"=>5, "column"=>9}],
+                "path"=>["cheese", "error1"]
+              },
+              {
+                "message"=>"No cheeses are made from Yak milk!",
+                "locations"=>[{"line"=>8, "column"=>9}],
+                "path"=>["cheese", "error2"]
+              },
+              {
+                "message"=>"There was an execution error",
+                "locations"=>[{"line"=>22, "column"=>11}],
+                "path"=>["allDairy", 3, "executionError"]
+              },
+              {
+                "message"=>"missing dairy",
+                "locations"=>[{"line"=>25, "column"=>7}],
+                "path"=>["dairyErrors", 1]
+              },
+              {
+                "message"=>"There was an execution error",
+                "locations"=>[{"line"=>31, "column"=>11}],
+                "path"=>["dairy", "milks", 0, "executionError"]
+              },
+              {
+                "message"=>"There was an execution error",
+                "locations"=>[{"line"=>36, "column"=>15}],
+                "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
+              },
+              {
+                "message"=>"There was an execution error",
+                "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.to_h)
+      end
     end
   end
 
@@ -294,15 +296,27 @@ describe GraphQL::ExecutionError do
   describe "more than one ExecutionError" do
     let(:query_string) { %|{ multipleErrorsOnNonNullableField} |}
     it "the errors are inserted into the errors key and the data is nil even for a NonNullable field " do
+
+      # I Think the path here is _wrong_, since this is not an array field:
+      # expected_result = {
+      #     "data"=>nil,
+      #     "errors"=>
+      #         [{"message"=>"This is an error message for some error.",
+      #           "locations"=>[{"line"=>1, "column"=>3}],
+      #           "path"=>["multipleErrorsOnNonNullableField", 0]},
+      #          {"message"=>"This is another error message for a different error.",
+      #           "locations"=>[{"line"=>1, "column"=>3}],
+      #           "path"=>["multipleErrorsOnNonNullableField", 1]}]
+      # }
       expected_result = {
-          "data"=>nil,
-          "errors"=>
-              [{"message"=>"This is an error message for some error.",
-                "locations"=>[{"line"=>1, "column"=>3}],
-                "path"=>["multipleErrorsOnNonNullableField", 0]},
-               {"message"=>"This is another error message for a different error.",
-                "locations"=>[{"line"=>1, "column"=>3}],
-                "path"=>["multipleErrorsOnNonNullableField", 1]}]
+        "data"=>nil,
+        "errors"=>
+          [{"message"=>"This is an error message for some error.",
+            "locations"=>[{"line"=>1, "column"=>3}],
+            "path"=>["multipleErrorsOnNonNullableField"]},
+           {"message"=>"This is another error message for a different error.",
+            "locations"=>[{"line"=>1, "column"=>3}],
+            "path"=>["multipleErrorsOnNonNullableField"]}],
       }
       assert_equal(expected_result, result)
     end

data/spec/graphql/field_spec.rb

@@ -116,7 +116,7 @@ describe GraphQL::Field do
 
   describe "#metadata" do
     it "accepts user-defined metadata" do
-      similar_cheese_field = Dummy::CheeseType.get_field("similarCheese")
+      similar_cheese_field = Dummy::Cheese.graphql_definition.get_field("similarCheese")
       assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
     end
   end

data/spec/graphql/input_object_type_spec.rb

@@ -1,364 +1,25 @@
 # frozen_string_literal: true
-require "spec_helper"
+require 'spec_helper'
 
 describe GraphQL::InputObjectType do
-  let(:input_object) { Dummy::DairyProductInputType }
-  it "has a description" do
-    assert(input_object.description)
-  end
-
-  it "has input fields" do
-    assert(input_object.input_fields["fatContent"])
-  end
-
-  describe "on a type unused by the schema" do
-    it "has input fields" do
-      UnreachedInputType = GraphQL::InputObjectType.define do
-        name 'UnreachedInputType'
-        description 'An input object type not directly used in the schema.'
-
-        input_field :field, types.String
-      end
-      assert(UnreachedInputType.input_fields['field'])
-    end
-  end
-
-  describe "input validation" do
-    it "Accepts anything that yields key-value pairs to #all?" do
-      values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})
-      assert input_object.valid_isolated_input?(values_obj)
-    end
-
-    describe "validate_input with non-enumerable input" do
-      it "returns a valid result for MinimumInputObject" do
-        result = input_object.validate_isolated_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
-        assert(result.valid?)
-      end
-
-      it "returns an invalid result for MinimumInvalidInputObject" do
-        invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
-        result = input_object.validate_isolated_input(invalid_input)
-        assert(!result.valid?)
-      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_isolated_input(invalid_input)
-        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_isolated_input(invalid_input)
-        assert(result.valid?)
-      end
-    end
-
-    describe "validate_input with enumerable input" do
-      describe "with good input" do
-        let(:input) do
-          {
-            "source" => "COW",
-            "fatContent" => 0.4
-          }
-        end
-        let(:result) { input_object.validate_isolated_input(input) }
-
-        it "returns a valid result" do
-          assert(result.valid?)
-        end
-      end
-
-      if ActionPack::VERSION::MAJOR > 3
-        describe "with a ActionController::Parameters" do
-          let(:input) do
-            ActionController::Parameters.new(
-              "source" => "COW",
-              "fatContent" => 0.4,
-            )
-          end
-          let(:result) { input_object.validate_isolated_input(input) }
-
-          it "returns a valid result" do
-            assert(result.valid?)
-          end
-        end
-      end
-
-      describe "with bad enum and float" do
-        let(:result) { input_object.validate_isolated_input({"source" => "KOALA", "fatContent" => "bad_num"}) }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problems with correct paths" do
-          paths = result.problems.map { |p| p["path"] }
-          assert(paths.include?(["source"]))
-          assert(paths.include?(["fatContent"]))
-        end
-
-        it "has correct problem explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
-
-          source_problem = result.problems.detect { |p| p["path"] == ["source"] }
-          actual = source_problem["explanation"]
-
-          assert_equal(expected, actual)
-        end
-      end
-
-      describe 'with a string as input' do
-        let(:result) { input_object.validate_isolated_input("just a string") }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problem with correct path" do
-          paths = result.problems.map { |p| p["path"] }
-          assert(paths.include?([]))
-        end
-
-        it "has correct problem explanation" do
-          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
-        end
-      end
-
-      describe 'with an array as input' do
-        let(:result) { input_object.validate_isolated_input(["string array"]) }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problem with correct path" do
-          paths = result.problems.map { |p| p["path"] }
-          assert(paths.include?([]))
-        end
-
-        it "has correct problem explanation" do
-          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
-        end
-      end
-
-      describe 'with a int as input' do
-        let(:result) { input_object.validate_isolated_input(10) }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
+  describe 'default values' do
+    describe 'when the type is an enum with underlying ruby values' do
+      it 'provides the default value' do
+        TestEnum = GraphQL::EnumType.define do
+          name 'Test'
 
-        it "has problem with correct path" do
-          paths = result.problems.map { |p| p["path"] }
-          assert(paths.include?([]))
+          value 'A', 'Represents an authorized agent in our system.', value: 'a'
+          value 'B', 'Agent is disabled, web app access is denied.', value: 'b'
         end
 
-        it "has correct problem explanation" do
-          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        class TestInput < GraphQL::Schema::InputObject
+          argument :foo, TestEnum, 'TestEnum', required: false, default_value: 'a'
         end
-      end
-
-      describe "with extra argument" do
-        let(:result) { input_object.validate_isolated_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}) }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problem with correct path" do
-          paths = result.problems.map { |p| p["path"] }
-          assert_equal([["isDelicious"]], paths)
-        end
-
-        it "has correct problem explanation" do
-          assert(result.problems[0]["explanation"].include?("Field is not defined"))
-        end
-      end
-
-      describe "list with one invalid element" do
-        let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInputType) }
-        let(:result) do
-          list_type.validate_isolated_input([
-            { "source" => "COW", "fatContent" => 0.4 },
-            { "source" => "KOALA", "fatContent" => 0.4 }
-          ])
-        end
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has one problem" do
-          assert_equal(result.problems.length, 1)
-        end
-
-        it "has problem with correct path" do
-          path = result.problems[0]["path"]
-          assert_equal(path, [1, "source"])
-        end
-
-        it "has problem with correct explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
-          actual = result.problems[0]["explanation"]
-          assert_equal(expected, actual)
-        end
-      end
-
-      describe 'with invalid name' do
-        it 'raises the correct error' do
-          assert_raises(GraphQL::InvalidNameError) do
-            InvalidInputTest = GraphQL::InputObjectType.define do
-              name "Some::Invalid Name"
-            end
-
-            # Force evaluation
-            InvalidInputTest.name
-          end
-        end
-      end
-    end
-  end
-
-  describe "coerce_result" do
-    it "omits unspecified arguments" do
-      result = input_object.coerce_isolated_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"
-        d: Boolean = false
-      }
-
-      input SecondLevelInputObject {
-        example: ExampleInputObject = {b: 42, d: true}
-      }
-    |) }
-    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_isolated_input(input)
-
-      assert_equal 'Test', result['a']
-
-      assert result.key?('b')
-      assert_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_isolated_input(input)
-
-      assert_equal 'Test', result['a']
-      assert_equal 1, result['b']
-
-      assert result.key?('c')
-      assert_nil result['c']
-    end
-
-    it "omitted arguments are not returned" do
-      input = MinimumInputObject.new({"b" => 1, "c" => "Test"})
-      result = input_type.coerce_isolated_input(input)
-
-      assert !result.key?('a')
-      assert_equal 1, result['b']
-      assert_equal 'Test', result['c']
-    end
-
-    it "false default values are returned" do
-      input = MinimumInputObject.new({"b" => 1})
-      result = input_type.coerce_isolated_input(input)
-
-      assert_equal false, result['d']
-    end
-
-    it "merges defaults of nested input objects" do
-      result = schema.types['SecondLevelInputObject'].coerce_isolated_input({})
-      assert_equal 42, result['example']['b']
-      assert_equal "Default", result['example']['c']
-      assert_equal true, result['example']['d']
-    end
-  end
-
-  describe "when sent into a query" do
-    let(:variables) { {} }
-    let(:result) { Dummy::Schema.execute(query_string, variables: variables) }
-
-    describe "list inputs" do
-      let(:variables) { {"search" => [MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})]} }
-      let(:query_string) {%|
-        query getCheeses($search: [DairyProductInput]!){
-            sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {
-              ... cheeseFields
-            }
-            cow: searchDairy(product: $search) {
-              ... cheeseFields
-            }
-        }
-
-        fragment cheeseFields on Cheese {
-          flavor
-        }
-      |}
-
-      it "converts items to plain values" do
-        sheep_value = result["data"]["sheep"]["flavor"]
-        cow_value = result["data"]["cow"]["flavor"]
-        assert_equal("Manchego", sheep_value)
-        assert_equal("Brie", cow_value)
+        test_input_type = TestInput.to_graphql
+        default_test_input_value = test_input_type.coerce_isolated_input({})
+        assert_equal default_test_input_value[:foo], 'a'
       end
     end
-
-    describe "scalar inputs" do
-      let(:query_string) {%|
-        {
-          cheese(id: 1.4) {
-            flavor
-          }
-        }
-      |}
-
-      it "converts them to the correct type" do
-        cheese_name = result["data"]["cheese"]["flavor"]
-        assert_equal("Brie", cheese_name)
-      end
-    end
-  end
-
-  describe "#dup" do
-    it "shallow-copies internal state" do
-      input_object_2 = input_object.dup
-      input_object_2.arguments["nonsense"] = GraphQL::Argument.define(name: "int", type: GraphQL::INT_TYPE)
-      assert_equal 5, input_object.arguments.size
-      assert_equal 6, input_object_2.arguments.size
-    end
   end
 end

data/spec/graphql/int_type_spec.rb

@@ -12,5 +12,24 @@ describe GraphQL::INT_TYPE do
       assert_nil GraphQL::INT_TYPE.coerce_isolated_input("55")
       assert_nil GraphQL::INT_TYPE.coerce_isolated_input(true)
     end
+
+    describe "handling boundaries" do
+      let(:context) { GraphQL::Query.new(Dummy::Schema, "{ __typename }").context }
+
+      it "accepts result values in bounds" do
+        assert_equal 0, GraphQL::INT_TYPE.coerce_result(0, context)
+        assert_equal (2**31) - 1, GraphQL::INT_TYPE.coerce_result((2**31) - 1, context)
+        assert_equal -(2**31), GraphQL::INT_TYPE.coerce_result(-(2**31), context)
+      end
+
+      it "replaces values, if configured to do so" do
+        assert_equal Dummy::Schema::MAGIC_INT_COERCE_VALUE, GraphQL::INT_TYPE.coerce_result(99**99, context)
+      end
+
+      it "raises on values out of bounds" do
+        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(2**31, context) }
+        assert_raises(GraphQL::IntegerEncodingError) { GraphQL::INT_TYPE.coerce_result(-(2**31 + 1), context) }
+      end
+    end
   end
 end

data/spec/graphql/interface_type_spec.rb

@@ -2,11 +2,11 @@
 require "spec_helper"
 
 describe GraphQL::InterfaceType do
-  let(:interface) { Dummy::EdibleInterface }
+  let(:interface) { Dummy::Edible.graphql_definition }
   let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
 
   it "has possible types" do
-    assert_equal([Dummy::CheeseType, Dummy::HoneyType, Dummy::MilkType], Dummy::Schema.possible_types(interface))
+    assert_equal([Dummy::Cheese.graphql_definition, Dummy::Honey.graphql_definition, Dummy::Milk.graphql_definition], Dummy::Schema.possible_types(interface))
   end
 
   describe "query evaluation" do
@@ -96,11 +96,11 @@ describe GraphQL::InterfaceType do
     it "copies orphan types without affecting the original" do
       interface = GraphQL::InterfaceType.define do
         name "AInterface"
-        orphan_types [Dummy::HoneyType]
+        orphan_types [Dummy::Honey]
       end
 
       interface_2 = interface.dup
-      interface_2.orphan_types << Dummy::CheeseType
+      interface_2.orphan_types << Dummy::Cheese
       assert_equal 1, interface.orphan_types.size
       assert_equal 2, interface_2.orphan_types.size
     end