graphql 1.8.0.pre10 → 1.8.0.pre11

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/scalar_spec.rb

@@ -36,5 +36,60 @@ describe GraphQL::Schema::Scalar do
       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/subscriptions_spec.rb

@@ -192,10 +192,10 @@ describe GraphQL::Subscriptions do
 
       # Application stuff happens.
       # The application signals graphql via `subscriptions.trigger`:
-      schema.subscriptions.trigger("payload", {"id" => "100"}, root_object.payload)
+      schema.subscriptions.trigger(:payload, {"id" => "100"}, root_object.payload)
       schema.subscriptions.trigger("payload", {"id" => "200"}, root_object.payload)
       # Symobls are OK too
-      schema.subscriptions.trigger("payload", {:id => "100"}, root_object.payload)
+      schema.subscriptions.trigger(:payload, {:id => "100"}, root_object.payload)
       schema.subscriptions.trigger("payload", {"id" => "300"}, nil)
 
       # Let's see what GraphQL sent over the wire:
@@ -267,8 +267,8 @@ describe GraphQL::Subscriptions do
       schema.subscriptions.trigger("event", { "stream" => {"type" => "ONE", "userId" => "3"} }, OpenStruct.new(str: "", int: 2))
       # This is a non-trigger
       schema.subscriptions.trigger("event", { "stream" => {"userId" => "3", "type" => "TWO"} }, OpenStruct.new(str: "", int: 3))
-      # These get default value of ONE
-      schema.subscriptions.trigger("event", { "stream" => {"userId" => "3"} }, OpenStruct.new(str: "", int: 4))
+      # These get default value of ONE (underscored / symbols are ok)
+      schema.subscriptions.trigger("event", { stream: { user_id: "3"} }, OpenStruct.new(str: "", int: 4))
       # Trigger with null updates subscriptionss to null
       schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => nil} }, OpenStruct.new(str: "", int: 5))
 
@@ -391,4 +391,31 @@ describe GraphQL::Subscriptions do
       refute_equal schema.subscriptions.build_id, schema.subscriptions.build_id
     end
   end
+
+  describe ".trigger" do
+    it "raises when event name is not found" do
+      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+        schema.subscriptions.trigger(:nonsense_field, {}, nil)
+      end
+
+      assert_includes err.message, "trigger: nonsense_field"
+      assert_includes err.message, "Subscription.nonsenseField"
+    end
+
+    it "raises when argument is not found" do
+      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+        schema.subscriptions.trigger(:event, { scream: {"userId" => "😱"} }, nil)
+      end
+
+      assert_includes err.message, "arguments: scream"
+      assert_includes err.message, "arguments of Subscription.event"
+
+      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+        schema.subscriptions.trigger(:event, { stream: { user_id_number: "😱"} }, nil)
+      end
+
+      assert_includes err.message, "arguments: user_id_number"
+      assert_includes err.message, "arguments of StreamInput"
+    end
+  end
 end

data/spec/graphql/upgrader/member_spec.rb

@@ -111,10 +111,12 @@ describe GraphQL::Upgrader::Member do
         end
       }
       new = %{
-        class UserInterface < Types::BaseInterface
+        module UserInterface
+          include Types::BaseInterface
           graphql_name "User"
         end
       }
+
       assert_equal new, upgrade(old)
 
       old = %{
@@ -139,10 +141,16 @@ describe GraphQL::Upgrader::Member do
       end}
       assert_equal new, upgrade(old)
 
