graphql 1.7.6 → 1.8.0

data/spec/fixtures/upgrader/type_x.original.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    X = define_active_record_type(-> { ::X }) do
+      name "X"
+      description "An x on a y."
+      visibility :internal
+      minimum_accepted_scopes ["z"]
+
+      global_id_field :id
+      interfaces [GraphQL::Relay::Node.interface]
+
+      field :f1,    !Objects::O1, "The x being y."
+      field :f2,    !Enums::E1, "x for the y.",
+        property: :field_2
+      field :f3, Enums::E2, "x for y."
+      field :details, types.String, "Details."
+
+      field :f4, !Objects::O2, "x as a y inside the z." do
+        argument :a1, !Inputs::I1
+
+        resolve ->(obj_x, arguments, context) do
+          Class1.new(
+            a: Class2.new(
+              b: obj_x.b_1,
+              c: obj_x.c_1
+            ),
+            d: Class3.new(
+              b: obj_x.b_2,
+              c: obj_x.c_3,
+            )
+          )
+        end
+      end
+
+      field :f5, -> { !types.String } do
+        description "The thing"
+        property :custom_property
+        visibility :custom_value
+      end
+
+      field :f6, -> { !types.String } do
+        description "The thing"
+        property :custom_property
+        visibility :custom_value
+      end
+
+      field :f7, field: SomeField
+      field :f8, function: SomeFunction
+      field :f9, types[Objects::O2]
+      field :fieldField, types.String, hash_key: "fieldField"
+      field :fieldField2, types.String, property: :field_field2
+
+      field :f10, types.String do
+        resolve ->(obj, _, _) do
+          obj.something do |_|
+            xyz_obj.obj
+            obj.f10
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/type_x.transformed.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    class X < Platform::Objects::Base
+      model_name "X"
+      description "An x on a y."
+      visibility :internal
+      minimum_accepted_scopes ["z"]
+
+      global_id_field :id
+      implements GraphQL::Relay::Node.interface
+
+      field :f1, Objects::O1, "The x being y.", null: false
+      field :f2, Enums::E1, "x for the y.", method: :field_2, null: false
+      field :f3, Enums::E2, "x for y.", null: true
+      field :details, String, "Details.", null: true
+
+      field :f4, Objects::O2, "x as a y inside the z.", null: false do
+        argument :a1, Inputs::I1, required: true
+      end
+
+      def f4(**arguments)
+        Class1.new(
+          a: Class2.new(
+            b: @object.b_1,
+            c: @object.c_1
+          ),
+          d: Class3.new(
+            b: @object.b_2,
+            c: @object.c_3,
+          )
+        )
+      end
+
+      field :f5, String, visibility: :custom_value, method: :custom_property, description: "The thing", null: false
+
+      field :f6, String, visibility: :custom_value, method: :custom_property, description: "The thing", null: false
+
+      field :f7, field: SomeField
+      field :f8, function: SomeFunction
+      field :f9, [Objects::O2, null: true], null: true
+      field :field_field, String, hash_key: "fieldField", null: true
+      field :field_field2, String, null: true
+
+      field :f10, String, null: true
+
+      def f10
+        @object.something do |_|
+          xyz_obj.obj
+          @object.f10
+        end
+      end
+    end
+  end
+end

data/spec/generators/graphql/function_generator_spec.rb

@@ -30,4 +30,30 @@ RUBY
 
     assert_file "app/graphql/functions/find_record.rb", expected_content
   end
+
+  test "it generates a namespaced function by name" do
+    run_generator(["finders::find_record"])
+
+    expected_content = <<-RUBY
+class Functions::Finders::FindRecord < GraphQL::Function
+  # Define `initialize` to store field-level options, eg
+  #
+  #     field :myField, function: Functions::Finders::FindRecord.new(type: MyType)
+  #
+  # attr_reader :type
+  # def initialize(type:)
+  #   @type = type
+  # end
+
+  # add arguments by type:
+  # argument :id, !types.ID
+
+  # Resolve function:
+  def call(obj, args, ctx)
+  end
+end
+RUBY
+
+    assert_file "app/graphql/functions/finders/find_record.rb", expected_content
+  end
 end

