graphql 1.6.4 → 1.6.5

data/spec/graphql/query/context_spec.rb

@@ -24,6 +24,13 @@ describe GraphQL::Query::Context do
     field :pushContext, types.Int do
       resolve ->(t,a,c) { CTX << c; 1 }
     end
+
+    field :pushQueryError, types.Int do
+      resolve ->(t,a,c) {
+        c.query.context.add_error(GraphQL::ExecutionError.new("Query-level error"))
+        1
+      }
+    end
   }}
   let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
   let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
@@ -118,4 +125,15 @@ describe GraphQL::Query::Context do
       assert_equal [2, 9], [err.ast_node.line, err.ast_node.col]
     end
   end
+
+  describe "query-level errors" do
+    let(:query_string) { %|
+      { pushQueryError }
+    |}
+
+    it "allows query-level errors" do
+      expected_err = { "message" => "Query-level error" }
+      assert_equal [expected_err], result["errors"]
+    end
+  end
 end

data/spec/graphql/query/executor_spec.rb

@@ -119,7 +119,7 @@ describe GraphQL::Query::Executor do
         end
       end
 
-      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutationType, resolve_type: :pass, id_from_object: :pass)
+      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutationType, resolve_type: ->(a,b,c) { :pass }, id_from_object: :pass)
     }
     let(:variables) { nil }
     let(:query_string) { %|

data/spec/graphql/query/literal_input_spec.rb

@@ -5,8 +5,8 @@ describe GraphQL::Query::LiteralInput do
   describe ".from_arguments" do
     describe "arguments are prepared" do
       let(:schema) {
-        query = GraphQL::ObjectType.define do
-          name "Query"
+        type = GraphQL::ObjectType.define do
+          name "SomeType"
 
           field :addToArgumentValue do
             type !types.Int
@@ -35,40 +35,56 @@ describe GraphQL::Query::LiteralInput do
           end
         end
 
+        query = GraphQL::ObjectType.define do
+          name "Query"
+
+          field :top, type, resolve: ->(_, _, _) { true }
+        end
+
         GraphQL::Schema.define(query: query)
       }
 
       it "prepares values from query literals" do
-        result = schema.execute("{ addToArgumentValue(value: 1) }", context: { val: 1 })
-        assert_equal(result["data"]["addToArgumentValue"], 2)
+        result = schema.execute("{ top { addToArgumentValue(value: 1) } }", context: { val: 1 })
+        assert_equal(result["data"]["top"]["addToArgumentValue"], 2)
       end
 
       it "prepares default values" do
-        result = schema.execute("{ addToArgumentValue }", context: { val: 4 })
-        assert_equal(7, result["data"]["addToArgumentValue"])
+        result = schema.execute("{ top { addToArgumentValue } }", context: { val: 4 })
+        assert_equal(7, result["data"]["top"]["addToArgumentValue"])
       end
 
       it "raises an execution error if the default value is bad" do
-        result = schema.execute("{ fieldWithArgumentThatIsBadByDefault }", context: { })
-        assert_equal(result["errors"], [{"message" => "Always bad"}])
+        result = schema.execute("{ top { fieldWithArgumentThatIsBadByDefault } }", context: { })
+        assert_equal(result["data"], {
+          "top"=>{
+            "fieldWithArgumentThatIsBadByDefault"=>nil}
+        })
+        assert_equal(result["errors"], [
+          {"message"=>"Always bad",
+           "locations"=>[{"line"=>1, "column"=>9}],
+           "path"=>["top", "fieldWithArgumentThatIsBadByDefault"]}
+        ])
       end
 
       it "prepares values from variables" do
-        result = schema.execute("query ($value: Int!) { addToArgumentValue(value: $value) }", variables: { "value" => 1}, context: { val: 2 } )
-        assert_equal(result["data"]["addToArgumentValue"], 3)
+        result = schema.execute("query ($value: Int!) { top { addToArgumentValue(value: $value) } }", variables: { "value" => 1}, context: { val: 2 } )
+        assert_equal(result["data"]["top"]["addToArgumentValue"], 3)
       end
 
       it "prepares values correctly if called multiple times with different arguments" do
-        result = schema.execute("{ first: addToArgumentValue(value: 1) second: addToArgumentValue(value: 2) }", context: { val: 3 })
-        assert_equal(result["data"]["first"], 4)
-        assert_equal(result["data"]["second"], 5)
+        result = schema.execute("{ top { first: addToArgumentValue(value: 1) second: addToArgumentValue(value: 2) } }", context: { val: 3 })
+        assert_equal(result["data"]["top"]["first"], 4)
+        assert_equal(result["data"]["top"]["second"], 5)
       end
 
       it "adds message to errors key if an ExecutionError is returned from the prepare function" do
-        result = schema.execute("{ addToArgumentValue(value: 999) }")
+        result = schema.execute("{ top { addToArgumentValue(value: 999) } }")
+        assert_equal(result["data"]["top"], nil)
         assert_equal(result["errors"][0]["message"], "Can't return more than 3 digits")
         assert_equal(result["errors"][0]["locations"][0]["line"], 1)
-        assert_equal(result["errors"][0]["locations"][0]["column"], 22)
+        assert_equal(result["errors"][0]["locations"][0]["column"], 28)
+        assert_equal(result["errors"][0]["path"], ["top", "addToArgumentValue"])
       end
     end
   end

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -45,7 +45,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
     GraphQL::Schema.define do
       query(query_root)
       orphan_types [some_object]
-      resolve_type ->(obj, ctx) do
+      resolve_type ->(type, obj, ctx) do
         if obj.is_a?(Symbol)
           other_object
         else

data/spec/graphql/query/variables_spec.rb

@@ -16,7 +16,8 @@ describe GraphQL::Query::Variables do
   |}
   let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
   let(:schema) { Dummy::Schema }