-      old = %{UserInterface = GraphQL::InterfaceType.define do
-      end}
-      new = %{class UserInterface < Types::BaseInterface
-      end}
+      old = <<-RUBY
+UserInterface = GraphQL::InterfaceType.define do
+end
+RUBY
+      new = <<-RUBY
+module UserInterface
+  include Types::BaseInterface
+end
+RUBY
+
       assert_equal new, upgrade(old)
 
       old = %{UserUnion = GraphQL::UnionType.define do
@@ -474,7 +482,7 @@ describe GraphQL::Upgrader::Member do
       # Replace the default one with a custom one:
       type_transforms = GraphQL::Upgrader::Member::DEFAULT_TYPE_TRANSFORMS.map { |t|
         if t == GraphQL::Upgrader::TypeDefineToClassTransform
-          GraphQL::Upgrader::TypeDefineToClassTransform.new(base_class_pattern: "Platform::\\2s::Base")
+          GraphQL::Upgrader::TypeDefineToClassTransform.new(base_class_pattern: "Platform::\\3s::Base")
         else
           t
         end

data/spec/spec_helper.rb

@@ -16,6 +16,7 @@ if rails_should_be_installed?
   require "jdbc/sqlite3" if RUBY_ENGINE == 'jruby'
   require "sqlite3" if RUBY_ENGINE == 'ruby'
   require "pg" if RUBY_ENGINE == 'ruby'
+  require "mongoid" if RUBY_ENGINE == 'ruby'
   require "sequel"
 end
 
@@ -40,6 +41,7 @@ assign_metadata_key = ->(target, key, value) { target.metadata[key] = value }
 assign_metadata_flag = ->(target, flag) { target.metadata[flag] = true }
 GraphQL::Schema.accepts_definitions(set_metadata: assign_metadata_key)
 GraphQL::BaseType.accepts_definitions(metadata: assign_metadata_key)
+GraphQL::BaseType.accepts_definitions(metadata2: assign_metadata_key)
 GraphQL::Field.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::Argument.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::Argument.accepts_definitions(metadata_flag: assign_metadata_flag)
@@ -62,11 +64,16 @@ NO_OP_RESOLVE_TYPE = ->(type, obj, ctx) {
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
   unless rails_should_be_installed?
     next if f.end_with?('star_wars/data.rb')
+    next if f.end_with?('star_trek/data.rb')
     next if f.end_with?('base_generator_test.rb')
   end
   require f
 end
 
+def star_trek_query(string, variables={}, context: {})
+  StarTrek::Schema.execute(string, variables: variables, context: context)
+end
+
 def star_wars_query(string, variables={}, context: {})
   StarWars::Schema.execute(string, variables: variables, context: context)
 end

data/spec/support/dummy/schema.rb

@@ -366,6 +366,14 @@ module Dummy
       }
     end
 
+    field :multipleErrorsOnNonNullableField do
+      type !GraphQL::STRING_TYPE
+      resolve ->(t, a, c) {
+        [GraphQL::ExecutionError.new("This is an error message for some error."),
+         GraphQL::ExecutionError.new("This is another error message for a different error.")]
+      }
+    end
+
     field :executionErrorWithOptions do
       type GraphQL::INT_TYPE
       resolve ->(t, a, c) {

data/spec/support/jazz.rb

@@ -31,6 +31,7 @@ module Jazz
         ],
         "Ensemble" => [
           Models::Ensemble.new("Bela Fleck and the Flecktones"),
+          Models::Ensemble.new("Robert Glasper Experiment"),
         ],
         "Musician" => [
           Models::Musician.new("Herbie Hancock", Models::Key.from_notation("B♭")),
@@ -64,15 +65,13 @@ module Jazz
       super(*args, **options, &block)
     end
 
-    def to_graphql
-      field_defn = super
-      if @upcase
-        inner_resolve = field_defn.resolve_proc
-        field_defn.resolve = ->(obj, args, ctx) {
-          inner_resolve.call(obj, args, ctx).upcase
-        }
+    def resolve_field(*)
+      result = super
+      if @upcase && result
+        result.upcase
+      else
+        result
       end
-      field_defn
     end
   end
 
@@ -99,9 +98,17 @@ module Jazz
     end
   end
 
-  class BaseInterface < GraphQL::Schema::Interface
+  module BaseInterface
+    include GraphQL::Schema::Interface
     # Use this overridden field class
     field_class BaseField
+
+    # These methods are available to child interfaces
+    definition_methods do
+      def upcased_field(*args, **kwargs, &block)
+        field(*args, upcase: true, **kwargs, &block)
+      end
+    end
   end
 
   class BaseEnumValue < GraphQL::Schema::EnumValue
@@ -123,15 +130,14 @@ module Jazz
 
   # Some arbitrary global ID scheme
   # *Type suffix is removed automatically
-  class GloballyIdentifiableType < BaseInterface
+  module GloballyIdentifiableType
+    include BaseInterface
     description "A fetchable object in the system"
     field :id, ID, "A unique identifier for this object", null: false
-    field :upcased_id, ID, null: false, upcase: true, method: :id
+    upcased_field :upcased_id, ID, null: false, method: :id # upcase: true added by helper
 
-    module Implementation
-      def id
-        GloballyIdentifiableType.to_id(@object)
-      end
+    def id
+      GloballyIdentifiableType.to_id(@object)
     end
 
     def self.to_id(object)
@@ -160,15 +166,25 @@ module Jazz
     end
   end
 
+  module HasMusicians
+    include BaseInterface
+    field :musicians, "[Jazz::Musician]", null: false
+  end
+
+
   # Here's a new-style GraphQL type definition
   class Ensemble < ObjectWithUpcasedName
-    implements GloballyIdentifiableType, NamedEntity
+    # Test string type names
+    # This method should override inherited one
+    field :name, "String", null: false, method: :overridden_name
+    implements GloballyIdentifiableType, NamedEntity, HasMusicians
     description "A group of musicians playing together"
     config :config, :configged
-    # Test string type names:
-    field :name, "String", null: false
-    field :musicians, "[Jazz::Musician]", null: false
     field :formed_at, String, null: true, hash_key: "formedAtDate"
+
+    def overridden_name
+      @object.name.sub("Robert Glasper", "ROBERT GLASPER")
+    end
   end
 
   class Family < BaseEnum
@@ -212,6 +228,16 @@ module Jazz
     end
   end
 
+  class RawJson < GraphQL::Schema::Scalar
+    def self.coerce_input(val, ctx)
+      val
+    end
+
+    def self.coerce_result(val, ctx)
+      val
+    end
+  end
+
   class Musician < BaseObject
     implements GloballyIdentifiableType
     implements NamedEntity
@@ -279,6 +305,10 @@ module Jazz
     end
   end
 
+  class HashKeyTest < BaseObject
+    field :falsey, Boolean, null: false
+  end
+
   # Another new-style definition, with method overrides
   class Query < BaseObject
     field :ensembles, [Ensemble], null: false
@@ -300,6 +330,14 @@ module Jazz
     field :inspect_context, [String], null: false
     field :hashyEnsemble, Ensemble, null: false
 
+    field :echo_json, RawJson, null: false do
+      argument :input, RawJson, required: true
+    end
+
+    field :echo_first_json, RawJson, null: false do
+      argument :input, [RawJson], required: true
+    end
+
     def ensembles
       Models.data["Ensemble"]
     end
@@ -358,6 +396,24 @@ module Jazz
           "formedAtDate" => "May 5, 1965",
       }
     end
+
+    def echo_json(input:)
+      input
+    end
+
+    def echo_first_json(input:)
+      input.first
+    end
+
+    field :hash_by_string, HashKeyTest, null: false
+    field :hash_by_sym, HashKeyTest, null: false
+    def hash_by_string
+      { "falsey" => false }
+    end
+
+    def hash_by_sym
+      { falsey: false }
+    end
   end
 
   class EnsembleInput < GraphQL::Schema::InputObject
@@ -365,6 +421,7 @@ module Jazz
   end
 
   class AddInstrument < GraphQL::Schema::Mutation
+    null true
     description "Register a new musical instrument in the database"
 
     argument :name, String, required: true
@@ -396,6 +453,19 @@ module Jazz
       Models.data["Ensemble"] << ens
       ens
     end
+
+    field :prepare_input, Integer, null: false do
+      argument :input, Integer, required: true, prepare: :square, as: :squared_input
+    end
+
+    def prepare_input(squared_input:)
+      # Test that `square` is called
+      squared_input
+    end
+
+    def square(value)
+      value ** 2
+    end
   end
 
   class MetadataPlugin

data/spec/support/star_trek/data.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+require 'ostruct'
+
+module StarTrek
+  names = [
+    'USS Enterprise',
+    'USS Excelsior',
+    'USS Reliant',
+    'IKS Koraga',
+    'IKS Kronos One',
+    'IRW Khazara',
+    'IRW Praetus',
+  ]
+
+  MONGOID_CONFIG = {
+    clients: {
+      default: {
+        database: 'graphql_ruby_test',
+        hosts: ['localhost:27017']
+      }
+    },
+    sessions: {
+      default: {
+        database: 'graphql_ruby_test',
+        hosts: ['localhost:27017']
+      }
+    }
+  }.freeze
+
+  def db_name
+    MONGOID_CONFIG[:clients][:default][:database]
+  end
+  module_function :db_name
+
+  # Set up "Bases" in MongoDB
+  Mongoid.load_configuration(MONGOID_CONFIG)
+
+  class Base
+    include Mongoid::Document
+    field :name, type: String
+    field :sector, type: String
+    field :faction_id, type: Integer
+  end
+
+  Base.collection.drop
+  Base.create!(name: "Deep Space Station K-7", sector: "Mempa", faction_id: 1)
+  Base.create!(name: "Regula I", sector: "Mutara", faction_id: 1)
+  Base.create!(name: "Deep Space Nine", sector: "Bajoran", faction_id: 1)
+  Base.create!(name: "Firebase P'ok", sector: nil, faction_id: 2)
+  Base.create!(name: "Ganalda Space Station", sector: "Archanis", faction_id: 2)
+  Base.create!(name: "Rh'Ihho Station", sector: "Rator", faction_id: 3)
+
+  class FactionRecord
+    attr_reader :id, :name, :ships, :bases, :bases_clone
+    def initialize(id:, name:, ships:, bases:, bases_clone:)
+      @id = id
+      @name = name
+      @ships = ships
+      @bases = bases
+      @bases_clone = bases_clone
+    end
+  end
+
+  federation = FactionRecord.new({
+    id: '1',
+    name: 'United Federation of Planets',
+    ships:  ['1', '2', '3'],
+    bases: Base.where(faction_id: 1),
+    bases_clone: Base.where(faction_id: 1),
+  })
+
+  klingon = FactionRecord.new({
+    id: '2',
+    name: 'Klingon Empire',
+    ships: ['4', '5'],
+    bases: Base.where(faction_id: 2),
+    bases_clone: Base.where(faction_id: 2),
+  })
+
+  romulan = FactionRecord.new({
+    id: '2',
+    name: 'Romulan Star Empire',
+    ships: ['6', '7'],
+    bases: Base.where(faction_id: 3),
+    bases_clone: Base.where(faction_id: 3),
+  })
+
+  DATA = {
+    "Faction" => {
+      "1" => federation,
+      "2" => klingon,
+      "3" => romulan,
+    },
+    "Ship" => names.each_with_index.reduce({}) do |memo, (name, idx)|
+      id = (idx + 1).to_s
+      memo[id] = OpenStruct.new(name: name, id: id)
+      memo
+    end,
+    "Base" => Hash.new { |h, k| h[k] = Base.find(k) }
+  }
+
+  def DATA.create_ship(name, faction_id)
+    new_id = (self["Ship"].keys.map(&:to_i).max + 1).to_s
+    new_ship = OpenStruct.new(id: new_id, name: name)
+    self["Ship"][new_id] = new_ship
+    self["Faction"][faction_id].ships << new_id
+    new_ship
+  end
+end