graphql 1.2.6 → 1.3.0

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::CatchallMiddleware do

data/spec/graphql/schema/loader_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::Loader do
@@ -197,6 +198,12 @@ describe GraphQL::Schema::Loader do
       assert loaded_schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
     end
 
+    it "has no-op coerce functions" do
+      custom_scalar = loaded_schema.types["BigInt"]
+      assert_equal true, custom_scalar.valid_input?("anything", PermissiveWarden)
+      assert_equal true, custom_scalar.valid_input?(12345, PermissiveWarden)
+    end
+
     it "sets correct default values on custom scalar arguments" do
       type = loaded_schema.types["Comment"]
       field = type.fields['fieldWithArg']

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::MiddlewareChain do

data/spec/graphql/schema/printer_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::Printer do

data/spec/graphql/schema/reduce_types_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::ReduceTypes do

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 class SpecExampleError < StandardError; end

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::TimeoutMiddleware do

data/spec/graphql/schema/type_expression_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::TypeExpression do

data/spec/graphql/schema/unique_within_type_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::UniqueWithinType do

data/spec/graphql/schema/validation_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema::Validation do
@@ -6,6 +7,10 @@ describe GraphQL::Schema::Validation do
     assert_includes validation_error, error_substring
   end
 
+  def assert_validation_warns(object, warning)
+    assert_output("", warning + "\n") { GraphQL::Schema::Validation.validate(object) }
+  end
+
   describe "validating Fields" do
     let(:unnamed_field) {
       GraphQL::Field.define do
@@ -13,6 +18,13 @@ describe GraphQL::Schema::Validation do
       end
     }
 
+    let(:invalid_name_field) {
+      GraphQL::Field.define do
+        name "__Something"
+        type GraphQL::STRING_TYPE
+      end
+    }
+
     let(:untyped_field) {
       GraphQL::Field.define do
         name "Untyped"
@@ -44,6 +56,10 @@ describe GraphQL::Schema::Validation do
       assert_error_includes unnamed_field, "must return String, not NilClass"
     end
 
+    it "cannot use reserved name" do
+      assert_validation_warns invalid_name_field, 'Name "__Something" must not begin with "__", which is reserved by GraphQL introspection.'
+    end
+
     it "requires a BaseType for type" do
       assert_error_includes untyped_field, "must return GraphQL::BaseType, not Symbol"
     end
@@ -64,16 +80,27 @@ describe GraphQL::Schema::Validation do
       end
     }
 
+    let(:invalid_name_type) {
+      GraphQL::BaseType.define do
+        name '__Something'
+      end
+    }
+
     let(:wrongly_described_type) {
       GraphQL::BaseType.define do
         name "WronglyDescribed"
         description 12345
       end
     }
+
     it "requires a String name" do
       assert_error_includes unnamed_type, "must return String, not Symbol"
     end
 
+    it "cannot use reserved name" do
+      assert_validation_warns invalid_name_type, 'Name "__Something" must not begin with "__", which is reserved by GraphQL introspection.'
+    end
+
     it "requires String-or-nil description" do
       assert_error_includes wrongly_described_type, "must return String or NilClass, not Fixnum"
     end
@@ -86,6 +113,7 @@ describe GraphQL::Schema::Validation do
         interfaces(55)
       end
     }
+
     let(:invalid_interface_member_object) {
       GraphQL::ObjectType.define do
         name "InvalidInterfaceMember"
@@ -208,6 +236,13 @@ describe GraphQL::Schema::Validation do
       end
     }
 
