graphql 0.18.15 → 0.19.0

data/spec/graphql/schema/printer_spec.rb

@@ -13,6 +13,8 @@ describe GraphQL::Schema::Printer do
 
       value "FOO"
       value "BAR"
+      value "BAZ", deprecation_reason: 'Use "BAR".'
+      value "WOZ", deprecation_reason: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
     end
 
     sub_input_type = GraphQL::InputObjectType.define do
@@ -46,6 +48,7 @@ describe GraphQL::Schema::Printer do
       field :title, !types.String
       field :body, !types.String
       field :comments, types[!comment_type]
+      field :comments_count, !types.Int, deprecation_reason: 'Use "comments".'
     end
 
     query_root = GraphQL::ObjectType.define do
@@ -70,14 +73,20 @@ schema {
   query: Query
 }
 
+directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+directive @deprecated(reason: String = \"No longer supported\") on FIELD_DEFINITION | ENUM_VALUE
+
 type __Directive {
   name: String!
   description: String
-  args: [__InputValue!]!
   locations: [__DirectiveLocation!]!
-  onOperation: Boolean!
-  onFragment: Boolean!
-  onField: Boolean!
+  args: [__InputValue!]!
+  onOperation: Boolean! @deprecated(reason: \"Use `locations`.\")
+  onFragment: Boolean! @deprecated(reason: \"Use `locations`.\")
+  onField: Boolean! @deprecated(reason: \"Use `locations`.\")
 }
 
 enum __DirectiveLocation {
@@ -88,21 +97,32 @@ enum __DirectiveLocation {
   FRAGMENT_DEFINITION
   FRAGMENT_SPREAD
   INLINE_FRAGMENT
+  SCHEMA
+  SCALAR
+  OBJECT
+  FIELD_DEFINITION
+  ARGUMENT_DEFINITION
+  INTERFACE
+  UNION
+  ENUM
+  ENUM_VALUE
+  INPUT_OBJECT
+  INPUT_FIELD_DEFINITION
 }
 
 type __EnumValue {
   name: String!
   description: String
-  deprecationReason: String
   isDeprecated: Boolean!
+  deprecationReason: String
 }
 
 type __Field {
   name: String!
   description: String
+  args: [__InputValue!]!
   type: __Type!
   isDeprecated: Boolean!
-  args: [__InputValue!]!
   deprecationReason: String
 }
 
@@ -115,10 +135,10 @@ type __InputValue {
 
 type __Schema {
   types: [__Type!]!
-  directives: [__Directive!]!
   queryType: __Type!
   mutationType: __Type
   subscriptionType: __Type
+  directives: [__Directive!]!
 }
 
 type __Type {
@@ -158,6 +178,8 @@ schema {
 enum Choice {
   FOO
   BAR
+  BAZ @deprecated(reason: "Use \\\"BAR\\\".")
+  WOZ @deprecated
 }
 
 type Comment implements Node {
@@ -173,6 +195,7 @@ type Post {
   title: String!
   body: String!
   comments: [Comment!]
+  comments_count: Int! @deprecated(reason: \"Use \\\"comments\\\".\")
 }
 
 type Query {

data/spec/graphql/schema/unique_within_type_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe GraphQL::Schema::UniqueWithinType do
+  describe 'encode / decode' do
+    it 'Converts typename and ID to and from ID' do
+      global_id = GraphQL::Schema::UniqueWithinType.encode("SomeType", 123)
+      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id)
+      assert_equal("SomeType", type_name)
+      assert_equal("123", id)
+    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)
+      type_name, id = GraphQL::Schema::UniqueWithinType.decode(global_id, separator: custom_separator)
+      assert_equal("Type-With-UUID", type_name)
+      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
+    end
+
+    it "raises an error if you try and use a reserved character in the ID" do
+      err = assert_raises(RuntimeError) {
+        GraphQL::Schema::UniqueWithinType.encode("Best-Thing", "234")
+      }
+      assert_includes err.message, "encode(Best-Thing, 234) contains reserved characters `-`"
+    end
+  end
+end

data/spec/graphql/schema/validation_spec.rb

@@ -34,7 +34,7 @@ describe GraphQL::Schema::Validation do
         name "InvalidArgument"
         type !types[!GraphQL::INT_TYPE]
         argument :invalid do
-          type GraphQL::STRING_TYPE
+          type GraphQL::FLOAT_TYPE
           default_value [1,2,3]
         end
       end
@@ -53,7 +53,7 @@ describe GraphQL::Schema::Validation do
     end
 
     it "applies validation to its member Arguments" do
-      assert_error_includes invalid_argument_member_field, "default value [1, 2, 3] is not valid for type String"
+      assert_error_includes invalid_argument_member_field, "default value [1, 2, 3] is not valid for type Float"
     end
   end
 
@@ -159,7 +159,7 @@ describe GraphQL::Schema::Validation do
         name "InvalidArgumentMember"
         argument :nonsense do
           type GraphQL::FLOAT_TYPE
-          default_value "xyz"
+          default_value ["xyz"]
         end
       end
     }
@@ -169,7 +169,7 @@ describe GraphQL::Schema::Validation do
     end
 
     it "applies validation to its member Arguments" do
-      assert_error_includes invalid_argument_member_input, "default value \"xyz\" is not valid for type Float"
+      assert_error_includes invalid_argument_member_input, "default value [\"xyz\"] is not valid for type Float"
     end
   end
 
@@ -180,15 +180,15 @@ describe GraphQL::Schema::Validation do
         field :invalid do
           type GraphQL::BOOLEAN_TYPE
           argument :invalid do
-            type GraphQL::STRING_TYPE
-            default_value 4.56
+            type GraphQL::FLOAT_TYPE
+            default_value ["123"]
           end
         end
       end
     }
 
     it "validates fields" do
-      assert_error_includes invalid_field_interface, "default value 4.56 is not valid for type String"
+      assert_error_includes invalid_field_interface, "default value [\"123\"] is not valid for type Float"
     end
   end
 
@@ -211,9 +211,5 @@ describe GraphQL::Schema::Validation do
     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 "requires the default value is compatible" do
-      assert_error_includes invalid_default_argument, 'default value "abc" is not valid for type Int'
-    end
   end
 end

data/spec/graphql/schema_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 
 describe GraphQL::Schema do
   let(:schema) { DummySchema }
+  let(:relay_schema)  { StarWarsSchema }
+  let(:empty_schema) { GraphQL::Schema.define }
 
   describe "#rescue_from" do
     let(:rescue_middleware) { schema.middleware.first }
@@ -24,7 +26,7 @@ describe GraphQL::Schema do
   describe "#resolve_type" do
     describe "when the return value is nil" do
       it "returns nil" do
-        result = StarWarsSchema.resolve_type(123, nil)
+        result = relay_schema.resolve_type(123, nil)
         assert_equal(nil, result)
       end
     end
@@ -32,10 +34,38 @@ describe GraphQL::Schema do
     describe "when the return value is not a BaseType" do
       it "raises an error " do
         err = assert_raises(RuntimeError) {
-          StarWarsSchema.resolve_type(:test_error, nil)
+          relay_schema.resolve_type(:test_error, nil)
         }
         assert_includes err.message, "not_a_type (Symbol)"
       end
     end
+
+    describe "when the hook wasn't implemented" do
+      it "raises not implemented" do
+        assert_raises(NotImplementedError) {
+          empty_schema.resolve_type(nil, nil)
+        }
+      end
+    end
+  end
+
+  describe "object_from_id" do
+    describe "when the hook wasn't implemented" do
+      it "raises not implemented" do
+        assert_raises(NotImplementedError) {
+          empty_schema.object_from_id(nil, nil)
+        }
+      end
+    end
+  end
+
+  describe "id_from_object" do
+    describe "when the hook wasn't implemented" do
+      it "raises not implemented" do
+        assert_raises(NotImplementedError) {
+          empty_schema.id_from_object(nil, nil, nil)
+        }
+      end
+    end
   end
 end

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

@@ -1,33 +1,32 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
+  include StaticValidationHelpers
+
   let(:query_string) {%|
     query getCheese {
-      cheese(id: "aasdlkfj") { source }
-      cheese(id: 1) { source @skip(if: {id: 1})}
-      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { source }
-      badSource: searchDairy(product: [{source: 1.1}]) { source }
-      missingSource: searchDairy(product: [{fatContent: 1.1}]) { source }
-      listCoerce: cheese(id: 1) { similarCheese(source: YAK) }
-      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}])
+      stringCheese: cheese(id: "aasdlkfj") { ...cheeseFields }
+      cheese(id: 1) { source @skip(if: "whatever") }
+      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { __typename }
+      badSource: searchDairy(product: [{source: 1.1}]) { __typename }
+      missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
+      listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
+      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
     }
 
     fragment cheeseFields on Cheese {
-      similarCheese(source: 4.5)
+      similarCheese(source: 4.5) { __typename }
     }
   |}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentLiteralsAreCompatible]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds undefined or missing-required arguments to fields and directives" do
-    assert_equal(6, errors.length)
+    # `wacky` above is handled by ArgumentsAreDefined, so only 6 are tested below
+    assert_equal(7, errors.length)
 
     query_root_error = {
-      "message"=>"Argument 'id' on Field 'cheese' has an invalid value. Expected type 'Int!'.",
+      "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
       "locations"=>[{"line"=>3, "column"=>7}],
-      "fields"=>["query getCheese", "cheese", "id"],
+      "fields"=>["query getCheese", "stringCheese", "id"],
     }
     assert_includes(errors, query_root_error)
 

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

@@ -1,25 +1,25 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentsAreDefined do
+  include StaticValidationHelpers
+
   let(:query_string) {"
     query getCheese {
-      cheese(id: 1) { source }
-      cheese(silly: false) { source }
-      searchDairy(product: [{wacky: 1}])
+      okCheese: cheese(id: 1) { source }
+      cheese(silly: false, id: 2) { source }
+      searchDairy(product: [{wacky: 1}]) { ...cheeseFields }
     }
 
     fragment cheeseFields on Cheese {
-      similarCheese(source: SHEEP, nonsense: 1)
-      id @skip(something: 3.4)
+      similarCheese(source: SHEEP, nonsense: 1) { __typename }
+      id @skip(something: 3.4, if: false)
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "finds undefined arguments to fields and directives" do
-    assert_equal(4, errors.length)
+    # There's an extra error here, the unexpected argument on "DairyProductInput"
+    # triggers _another_ error that the field expected a different type
+    assert_equal(5, errors.length)
 
     query_root_error = {
       "message"=>"Field 'cheese' doesn't accept argument 'silly'",

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

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::DirectivesAreDefined do
+  include StaticValidationHelpers
   let(:query_string) {"
     query getCheese {
       okCheese: cheese(id: 1) {
@@ -12,11 +13,6 @@ describe GraphQL::StaticValidation::DirectivesAreDefined do
       }
     }
   "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   describe "non-existent directives" do
     it "makes errors for them" do
       expected = [

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

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
+  include StaticValidationHelpers
   let(:query_string) {"
     query getCheese @skip(if: true) {
       okCheese: cheese(id: 1) {
@@ -8,6 +9,7 @@ describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
         source
         ... on Cheese @skip(if: true) {
           flavor
+          ... whatever
         }
       }
     }
@@ -17,10 +19,6 @@ describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreInValidLocations]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   describe "invalid directive locations" do
     it "makes errors for them" do
       expected = [
@@ -31,7 +29,7 @@ describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
         },
         {
           "message"=>"'@skip' can't be applied to fragment definitions (allowed: fields, fragment spreads, inline fragments)",
-          "locations"=>[{"line"=>12, "column"=>33}],
+          "locations"=>[{"line"=>13, "column"=>33}],
            "fields"=>["fragment whatever"],
         },
       ]

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

@@ -1,21 +1,17 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
+  include StaticValidationHelpers
   let(:query_string) { "
-    query getCheese($sourceVar: DairyAnimal!) {
+    query getCheese {
       notDefinedField { name }
-      cheese(id: 1) { nonsenseField, flavor }
+      cheese(id: 1) { nonsenseField, flavor ...cheeseFields }
       fromSource(source: COW) { bogusField }
     }
 
     fragment cheeseFields on Cheese { fatContent, hogwashField }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-  let(:error_messages) { errors.map { |e| e["message"] } }
-
   it "finds fields that are requested on types that don't have that field" do
     expected_errors = [
       "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
@@ -58,9 +54,9 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
 
   describe "on unions" do
     let(:query_string) { "
-      query notOnUnion { favoriteEdible { ...dpFields } }
-      fragment dbFields on DairyProduct { source }
-      fragment dbIndirectFields on DairyProduct { ... on Cheese { source } }
+      query notOnUnion { favoriteEdible { ...dpFields ...dpIndirectFields } }
+      fragment dpFields on DairyProduct { source }
+      fragment dpIndirectFields on DairyProduct { ... on Cheese { source } }
     "}
 
 
@@ -71,7 +67,7 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
           "locations"=>[
             {"line"=>3, "column"=>7}
           ],
-          "fields"=>["fragment dbFields", "source"],
+          "fields"=>["fragment dpFields", "source"],
         }
       ]
       assert_equal(expected_errors, errors)

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

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
+  include StaticValidationHelpers
   let(:query_string) {"
     query getCheese {
       okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
@@ -9,10 +10,6 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
     }
   "}
 
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
   it "adds errors for selections on scalars" do
     assert_equal(2, errors.length)