-  let(:variables) { GraphQL::Query::Variables.new(
+  let(:variables) {
+    GraphQL::Query::Variables.new(
     OpenStruct.new({
       schema: schema,
       warden: GraphQL::Schema::Warden.new(schema.default_filter, schema: schema, context: nil),
@@ -34,6 +35,29 @@ describe GraphQL::Query::Variables do
       end
     end
 
+    describe "validating input objects" do
+      let(:query_string) {%|
+      query searchMyDairy (
+        $product: DairyProductInput
+      ) {
+        searchDairy(product: $product) {
+          ... on Cheese {
+            flavor
+          }
+        }
+      }
+      |}
+
+      describe "when provided input is an array" do
+        let(:provided_variables) { { "product" => [] } }
+
+        it "validates invalid input objects" do
+          expected = "Variable product of type DairyProductInput was provided invalid value"
+          assert_equal expected, variables.errors.first.message
+        end
+      end
+    end
+
     describe "nullable variables" do
       module ObjectWithThingsCount
         def self.thingsCount(args, ctx) # rubocop:disable Style/MethodName

data/spec/graphql/query_spec.rb

@@ -45,15 +45,15 @@ describe GraphQL::Query do
   let(:result) { query.result }
 
   describe "when passed no query string or document" do
-    it 'fails with an ArgumentError' do
-      assert_raises(ArgumentError) {
-        GraphQL::Query.new(
-          schema,
-          variables: query_variables,
-          operation_name: operation_name,
-          max_depth: max_depth,
-        ).result
-      }
+    it 'returns an error to the client' do
+      res = GraphQL::Query.new(
+        schema,
+        variables: query_variables,
+        operation_name: operation_name,
+        max_depth: max_depth,
+      ).result
+      assert_equal 1, res["errors"].length
+      assert_equal "No query string was present", res["errors"][0]["message"]
     end
 
     it 'can be assigned later' do
@@ -94,6 +94,21 @@ describe GraphQL::Query do
         assert_equal "q3", query.selected_operation_name
       end
     end
+
+    describe "assigning operation_name=" do
+      let(:query_string) { <<-GRAPHQL
+          query q3 { manchego: cheese(id: 3) { flavor } }
+          query q2 { gouda: cheese(id: 2) { flavor } }
+        GRAPHQL
+      }
+
+      it "runs the assigned name" do
+        query = GraphQL::Query.new(Dummy::Schema, query_string, operation_name: "q3")
+        query.operation_name = "q2"
+        res = query.result
+        assert_equal "Gouda", res["data"]["gouda"]["flavor"]
+      end
+    end
   end
 
   describe "when passed a document instance" do

data/spec/graphql/relay/mutation_spec.rb

@@ -258,7 +258,7 @@ describe GraphQL::Relay::Mutation do
 
       GraphQL::Schema.define do
         mutation(mutation_root)
-        resolve_type ->(obj, ctx) { "not really used" }
+        resolve_type NO_OP_RESOLVE_TYPE
       end
     }
 

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -735,7 +735,7 @@ SCHEMA
             val.to_f
           }
         },
-        resolve_type: ->(obj, ctx) {
+        resolve_type: ->(type, obj, ctx) {
           return ctx.schema.types['A']
         },
         Query: {

data/spec/graphql/schema/loader_spec.rb

@@ -125,7 +125,7 @@ describe GraphQL::Schema::Loader do
       query: query_root,
       mutation: mutation_root,
       orphan_types: [audio_type, video_type],
-      resolve_type: :pass,
+      resolve_type: ->(a,b,c) { :pass },
     )
   }
 

data/spec/graphql/schema/printer_spec.rb

@@ -123,7 +123,7 @@ describe GraphQL::Schema::Printer do
       query: query_root,
       mutation: mutation_root,
       subscription: subscription_root,
-      resolve_type: :pass,
+      resolve_type: ->(a,b,c) { :pass },
       orphan_types: [media_union_type]
     )
   }

data/spec/graphql/schema/{reduce_types_spec.rb → traversal_spec.rb}

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 require "spec_helper"
 
-describe GraphQL::Schema::ReduceTypes do
+describe GraphQL::Schema::Traversal do
   def reduce_types(types)
-    GraphQL::Schema::ReduceTypes.reduce(types)
+    schema = GraphQL::Schema.define(orphan_types: types, resolve_type: :dummy)
+    traversal = GraphQL::Schema::Traversal.new(schema, introspection: false)
+    traversal.type_map
   end
 
   it "finds types from a single type and its fields" do
@@ -12,13 +14,14 @@ describe GraphQL::Schema::ReduceTypes do
       "Float" => GraphQL::FLOAT_TYPE,
       "String" => GraphQL::STRING_TYPE,
       "Edible" => Dummy::EdibleInterface,
+      "EdibleAsMilk" => Dummy::EdibleAsMilkInterface,
       "DairyAnimal" => Dummy::DairyAnimalEnum,
       "Int" => GraphQL::INT_TYPE,
       "AnimalProduct" => Dummy::AnimalProductInterface,
       "LocalProduct" => Dummy::LocalProductInterface,
     }
     result = reduce_types([Dummy::CheeseType])
