graphql 1.7.14 → 1.8.0.pre1

data/spec/graphql/schema/scalar_spec.rb

@@ -0,0 +1,40 @@
+# 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
+  end
+end

data/spec/graphql/schema/union_spec.rb

@@ -0,0 +1,35 @@
+# 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 "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_nil GraphQL::Schema::Validation.validate(null_default_value)
+      assert_equal 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_nil res["data"]["__schema"]["mutationType"]
-      assert_nil res["data"]["__schema"]["subscriptionType"]
+      assert_equal nil, res["data"]["__schema"]["mutationType"]
+      assert_equal 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_nil res["data"]["Phoneme"]
+      assert_equal 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_nil type
+        assert_equal nil, type
       end
     end
   end
@@ -543,7 +543,7 @@ describe GraphQL::Schema::Warden do
 
       res = MaskHelpers.query_with_mask(query_string, mask)
 
-      assert_nil res["data"]["WithinInput"], "The type isn't accessible by name"
+      assert_equal 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_nil res["data"]["input"]
+      assert_equal 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_nil res["data"]["input"]
+        assert_equal 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_nil res["data"]["type"]
+        assert_equal 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_nil res["data"]["input"]
+        assert_equal 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_nil res["data"]["input"]
+        assert_equal 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_nil res["data"]["type"]
+        assert_equal nil, res["data"]["type"]
       end
     end
   end

data/spec/graphql/schema_spec.rb

@@ -23,19 +23,12 @@ describe GraphQL::Schema do
     end
   end
 
