graphql 1.8.7 → 1.9.0

data/spec/support/error_bubbling_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# helpers to enable / disable error bubbling in a block scope
+module ErrorBubblingHelpers
+  def without_error_bubbling(schema)
+    original_error_bubbling = schema.error_bubbling
+    begin
+      schema.error_bubbling = false
+      yield if block_given?
+    ensure
+      schema.error_bubbling = original_error_bubbling
+    end
+  end
+
+  def with_error_bubbling(schema)
+    original_error_bubbling = schema.error_bubbling
+    begin
+      schema.error_bubbling = true
+      yield if block_given?
+    ensure
+      schema.error_bubbling = original_error_bubbling
+    end
+  end
+end

data/spec/support/jazz.rb

@@ -9,7 +9,7 @@ module Jazz
     Key = Struct.new(:root, :sharp, :flat) do
       def self.from_notation(key_str)
         key, sharp_or_flat = key_str.split("")
-        sharp = sharp_or_flat ==  "♯"
+        sharp = sharp_or_flat == "♯"
         flat = sharp_or_flat == "♭"
         Models::Key.new(key, sharp, flat)
       end
@@ -36,7 +36,7 @@ module Jazz
         ],
         "Musician" => [
           Models::Musician.new("Herbie Hancock", Models::Key.from_notation("B♭")),
-        ]
+        ],
       }
     end
 
@@ -61,6 +61,8 @@ module Jazz
   # A custom field class that supports the `upcase:` option
   class BaseField < GraphQL::Schema::Field
     argument_class BaseArgument
+    attr_reader :upcase
+
     def initialize(*args, **options, &block)
       @upcase = options.delete(:upcase)
       super(*args, **options, &block)
@@ -74,6 +76,15 @@ module Jazz
         result
       end
     end
+
+    def resolve(*)
+      result = super
+      if @upcase && result
+        result.upcase
+      else
+        result
+      end
+    end
   end
 
   class BaseObject < GraphQL::Schema::Object
@@ -91,7 +102,7 @@ module Jazz
 
       def to_graphql
         type_defn = super
-        configs.each do |k,v|
+        configs.each do |k, v|
           type_defn.metadata[k] = v
         end
         type_defn
@@ -140,7 +151,7 @@ module Jazz
       null: false,
       description: "A unique identifier for this object",
     )
-    upcased_field :upcased_id, ID, null: false, method: :id # upcase: true added by helper
+    upcased_field :upcased_id, ID, null: false, resolver_method: :id # upcase: true added by helper
 
     def id
       GloballyIdentifiableType.to_id(@object)
@@ -156,10 +167,9 @@ module Jazz
     end
   end
 
-  # A legacy-style interface used by new-style types
-  NamedEntity = GraphQL::InterfaceType.define do
-    name "NamedEntity"
-    field :name, !types.String
+  module NamedEntity
+    include BaseInterface
+    field :name, String, null: false
   end
 
   # test field inheritance
@@ -177,12 +187,11 @@ module Jazz
     field :musicians, "[Jazz::Musician]", null: false
   end
 
-
   # Here's a new-style GraphQL type definition
   class Ensemble < ObjectWithUpcasedName
     # Test string type names
     # This method should override inherited one
-    field :name, "String", null: false, method: :overridden_name
+    field :name, "String", null: false, resolver_method: :overridden_name
     implements GloballyIdentifiableType, NamedEntity, HasMusicians
     description "A group of musicians playing together"
     config :config, :configged
@@ -210,23 +219,23 @@ module Jazz
     value "KEYS" do
       description "Neither here nor there, really"
     end
+    value "SILENCE", "Makes no sound", value: false
   end
 
   # Lives side-by-side with an old-style definition
   using GraphQL::DeprecatedDSL # for ! and types[]
-  InstrumentType = GraphQL::ObjectType.define do
-    name "Instrument"
-    interfaces [NamedEntity]
+
+  class InstrumentType < BaseObject
+    implements NamedEntity
     implements GloballyIdentifiableType
 
-    field :id, !types.ID, "A unique identifier for this object", resolve: ->(obj, args, ctx) { GloballyIdentifiableType.to_id(obj) }
-    field :upcasedId, !types.ID, resolve: ->(obj, args, ctx) { GloballyIdentifiableType.to_id(obj).upcase }
-    if RUBY_ENGINE == "jruby"
-      # JRuby doesn't support refinements, so the `using` above won't work
-      field :family, Family.to_non_null_type
-    else
-      field :family, !Family
+    field :upcased_id, ID, null: false
+
+    def upcased_id
+      GloballyIdentifiableType.to_id(object).upcase
     end