-    assert_equal(expected.keys, result.keys)
+    assert_equal(expected.keys.sort, result.keys.sort)
     assert_equal(expected, result.to_h)
   end
 
@@ -27,6 +30,20 @@ describe GraphQL::Schema::ReduceTypes do
     assert_equal(Dummy::DairyProductInputType, result["DairyProductInput"])
   end
 
+  it "finds types from field instrumentation" do
+    type = GraphQL::ObjectType.define do
+      name "ArgTypeTest"
+      connection :t, type.connection_type
+    end
+
+    result = reduce_types([type])
+    expected_types = [
+      "ArgTypeTest", "ArgTypeTestConnection", "ArgTypeTestEdge",
+      "Boolean", "Int", "PageInfo", "String"
+    ]
+    assert_equal expected_types, result.keys.sort
+  end
+
   it "finds types from nested InputObjectTypes" do
     type_child = GraphQL::InputObjectType.define do
       name "InputTypeChild"
@@ -92,7 +109,7 @@ describe GraphQL::Schema::ReduceTypes do
   describe "when getting a type which doesnt exist" do
     it "raises an error" do
       type_map = reduce_types([])
-      assert_raises(RuntimeError) { type_map["SomeType"] }
+      assert_raises(KeyError) { type_map.fetch("SomeType") }
     end
   end
 

data/spec/graphql/schema/warden_spec.rb

@@ -120,7 +120,7 @@ module MaskHelpers
     query QueryType
     mutation MutationType
     subscription MutationType
-    resolve_type ->(obj, ctx) { PhonemeType }
+    resolve_type ->(type, obj, ctx) { PhonemeType }
     instrument :query, FilterInstrumentation
   end
 

data/spec/graphql/schema_spec.rb

@@ -99,7 +99,7 @@ describe GraphQL::Schema do
         assert_raises(NotImplementedError) {
           GraphQL::Schema.define do
             query(query_type)
-            resolve_type ->(obj, ctx) { :whatever }
+            resolve_type NO_OP_RESOLVE_TYPE
           end
         }
       end
@@ -125,7 +125,7 @@ describe GraphQL::Schema do
         assert_raises(NotImplementedError) {
           GraphQL::Schema.define do
             query(query_type)
-            resolve_type ->(obj, ctx) { :whatever }
+            resolve_type NO_OP_RESOLVE_TYPE
           end
         }
       end