data/spec/generators/graphql/install_generator_spec.rb

@@ -192,7 +192,7 @@ DummySchema = GraphQL::Schema.define do
   }
 
   # Object Resolution
-  resolve_type -> (obj, ctx) {
+  resolve_type -> (type, obj, ctx) {
     # TODO: Implement this function
     # to return the correct type for `obj`
     raise(NotImplementedError)

data/spec/generators/graphql/loader_generator_spec.rb

@@ -28,4 +28,28 @@ RUBY
 
     assert_file "app/graphql/loaders/record_loader.rb", expected_content
   end
+
+  test "it generates a namespaced loader by name" do
+    run_generator(["active_record::record_loader"])
+
+    expected_content = <<-RUBY
+class Loaders::ActiveRecord::RecordLoader < GraphQL::Batch::Loader
+  # Define `initialize` to store grouping arguments, eg
+  #
+  #     Loaders::ActiveRecord::RecordLoader.for(group).load(value)
+  #
+  # def initialize()
+  # end
+
+  # `keys` contains each key from `.load(key)`.
+  # Find the corresponding values, then
+  # call `fulfill(key, value)` or `fulfill(key, nil)`
+  # for each key.
+  def perform(keys)
+  end
+end
+RUBY
+
+    assert_file "app/graphql/loaders/active_record/record_loader.rb", expected_content
+  end
 end

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -37,7 +37,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
       Dummy::Schema.max_complexity = nil
     end
     it "doesn't error" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 
@@ -46,7 +46,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
       Dummy::Schema.max_complexity = 99
     end
     it "doesn't error" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 
@@ -68,7 +68,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
     let(:result) { Dummy::Schema.execute(query_string, max_complexity: 10) }
 
     it "doesn't error" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 

data/spec/graphql/analysis/max_query_depth_spec.rb

@@ -39,7 +39,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
     let(:result) { Dummy::Schema.execute(query_string, max_depth: 100) }
 
     it "obeys that max_depth" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 
@@ -49,7 +49,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
     end
 
     it "doesn't add an error" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 
@@ -59,7 +59,7 @@ describe GraphQL::Analysis::MaxQueryDepth do
     end
 
     it "doesn't add an error message" do
-      assert_equal nil, result["errors"]
+      assert_nil result["errors"]
     end
   end
 

data/spec/graphql/argument_spec.rb

@@ -32,6 +32,27 @@ describe GraphQL::Argument do
       assert_equal GraphQL::STRING_TYPE, arg.type
     end
 
+    it "accepts a definition block after defining kwargs" do
+      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do
+        description "my type is #{target.type}"
+      end
+
+      assert_equal "my type is String", arg.description
+    end
+
+    it "accepts a definition block with existing arg" do
+      existing = GraphQL::Argument.define do
+        name "bar"
+        type GraphQL::STRING_TYPE
+      end
+
+      arg = GraphQL::Argument.from_dsl(:foo, existing) do
+        description "Description for an existing field."
+      end
+
+      assert_equal "Description for an existing field.", arg.description
+    end
+
     it "creates an argument from dsl arguments" do
       arg = GraphQL::Argument.from_dsl(
         :foo,

data/spec/graphql/backtrace_spec.rb

@@ -126,6 +126,16 @@ describe GraphQL::Backtrace do
       assert_includes err.message, "more lines"
     end
 
+    it "annotates errors from Query#result" do
+      query_str = "query StrField { field2 { strField } __typename }"
+      context = { backtrace: true }
+      query = GraphQL::Query.new(schema, query_str, context: context)
+      err = assert_raises(GraphQL::Backtrace::TracedError) {
+        query.result
+      }
+      assert_instance_of RuntimeError, err.cause
+    end
+
     it "annotates errors inside lazy resolution" do
       # Test context-based flag
       err = assert_raises(GraphQL::Backtrace::TracedError) {

data/spec/graphql/base_type_spec.rb

@@ -28,6 +28,48 @@ describe GraphQL::BaseType do
     assert_equal ["Cheese"], Dummy::CheeseType.metadata[:class_names]
   end
 
+  describe "#name" do
+    describe "when containing spaces" do
+      BaseNameSpaceTest = GraphQL::BaseType.define do
+        name "Some Invalid Name"
+      end
+
+      it "is invalid" do
+        assert_raises(GraphQL::InvalidNameError) { BaseNameSpaceTest.name }
+      end
+    end
+
+    describe "when containing colons" do
+      BaseNameColonsTest = GraphQL::BaseType.define do
+        name "Some::Invalid::Name"
+      end
+
+      it 'is invalid' do
+        assert_raises(GraphQL::InvalidNameError) { BaseNameColonsTest.name }
+      end
+    end
+  end
+
+  describe "name" do
+    it "fails with a helpful message" do
+      error = assert_raises RuntimeError do
+        class BaseType < GraphQL::Schema::Object
+          name "KerkShine"
+        end
+      end
+
+      assert_equal error.message, "The new name override method is `graphql_name`, not `name`. Usage: graphql_name \"KerkShine\""
+    end
+  end
+
+  describe "forwards-compat with new api" do
+    let(:type_defn) { Dummy::CheeseType }
+    it "responds to new methods" do
+      assert_equal "Cheese", type_defn.graphql_name
+      assert_equal type_defn, type_defn.graphql_definition
+    end
+  end
+
   describe "#dup" do
     let(:obj_type) {
       GraphQL::ObjectType.define do

data/spec/graphql/boolean_type_spec.rb

@@ -13,9 +13,9 @@ describe GraphQL::BOOLEAN_TYPE do
     end
 
     it "rejects other types" do
-      assert_equal nil, coerce_input("true")
-      assert_equal nil, coerce_input(5.5)
-      assert_equal nil, coerce_input(nil)
+      assert_nil coerce_input("true")
+      assert_nil coerce_input(5.5)
+      assert_nil coerce_input(nil)
     end
   end
 end

data/spec/graphql/directive_spec.rb

@@ -31,7 +31,9 @@ describe GraphQL::Directive do
     describe "child fields" do
       let(:query_string) { <<-GRAPHQL
       {
-        __type(name: "Cheese") {
+        __type(name: """
+        Cheese
+        """) {
           fields { name }
           fields @skip(if: true) { isDeprecated }
         }

data/spec/graphql/enum_type_spec.rb

@@ -37,21 +37,34 @@ describe GraphQL::EnumType do
     end
   end
 
-  describe "invalid names" do
-    it "rejects names with a space" do
+  describe "invalid values" do
+    it "rejects value names with a space" do
       assert_raises(GraphQL::InvalidNameError) {
-        InvalidEnumTest = GraphQL::EnumType.define do
-          name "InvalidEnumTest"
+        InvalidEnumValueTest = GraphQL::EnumType.define do
+          name "InvalidEnumValueTest"
 
           value("SPACE IN VALUE", "Invalid enum because it contains spaces", value: 1)
         end
 
         # Force evaluation
-        InvalidEnumTest.name
+        InvalidEnumValueTest.name
       }
     end
   end
 
+  describe "invalid name" do
+    it "reject names with invalid format" do
+      assert_raises(GraphQL::InvalidNameError) do
+        InvalidEnumNameTest = GraphQL::EnumType.define do
+          name "Some::Invalid::Name"
+        end
+
+        # Force evaluation
+        InvalidEnumNameTest.name
+      end
+    end
+  end
+
   describe "values that are Arrays" do
     let(:schema) {
       enum = GraphQL::EnumType.define do

data/spec/graphql/execution/execute_spec.rb

@@ -120,7 +120,7 @@ describe GraphQL::Execution::Execute do
       }
       GRAPHQL
 
-      assert_equal nil, res["data"]
+      assert_nil res["data"]
       assert_equal "👻", res["errors"].first["message"]
     end
 
@@ -163,10 +163,10 @@ describe GraphQL::Execution::Execute do
           "execute_field",
           "execute_query",
           "lazy_loader",
-          "execute_field",
           "execute_field_lazy",
           "execute_field",
           "execute_field_lazy",
+          "execute_field",
           "execute_field_lazy",
           "execute_field_lazy",
           "execute_query_lazy",
@@ -177,8 +177,8 @@ describe GraphQL::Execution::Execute do
         field_1_eager, field_2_eager,
           query_eager, lazy_loader,
           # field 3 is eager-resolved _during_ field 1's lazy resolve
-          field_3_eager, field_1_lazy,
-          field_4_eager, field_2_lazy,
+          field_1_lazy, field_3_eager,
+          field_2_lazy, field_4_eager,
           # field 3 didn't finish above, it's resolved in the next round
           field_3_lazy, field_4_lazy,
           query_lazy, multiplex = exec_traces

data/spec/graphql/execution/instrumentation_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema do
+  describe "instrumentation teardown bug" do
+    # This instrumenter records that it ran,
+    # or raises an error if instructed to do so
+    class InstrumenterError < StandardError
+      attr_reader :key
+      def initialize(key)
+        @key = key
+        super()
+      end
+    end
+
+    class LogInstrumenter
+      def before_query(unit_of_work)
+        run_hook(unit_of_work, "begin")
+      end
+
+      def after_query(unit_of_work)
+        run_hook(unit_of_work, "end")
+      end
+
+      alias :before_multiplex :before_query
+      alias :after_multiplex :after_query
+
+      private
+
+      def run_hook(unit_of_work, event_name)
+        unit_of_work.context[log_key(event_name)] = true
+        if unit_of_work.context[raise_key(event_name)]
+          raise InstrumenterError.new(log_key(event_name))
+        end
+      end
+
+      def log_key(event_name)
+        context_key("did_#{event_name}")
+      end
+
+      def raise_key(event_name)
+        context_key("should_raise_#{event_name}")
+      end
+
+      def context_key(suffix)
+        prefix = self.class.name.sub("Instrumenter", "").downcase
+        :"#{prefix}_instrumenter_#{suffix}"
+      end
+    end
+
+    class FirstInstrumenter < LogInstrumenter; end
+    class SecondInstrumenter < LogInstrumenter; end
+
+    let(:query_type) {
+      GraphQL::ObjectType.define do
+        name "Query"
+        field :int, types.Int do
+          argument :value, types.Int
+          resolve ->(obj, args, ctx) { args.value }
+        end
+      end
+    }
+
+    let(:schema) {
+      spec = self
+      GraphQL::Schema.define do
+        query(spec.query_type)
+        instrument(:query, FirstInstrumenter.new)
+        instrument(:query, SecondInstrumenter.new)
+      end
+    }
+
+    describe "query instrumenters" do
+      it "before_query of the 2nd instrumenter does not run but after_query does" do
+        context = {second_instrumenter_should_raise_begin: true}
+        assert_raises InstrumenterError do
+          schema.execute(" { int(value: 2) } ", context: context)
+        end
+        assert context[:first_instrumenter_did_begin]
+        assert context[:first_instrumenter_did_end]
+        assert context[:second_instrumenter_did_begin]
+        refute context[:second_instrumenter_did_end]
+      end
+
+      it "runs after_query even if a previous after_query raised an error" do
+        context = {second_instrumenter_should_raise_end: true}
+        err = assert_raises InstrumenterError do
+          schema.execute(" { int(value: 2) } ", context: context)
+        end
+        # The error came from the second instrumenter:
+        assert_equal :second_instrumenter_did_end, err.key
+        # But the first instrumenter still got a chance to teardown
+        assert context[:first_instrumenter_did_begin]
+        assert context[:first_instrumenter_did_end]
+        assert context[:second_instrumenter_did_begin]
+        assert context[:second_instrumenter_did_end]
+      end
+    end
+
+    describe "within a multiplex" do
+      let(:multiplex_schema) {
+        schema.redefine {
+          instrument(:multiplex, FirstInstrumenter.new)
+          instrument(:multiplex, SecondInstrumenter.new)
+        }
+      }
+
+      it "only runs after_multiplex if before_multiplex finished" do
+        multiplex_ctx = {second_instrumenter_should_raise_begin: true}
+        query_1_ctx = {}
+        query_2_ctx = {}
+        assert_raises InstrumenterError do
+          multiplex_schema.multiplex(
+            [
+              {query: "{int(value: 1)}", context: query_1_ctx},
+              {query: "{int(value: 2)}", context: query_2_ctx},
+            ],
+            context: multiplex_ctx
+          )
+        end
+
+        assert multiplex_ctx[:first_instrumenter_did_begin]
+        assert multiplex_ctx[:first_instrumenter_did_end]
+        assert multiplex_ctx[:second_instrumenter_did_begin]
+        refute multiplex_ctx[:second_instrumenter_did_end]
+        # No query instrumentation was run at all
+        assert_equal 0, query_1_ctx.size
+        assert_equal 0, query_2_ctx.size
+      end
+
+      it "does full and partial query runs" do
+        multiplex_ctx = {}
+        query_1_ctx = {}
+        query_2_ctx = {second_instrumenter_should_raise_begin: true}
+        assert_raises InstrumenterError do
+          multiplex_schema.multiplex(
+            [
+              { query: " { int(value: 2) } ", context: query_1_ctx },
+              { query: " { int(value: 2) } ", context: query_2_ctx },
+            ],
+            context: multiplex_ctx
+          )
+        end
+
+        # multiplex got a full run
+        assert multiplex_ctx[:first_instrumenter_did_begin]
+        assert multiplex_ctx[:first_instrumenter_did_end]
+        assert multiplex_ctx[:second_instrumenter_did_begin]
+        assert multiplex_ctx[:second_instrumenter_did_end]
+
+        # query 1 got a full run
+        assert query_1_ctx[:first_instrumenter_did_begin]
+        assert query_1_ctx[:first_instrumenter_did_end]
+        assert query_1_ctx[:second_instrumenter_did_begin]
+        assert query_1_ctx[:second_instrumenter_did_end]
+
+        # query 2 got a partial run
+        assert query_2_ctx[:first_instrumenter_did_begin]
+        assert query_2_ctx[:first_instrumenter_did_end]
+        assert query_2_ctx[:second_instrumenter_did_begin]
+        refute query_2_ctx[:second_instrumenter_did_end]
+      end
+    end
+  end
+end

data/spec/graphql/execution/multiplex_spec.rb

@@ -126,7 +126,7 @@ describe GraphQL::Execution::Multiplex do
         "before multiplex 1",
         "before multiplex 2",
         "before Q1", "before Q2", "before Q3",
-        "after Q1", "after Q2", "after Q3",
+        "after Q3", "after Q2", "after Q1",
         "after multiplex 2",
         "after multiplex 1",
       ], checks
@@ -176,7 +176,7 @@ describe GraphQL::Execution::Multiplex do
       assert_raises(GraphQL::Error) do
         InspectSchema.execute("{ raiseError }")
       end
-      unhandled_err_json = 'null'
+      unhandled_err_json = '{}'
       assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
     end
   end

data/spec/graphql/execution_error_spec.rb

@@ -271,4 +271,22 @@ describe GraphQL::ExecutionError do
       assert_equal(expected_result, result)
     end
   end
+  
+  describe "more than one ExecutionError" do
+    let(:query_string) { %|{ multipleErrorsOnNonNullableField} |}
+    it "the errors are inserted into the errors key and the data is nil even for a NonNullable field " do
+      expected_result = {
+          "data"=>nil,
+          "errors"=>
+              [{"message"=>"This is an error message for some error.",
+                "locations"=>[{"line"=>1, "column"=>3}],
+                "path"=>["multipleErrorsOnNonNullableField", 0]},
+               {"message"=>"This is another error message for a different error.",
+                "locations"=>[{"line"=>1, "column"=>3}],
+                "path"=>["multipleErrorsOnNonNullableField", 1]}]
+      }
+      assert_equal(expected_result, result)
+    end
+  end
+
 end

data/spec/graphql/float_type_spec.rb

@@ -9,8 +9,8 @@ describe GraphQL::FLOAT_TYPE do
     end
 
     it "rejects other types" do
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
+      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
+      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/id_type_spec.rb

@@ -26,7 +26,7 @@ describe GraphQL::ID_TYPE do
     let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
 
     it "doesn't allow other types" do
-      assert_equal nil, result["data"]
+      assert_nil result["data"]
       assert_equal 1, result["errors"].length
     end
   end