graphql 1.8.0.pre1 → 1.8.0.pre2

data/spec/graphql/query/arguments_spec.rb

@@ -115,8 +115,8 @@ describe GraphQL::Query::Arguments do
     end
 
     it "returns nil for missing keys" do
-      assert_equal nil, arguments["z"]
-      assert_equal nil, arguments[7]
+      assert_nil arguments["z"]
+      assert_nil arguments[7]
     end
   end
 
@@ -303,7 +303,7 @@ describe GraphQL::Query::Arguments do
     end
 
     it "generates argument classes that responds to keys as functions" do
-      assert_equal nil, input_object.arguments_class
+      assert_nil input_object.arguments_class
 
       GraphQL::Query::Arguments.construct_arguments_class(input_object)
       args = input_object.arguments_class.new({foo: 3, bar: -90}, context: nil)

data/spec/graphql/query/variables_spec.rb

@@ -111,7 +111,7 @@ describe GraphQL::Query::Variables do
         let(:provided_variables) { { "ids" => [nil] } }
         it "returns an error" do
           assert_equal 1, result["errors"].length
-          assert_equal nil, result["data"]
+          assert_nil result["data"]
         end
       end
     end

data/spec/graphql/query_spec.rb

@@ -111,7 +111,7 @@ describe GraphQL::Query do
       }
 
       it "returns nil" do
-        assert_equal nil, query.operation_name
+        assert_nil query.operation_name
       end
     end
 
@@ -148,7 +148,7 @@ describe GraphQL::Query do
         }
 
         it "returns the inferred operation name" do
-          assert_equal nil, query.selected_operation_name
+          assert_nil query.selected_operation_name
         end
       end
     end
@@ -532,7 +532,7 @@ describe GraphQL::Query do
 
       it "overrides the schema's max_depth" do
         assert result["data"].key?("cheese")
-        assert_equal nil, result["errors"]
+        assert_nil result["errors"]
       end
     end
   end
@@ -699,7 +699,7 @@ describe GraphQL::Query do
 
     it "returns nil when there is no selected operation" do
       query = GraphQL::Query.new(schema, '# Only a comment')
-      assert_equal nil, query.irep_selection
+      assert_nil query.irep_selection
     end
   end
 

data/spec/graphql/relay/base_connection_spec.rb

@@ -38,7 +38,7 @@ describe GraphQL::Relay::BaseConnection do
         first: nil,
       }
       conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_equal nil, conn.first
+      assert_nil conn.first
     end
   end
 

data/spec/graphql/relay/connection_resolve_spec.rb

@@ -57,7 +57,7 @@ describe GraphQL::Relay::ConnectionResolve do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })
       conn = result["data"]["rebels"]["ships"]
-      assert_equal nil, conn
+      assert_nil conn
     end
   end
 end

data/spec/graphql/relay/connection_type_spec.rb

@@ -73,7 +73,7 @@ describe GraphQL::Relay::ConnectionType do
 
       it "nullifies the parent and adds an error" do
         result = star_wars_query(query_string)
-        assert_equal nil, result["data"]["basesWithNullName"]["edges"][0]["node"]
+        assert_nil result["data"]["basesWithNullName"]["edges"][0]["node"]
         assert_equal "Boom!", result["errors"][0]["message"]
       end
     end

data/spec/graphql/relay/mutation_spec.rb

@@ -193,17 +193,17 @@ describe GraphQL::Relay::Mutation do
     end
 
     it "doesn't get a mutation in the metadata" do
-      assert_equal nil, custom_return_type.mutation
+      assert_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
+      assert_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
+      assert_nil input.arguments['noDefault'].default_value
     end
 
     it "supports input fields with non-nil default value" do

data/spec/graphql/relay/relation_connection_spec.rb

@@ -74,6 +74,35 @@ describe GraphQL::Relay::RelationConnection do
       )
     end
 