+
+    field :family, Family, null: false
   end
 
   class Key < GraphQL::Schema::Scalar
@@ -261,6 +270,7 @@ module Jazz
     # Test lists with nullable members:
     field :inspect_context, [String, null: true], null: false
     field :add_error, String, null: false, extras: [:execution_errors]
+
     def inspect_context
       [
         @context.custom_method,
@@ -276,21 +286,22 @@ module Jazz
     end
   end
 
-  LegacyInputType = GraphQL::InputObjectType.define do
-    name "LegacyInput"
-    argument :intValue, !types.Int
+  # Since this is not a legacy input type, this test can be removed
+  class LegacyInputType < GraphQL::Schema::InputObject
+    argument :int_value, Int, required: true
   end
 
   class InspectableInput < GraphQL::Schema::InputObject
     argument :string_value, String, required: true, description: "Test description kwarg"
     argument :nested_input, InspectableInput, required: false
     argument :legacy_input, LegacyInputType, required: false
+
     def helper_method
       [
         # Context is available in the InputObject
         context[:message],
-        # A GraphQL::Query::Arguments instance is available
-        arguments[:stringValue],
+        # ~~A GraphQL::Query::Arguments instance is available~~ not anymore
+        self[:string_value],
         # Legacy inputs have underscored method access too
         legacy_input ? legacy_input.int_value : "-",
         # Access by method call is available
@@ -309,10 +320,12 @@ module Jazz
     possible_types Musician, Ensemble
 
     def self.resolve_type(object, context)
-      if object.is_a?(Models::Ensemble)
-        Ensemble
-      else
-        Musician
+      GraphQL::Execution::Lazy.new do
+        if object.is_a?(Models::Ensemble)
+          Ensemble
+        else
+          Musician
+        end
       end
     end
   end
@@ -336,9 +349,12 @@ module Jazz
     field :inspect_key, InspectableKey, null: false do
       argument :key, Key, required: true
     end
-    field :nowPlaying, PerformingAct, null: false, resolve: ->(o, a, c) { Models.data["Ensemble"].first }
+    field :now_playing, PerformingAct, null: false
+
+    def now_playing; Models.data["Ensemble"].first; end
+
     # For asserting that the object is initialized once:
-    field :object_id, Integer, null: false
+    field :object_id, String, null: false
     field :inspect_context, [String], null: false
     field :hashyEnsemble, Ensemble, null: false
 
@@ -350,6 +366,14 @@ module Jazz
       argument :input, [RawJson], required: true
     end
 
+    field :upcase_check_1, String, null: true, resolver_method: :upcase_check, extras: [:upcase]
+    field :upcase_check_2, String, null: false, upcase: false, resolver_method: :upcase_check, extras: [:upcase]
+    field :upcase_check_3, String, null: false, upcase: true, resolver_method: :upcase_check, extras: [:upcase]
+    field :upcase_check_4, String, null: false, upcase: "why not?", resolver_method: :upcase_check, extras: [:upcase]
+    def upcase_check(upcase:)
+      upcase.inspect
+    end
+
     def ensembles
       # Filter out the unauthorized one to avoid an error later
       Models.data["Ensemble"].select { |e| e.name != "Spinal Tap" }
@@ -381,8 +405,8 @@ module Jazz
         # Access by key:
         input[:string_value],
         input.key?(:string_value).to_s,
-        # Access by legacy key
-        input[:stringValue],
+        # ~~Access by legacy key~~ # not anymore
+        input[:string_value],
       ]
     end
 
@@ -394,7 +418,7 @@ module Jazz
       [
         context.custom_method,
         context[:magic_key],
-        context[:normal_key]
+        context[:normal_key],
       ]
     end
 
@@ -402,11 +426,11 @@ module Jazz
       # Both string and symbol keys are supported:
 
       {
-          name: "The Grateful Dead",
-          "musicians" => [
-            OpenStruct.new(name: "Jerry Garcia"),
-          ],
-          "formedAtDate" => "May 5, 1965",
+        name: "The Grateful Dead",
+        "musicians" => [
+          OpenStruct.new(name: "Jerry Garcia"),
+        ],
+        "formedAtDate" => "May 5, 1965",
       }
     end
 
@@ -420,12 +444,13 @@ module Jazz
 
     field :hash_by_string, HashKeyTest, null: false
     field :hash_by_sym, HashKeyTest, null: false
+
     def hash_by_string
-      { "falsey" => false }
+      {"falsey" => false}
     end
 
     def hash_by_sym
-      { falsey: false }
+      {falsey: false}
     end
 
     field :named_entities, [NamedEntity, null: true], null: false
@@ -433,6 +458,20 @@ module Jazz
     def named_entities
       [Models.data["Ensemble"].first, nil]
     end
+
+    field :default_value_test, String, null: false do
+      if TESTING_INTERPRETER
+        argument :arg_with_default, InspectableInput, required: false, default_value: { string_value: "S" }
+      else
+        argument :arg_with_default, InspectableInput, required: false, default_value: { "stringValue" => "S" }
+      end
+    end
+
+    def default_value_test(arg_with_default:)
+      "#{arg_with_default.class.name} -> #{arg_with_default.to_h}"
+    end
+
+    field :complex_hash_key, String, null: false, hash_key: :'foo bar/fizz-buzz'
   end
 
   class EnsembleInput < GraphQL::Schema::InputObject
@@ -453,10 +492,11 @@ module Jazz
 
     field :ee, String, null: false
     extras [:execution_errors]
+
     def resolve(name:, family:, execution_errors:)
       instrument = Jazz::Models::Instrument.new(name, family)
       Jazz::Models.data["Instrument"] << instrument
-      { instrument: instrument, entries: Jazz::Models.data["Instrument"], ee: execution_errors.class.name}
+      {instrument: instrument, entries: Jazz::Models.data["Instrument"], ee: execution_errors.class.name}
     end
   end
 
@@ -468,7 +508,59 @@ module Jazz
 
     def resolve
       instrument = Models::Instrument.new("Sitar", :str)
-      { instrument: instrument }
+      {instrument: instrument}
+    end
+  end
+
+  class HasExtras < GraphQL::Schema::RelayClassicMutation
+    null true
+    description "Test extras in RelayClassicMutation"
+
+    argument :int, Integer, required: false
+    extras [:ast_node]
+
+    field :node_class, String, null: false
+    field :int, Integer, null: true
+
+    def resolve(int: nil, ast_node:)
+      {
+        int: int,
+        node_class: ast_node.class.name,
+      }
+    end
+  end
+
+  class RenameNamedEntity < GraphQL::Schema::RelayClassicMutation
+    argument :named_entity_id, ID, required: true, loads: NamedEntity
+    argument :new_name, String, required: true
+
+    field :named_entity, NamedEntity, null: false
+
+    def resolve(named_entity:, new_name:)
+      # doesn't actually update the "database"
+      dup_named_entity = named_entity.dup
+      dup_named_entity.name = new_name
+
+      {
+        named_entity: dup_named_entity
+      }
+    end
+  end
+
+  class RenamePerformingAct < GraphQL::Schema::RelayClassicMutation
+    argument :performing_act_id, ID, required: true, loads: PerformingAct
+    argument :new_name, String, required: true
+
+    field :performing_act, PerformingAct, null: false
+
+    def resolve(performing_act:, new_name:)
+      # doesn't actually update the "database"
+      dup_performing_act = performing_act.dup
+      dup_performing_act.name = new_name
+
+      {
+        performing_act: dup_performing_act
+      }
     end
   end
 
@@ -483,11 +575,55 @@ module Jazz
       dup_ensemble = ensemble.dup
       dup_ensemble.name = new_name
       {
-        ensemble: dup_ensemble
+        ensemble: dup_ensemble,
+      }
+    end
+  end
+
+  class UpvoteEnsembles < GraphQL::Schema::RelayClassicMutation
+    argument :ensemble_ids, [ID], required: true, loads: Ensemble
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(ensembles:)
+      {
+        ensembles: ensembles
+      }
+    end
+  end
+
+  class UpvoteEnsemblesAsBands < GraphQL::Schema::RelayClassicMutation
+    argument :ensemble_ids, [ID], required: true, loads: Ensemble, as: :bands
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(bands:)
+      {
+        ensembles: bands
       }
     end
   end
 
+  class UpvoteEnsemblesIds < GraphQL::Schema::RelayClassicMutation
+    argument :ensembles_ids, [ID], required: true, loads: Ensemble
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(ensembles:)
+      {
+        ensembles: ensembles
+      }
+    end
+  end
+
+  class RenameEnsembleAsBand < RenameEnsemble
+    argument :ensemble_id, ID, required: true, loads: Ensemble, as: :band
+
+    def resolve(band:, new_name:)
+      super(ensemble: band, new_name: new_name)
+    end
+  end
+
   class Mutation < BaseObject
     field :add_ensemble, Ensemble, null: false do
       argument :input, EnsembleInput, required: true
@@ -496,6 +632,13 @@ module Jazz
     field :add_instrument, mutation: AddInstrument
     field :add_sitar, mutation: AddSitar
     field :rename_ensemble, mutation: RenameEnsemble
+    field :rename_named_entity, mutation: RenameNamedEntity
+    field :rename_performing_act, mutation: RenamePerformingAct
+    field :upvote_ensembles, mutation: UpvoteEnsembles
+    field :upvote_ensembles_as_bands, mutation: UpvoteEnsemblesAsBands
+    field :upvote_ensembles_ids, mutation: UpvoteEnsemblesIds
+    field :rename_ensemble_as_band, mutation: RenameEnsembleAsBand
+    field :has_extras, mutation: HasExtras
 
     def add_ensemble(input:)
       ens = Models::Ensemble.new(input.name)
@@ -539,15 +682,29 @@ module Jazz
 
   module Introspection
     class TypeType < GraphQL::Introspection::TypeType
+      def name
+        n = object.graphql_name
+        n && n.upcase
+      end
+    end
+
+    class NestedType < GraphQL::Introspection::TypeType
       def name
         object.name.upcase
       end
+
+      class DeeplyNestedType < GraphQL::Introspection::TypeType
+        def name
+          object.name.upcase
+        end
+      end
     end
 
     class SchemaType < GraphQL::Introspection::SchemaType
       graphql_name "__Schema"
 
       field :is_jazzy, Boolean, null: false
+
       def is_jazzy
         true
       end
@@ -556,7 +713,8 @@ module Jazz
     class DynamicFields < GraphQL::Introspection::DynamicFields
       field :__typename_length, Int, null: false, extras: [:irep_node]
       field :__ast_node_class, String, null: false, extras: [:ast_node]
-      def __typename_length(irep_node:)
+
+      def __typename_length(irep_node: nil)
         __typename(irep_node: irep_node).length
       end
 
@@ -567,8 +725,13 @@ module Jazz
 
     class EntryPoints < GraphQL::Introspection::EntryPoints
       field :__classname, String, "The Ruby class name of the root object", null: false
+
       def __classname
-        object.class.name
+        if context.interpreter?
+          object.object.class.name
+        else
+          object.class.name
+        end
       end
     end
   end
@@ -588,5 +751,9 @@ module Jazz
     def self.object_from_id(id, ctx)
       GloballyIdentifiableType.find(id)
     end
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+      use GraphQL::Analysis::AST
+    end
   end
 end

data/spec/support/lazy_helpers.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 module LazyHelpers
+  MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK = 44
+  MAGIC_NUMBER_THAT_RETURNS_NIL = 0
+  MAGIC_NUMBER_THAT_RAISES_ERROR = 13
   class Wrapper
     def initialize(item = nil, &block)
       if block
@@ -22,7 +25,7 @@ module LazyHelpers
     attr_reader :own_value
     attr_writer :value
 
-    def initialize(ctx, own_value)
+    def initialize(own_value)
       @own_value = own_value
       all << self
     end
@@ -47,16 +50,32 @@ module LazyHelpers
   end
 
   class LazySum < GraphQL::Schema::Object
-    field :value, Integer, null: true, resolve: ->(o, a, c) { o == 13 ? nil : o }
+    field :value, Integer, null: true
+    def value
+      if object == MAGIC_NUMBER_THAT_RAISES_ERROR
+        nil
+      else
+        object
+      end
+    end
+
+    def self.authorized?(obj, ctx)
+      if obj == MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK
+        Wrapper.new { true }
+      else
+        true
+      end
+    end
+
     field :nestedSum, LazySum, null: false do
       argument :value, Integer, required: true
     end
 
     def nested_sum(value:)
-      if value == 13
+      if value == MAGIC_NUMBER_THAT_RAISES_ERROR
         Wrapper.new(nil)
       else
-        SumAll.new(@context, @object + value)
+        SumAll.new(@object + value)
       end
     end
 
@@ -72,33 +91,42 @@ module LazyHelpers
     GraphQL::DeprecatedDSL.activate
   end
 
-  LazyQuery = GraphQL::ObjectType.define do
-    name "Query"
-    field :int, !types.Int do
-      argument :value, !types.Int
-      argument :plus, types.Int, default_value: 0
-      resolve ->(o, a, c) { Wrapper.new(a[:value] + a[:plus])}
+  class LazyQuery < GraphQL::Schema::Object
+    field :int, Integer, null: false do
+      argument :value, Integer, required: true
+      argument :plus, Integer, required: false, default_value: 0
+    end
+    def int(value:, plus:)
+      Wrapper.new(value + plus)
     end
 
-    field :nestedSum, !LazySum do
-      argument :value, !types.Int
-      resolve ->(o, args, c) { SumAll.new(c, args[:value]) }
+    field :nested_sum, LazySum, null: false do
+      argument :value, Integer, required: true
     end
 
-    field :nullableNestedSum, LazySum do
-      argument :value, types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new { raise GraphQL::ExecutionError.new("13 is unlucky") }
-        else
-          SumAll.new(c, args[:value])
-        end
-      }
+    def nested_sum(value:)
+      SumAll.new(value)
     end
 