+    let(:invalid_name_argument) {
+      GraphQL::Argument.define do
+        name "__Something"
+        type GraphQL::INT_TYPE
+      end
+    }
+
     let(:null_default_value) {
       GraphQL::Argument.define do
         name "NullDefault"
@@ -224,8 +259,28 @@ describe GraphQL::Schema::Validation 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 "cannot use reserved name" do
+      assert_validation_warns invalid_name_argument, 'Name "__Something" must not begin with "__", which is reserved by GraphQL introspection.'
+    end
+
     it "allows null default value for nullable argument" do
       assert_equal nil, GraphQL::Schema::Validation.validate(null_default_value)
     end
   end
+
+  describe "validating instrumentation" do
+    let(:schema) {
+      query_type = GraphQL::ObjectType.define(name: "Query")
+      GraphQL::Schema.define do
+        query(query_type)
+        instrument(:field, 1)
+        instrument(:query, :oops)
+      end
+    }
+    it "finds instrumenters missing methods" do
+      err = assert_raises(NotImplementedError) { schema }
+      assert_includes err.message, "before_query(query)"
+      assert_includes err.message, "instrument(type, field)"
+    end
+  end
 end

data/spec/graphql/schema/warden_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 module MaskHelpers

data/spec/graphql/schema_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::Schema do
@@ -271,4 +272,42 @@ type Query {
       assert_equal 24, res["data"]["int"]
     end
   end
+
+  describe "#lazy? / #lazy_method_name" do
+    class LazyObj; end
+    class LazyObjChild < LazyObj; end
+
+    let(:schema) {
+      query_type = GraphQL::ObjectType.define(name: "Query")
+      GraphQL::Schema.define do
+        query(query_type)
+        lazy_resolve(Integer, :itself)
+        lazy_resolve(LazyObj, :dup)
+      end
+    }
+
+    it "returns registered lazy method names by class/superclass, or returns nil" do
+      assert_equal :itself, schema.lazy_method_name(68)
+      assert_equal true, schema.lazy?(77)
+      assert_equal :dup, schema.lazy_method_name(LazyObj.new)
+      assert_equal true, schema.lazy?(LazyObj.new)
+      assert_equal :dup, schema.lazy_method_name(LazyObjChild.new)
+      assert_equal true, schema.lazy?(LazyObjChild.new)
+      assert_equal nil, schema.lazy_method_name({})
+      assert_equal false, schema.lazy?({})
+    end
+  end
+
+  describe "#dup" do
+    it "copies internal state" do
+      schema_2 = schema.dup
+      refute schema_2.types.equal?(schema.types)
+
+      refute schema_2.instrumenters.equal?(schema.instrumenters)
+      assert_equal schema_2.instrumenters, schema.instrumenters
+
+      refute schema_2.middleware.equal?(schema.middleware)
+      assert_equal schema_2.middleware, schema.middleware
+    end
+  end
 end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentsAreDefined do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::DirectivesAreDefined do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::DirectivesAreInValidLocations do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsAreDefinedOnType do

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do

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

@@ -1,43 +1,527 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsWillMerge do
   include StaticValidationHelpers
 
-  let(:query_string) {"
-    query getCheese($sourceVar: [DairyAnimal!] = [YAK]) {
-      cheese(id: 1) {
-        id,
-        nickname: flavor,
-        nickname: fatContent,
-        fatContent
-        differentLevel: fatContent
-        similarCheese(source: $sourceVar) { __typename }
+  let(:schema) {
+    GraphQL::Schema.from_definition(%|
+      type Query {
+        dog: Dog
+        cat: Cat
+        pet: Pet
+        toy: Toy
+      }
+
+      enum PetCommand {
+        SIT
+        HEEL
+        JUMP
+        DOWN
+      }
+
+      enum ToySize {
+        SMALL
+        LARGE
+      }
 
-        similarCow: similarCheese(source: COW) {
-          similarCowSource: source,
-          differentLevel: fatContent
+      interface Pet {
+        name(surname: Boolean = false): String!
+        nickname: String
+        toys: [Toy!]!
+      }
+
+      type Dog implements Pet {
+        name(surname: Boolean = false): String!
+        nickname: String
+        doesKnowCommand(dogCommand: PetCommand): Boolean!
+        barkVolume: Int!
+        toys: [Toy!]!
+      }
+
+      type Cat implements Pet {
+        name(surname: Boolean = false): String!
+        nickname: String
+        doesKnowCommand(catCommand: PetCommand): Boolean!
+        meowVolume: Int!
+        toys: [Toy!]!
+      }
+
+      type Toy {
+        name: String!
+        size: ToySize!
+        image(maxWidth: Int!): String!
+      }
+    |)
+  }
+
+  describe "unique fields" do
+    let(:query_string) {%|
+      {
+        dog {
+          name
+          nickname
         }
-        ...cheeseFields
-        ... on Cheese {
-          fatContent: flavor
-          similarCheese(source: SHEEP) { __typename }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "identical fields" do
+    let(:query_string) {%|
+      {
+        dog {
+          name
+          name
         }
       }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "identical fields with identical args" do
+    let(:query_string) {%|
+      {
+        dog {
+          doesKnowCommand(dogCommand: SIT)
+          doesKnowCommand(dogCommand: SIT)
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "identical fields with identical values" do
+    let(:query_string) {%|
+      query($dogCommand: PetCommand) {
+        dog {
+          doesKnowCommand(dogCommand: $dogCommand)
+          doesKnowCommand(dogCommand: $dogCommand)
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "identical aliases and fields" do
+    let(:query_string) {%|
+      {
+        dog {
+          otherName: name
+          otherName: name
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "different args with different aliases" do
+    let(:query_string) {%|
+      {
+        dog {
+          knowsSit: doesKnowCommand(dogCommand: SIT)
+          knowsDown: doesKnowCommand(dogCommand: DOWN)
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "conflicting args value and var" do
+    let(:query_string) {%|
+      query ($dogCommand: PetCommand) {
+        dog {
+          doesKnowCommand(dogCommand: SIT)
+          doesKnowCommand(dogCommand: $dogCommand)
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'doesKnowCommand' has an argument conflict: {"dogCommand":"SIT"} or {"dogCommand":"$dogCommand"}?)], error_messages
+    end
+  end
+
+  describe "conflicting args value and var" do
+    let(:query_string) {%|
+      query ($varOne: PetCommand, $varTwo: PetCommand) {
+        dog {
+          doesKnowCommand(dogCommand: $varOne)
+          doesKnowCommand(dogCommand: $varTwo)
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'doesKnowCommand' has an argument conflict: {"dogCommand":"$varOne"} or {"dogCommand":"$varTwo"}?)], error_messages
+    end
+  end
+
+  describe "different directives with different aliases" do
+    let(:query_string) {%|
+      {
+        dog {
+          nameIfTrue: name @include(if: true)
+          nameIfFalse: name @include(if: false)
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "different skip/include directives accepted" do
+    let(:query_string) {%|
+      {
+        dog {
+          name @include(if: true)
+          name @include(if: false)
+        }
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "same aliases with different field targets" do
+    let(:query_string) {%|
+      {
+        dog {
+          fido: name
+          fido: nickname
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal ["Field 'fido' has a field conflict: name or nickname?"], error_messages
+    end
+  end
+
+  describe "alias masking direct field access" do
+    let(:query_string) {%|
+      {
+        dog {
+          name: nickname
+          name
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal ["Field 'name' has a field conflict: nickname or name?"], error_messages
+    end
+  end
+
+  describe "different args, second adds an argument" do
+    let(:query_string) {%|
+      {
+        dog {
+          doesKnowCommand
+          doesKnowCommand(dogCommand: HEEL)
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'doesKnowCommand' has an argument conflict: {} or {"dogCommand":"HEEL"}?)], error_messages
+    end
+  end
+
+  describe "different args, second missing an argument" do
+    let(:query_string) {%|
+      {
+        dog {
+          doesKnowCommand(dogCommand: SIT)
+          doesKnowCommand
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'doesKnowCommand' has an argument conflict: {"dogCommand":"SIT"} or {}?)], error_messages
+    end
+  end
+
+  describe "conflicting args" do
+    let(:query_string) {%|
+      {
+        dog {
+          doesKnowCommand(dogCommand: SIT)
+          doesKnowCommand(dogCommand: HEEL)
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'doesKnowCommand' has an argument conflict: {"dogCommand":"SIT"} or {"dogCommand":"HEEL"}?)], error_messages
+    end
+  end
+
+  describe "conflicting arg values" do
+    let(:query_string) {%|
+      {
+        toy {
+          image(maxWidth: 10)
+          image(maxWidth: 20)
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [%q(Field 'image' has an argument conflict: {"maxWidth":"10"} or {"maxWidth":"20"}?)], error_messages
+    end
+  end
+
+  describe "encounters conflict in fragments" do
+    let(:query_string) {%|
+      {
+        pet {
+          ...A
+          ...B
+          name
+        }
+      }
+
+      fragment A on Dog {
+        x: name
+      }
+
+      fragment B on Dog {
+        x: nickname
+        name: nickname
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [
+        "Field 'x' has a field conflict: name or nickname?",
+        "Field 'name' has a field conflict: nickname or name?",
+      ], error_messages
+    end
+  end
+
+  describe "deep conflict" do
+    let(:query_string) {%|
+      {
+        dog {
+          x: name
+        }
+
+        dog {
+          x: nickname
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal ["Field 'x' has a field conflict: name or nickname?"], error_messages
+    end
+  end
+
+  describe "deep conflict with multiple issues" do
+    let(:query_string) {%|
+      {
+        dog {
+          x: name
+          y: barkVolume
+        }
+
+        dog {
+          x: nickname
+          y: doesKnowCommand
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [
+        "Field 'x' has a field conflict: name or nickname?",
+        "Field 'y' has a field conflict: barkVolume or doesKnowCommand?",
+      ], error_messages
+    end
+  end
+
+  describe "very deep conflict" do
+    let(:query_string) {%|
+      {
+        dog {
+          toys {
+            x: name
+          }
+        }
+
+        dog {
+          toys {
+            x: size
+          }
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [
+        "Field 'x' has a field conflict: name or size?",
+      ], error_messages
+    end
+  end
+
+  describe "return types must be unambiguous" do
+    let(:schema) {
+      GraphQL::Schema.from_definition(%|
+        type Query {
+          someBox: SomeBox
+          connection: Connection
+        }
+
+        type Edge {
+          id: ID
+          name: String
+        }
+
+        interface SomeBox {
+          deepBox: SomeBox
+          unrelatedField: String
+        }
+
+        type StringBox implements SomeBox {
+          scalar: String
+          deepBox: StringBox
+          unrelatedField: String
+          listStringBox: [StringBox]
+          stringBox: StringBox
+          intBox: IntBox
+        }
+
+        type IntBox implements SomeBox {
+          scalar: Int
+          deepBox: IntBox
+          unrelatedField: String
+          listStringBox: [StringBox]
+          stringBox: StringBox
+          intBox: IntBox
+        }
+
+        interface NonNullStringBox1 {
+          scalar: String!
+        }
+
+        type NonNullStringBox1Impl implements SomeBox, NonNullStringBox1 {
+          scalar: String!
+          unrelatedField: String
+          deepBox: SomeBox
+        }
+
+        interface NonNullStringBox2 {
+          scalar: String!
+        }
+
+        type NonNullStringBox2Impl implements SomeBox, NonNullStringBox2 {
+          scalar: String!
+          unrelatedField: String
+          deepBox: SomeBox
+        }
+
+        type Connection {
+          edges: [Edge]
+        }
+      |)
     }
-    fragment cheeseFields on Cheese {
-      fatContent,
-      similarCow: similarCheese(source: COW) { similarCowSource: id, id }
-      id @skip(if: true)
-    }
-  "}
-
-  it "finds field naming conflicts" do
-    expected_errors = [
-      "Field 'nickname' has a field conflict: flavor or fatContent?",             # alias conflict in query
-      "Field 'fatContent' has a field conflict: fatContent or flavor?",           # alias/name conflict in query and fragment
-      "Field 'similarCheese' 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, error_messages)
+
+    describe "compatible return shapes on different return types" do
+      let(:query_string) {%|
+        {
+          someBox {
+            ... on SomeBox {
+              deepBox {
+                unrelatedField
+              }
+            }
+            ... on StringBox {
+              deepBox {
+                unrelatedField
+              }
+            }
+          }
+        }
+      |}
+
+      it "passes rule" do
+        assert_equal [], errors
+      end
+    end
+
+    describe "reports correctly when a non-exclusive follows an exclusive" do
+      let(:query_string) {%|
+        {
+          someBox {
+            ... on IntBox {
+              deepBox {
+                ...X
+              }
+            }
+          }
+          someBox {
+            ... on StringBox {
+              deepBox {
+                ...Y
+              }
+            }
+          }
+          memoed: someBox {
+            ... on IntBox {
+              deepBox {
+                ...X
+              }
+            }
+          }
+          memoed: someBox {
+            ... on StringBox {
+              deepBox {
+                ...Y
+              }
+            }
+          }
+          other: someBox {
+            ...X
+          }
+          other: someBox {
+            ...Y
+          }
+        }
+        fragment X on SomeBox {
+          scalar
+        }
+        fragment Y on SomeBox {
+          scalar: unrelatedField
+        }
+      |}
+
+      it "fails rule" do
+        assert_includes error_messages, "Field 'scalar' has a field conflict: scalar or unrelatedField?"
+      end
+    end
   end
 end