+    it "makes one sql query for items and another for count" do
+      query_str = <<-GRAPHQL
+      {
+        empire {
+          bases(first: 2) {
+            totalCount
+            edges {
+              cursor
+              node {
+                name
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+      io = StringIO.new
+      begin
+        prev_logger = ActiveRecord::Base.logger
+        ActiveRecord::Base.logger = Logger.new(io)
+        result = star_wars_query(query_str, "first" => 2)
+      ensure
+        ActiveRecord::Base.logger = prev_logger
+      end
+      assert_equal 2, io.string.scan("\n").count, "Two log entries"
+      assert_equal 3, result["data"]["empire"]["bases"]["totalCount"]
+      assert_equal 2, result["data"]["empire"]["bases"]["edges"].size
+    end
+
     it "provides bidirectional_pagination" do
       result = star_wars_query(query_string, "first" => 1)
       last_cursor = get_last_cursor(result)
@@ -564,6 +593,35 @@ describe GraphQL::Relay::RelationConnection do
         result = star_wars_query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
         assert_equal(["Death Star"], get_names(result))
       end
+
+      it "makes one sql query for items and another for count" do
+        query_str = <<-GRAPHQL
+        {
+          empire {
+            basesAsSequelDataset(first: 2) {
+              totalCount
+              edges {
+                cursor
+                node {
+                  name
+                }
+              }
+            }
+          }
+        }
+        GRAPHQL
+        result = nil
+        io = StringIO.new
+        begin
+          StarWars::DB.loggers << Logger.new(io)
+          result = star_wars_query(query_str, "first" => 2)
+        ensure
+          StarWars::DB.loggers.pop
+        end
+        assert_equal 2, io.string.scan("SELECT").count
+        assert_equal 3, result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
+        assert_equal 2, result["data"]["empire"]["basesAsSequelDataset"]["edges"].size
+      end
     end
   end
 

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -30,6 +30,20 @@ type HelloScalars {
       build_schema_and_compare_output(schema.chop)
     end
 
+    it 'can build a schema with default input object values' do
+      schema = <<-SCHEMA
+input InputObject {
+  a: Int
+}
+
+type Query {
+  a(input: InputObject = {a: 1}): String
+}
+      SCHEMA
+
+      build_schema_and_compare_output(schema.chop)
+    end
+
     it 'can build a schema with directives' do
       schema = <<-SCHEMA
 schema {

data/spec/graphql/schema/field_spec.rb

@@ -4,11 +4,15 @@ require "spec_helper"
 describe GraphQL::Schema::Field do
   describe "graphql definition" do
     let(:object_class) { Jazz::Query }
-    let(:field) { object_class.fields.find { |f| f.name == "find" } }
+    let(:field) { object_class.fields.find { |f| f.name == "inspect_input" } }
 
     it "uses the argument class" do
       arg_defn = field.graphql_definition.arguments.values.first
       assert_equal :ok, arg_defn.metadata[:custom]
     end
+
+    it "camelizes the field name" do
+      assert_equal 'inspectInput', field.graphql_definition.name
+    end
   end
 end

data/spec/graphql/schema/instrumentation_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module InstrumentationSpec
+  class SomeInterface < GraphQL::Schema::Interface
+    field :neverCalled, String, null: false
+
+    def never_called
+      "should never be called"
+    end
+  end
+
+  class SomeType < GraphQL::Schema::Object
+    implements SomeInterface
+  end
+
+  class Query < GraphQL::Schema::Object
+    field :someField, [SomeInterface], null: true
+
+    def some_field
+      nil
+    end
+  end
+
+  class Schema < GraphQL::Schema
+    query Query
+    orphan_types [SomeType]
+  end
+end
+
+describe GraphQL::Schema::Member::Instrumentation do
+  describe "resolving nullable interface lists to nil" do
+    let(:query) { "query { someField { neverCalled } }"}
+    it "returns nil instead of failing" do
+      result = InstrumentationSpec::Schema.execute(query)
+      assert_nil(result["someField"])
+    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

data/spec/graphql/schema_spec.rb

@@ -23,6 +23,13 @@ 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(
@@ -372,7 +379,7 @@ 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_equal nil, schema.lazy_method_name({})
+      assert_nil schema.lazy_method_name({})
       assert_equal false, schema.lazy?({})
     end
   end

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_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)
+      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)
     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_equal nil, delivery.fetch("data")
+      assert_nil delivery.fetch("data")
       assert_equal 1, delivery["errors"].length
     end
 

data/spec/graphql/tracing/platform_tracing_spec.rb

@@ -53,4 +53,63 @@ describe GraphQL::Tracing::PlatformTracing do
       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",
+        "eql",
+      ]
+      assert_equal expected_trace, CustomPlatformTracer::TRACE
+    end
+  end
 end