graphql 1.7.6 → 1.8.0

data/spec/graphql/schema/printer_spec.rb

@@ -14,7 +14,11 @@ describe GraphQL::Schema::Printer do
 
       value "FOO", value: :foo
       value "BAR", value: :bar
-      value "BAZ", deprecation_reason: 'Use "BAR".'
+      value "BAZ", deprecation_reason: <<-REASON
+Use "BAR" instead.
+
+It's the replacement for this value.
+REASON
       value "WOZ", deprecation_reason: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
     end
 
@@ -136,6 +140,14 @@ schema {
   query: Root
 }
 
+# Marks an element of a GraphQL schema as no longer supported.
+directive @deprecated(
+  # Explains why this element was deprecated, usually also including a suggestion
+  # for how to access supported similar data. Formatted in
+  # [Markdown](https://daringfireball.net/projects/markdown/).
+  reason: String = "No longer supported"
+) on FIELD_DEFINITION | ENUM_VALUE
+
 # Directs the executor to include this field or fragment only when the `if` argument is true.
 directive @include(
   # Included when true.
@@ -148,14 +160,6 @@ directive @skip(
   if: Boolean!
 ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
-# Marks an element of a GraphQL schema as no longer supported.
-directive @deprecated(
-  # Explains why this element was deprecated, usually also including a suggestion
-  # for how to access supported similar data. Formatted in
-  # [Markdown](https://daringfireball.net/projects/markdown/).
-  reason: String = "No longer supported"
-) on FIELD_DEFINITION | ENUM_VALUE
-
 # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
 #
 # In some cases, you need to provide options to alter GraphQL's execution behavior
@@ -345,7 +349,6 @@ schema {
   subscription: Subscription
 }
 SCHEMA
-
       assert_match expected, GraphQL::Schema::Printer.print_schema(custom_schema)
     end
 
@@ -353,7 +356,6 @@ SCHEMA
       custom_mutation = schema.mutation.redefine(name: "MyMutationRoot")
       custom_schema = schema.redefine(mutation: custom_mutation)
 
-
       expected = <<SCHEMA
 schema {
   query: Query
@@ -390,7 +392,7 @@ type Audio {
 
 enum Choice {
   BAR
-  BAZ @deprecated(reason: "Use \\\"BAR\\\".")
+  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
   FOO
   WOZ @deprecated
 }
@@ -479,6 +481,25 @@ SCHEMA
 
       assert_equal expected.chomp, GraphQL::Schema::Printer.print_schema(schema)
     end
+
+    it 'prints a schema without directives' do
+      query_type = Class.new(GraphQL::Schema::Object) do
+        graphql_name 'Query'
+
+        field :foobar, Integer, null: false
+
+        def foobar
+          152
+        end
+      end
+
+      schema = Class.new(GraphQL::Schema) do
+        query query_type
+      end
+
+      expected = "type Query {\n  foobar: Int!\n}"
+      assert_equal expected, GraphQL::Schema::Printer.new(schema).print_schema
+    end
   end
 
   it "applies an `only` filter" do
@@ -489,7 +510,6 @@ enum Choice {
 }
 
 type Subscription {
-
 }
 
 input Varied {
@@ -509,7 +529,9 @@ SCHEMA
       when GraphQL::Argument
         member.name != "id"
       else
-        member.deprecation_reason.nil?
+        if member.respond_to?(:deprecation_reason)
+          member.deprecation_reason.nil?
+        end
       end
     }
 
@@ -600,12 +622,86 @@ SCHEMA
 type Post {
   body: String!
   comments: [Comment!]
-  comments_count: Int! @deprecated(reason: \"Use \\\"comments\\\".\")
+  comments_count: Int! @deprecated(reason: "Use \\\"comments\\\".")
   id: ID!
   title: String!
 }
 SCHEMA
       assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(schema.types['Post'])
     end
+
+    it "can print arguments that use non-standard Ruby objects as default values" do
+      backing_object = Struct.new(:value)
+
+      scalar_type = GraphQL::ScalarType.define do
+        name "SomeType"
+        coerce_input ->(value, ctx) { backing_object.new(value) }
+        coerce_result ->(obj, ctx) { obj.value }
+      end
+
+      query_root = GraphQL::ObjectType.define do
+        name "Query"
+        description "The query root of this schema"
+
+        field :example do
+          type scalar_type
+          argument :input, scalar_type, default_value: backing_object.new("Howdy")
+          resolve ->(obj, args, ctx) { args[:input] }
+        end
+      end
+
+      schema = GraphQL::Schema.define do
+        query query_root
+      end
+
+      expected = <<SCHEMA
+# The query root of this schema
+type Query {
+  example(input: SomeType = "Howdy"): SomeType
+}
+SCHEMA
+
+      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(query_root)
+    end
+  end
+
+  describe "#print_directive" do
+    it "prints the deprecation reason in a single line escaped string including line breaks" do
+      expected = <<SCHEMA
+enum Choice {
+  BAR
+  BAZ @deprecated(reason: "Use \\\"BAR\\\" instead.\\n\\nIt's the replacement for this value.\\n")
+  FOO
+  WOZ @deprecated
+}
+
+type Subscription {
+}
+
+input Varied {
+  bool: Boolean
+  enum: Choice = FOO
+  float: Float
+  int: Int
+}
+SCHEMA
+
+      only_filter = ->(member, ctx) {
+        case member
+        when GraphQL::ScalarType
+          true
+        when GraphQL::BaseType
+          ctx[:names].include?(member.name)
+        when GraphQL::Argument
+          member.name != "id"
+        else
+          true
+        end
+      }
+
+      context = { names: ["Varied", "Choice", "Subscription"] }
+
+      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema, context: context, only: only_filter).print_schema
+    end
   end
 end

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::RelayClassicMutation do
+  describe ".input_object_class" do
+    it "is inherited, with a default" do
+      custom_input = Class.new(GraphQL::Schema::InputObject)
+      mutation_base_class = Class.new(GraphQL::Schema::RelayClassicMutation) do
+        input_object_class(custom_input)
+      end
+      mutation_subclass = Class.new(mutation_base_class)
+
+      assert_equal GraphQL::Schema::InputObject, GraphQL::Schema::RelayClassicMutation.input_object_class
+      assert_equal custom_input, mutation_base_class.input_object_class
+      assert_equal custom_input, mutation_subclass.input_object_class
+    end
+  end
+
+  describe ".input_type" do
+    it "has a reference to the mutation" do
+      mutation = Class.new(GraphQL::Schema::RelayClassicMutation) do
+        graphql_name "Test"
+      end
+      assert_equal mutation, mutation.input_type.mutation
+      assert_equal mutation, mutation.input_type.graphql_definition.mutation
+    end
+  end
+
+  describe ".null" do
+    it "is inherited as true" do
+      mutation = Class.new(GraphQL::Schema::RelayClassicMutation) do
+        graphql_name "Test"
+      end
+
+      assert mutation.null
+    end
+  end
+end

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -25,6 +25,17 @@ describe GraphQL::Schema::RescueMiddleware do
       assert_equal(GraphQL::ExecutionError, result.class)
     end
 
+    describe "rescue_from superclass" do
+      class ChildSpecExampleError < SpecExampleError; end
+
+      let(:error_class) { ChildSpecExampleError }
+      it "handles them as execution errors" do
+        result = middleware_chain.invoke([])
+        assert_equal("there was an example error: ChildSpecExampleError", result.message)
+        assert_equal(GraphQL::ExecutionError, result.class)
+      end
+    end
+
     describe "with multiple error classes" do
       let(:error_class) { SecondSpecExampleError }
       let(:rescue_middleware) do

data/spec/graphql/schema/resolver_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Resolver do
+  module ResolverTest
+    class BaseResolver < GraphQL::Schema::Resolver
+    end
+
+    class Resolver1 < BaseResolver
+      argument :value, Integer, required: false
+      type [Integer, null: true], null: false
+
+      def initialize(object:, context:)
+        super
+        if defined?(@value)
+          raise "The instance should start fresh"
+        end
+        @value = [100]
+      end
+
+      def resolve(value: nil)
+        @value << value
+        @value
+      end
+    end
+
+    class Resolver2 < Resolver1
+      argument :extra_value, Integer, required: true
+
+      def resolve(extra_value:, **_rest)
+        value = super(_rest)
+        value << extra_value
+        value
+      end
+    end
+
+    class Resolver3 < Resolver1
+    end
+
+    class Resolver4 < BaseResolver
+      type Integer, null: false
+
+      extras [:ast_node]
+      def resolve(ast_node:)
+        object.value + ast_node.name.size
+      end
+    end
+
+    class Resolver5 < Resolver4
+    end
+
+    class Query < GraphQL::Schema::Object
+      class CustomField < GraphQL::Schema::Field
+        def resolve_field(*args)
+          value = super
+          if @name == "resolver3"
+            value << -1
+          end
+          value
+        end
+      end
+
+      field_class(CustomField)
+
+      field :resolver_1, resolver: Resolver1
+      field :resolver_2, resolver: Resolver2
+      field :resolver_3, resolver: Resolver3
+      field :resolver_3_again, resolver: Resolver3, description: "field desc"
+      field :resolver_4, "Positional description", resolver: Resolver4
+      field :resolver_5, resolver: Resolver5
+    end
+
+    class Schema < GraphQL::Schema
+      query(Query)
+    end
+  end
+
+  it "gets initialized for each resolution" do
+    # State isn't shared between calls:
+    res = ResolverTest::Schema.execute " { r1: resolver1(value: 1) r2: resolver1 }"
+    assert_equal [100, 1], res["data"]["r1"]
+    assert_equal [100, nil], res["data"]["r2"]
+  end
+
+  it "inherits type and arguments" do
+    res = ResolverTest::Schema.execute " { r1: resolver2(value: 1, extraValue: 2) r2: resolver2(extraValue: 3) }"
+    assert_equal [100, 1, 2], res["data"]["r1"]
+    assert_equal [100, nil, 3], res["data"]["r2"]
+  end
+
+  it "uses the object's field_class" do
+    res = ResolverTest::Schema.execute " { r1: resolver3(value: 1) r2: resolver3 }"
+    assert_equal [100, 1, -1], res["data"]["r1"]
+    assert_equal [100, nil, -1], res["data"]["r2"]
+  end
+
+  describe "resolve method" do
+    it "has access to the application object" do
+      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 4)
+      assert_equal 13, res["data"]["resolver4"]
+    end
+
+    it "gets extras" do
+      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 0)
+      assert_equal 9, res["data"]["resolver4"]
+    end
+  end
+
+  describe "extras" do
+    it "is inherited" do
+      res = ResolverTest::Schema.execute " { resolver4 resolver5 } ", root_value: OpenStruct.new(value: 0)
+      assert_equal 9, res["data"]["resolver4"]
+      assert_equal 9, res["data"]["resolver5"]
+    end
+  end
+
+  describe "when applied to a field" do
+    it "gets the field's description" do
+      assert_nil ResolverTest::Schema.find("Query.resolver3").description
+      assert_equal "field desc", ResolverTest::Schema.find("Query.resolver3Again").description
+      assert_equal "Positional description", ResolverTest::Schema.find("Query.resolver4").description
+    end
+
+    it "gets the field's name" do
+      # Matching name:
+      assert ResolverTest::Schema.find("Query.resolver3")
+      # Mismatched name:
+      assert ResolverTest::Schema.find("Query.resolver3Again")
+    end
+  end
+end

data/spec/graphql/schema/scalar_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Scalar do
+  describe "in queries" do
+    it "becomes output" do
+      query_str = <<-GRAPHQL
+      {
+        find(id: "Musician/Herbie Hancock") {
+          ... on Musician {
+            name
+            favoriteKey
+          }
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal "B♭", res["data"]["find"]["favoriteKey"]
+    end
+
+    it "can be input" do
+      query_str = <<-GRAPHQL
+      {
+        inspectKey(key: "F♯") {
+          root
+          isSharp
+          isFlat
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      key_info = res["data"]["inspectKey"]
+      assert_equal "F", key_info["root"]
+      assert_equal true, key_info["isSharp"]
+      assert_equal false, key_info["isFlat"]
+    end
+
+    it "can be nested JSON" do
+      query_str = <<-GRAPHQL
+      {
+        echoJson(input: {foo: [{bar: "baz"}]})
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal({"foo" => [{"bar" => "baz"}]}, res["data"]["echoJson"])
+    end
+
+    it "can be a JSON array" do
+      query_str = <<-GRAPHQL
+      {
+        echoFirstJson(input: [{foo: "bar"}, {baz: "boo"}])
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal({"foo" => "bar"}, res["data"]["echoFirstJson"])
+    end
+
+    it "can be a JSON array even if the GraphQL type is not an array" do
+      query_str = <<-GRAPHQL
+      {
+        echoJson(input: [{foo: "bar"}])
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal([{"foo" => "bar"}], res["data"]["echoJson"])
+    end
+
+    it "can be JSON with a nested enum" do
+      query_str = <<-GRAPHQL
+      {
+        echoJson(input: [{foo: WOODWIND}])
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_equal([{"foo" => "WOODWIND"}], res["data"]["echoJson"])
+    end
+
+    it "cannot be JSON with a nested variable" do
+      query_str = <<-GRAPHQL
+      {
+        echoJson(input: [{foo: $var}])
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      assert_includes(res["errors"][0]["message"], "Argument 'input' on Field 'echoJson' has an invalid value")
+    end
+  end
+end

data/spec/graphql/schema/traversal_spec.rb

@@ -188,4 +188,35 @@ describe GraphQL::Schema::Traversal do
     }
     assert_equal expected, result
   end
+
+  it "finds orphan types from interfaces" do
+    b_type = GraphQL::ObjectType.define do
+      name "B"
+    end
+
+    c_type = GraphQL::ObjectType.define do
+      name "C"
+    end
+
+    interface = GraphQL::InterfaceType.define do
+      name "AInterface"
+      orphan_types [b_type]
+    end
+
+    another_interface = GraphQL::InterfaceType.define do
+      name "AnotherIterface"
+      orphan_types [b_type, c_type]
+    end
+
+    result = traversal([interface, another_interface]).type_map
+    expected = {
+      "Boolean" => GraphQL::BOOLEAN_TYPE,
+      "String" => GraphQL::STRING_TYPE,
+      "AInterface" => interface,
+      "AnotherIterface" => another_interface,
+      "B" => b_type,
+      "C" => c_type
+    }
+    assert_equal expected, result
+  end
 end

data/spec/graphql/schema/union_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Union do
+  let(:union) { Jazz::PerformingAct }
+  describe "type info" do
+    it "has some" do
+      assert_equal 2, union.possible_types.size
+    end
+  end
+
+  describe ".to_graphql" do
+    it "creates a UnionType" do
+      union = Class.new(GraphQL::Schema::Union) do
+        possible_types Jazz::Musician, Jazz::Ensemble
+
+        def self.name
+          "MyUnion"
+        end
+      end
+      union_type = union.to_graphql
+      assert_equal "MyUnion", union_type.name
+      assert_equal [Jazz::Musician.to_graphql, Jazz::Ensemble.to_graphql], union_type.possible_types
+      assert_nil union_type.resolve_type_proc
+    end
+
+    it "can specify a resolve_type method" do
+      union = Class.new(GraphQL::Schema::Union) do
+        def self.resolve_type(_object, _context)
+          "MyType"
+        end
+
+        def self.name
+          "MyUnion"
+        end
+      end
+      union_type = union.to_graphql
+      assert_equal "MyType", union_type.resolve_type_proc.call(nil, nil)
+    end
+  end
+
+  describe "in queries" do
+    it "works" do
+      query_str = <<-GRAPHQL
+      {
+        nowPlaying {
+          ... on Musician {
+            name
+            instrument {
+              family
+            }
+          }
+          ... on Ensemble {
+            name
+          }
+        }
+      }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query_str)
+      expected_data = { "name" => "Bela Fleck and the Flecktones" }
+      assert_equal expected_data, res["data"]["nowPlaying"]
+    end
+  end
+end

data/spec/graphql/schema/validation_spec.rb

@@ -333,7 +333,7 @@ describe GraphQL::Schema::Validation do
     end
 
     it "allows null default value for nullable argument" do
-      assert_equal nil, GraphQL::Schema::Validation.validate(null_default_value)
+      assert_nil GraphQL::Schema::Validation.validate(null_default_value)
     end
   end
 

data/spec/graphql/schema/warden_spec.rb

@@ -242,8 +242,8 @@ describe GraphQL::Schema::Warden do
       GRAPHQL
       res = MaskHelpers.query_with_mask(query_string, mask)
       assert_equal "Query", res["data"]["__schema"]["queryType"]["name"]
-      assert_equal nil, res["data"]["__schema"]["mutationType"]
-      assert_equal nil, res["data"]["__schema"]["subscriptionType"]
+      assert_nil res["data"]["__schema"]["mutationType"]
+      assert_nil res["data"]["__schema"]["subscriptionType"]
       type_names = res["data"]["__schema"]["types"].map { |t| t["name"] }
       refute type_names.include?("Mutation")
       refute type_names.include?("Subscription")
@@ -344,7 +344,7 @@ describe GraphQL::Schema::Warden do
       res = MaskHelpers.run_query(query_string, only: whitelist)
 
       # It's not visible by name
-      assert_equal nil, res["data"]["Phoneme"]
+      assert_nil res["data"]["Phoneme"]
 
       # It's not visible in `__schema`
       all_type_names = type_names(res)
@@ -423,7 +423,7 @@ describe GraphQL::Schema::Warden do
 
         res = MaskHelpers.query_with_mask(query_string, mask)
         type = res["data"]["__type"]
-        assert_equal nil, type
+        assert_nil type
       end
     end
   end
@@ -543,7 +543,7 @@ describe GraphQL::Schema::Warden do
 
       res = MaskHelpers.query_with_mask(query_string, mask)
 
-      assert_equal nil, res["data"]["WithinInput"], "The type isn't accessible by name"
+      assert_nil res["data"]["WithinInput"], "The type isn't accessible by name"
 
       languages_arg_names = res["data"]["Query"]["fields"].find { |f| f["name"] == "languages" }["args"].map { |a| a["name"] }
       refute_includes languages_arg_names, "within", "Arguments that point to it are gone"
@@ -666,7 +666,7 @@ describe GraphQL::Schema::Warden do
     it "is additive with query filters" do
       query_except = ->(member, ctx) { member.metadata[:hidden_input_object_type] }
       res = schema.execute(query_str, except: query_except)
-      assert_equal nil, res["data"]["input"]
+      assert_nil res["data"]["input"]
       enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
       refute_includes enum_values, "TRILL"
     end
@@ -695,13 +695,13 @@ describe GraphQL::Schema::Warden do
           only: [visible_enum_value, visible_abstract_type],
           except: [hidden_input_object, hidden_type],
         )
-        assert_equal nil, res["data"]["input"]
+        assert_nil res["data"]["input"]
         enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
         assert_equal 5, enum_values.length
         refute_includes enum_values, "TRILL"
         # These are also filtered out:
         assert_equal 0, res["data"]["abstractType"]["interfaces"].length
-        assert_equal nil, res["data"]["type"]
+        assert_nil res["data"]["type"]
       end
     end
 
@@ -712,7 +712,7 @@ describe GraphQL::Schema::Warden do
           except: hidden_input_object,
         }
         res = MaskHelpers.run_query(query_str, context: { filters: filters })
-        assert_equal nil, res["data"]["input"]
+        assert_nil res["data"]["input"]
         enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
         assert_equal 5, enum_values.length
         refute_includes enum_values, "TRILL"
@@ -727,13 +727,13 @@ describe GraphQL::Schema::Warden do
           except: [hidden_input_object, hidden_type],
         }
         res = MaskHelpers.run_query(query_str, context: { filters: filters })
-        assert_equal nil, res["data"]["input"]
+        assert_nil res["data"]["input"]
         enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
         assert_equal 5, enum_values.length
         refute_includes enum_values, "TRILL"
         # These are also filtered out:
         assert_equal 0, res["data"]["abstractType"]["interfaces"].length
-        assert_equal nil, res["data"]["type"]
+        assert_nil res["data"]["type"]
       end
     end
   end