-    field :listSum, types[LazySum] do
-      argument :values, types[types.Int]
-      resolve ->(o, args, c) { args[:values] }
+    field :nullable_nested_sum, LazySum, null: true do
+      argument :value, Integer, required: true
+    end
+
+    def nullable_nested_sum(value:)
+      if value == MAGIC_NUMBER_THAT_RAISES_ERROR
+        Wrapper.new { raise GraphQL::ExecutionError.new("#{MAGIC_NUMBER_THAT_RAISES_ERROR} is unlucky") }
+      elsif value == MAGIC_NUMBER_THAT_RETURNS_NIL
+        nil
+      else
+        SumAll.new(value)
+      end
+    end
+
+    field :list_sum, [LazySum, null: true], null: true do
+      argument :values, [Integer], required: true
+    end
+    def list_sum(values:)
+      values.map { |v| v == MAGIC_NUMBER_THAT_RETURNS_NIL ? nil : v }
     end
   end
 
@@ -142,9 +170,23 @@ module LazyHelpers
     instrument(:query, SumAllInstrumentation.new(counter: nil))
     instrument(:multiplex, SumAllInstrumentation.new(counter: 1))
     instrument(:multiplex, SumAllInstrumentation.new(counter: 2))
+
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+      use GraphQL::Analysis::AST
+    end
+
+    def self.sync_lazy(lazy)
+      if lazy.is_a?(SumAll) && lazy.own_value > 1000
+        lazy.value # clear the previous set
+        lazy.own_value - 900
+      else
+        super
+      end
+    end
   end
 
-  def run_query(query_str)
-    LazySchema.execute(query_str)
+  def run_query(query_str, **rest)
+    LazySchema.execute(query_str, **rest)
   end
 end

data/spec/support/new_relic.rb

@@ -6,9 +6,11 @@ end
 
 module NewRelic
   TRANSACTION_NAMES = []
+  EXECUTION_SCOPES = []
   # Reset state between tests
   def self.clear_all
     TRANSACTION_NAMES.clear
+    EXECUTION_SCOPES.clear
   end
   module Agent
     def self.set_transaction_name(name)
@@ -17,6 +19,7 @@ module NewRelic
 
     module MethodTracerHelpers
       def self.trace_execution_scoped(trace_name)
+        EXECUTION_SCOPES << trace_name
         yield
       end
     end

data/spec/support/skylight.rb

@@ -9,9 +9,11 @@ end
 
 module Skylight
   ENDPOINT_NAMES = []
+  TITLE_NAMES = []
   # Reset state between tests
   def self.clear_all
     ENDPOINT_NAMES.clear
+    TITLE_NAMES.clear
   end
 
   def self.instrumenter
@@ -19,6 +21,7 @@ module Skylight
   end
 
   def self.instrument(category:, title:)
+    TITLE_NAMES << title
     yield
   end