graphql 1.1.0 → 1.2.0

data/spec/graphql/introspection/schema_type_spec.rb

@@ -32,6 +32,7 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"milk"},
             {"name"=>"root"},
             {"name"=>"searchDairy"},
+            {"name"=>"valueWithExecutionError"},
           ]
         },
         "mutationType"=> {

data/spec/graphql/introspection/type_type_spec.rb

@@ -18,6 +18,7 @@ describe GraphQL::Introspection::TypeType do
     {"name"=>"id",          "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "Int"}}},
     {"name"=>"nullableCheese", "isDeprecated"=>false, "type"=>{ "kind" => "OBJECT",  "name" => "Cheese", "ofType"=>nil}},
     {"name"=>"origin",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "String"}}},
+    {"name"=>"selfAsEdible", "isDeprecated"=>false, "type"=>{"kind"=>"INTERFACE", "name"=>"Edible", "ofType"=>nil}},
     {"name"=>"similarCheese", "isDeprecated"=>false, "type"=>{ "kind" => "OBJECT", "name"=>"Cheese", "ofType"=>nil}},
     {"name"=>"source",      "isDeprecated" => false, "type" => { "kind" => "NON_NULL", "name" => nil, "ofType" => { "name" => "DairyAnimal"}}},
   ]}
@@ -49,6 +50,7 @@ describe GraphQL::Introspection::TypeType do
           {"type"=>{"kind"=>"LIST","name"=>nil, "ofType"=>{"name"=>"String"}}},
           {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"ID"}}},
           {"type"=>{"kind"=>"NON_NULL","name"=>nil, "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"kind"=>"INTERFACE", "name"=>"Edible", "ofType"=>nil}},
           {"type"=>{"kind"=>"ENUM","name"=>"DairyAnimal", "ofType"=>nil}},
         ]
       },

data/spec/graphql/language/generation_spec.rb