-  describe "#to_document" do
-    it "returns the AST for the schema IDL" do
-      expected = GraphQL::Language::DocumentFromSchemaDefinition.new(schema).document
-      assert expected.eql?(schema.to_document)
-    end
-  end
-
   describe "#root_types" do
     it "returns a list of the schema's root types" do
       assert_equal(
         [
           Dummy::DairyAppQueryType,
-          Dummy::DairyAppMutationType,
+          Dummy::DairyAppMutationType.graphql_definition,
           Dummy::SubscriptionType
         ],
         schema.root_types
@@ -379,24 +372,25 @@ type Query {
       assert_equal true, schema.lazy?(LazyObj.new)
       assert_equal :dup, schema.lazy_method_name(LazyObjChild.new)
       assert_equal true, schema.lazy?(LazyObjChild.new)
-      assert_nil schema.lazy_method_name({})
+      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)
+      schema_1 = schema.graphql_definition
+      schema_2 = schema_1.dup
+      refute schema_2.types.equal?(schema_1.types)
 
-      refute schema_2.instrumenters.equal?(schema.instrumenters)
-      assert_equal schema_2.instrumenters, schema.instrumenters
+      refute schema_2.instrumenters.equal?(schema_1.instrumenters)
+      assert_equal schema_2.instrumenters, schema_1.instrumenters
 
-      refute schema_2.middleware.equal?(schema.middleware)
-      assert_equal schema_2.middleware, schema.middleware
+      refute schema_2.middleware.equal?(schema_1.middleware)
+      assert_equal schema_2.middleware, schema_1.middleware
 
       schema_2.middleware << ->(*args) { :noop }
-      refute_equal schema_2.middleware, schema.middleware
+      refute_equal schema_2.middleware, schema_1.middleware
     end
   end
 
@@ -425,13 +419,6 @@ type Query {
     end
   end
 
-  describe "#as_json" do
-    it "returns a hash" do
-      result = schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-      assert_equal result.as_json.class, Hash
-    end
-  end
-
   describe "#get_field" do
     it "returns fields by type or type name" do
       field = schema.get_field("Cheese", "id")
@@ -440,4 +427,19 @@ type Query {
       assert_equal field, field_2
     end
   end
+
+  describe "class-based schemas" do
+    it "delegates to the graphql definition" do
+      # Not delegated:
+      assert_equal Jazz::Query.graphql_definition, Jazz::Schema.query
+      assert Jazz::Schema.respond_to?(:query)
+      # Delegated
+      assert_equal [], Jazz::Schema.tracers
+      assert Jazz::Schema.respond_to?(:tracers)
+    end
+
+    it "works with plugins" do
+      assert_equal "xyz", Jazz::Schema.metadata[:plugin_key]
+    end
+  end
 end

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

@@ -8,19 +8,18 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
       okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
       missingFieldsCheese: cheese(id: 1)
       illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
-      incorrectFragmentSpread: cheese(id: 1) { flavor { ... on String { __typename } } }
     }
   "}
 
   it "adds errors for selections on scalars" do
-    assert_equal(3, errors.length)
+    assert_equal(2, errors.length)
 
     illegal_selection_error = {
       "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
       "locations"=>[{"line"=>5, "column"=>47}],
       "fields"=>["query getCheese", "illegalSelectionCheese", "id"],
     }
-    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalars")
+    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalarss")
 
     selection_required_error = {
       "message"=>"Objects must have selections (field 'cheese' returns Cheese but has no selections)",
@@ -28,13 +27,6 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
       "fields"=>["query getCheese", "missingFieldsCheese"],
     }
     assert_includes(errors, selection_required_error, "finds objects without selections")
-
-    incorrect_fragment_error = {
-      "message"=>"Selections can't be made on scalars (field 'flavor' returns String but has inline fragments [String])",
-      "locations"=>[{"line"=>6, "column"=>48}],
-      "fields"=>["query getCheese", "incorrectFragmentSpread", "flavor"],
-    }
-    assert_includes(errors, incorrect_fragment_error, "finds scalar fields with selections")
   end
 
   describe "anonymous operations" do

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

@@ -515,7 +515,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           scalar: String!
         }
 
-        type NonNullStringBox1Impl implements SomeBox & NonNullStringBox1 {
+        type NonNullStringBox1Impl implements SomeBox, NonNullStringBox1 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox
@@ -525,7 +525,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           scalar: String!
         }
 
-        type NonNullStringBox2Impl implements SomeBox & NonNullStringBox2 {
+        type NonNullStringBox2Impl implements SomeBox, NonNullStringBox2 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox

data/spec/graphql/string_type_spec.rb

@@ -72,9 +72,9 @@ describe GraphQL::STRING_TYPE do
     end
 
     it "doesn't accept other types" do
-      assert_nil string_type.coerce_isolated_input(100)
-      assert_nil string_type.coerce_isolated_input(true)
-      assert_nil string_type.coerce_isolated_input(0.999)
+      assert_equal nil, string_type.coerce_isolated_input(100)
+      assert_equal nil, string_type.coerce_isolated_input(true)
+      assert_equal nil, string_type.coerce_isolated_input(0.999)
     end
   end
 end

data/spec/graphql/subscriptions_spec.rb

@@ -242,7 +242,7 @@ describe GraphQL::Subscriptions do
       schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
       schema.subscriptions.trigger("payload", { "id" => "8"}, OpenStruct.new(str: nil, int: nil))
       delivery = deliveries["1"].first
-      assert_nil delivery.fetch("data")
+      assert_equal nil, delivery.fetch("data")
       assert_equal 1, delivery["errors"].length
     end
 

data/spec/graphql/tracing/platform_tracing_spec.rb

@@ -41,72 +41,13 @@ describe GraphQL::Tracing::PlatformTracing do
       schema.execute(" { cheese(id: 1) { flavor } }")
       expected_trace = [
         "em",
-        "am",
         "l",
         "p",
         "v",
-        "aq",
-        "eq",
-        "Q.c", # notice that the flavor is skipped
-        "eql",
-      ]
-      assert_equal expected_trace, CustomPlatformTracer::TRACE
-    end
-  end
-
-  describe "by default, scalar fields are not traced" do
-    let(:schema) {
-      Dummy::Schema.redefine {
-        use(CustomPlatformTracer)
-      }
-    }
-
-    before do
-      CustomPlatformTracer::TRACE.clear
-    end
-
-    it "only traces traceTrue, not traceFalse or traceNil" do
-      schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      expected_trace = [
-        "em",
         "am",
-        "l",
-        "p",
-        "v",
         "aq",
         "eq",
-        "Q.t",
-        "T.t",
-        "eql",
-      ]
-      assert_equal expected_trace, CustomPlatformTracer::TRACE
-    end
-  end
-
-  describe "when scalar fields are traced by default, they are unless specified" do
-    let(:schema) {
-      Dummy::Schema.redefine {
-        use(CustomPlatformTracer, trace_scalars: true)
-      }
-    }
-
-    before do
-      CustomPlatformTracer::TRACE.clear
-    end
-
-    it "traces traceTrue and traceNil but not traceFalse" do
-      schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      expected_trace = [
-        "em",
-        "am",
-        "l",
-        "p",
-        "v",
-        "aq",
-        "eq",
-        "Q.t",
-        "T.t",
-        "T.t",
+        "Q.c", # notice that the flavor is skipped
         "eql",
       ]
       assert_equal expected_trace, CustomPlatformTracer::TRACE

data/spec/support/dummy/schema.rb

@@ -149,15 +149,6 @@ module Dummy
     field :cheese, CheeseType
   end
 
-  TracingScalarType = GraphQL::ObjectType.define do
-    name "TracingScalar"
-    description "An object which has traced scalars"
-
-    field :traceNil, types.Int
-    field :traceFalse, types.Int, trace: false
-    field :traceTrue, types.Int, trace: true
-  end
-
   DairyProductUnion = GraphQL::UnionType.define do
     name "DairyProduct"
     description "Kinds of food made from milk"
@@ -381,16 +372,6 @@ module Dummy
       resolve ->(t, a, c) { OpenStruct.new(cheese: nil) }
     end
 
-    field :tracingScalar, TracingScalarType do
-      resolve ->(o, a, c) do
-        OpenStruct.new(
-          traceNil: 2,
-          traceFalse: 3,
-          tracetrue: 5,
-        )
-      end
-    end
-
     field :deepNonNull, !DeepNonNullType do
       resolve ->(o, a, c) { :deepNonNull }
     end
@@ -403,26 +384,31 @@ module Dummy
     input_field :values, !types[!types.Int]
   end
 
-  DairyAppMutationType = GraphQL::ObjectType.define do
-    name "Mutation"
+  PushValueField = GraphQL::Field.define do
+    name :pushValue
+    type !types[!types.Int]
+    description("Push a value onto a global array :D")
+    argument :value, !types.Int, as: :val
+    resolve ->(o, args, ctx) {
+      GLOBAL_VALUES << args.val
+      GLOBAL_VALUES
+    }
+  end
+
+  class DairyAppMutationType < GraphQL::Schema::Object
+    graphql_name "Mutation"
     description "The root for mutations in this schema"
-    field :pushValue, !types[!types.Int] do
-      description("Push a value onto a global array :D")
-      argument :value, !types.Int, as: :val
-      resolve ->(o, args, ctx) {
-        GLOBAL_VALUES << args.val
-        GLOBAL_VALUES
-      }
+    # Test the `field:` compatibility option
+    field :pushValue, field: PushValueField
+
+    field :replaceValues, [Integer], "Replace the global array with new values", null: false do
+      argument :input, ReplaceValuesInputType, required: true
     end
 
-    field :replaceValues, !types[!types.Int] do
-      description("Replace the global array with new values")
-      argument :input, !ReplaceValuesInputType
-      resolve ->(o, args, ctx) {
-        GLOBAL_VALUES.clear
-        GLOBAL_VALUES.push(*args.input[:values])
-        GLOBAL_VALUES
-      }
+    def replace_values(input:)
+      GLOBAL_VALUES.clear
+      GLOBAL_VALUES.concat(input["values"])
+      GLOBAL_VALUES
     end
   end
 
@@ -433,7 +419,7 @@ module Dummy
     end
   end
 
-  Schema = GraphQL::Schema.define do
+  class Schema < GraphQL::Schema
     query DairyAppQueryType
     mutation DairyAppMutationType
     subscription SubscriptionType
@@ -442,8 +428,8 @@ module Dummy
 
     rescue_from(NoSuchDairyError) { |err| err.message  }
 
-    resolve_type ->(type, obj, ctx) {
+    def self.resolve_type(type, obj, ctx)
       Schema.types[obj.class.name.split("::").last]
-    }
+    end
   end
 end