@@ -293,6 +293,27 @@ type Query {
       res = schema.execute("query { int(value: 2) } ")
       assert_equal 24, res["data"]["int"]
     end
+
+    class CyclicalDependencyInstrumentation
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def instrument(type, field)
+        @schema.types # infinite loop
+        field
+      end
+    end
+
+    describe "field instrumenters which cause loops" do
+      it "has a nice error message" do
+        assert_raises(GraphQL::Schema::CyclicalDefinitionError) do
+          schema.redefine {
+            instrument(:field, CyclicalDependencyInstrumentation.new(self.target))
+          }
+        end
+      end
+    end
   end
 
   describe "#lazy? / #lazy_method_name" do

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

@@ -80,4 +80,137 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
       assert_equal "Argument 'id' on Field 'cheese' has an invalid value. Expected type 'Int!'.", errors[0]["message"]
     end
   end
+
+  describe "list-type variables" do
+    let(:schema) {
+      GraphQL::Schema.from_definition <<-GRAPHQL
+      input ImageSize {
+        height: Int
+        width: Int
+        scale: Int
+      }
+
+      type Query {
+        imageUrl(height: Int, width: Int, size: ImageSize, sizes: [ImageSize!]): String!
+      }
+      GRAPHQL
+    }
+
+    describe "nullability mismatch" do
+      let(:query_string) {
+        <<-GRAPHQL
+        # This variable _should_ be [ImageSize!]
+        query ($sizes: [ImageSize]) {
+          imageUrl(sizes: $sizes)
+        }
+        GRAPHQL
+      }
+
+      it "finds invalid inner definitions" do
+        assert_equal 1, errors.size
+        expected_message = "Nullability mismatch on variable $sizes and argument sizes ([ImageSize] / [ImageSize!])"
+        assert_equal [expected_message], errors.map { |e| e["message"] }
+      end
+    end
+
+    describe "list dimension mismatch" do
+      let(:query_string) {
+        <<-GRAPHQL
+        query ($sizes: [ImageSize]) {
+          imageUrl(sizes: [$sizes])
+        }
+        GRAPHQL
+      }
+
+      it "finds invalid inner definitions" do
+        assert_equal 1, errors.size
+        expected_message = "List dimension mismatch on variable $sizes and argument sizes ([[ImageSize]] / [ImageSize!])"
+        assert_equal [expected_message], errors.map { |e| e["message"] }
+      end
+    end
+
+    describe 'list is in the argument' do
+      let(:query_string) {
+        <<-GRAPHQL
+        query ($size: ImageSize!) {
+          imageUrl(sizes: [$size])
+        }
+        GRAPHQL
+      }
+
+      it "is a valid query" do
+        assert_equal 0, errors.size
+      end
+
+      describe "mixed with invalid literals" do
+        let(:query_string) {
+          <<-GRAPHQL
+          query ($size: ImageSize!) {
+            imageUrl(sizes: [$size, 1, true])
+          }
+          GRAPHQL
+        }
+
+        it "is an invalid query" do
+          assert_equal 1, errors.size
+        end
+      end
+
+      describe "mixed with invalid variables" do
+        let(:query_string) {
+          <<-GRAPHQL
+          query ($size: ImageSize!, $wrongSize: Boolean!) {
+            imageUrl(sizes: [$size, $wrongSize])
+          }
+          GRAPHQL
+        }
+
+        it "is an invalid query" do
+          assert_equal 1, errors.size
+        end
+      end
+
+      describe "mixed with valid literals and invalid variables" do
+        let(:query_string) {
+          <<-GRAPHQL
+          query ($size: ImageSize!, $wrongSize: Boolean!) {
+            imageUrl(sizes: [$size, {height: 100} $wrongSize])
+          }
+          GRAPHQL
+        }
+
+        it "is an invalid query" do
+          assert_equal 1, errors.size
+        end
+      end
+    end
+
+    describe 'argument contains a list with literal values' do
+      let(:query_string) {
+        <<-GRAPHQL
+        query  {
+          imageUrl(sizes: [{height: 100, width: 100, scale: 1}])
+        }
+        GRAPHQL
+      }
+
+      it "is a valid query" do
+        assert_equal 0, errors.size
+      end
+    end
+
+    describe 'argument contains a list with both literal and variable values' do
+      let(:query_string) {
+        <<-GRAPHQL
+        query($size1: ImageSize!, $size2: ImageSize!)  {
+          imageUrl(sizes: [{height: 100, width: 100, scale: 1}, $size1, {height: 1920, width: 1080, scale: 2}, $size2])
+        }
+        GRAPHQL
+      }
+
+      it "is a valid query" do
+        assert_equal 0, errors.size
+      end
+    end
+  end
 end