@@ -31,7 +31,7 @@ describe GraphQL::Language::Generation do
     describe "inputs" do
       let(:query_string) {%|
         query {
-          field(int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
+          field(null_value: null, null_in_array: [1, null, 3], int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
         }
       |}
 
@@ -102,7 +102,7 @@ describe GraphQL::Language::Generation do
       end
 
       describe "full featured schema" do
-        # From: https://github.com/graphql/graphql-js/blob/a725499b155285c2e33647a93393c82689b20b0f/src/language/__tests__/schema-kitchen-sink.graphql
+        # From: https://github.com/graphql/graphql-js/blob/bc96406ab44453a120da25a0bd6e2b0237119ddf/src/language/__tests__/schema-kitchen-sink.graphql
         let(:query_string) {<<-schema
           schema {
             query: QueryType
@@ -119,6 +119,7 @@ describe GraphQL::Language::Generation do
             four(argument: String = "string"): String
             five(argument: [String] = ["string", "string"]): String
             six(argument: InputType = {key: "value"}): Type
+            seven(argument: String = null): Type
           }
 
           # Scalar description

data/spec/graphql/query/arguments_spec.rb

@@ -168,11 +168,9 @@ describe GraphQL::Query::Arguments do
       assert_equal true, test_inputs.key?(:b)
 
       assert_equal false, test_inputs.key?(:c)
-      # This _was_ present in the variables,
-      # but it was nil, which is not allowed in GraphQL
-      assert_equal false, test_inputs.key?(:d)
+      assert_equal true, test_inputs.key?(:d)
 
-      assert_equal({"a" => 1, "b" => 2}, test_inputs.to_h)
+      assert_equal({"a" => 1, "b" => 2, "d" => nil}, test_inputs.to_h)
     end
 
     it "works with variable default values" do
@@ -188,5 +186,20 @@ describe GraphQL::Query::Arguments do
       assert_equal false, test_defaults.key?(:d)
       assert_equal({"a" => 1, "b" => 2}, test_defaults.to_h)
     end
+
+    it "works with variable default values with null" do
+      schema.execute("query ArgTest($arg: TestInput = {d: null}){ argTest(d: $arg) }")
+
+      test_defaults = arg_values.last["d"]
+
+      assert_equal false, test_defaults.key?(:a)
+      # This is present from default val
+      assert_equal true, test_defaults.key?(:b)
+
+      assert_equal false, test_defaults.key?(:c)
+      assert_equal true, test_defaults.key?(:d)
+
+      assert_equal({"d" => nil, "b" => 2}, test_defaults.to_h)
+    end
   end
 end

data/spec/graphql/query/context_spec.rb

@@ -1,6 +1,9 @@
 require "spec_helper"
 
 describe GraphQL::Query::Context do
+  CTX = []
+  before { CTX.clear }
+
   let(:query_type) { GraphQL::ObjectType.define {
     name "Query"
     field :context, types.String do
@@ -16,6 +19,10 @@ describe GraphQL::Query::Context do
     field :queryName, types.String do
       resolve ->(target, args, ctx) { ctx.query.class.name }
     end
+
+    field :pushContext, types.Int do
+      resolve ->(t,a,c) { CTX << c; 1 }
+    end
   }}
   let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
   let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
@@ -81,4 +88,20 @@ describe GraphQL::Query::Context do
       assert_equal("wow!", context[:some_key])
     end
   end
+
+  describe "accessing context after the fact" do
+    let(:query_string) { %|
+      { pushContext }
+    |}
+
+    it "preserves path information" do
+      assert_equal 1, result["data"]["pushContext"]
+      last_ctx = CTX.pop
+      assert_equal ["pushContext"], last_ctx.path
+      err = GraphQL::ExecutionError.new("Test position info")
+      last_ctx.add_error(err)
+      assert_equal ["pushContext"], err.path
+      assert_equal [2, 9], [err.ast_node.line, err.ast_node.col]
+    end
+  end
 end

data/spec/graphql/query/variables_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe GraphQL::Query::Variables do
   let(:query_string) {%|
-  query getCheese($animals: [DairyAnimal]) {
+  query getCheese($animals: [DairyAnimal], $int: Int, $intWithDefault: Int = 10) {
     cheese(id: 1) {
       similarCheese(source: $animals)
     }
@@ -25,5 +25,19 @@ describe GraphQL::Query::Variables do
         assert_equal ["YAK"], variables["animals"]
       end
     end
+
+    describe "coercing null" do
+      let(:provided_variables) {
+        {"int" => nil, "intWithDefault" => nil}
+      }
+
+      it "null variable" do
+        assert_equal nil, variables["int"]
+      end
+
+      it "preserves explicit null when variable has a default value" do
+        assert_equal nil, variables["intWithDefault"]
+      end
+    end
   end
 end

data/spec/graphql/relay/mutation_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe GraphQL::Relay::Mutation do
   let(:query_string) {%|
-    mutation addBagel($clientMutationId: String) {
-      introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: $clientMutationId}) {
+    mutation addBagel($clientMutationId: String, $shipName: String = "Bagel") {
+      introduceShip(input: {shipName: $shipName, factionId: "1", clientMutationId: $clientMutationId}) {
         clientMutationId
         shipEdge {
           node { name, id }
@@ -25,6 +25,24 @@ describe GraphQL::Relay::Mutation do
     STAR_WARS_DATA["Faction"]["1"].ships.delete("9")
   end
 
+  it "supports null values" do
+    result = star_wars_query(query_string, "clientMutationId" => "1234", "shipName" => nil)
+
+    expected = {"data" => {
+      "introduceShip" => {
+        "clientMutationId" => "1234",
+        "shipEdge" => {
+          "node" => {
+            "name" => nil,
+            "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
+          },
+        },
+        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+      }
+    }}
+    assert_equal(expected, result)
+  end
+
   it "returns the result & clientMutationId" do
     result = star_wars_query(query_string, "clientMutationId" => "1234")
     expected = {"data" => {
@@ -71,6 +89,11 @@ describe GraphQL::Relay::Mutation do
       custom_type = custom_return_type
       GraphQL::Relay::Mutation.define do
         name "CustomReturnTypeTest"
+
+        input_field :nullDefault, types.String, default_value: nil
+        input_field :noDefault, types.String
+        input_field :stringDefault, types.String, default_value: 'String'
+
         return_type custom_type
         resolve ->(obj, input, ctx) {
           OpenStruct.new(name: "Custom Return Type Test")
@@ -78,6 +101,8 @@ describe GraphQL::Relay::Mutation do
       end
     }
 
+    let(:input) { mutation.field.arguments['input'].type.unwrap }
+
     let(:schema) {
       mutation_field = mutation.field
 
@@ -102,5 +127,20 @@ describe GraphQL::Relay::Mutation do
     it "doesn't get a mutation in the metadata" do
       assert_equal nil, custom_return_type.mutation
     end
+
+    it "supports input fields with nil default value" do
+      assert input.arguments['nullDefault'].default_value?
+      assert_equal nil, input.arguments['nullDefault'].default_value
+    end
+
+    it "supports input fields with no default value" do
+      assert !input.arguments['noDefault'].default_value?
+      assert_equal nil, input.arguments['noDefault'].default_value
+    end
+
+    it "supports input fields with non-nil default value" do
+      assert input.arguments['stringDefault'].default_value?
+      assert_equal "String", input.arguments['stringDefault'].default_value
+    end
   end
 end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -31,7 +31,7 @@ schema {
   query: Hello
 }
 
-directive @foo(arg: Int) on FIELD
+directive @foo(arg: Int, nullDefault: Int = null) on FIELD
 
 type Hello {
   str: String
@@ -356,6 +356,7 @@ schema {
 
 input Input {
   int: Int
+  nullDefault: Int = null
 }
 
 type Root {
@@ -380,6 +381,7 @@ enum Color {
 type Hello {
   str(int: Int = 2): String
   hello(color: Color = RED): String
+  nullable(color: Color = null): String
 }
       SCHEMA
 
@@ -415,7 +417,7 @@ enum Color {
 }
 
 type Mutation {
-  hello(str: String, int: Int, color: Color = RED): String
+  hello(str: String, int: Int, color: Color = RED, nullDefault: Int = null): String
 }
 
 type Query {

data/spec/graphql/schema/loader_spec.rb

@@ -37,6 +37,17 @@ describe GraphQL::Schema::Loader do
       input_field :sub, types[sub_input_type]
     end
 
+    variant_input_type_with_nulls = GraphQL::InputObjectType.define do
+      name "VariedWithNulls"
+      input_field :id, types.ID, default_value: nil
+      input_field :int, types.Int, default_value: nil
+      input_field :bigint, big_int_type, default_value: nil
+      input_field :float, types.Float, default_value: nil
+      input_field :bool, types.Boolean, default_value: nil
+      input_field :enum, choice_type, default_value: nil
+      input_field :sub, types[sub_input_type], default_value: nil
+    end
+
     comment_type = GraphQL::ObjectType.define do
       name "Comment"
       description "A blog comment"
@@ -90,6 +101,7 @@ describe GraphQL::Schema::Loader do
         type post_type
         argument :id, !types.ID
         argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }
+        argument :variedWithNull, variant_input_type_with_nulls, default_value: { id: nil, int: nil, float: nil, enum: nil, sub: nil, bigint: nil, bool: nil }
       end
 
       field :content do
@@ -205,7 +217,53 @@ describe GraphQL::Schema::Loader do
       field = type.fields['post']
       arg = field.arguments['varied']
 
-      assert_equal arg.default_value, { 'id' => "123", 'bigint' => nil, 'bool' => nil, 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }
+      assert_equal arg.default_value, { 'id' => "123", 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }
+      assert !arg.default_value.key?('bool'), 'Omits default value for unspecified arguments'
+    end
+
+    it "does not set default value when there are none on input fields" do
+      type = loaded_schema.types['Varied']
+
+      assert !type.arguments['id'].default_value?
+      assert !type.arguments['int'].default_value?
+      assert type.arguments['bigint'].default_value?
+      assert !type.arguments['float'].default_value?
+      assert !type.arguments['bool'].default_value?
+      assert !type.arguments['enum'].default_value?
+      assert !type.arguments['sub'].default_value?
+    end
+
+    it "sets correct default values `null` on input fields" do
+      type = loaded_schema.types['VariedWithNulls']
+
+      assert type.arguments['id'].default_value?
+      assert type.arguments['id'].default_value.nil?
+
+      assert type.arguments['int'].default_value?
+      assert type.arguments['int'].default_value.nil?
+
+      assert type.arguments['bigint'].default_value?
+      assert type.arguments['bigint'].default_value.nil?
+
+      assert type.arguments['float'].default_value?
+      assert type.arguments['float'].default_value.nil?
+
+      assert type.arguments['bool'].default_value?
+      assert type.arguments['bool'].default_value.nil?
+
+      assert type.arguments['enum'].default_value?
+      assert type.arguments['enum'].default_value.nil?
+
+      assert type.arguments['sub'].default_value?
+      assert type.arguments['sub'].default_value.nil?
+    end
+
+    it "sets correct default values `null` on complex field arguments" do
+      type = loaded_schema.types['Query']
+      field = type.fields['post']
+      arg = field.arguments['variedWithNull']
+
+      assert_equal arg.default_value, { 'id' => nil, 'int' => nil, 'float' => nil, 'enum' => nil, 'sub' => nil, 'bool' => nil, 'bigint' => nil }
     end
   end
 end

data/spec/graphql/schema/printer_spec.rb

@@ -85,6 +85,7 @@ describe GraphQL::Schema::Printer do
         type post_type
         argument :id, !types.ID, 'Post ID'
         argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }
+        argument :variedWithNulls, variant_input_type, default_value: { id: nil, int: nil, float: nil, enum: nil, sub: nil }
         resolve ->(obj, args, ctx) { Post.find(args["id"]) }
       end
     end
@@ -444,6 +445,7 @@ type Query {
     # Post ID
     id: ID!
     varied: Varied = {id: \"123\", int: 234, float: 2.3, enum: FOO, sub: [{string: \"str\"}]}
+    variedWithNulls: Varied = {id: null, int: null, float: null, enum: null, sub: null}
   ): Post
 }
 

data/spec/graphql/schema/reduce_types_spec.rb

@@ -10,9 +10,9 @@ describe GraphQL::Schema::ReduceTypes do
       "Cheese" => CheeseType,
       "Float" => GraphQL::FLOAT_TYPE,
       "String" => GraphQL::STRING_TYPE,
+      "Edible" => EdibleInterface,
       "DairyAnimal" => DairyAnimalEnum,
       "Int" => GraphQL::INT_TYPE,
-      "Edible" => EdibleInterface,
       "AnimalProduct" => AnimalProductInterface,
       "LocalProduct" => LocalProductInterface,
     }

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -166,7 +166,7 @@ describe GraphQL::Schema::TimeoutMiddleware do
   describe "with a custom block" do
     let(:timeout_middleware) {
       GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) do |err, query|
-        raise("Query timed out after 2s: #{query.class.name} on #{query.context.ast_node.alias}")
+        raise("Query timed out after 2s: #{query.operations.count} on #{query.context.ast_node.alias}")
       end
     }
     let(:query_string) {%|
@@ -181,7 +181,7 @@ describe GraphQL::Schema::TimeoutMiddleware do
 
     it "calls the block" do
       err = assert_raises(RuntimeError) { result }
-      assert_equal "Query timed out after 2s: GraphQL::Query on d", err.message
+      assert_equal "Query timed out after 2s: 1 on d", err.message
     end
   end
 end

data/spec/graphql/schema/unique_within_type_spec.rb

@@ -9,6 +9,15 @@ describe GraphQL::Schema::UniqueWithinType do
       assert_equal("123", id)
     end
 
+    it "allows you specify default separator" do
+      GraphQL::Schema::UniqueWithinType.default_id_separator = '|'
+      global_id = GraphQL::Schema::UniqueWithinType.encode("Type-With-UUID", "250cda0e-a89d-41cf-99e1-2872d89f1100")
+      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
+      assert_equal("Type-With-UUID", type_name)
+      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
+      GraphQL::Schema::UniqueWithinType.default_id_separator = '-'
+    end
+
     it "allows you to specify the separator" do
       custom_separator = "---"
       global_id = GraphQL::Schema::UniqueWithinType.encode("Type-With-UUID", "250cda0e-a89d-41cf-99e1-2872d89f1100", separator: custom_separator)

data/spec/graphql/schema/validation_spec.rb

@@ -200,7 +200,7 @@ describe GraphQL::Schema::Validation do
       end
     }
 
-    let(:invalid_default_argument_for_non_null_field) {
+    let(:invalid_default_argument_for_non_null_argument) {
       GraphQL::Argument.define do
         name "InvalidDefault"
         type !GraphQL::INT_TYPE
@@ -208,12 +208,24 @@ describe GraphQL::Schema::Validation do
       end
     }
 
+    let(:null_default_value) {
+      GraphQL::Argument.define do
+        name "NullDefault"
+        type DairyAnimalEnum
+        default_value nil
+      end
+    }
+
     it "requires the type is a Base type" do
       assert_error_includes untyped_argument, "must be a valid input type (Scalar or InputObject), not Symbol"
     end
 
-    it "does not allow default values for non-null fields" do
-      assert_error_includes invalid_default_argument_for_non_null_field, 'Variable InvalidDefault of type "Int!" is required and will not use the default value. Perhaps you meant to use type "Int".'
+    it "does not allow default values for non-null argument" do
+      assert_error_includes invalid_default_argument_for_non_null_argument, 'Variable InvalidDefault of type "Int!" is required and will not use the default value. Perhaps you meant to use type "Int".'
+    end
+
+    it "allows null default value for nullable argument" do
+      assert_equal nil, GraphQL::Schema::Validation.validate(null_default_value)
     end
   end
 end

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

@@ -65,4 +65,126 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     }
     assert_includes(errors, fragment_error)
   end
+
+  describe "null value" do
+    describe "nullable arg" do
+      let(:schema) {
+        GraphQL::Schema.from_definition(%|
+          type Query {
+            field(arg: Int): Int
+          }
+        |)
+      }
+      let(:query_string) {%|
+        query {
+          field(arg: null)
+        }
+      |}
+
+      it "finds no errors" do
+        assert_equal [], errors
+      end
+    end
+
+    describe "non-nullable arg" do
+      let(:schema) {
+        GraphQL::Schema.from_definition(%|
+          type Query {
+            field(arg: Int!): Int
+          }
+        |)
+      }
+      let(:query_string) {%|
+        query {
+          field(arg: null)
+        }
+      |}
+
+      it "finds error" do
+        assert_equal [{
+          "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>11}],
+          "fields"=>["query", "field", "arg"],
+        }], errors
+      end
+    end
+
+    describe "non-nullable array" do
+      let(:schema) {
+        GraphQL::Schema.from_definition(%|
+          type Query {
+            field(arg: [Int!]): Int
+          }
+        |)
+      }
+      let(:query_string) {%|
+        query {
+          field(arg: [null])
+        }
+      |}
+
+      it "finds error" do
+        assert_equal [{
+          "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type '[Int!]'.",
+          "locations"=>[{"line"=>3, "column"=>11}],
+          "fields"=>["query", "field", "arg"],
+        }], errors
+      end
+    end
+
+    describe "array with nullable values" do
+      let(:schema) {
+        GraphQL::Schema.from_definition(%|
+          type Query {
+            field(arg: [Int]): Int
+          }
+        |)
+      }
+      let(:query_string) {%|
+        query {
+          field(arg: [null])
+        }
+      |}
+
+      it "finds no errors" do
+        assert_equal [], errors
+      end
+    end
+
+    describe "input object" do
+      let(:schema) {
+        GraphQL::Schema.from_definition(%|
+          type Query {
+            field(arg: Input): Int
+          }
+
+          input Input {
+            a: Int
+            b: Int!
+          }
+        |)
+      }
+      let(:query_string) {%|
+        query {
+          field(arg: {a: null, b: null})
+        }
+      |}
+
+      it "finds errors" do
+        assert_equal 2, errors.length
+
+        assert_includes errors, {
+          "message"=> "Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
+          "locations"=>[{"line"=>3, "column"=>11}],
+          "fields"=>["query", "field", "arg"]
+        }
+
+        assert_includes errors, {
+          "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>22}],
+          "fields"=>["query", "field", "arg", "b"]
+        }
+      end
+    end
+  end
 end