graphql 1.4.0 → 1.4.1

data/spec/support/star_wars/data.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require 'ostruct'
+module StarWars
+  names = [
+    'X-Wing',
+    'Y-Wing',
+    'A-Wing',
+    'Millenium Falcon',
+    'Home One',
+    'TIE Fighter',
+    'TIE Interceptor',
+    'Executor',
+  ]
+
+  # ActiveRecord::Base.logger = Logger.new(STDOUT)
+  `rm -f ./_test_.db`
+  # Set up "Bases" in ActiveRecord
+  ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "./_test_.db")
+
+  ActiveRecord::Schema.define do
+    self.verbose = false
+    create_table :bases do |t|
+      t.column :name, :string
+      t.column :planet, :string
+      t.column :faction_id, :integer
+    end
+  end
+
+  class Base < ActiveRecord::Base
+  end
+
+  Base.create!(name: "Yavin", planet: "Yavin 4", faction_id: 1)
+  Base.create!(name: "Echo Base", planet: "Hoth", faction_id: 1)
+  Base.create!(name: "Secret Hideout", planet: "Dantooine", faction_id: 1)
+  Base.create!(name: "Death Star", planet: nil, faction_id: 2)
+  Base.create!(name: "Shield Generator", planet: "Endor", faction_id: 2)
+  Base.create!(name: "Headquarters", planet: "Coruscant", faction_id: 2)
+
+  # Also, set up Bases with Sequel
+  DB = Sequel.sqlite("./_test_.db")
+  class SequelBase < Sequel::Model(:bases)
+  end
+
+  rebels  = OpenStruct.new({
+    id: '1',
+    name: 'Alliance to Restore the Republic',
+    ships:  ['1', '2', '3', '4', '5'],
+    bases: Base.where(faction_id: 1),
+    basesClone: Base.where(faction_id: 1),
+  })
+
+
+  empire = OpenStruct.new({
+    id: '2',
+    name: 'Galactic Empire',
+    ships: ['6', '7', '8'],
+    bases: Base.where(faction_id: 2),
+    basesClone: Base.where(faction_id: 2),
+  })
+
+  DATA = {
+    "Faction" => {
+      "1" => rebels,
+      "2" => empire,
+    },
+    "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

data/spec/support/star_wars/schema.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+module StarWars
+  # Adapted from graphql-relay-js
+  # https://github.com/graphql/graphql-relay-js/blob/master/src/__tests__/starWarsSchema.js
+
+  Ship = GraphQL::ObjectType.define do
+    name "Ship"
+    interfaces [GraphQL::Relay::Node.interface]
+    global_id_field :id
+    field :name, types.String
+  end
+
+  BaseType = GraphQL::ObjectType.define do
+    name "Base"
+    interfaces [GraphQL::Relay::Node.interface]
+    global_id_field :id
+    field :name, types.String
+    field :planet, types.String
+  end
+
+  # Use an optional block to add fields to the connection type:
+  BaseConnectionWithTotalCountType = BaseType.define_connection(nodes_field: true) do
+    name "BasesConnectionWithTotalCount"
+    field :totalCount do
+      type types.Int
+      resolve ->(obj, args, ctx) { obj.nodes.count }
+    end
+  end
+
+  class CustomBaseEdge < GraphQL::Relay::Edge
+    def upcased_name
+      node.name.upcase
+    end
+
+    def upcased_parent_name
+      parent.name.upcase
+    end
+  end
+
+  CustomBaseEdgeType = BaseType.define_edge do
+    name "CustomBaseEdge"
+    field :upcasedName, types.String, property: :upcased_name
+    field :upcasedParentName, types.String, property: :upcased_parent_name
+    field :edgeClassName, types.String do
+      resolve ->(obj, args, ctx) { obj.class.name }
+    end
+  end
+
+  CustomEdgeBaseConnectionType = BaseType.define_connection(edge_class: CustomBaseEdge, edge_type: CustomBaseEdgeType, nodes_field: true) do
+    name "CustomEdgeBaseConnection"
+
+    field :totalCountTimes100 do
+      type types.Int
+      resolve ->(obj, args, ctx) { obj.nodes.count * 100 }
+    end
+
+    field :fieldName, types.String, resolve: ->(obj, args, ctx) { obj.field.name }
+  end
+
+  Faction = GraphQL::ObjectType.define do
+    name "Faction"
+    interfaces [GraphQL::Relay::Node.interface]
+
+    field :id, !types.ID, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
+    field :name, types.String
+    connection :ships, Ship.connection_type do
+      resolve ->(obj, args, ctx) {
+        all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
+        if args[:nameIncludes]
+          all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
+        end
+        all_ships
+      }
+      # You can define arguments here and use them in the connection
+      argument :nameIncludes, types.String
+    end
+    connection :shipsWithMaxPageSize, Ship.connection_type, max_page_size: 2 do
+      resolve ->(obj, args, ctx) {
+        all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
+        if args[:nameIncludes]
+          all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
+        end
+        all_ships
+      }
+      # You can define arguments here and use them in the connection
+      argument :nameIncludes, types.String
+    end
+
+    connection :bases, BaseConnectionWithTotalCountType do
+      # Resolve field should return an Array, the Connection
+      # will do the rest!
+      resolve ->(obj, args, ctx) {
+        all_bases = Base.where(id: obj.bases)
+        if args[:nameIncludes]
+          all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
+        end
+        all_bases
+      }
+      argument :nameIncludes, types.String
+    end
+
+    connection :basesClone, BaseType.connection_type
+    connection :basesByName, BaseType.connection_type, property: :bases do
+      argument :order, types.String, default_value: "name"
+      resolve ->(obj, args, ctx) {
+        if args[:order].present?
+          obj.bases.order(args[:order])
+        else
+          obj.bases
+        end
+      }
+    end
+
+    connection :basesWithMaxLimitRelation, BaseType.connection_type, max_page_size: 2 do
+      resolve ->(object, args, context) { Base.all }
+    end
+
+    connection :basesWithMaxLimitArray, BaseType.connection_type, max_page_size: 2 do
+      resolve ->(object, args, context) { Base.all.to_a }
+    end
+
+    connection :basesAsSequelDataset, BaseConnectionWithTotalCountType do
+      argument :nameIncludes, types.String
+      resolve ->(obj, args, ctx) {
+        all_bases = SequelBase.where(faction_id: obj.id)
+        if args[:nameIncludes]
+          all_bases = all_bases.where("name LIKE ?", "%#{args[:nameIncludes]}%")
+        end
+        all_bases
+      }
+    end
+
+    connection :basesWithCustomEdge, CustomEdgeBaseConnectionType, property: :bases
+  end
+
+  # Define a mutation. It will also:
+  #   - define a derived InputObjectType
+  #   - define a derived ObjectType (for return)
+  #   - define a field, accessible from {Mutation#field}
+  #
+  # The resolve proc takes `inputs, ctx`, where:
+  #   - `inputs` has the keys defined with `input_field`
+  #   - `ctx` is the Query context (like normal fields)
+  #
+  # Notice that you leave out clientMutationId.
+  IntroduceShipMutation = GraphQL::Relay::Mutation.define do
+    # Used as the root for derived types:
+    name "IntroduceShip"
+    description "Add a ship to this faction"
+
+    # Nested under `input` in the query:
+    input_field :shipName, types.String
+    input_field :factionId, !types.ID
+
+    # Result may have access to these fields:
+    return_field :shipEdge, Ship.edge_type
+    return_field :faction, Faction
+
+    # Here's the mutation operation:
+    resolve ->(root_obj, inputs, ctx) {
+      faction_id = inputs["factionId"]
+      if inputs["shipName"] == 'Millennium Falcon'
+        GraphQL::ExecutionError.new("Sorry, Millennium Falcon ship is reserved")
+
+      else
+        ship = DATA.create_ship(inputs["shipName"], faction_id)
+        faction = DATA["Faction"][faction_id]
+        connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(faction.ships)
+        ships_connection = connection_class.new(faction.ships, inputs)
+        ship_edge = GraphQL::Relay::Edge.new(ship, ships_connection)
+        result = {
+          shipEdge: ship_edge,
+          faction: faction
+        }
+        if inputs["shipName"] == "Slave II"
+          LazyWrapper.new(result)
+        else
+          result
+        end
+      end
+    }
+  end
+
+
+  class LazyWrapper
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  QueryType = GraphQL::ObjectType.define do
+    name "Query"
+    field :rebels, Faction do
+      resolve ->(obj, args, ctx) { StarWars::DATA["Faction"]["1"]}
+    end
+
+    field :empire, Faction do
+      resolve ->(obj, args, ctx) { StarWars::DATA["Faction"]["2"]}
+    end
+
+    field :largestBase, BaseType do
+      resolve ->(obj, args, ctx) { Base.find(3) }
+    end
+
+    connection :newestBasesGroupedByFaction, BaseType.connection_type do
+      resolve ->(obj, args, ctx) {
+        Base.order('sum(faction_id) desc').group(:faction_id)
+      }
+    end
+
+    field :node, GraphQL::Relay::Node.field
+  end
+
+  MutationType = GraphQL::ObjectType.define do
+    name "Mutation"
+    # The mutation object exposes a field:
+    field :introduceShip, field: IntroduceShipMutation.field
+  end
+
+  Schema = GraphQL::Schema.define do
+    query(QueryType)
+    mutation(MutationType)
+
+    resolve_type ->(object, ctx) {
+      if object == :test_error
+        :not_a_type
+      elsif object.is_a?(Base)
+        BaseType
+      elsif DATA["Faction"].values.include?(object)
+        Faction
+      elsif DATA["Ship"].values.include?(object)
+        Ship
+      else
+        nil
+      end
+    }
+
+    object_from_id ->(node_id, ctx) do
+      type_name, id = GraphQL::Schema::UniqueWithinType.decode(node_id)
+      StarWars::DATA[type_name][id]
+    end
+
+    id_from_object ->(object, type, ctx) do
+      GraphQL::Schema::UniqueWithinType.encode(type.name, object.id)
+    end
+
+    lazy_resolve(LazyWrapper, :value)
+  end
+end

data/spec/support/static_validation_helpers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # This module assumes you have `let(:query_string)` in your spec.
 # It provides `errors` which are the validation errors for that string,
-# as validated against `DummySchema`.
+# as validated against `Dummy::Schema`.
 # You can override `schema` to provide another schema
 # @example testing static validation
 #   include StaticValidationHelpers
@@ -23,6 +23,6 @@ module StaticValidationHelpers
   end
 
   def schema
-    DummySchema
+    Dummy::Schema
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-08 00:00:00.000000000 Z
+date: 2017-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -547,11 +547,11 @@ files:
 - spec/graphql/string_type_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/spec_helper.rb
-- spec/support/dairy_app.rb
-- spec/support/dairy_data.rb
+- spec/support/dummy/data.rb
+- spec/support/dummy/schema.rb
 - spec/support/minimum_input_object.rb
-- spec/support/star_wars_data.rb
-- spec/support/star_wars_schema.rb
+- spec/support/star_wars/data.rb
+- spec/support/star_wars/schema.rb
 - spec/support/static_validation_helpers.rb
 homepage: http://github.com/rmosolgo/graphql-ruby
 licenses:
@@ -676,9 +676,9 @@ test_files:
 - spec/graphql/string_type_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/spec_helper.rb
-- spec/support/dairy_app.rb
-- spec/support/dairy_data.rb
+- spec/support/dummy/data.rb
+- spec/support/dummy/schema.rb
 - spec/support/minimum_input_object.rb
-- spec/support/star_wars_data.rb
-- spec/support/star_wars_schema.rb
+- spec/support/star_wars/data.rb
+- spec/support/star_wars/schema.rb
 - spec/support/static_validation_helpers.rb

data/spec/support/dairy_app.rb

@@ -1,369 +0,0 @@
-# frozen_string_literal: true
-require_relative "./dairy_data"
-
-class NoSuchDairyError < StandardError; end
-
-GraphQL::Field.accepts_definitions(joins: GraphQL::Define.assign_metadata_key(:joins))
-GraphQL::BaseType.accepts_definitions(class_names: GraphQL::Define.assign_metadata_key(:class_names))
-
-LocalProductInterface = GraphQL::InterfaceType.define do
-  name "LocalProduct"
-  description "Something that comes from somewhere"
-  field :origin, !types.String, "Place the thing comes from"
-end
-
-EdibleInterface = GraphQL::InterfaceType.define do
-  name "Edible"
-  description "Something you can eat, yum"
-  field :fatContent, !types.Float, "Percentage which is fat"
-  field :origin, !types.String, "Place the edible comes from"
-  field :selfAsEdible, EdibleInterface, resolve: ->(o, a, c) { o }
-end
-
-AnimalProductInterface = GraphQL::InterfaceType.define do
-  name "AnimalProduct"
-  description "Comes from an animal, no joke"
-  field :source, !types.String, "Animal which produced this product"
-end
-
-BeverageUnion = GraphQL::UnionType.define do
-  name "Beverage"
-  description "Something you can drink"
-  possible_types [MilkType]
-end
-
-DairyAnimalEnum = GraphQL::EnumType.define do
-  name "DairyAnimal"
-  description "An animal which can yield milk"
-  value("COW",      "Animal with black and white spots", value: 1)
-  value("DONKEY",   "Animal with fur", value: :donkey)
-  value("GOAT",     "Animal with horns")
-  value("REINDEER", "Animal with horns", value: 'reindeer')
-  value("SHEEP",    "Animal with wool")
-  value("YAK",      "Animal with long hair", deprecation_reason: "Out of fashion")
-end
-
-CheeseType = GraphQL::ObjectType.define do
-  name "Cheese"
-  class_names ["Cheese"]
-  description "Cultured dairy product"
-  interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
-
-  # Can have (name, type, desc)
-  field :id, !types.Int, "Unique identifier"
-  field :flavor, !types.String, "Kind of Cheese"
-  field :origin, !types.String, "Place the cheese comes from"
-
-  field :source, !DairyAnimalEnum,
-    "Animal which produced the milk for this cheese"
-
-  # Or can define by block, `resolve ->` should override `property:`
-  field :similarCheese, CheeseType, "Cheeses like this one", property: :this_should_be_overriden  do
-    # metadata test
-    joins [:cheeses, :milks]
-    argument :source, !types[!DairyAnimalEnum]
-    argument :nullableSource, types[!DairyAnimalEnum], default_value: [1]
-    resolve ->(t, a, c) {
-      # get the strings out:
-      sources = a["source"]
-      if sources.include?("YAK")
-        raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
-      else
-        CHEESES.values.find { |c| sources.include?(c.source) }
-      end
-    }
-  end
-
-  field :nullableCheese, CheeseType, "Cheeses like this one" do
-    argument :source, types[!DairyAnimalEnum]
-    resolve ->(t, a, c) { raise("NotImplemented") }
-  end
-
-  field :deeplyNullableCheese, CheeseType, "Cheeses like this one" do
-    argument :source, types[types[DairyAnimalEnum]]
-    resolve ->(t, a, c) { raise("NotImplemented") }
-  end
-
-  # Keywords can be used for definition methods
-  field :fatContent,
-    property: :fat_content,
-    type: !GraphQL::FLOAT_TYPE,
-    description: "Percentage which is milkfat",
-    deprecation_reason: "Diet fashion has changed"
-end
-
-MilkType = GraphQL::ObjectType.define do
-  name "Milk"
-  description "Dairy beverage"
-  interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
-  field :id, !types.ID
-  field :source, DairyAnimalEnum, "Animal which produced this milk", hash_key: :source
-  field :origin, !types.String, "Place the milk comes from"
-  field :flavors, types[types.String], "Chocolate, Strawberry, etc" do
-    argument :limit, types.Int
-    resolve ->(milk, args, ctx) {
-      args[:limit] ? milk.flavors.first(args[:limit]) : milk.flavors
-    }
-  end
-  field :executionError do
-    type GraphQL::STRING_TYPE
-    resolve ->(t, a, c) { raise(GraphQL::ExecutionError, "There was an execution error") }
-  end
-
-  field :allDairy, -> { types[DairyProductUnion] } do
-    resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
-  end
-end
-
-SweetenerInterface = GraphQL::InterfaceType.define do
-  name "Sweetener"
-  field :sweetness, types.Int
-end
-
-# No actual data; This type is an "orphan", only accessible through Interfaces
-HoneyType = GraphQL::ObjectType.define do
-  name "Honey"
-  description "Sweet, dehydrated bee barf"
-  field :flowerType, types.String, "What flower this honey came from"
-  interfaces [EdibleInterface, AnimalProductInterface, SweetenerInterface]
-end
-
-DairyType = GraphQL::ObjectType.define do
-  name "Dairy"
-  description "A farm where milk is harvested and cheese is produced"
-  field :id, !types.ID
-  field :cheese, CheeseType
-  field :milks, types[MilkType]
-end
-
-MaybeNullType = GraphQL::ObjectType.define do
-  name "MaybeNull"
-  description "An object whose fields return nil"
-  field :cheese, CheeseType
-end
-
-DairyProductUnion = GraphQL::UnionType.define do
-  name "DairyProduct"
-  description "Kinds of food made from milk"
-  # Test that these forms of declaration still work:
-  possible_types ["MilkType", -> { CheeseType }]
-end
-
-CowType = GraphQL::ObjectType.define do
-  name "Cow"
-  description "A farm where milk is harvested and cheese is produced"
-  field :id, !types.ID
-  field :name, types.String
-  field :last_produced_dairy, DairyProductUnion
-
-  field :cantBeNullButIs do
-    type !GraphQL::STRING_TYPE
-    resolve ->(t, a, c) { nil }
-  end
-
-  field :cantBeNullButRaisesExecutionError do
-    type !GraphQL::STRING_TYPE
-    resolve ->(t, a, c) { raise GraphQL::ExecutionError, "BOOM" }
-  end
-end
-
-DairyProductInputType = GraphQL::InputObjectType.define {
-  name "DairyProductInput"
-  description "Properties for finding a dairy product"
-  input_field :source, !DairyAnimalEnum do
-    # ensure we can define description in block
-    description "Where it came from"
-  end
-
-  input_field :originDairy, types.String, "Dairy which produced it", default_value: "Sugar Hollow Dairy" do
-    description   "Ignored because arg takes precedence"
-    default_value "Ignored because keyword arg takes precedence"
-  end
-
-  input_field :fatContent, types.Float, "How much fat it has" do
-    # ensure we can define default in block
-    default_value 0.3
-  end
-
-  # ensure default can be false
-  input_field :organic, types.Boolean, default_value: false
-}
-
-DeepNonNullType = GraphQL::ObjectType.define do
-  name "DeepNonNull"
-  field :nonNullInt, !types.Int do
-    argument :returning, types.Int
-    resolve ->(obj, args, ctx) { args[:returning] }
-  end
-
-  field :deepNonNull, DeepNonNullType.to_non_null_type do
-    resolve ->(obj, args, ctx) { :deepNonNull }
-  end
-end
-
-class FetchField
-  def self.create(type:, data:, id_type: !GraphQL::INT_TYPE)
-    desc = "Find a #{type.name} by id"
-    return_type = type
-    GraphQL::Field.define do
-      type(return_type)
-      description(desc)
-      argument :id, id_type
-
-      resolve ->(t, a, c) {
-        id_string = a["id"].to_s # Cheese has Int type, Milk has ID type :(
-        id, item = data.find { |id, item| id.to_s == id_string }
-        item
-      }
-    end
-  end
-end
-
-class SingletonField
-  def self.create(type:, data:)
-    desc = "Find the only #{type.name}"
-    return_type = type
-    GraphQL::Field.define do
-      type(return_type)
-      description(desc)
-
-      resolve ->(t, a, c) {data}
-    end
-  end
-end
-
-SourceFieldDefn = Proc.new {
-  type GraphQL::ListType.new(of_type: CheeseType)
-  description "Cheese from source"
-  argument :source, DairyAnimalEnum, default_value: 1
-  resolve ->(target, arguments, context) {
-    CHEESES.values.select{ |c| c.source == arguments["source"] }
-  }
-}
-
-FavoriteFieldDefn = GraphQL::Field.define do
-  name "favoriteEdible"
-  description "My favorite food"
-  type EdibleInterface
-  resolve ->(t, a, c) { MILKS[1] }
-end
-
-DairyAppQueryType = GraphQL::ObjectType.define do
-  name "Query"
-  description "Query root of the system"
-  field :root, types.String do
-    resolve ->(root_value, args, c) { root_value }
-  end
-  field :cheese, field: FetchField.create(type: CheeseType, data: CHEESES)
-  field :milk, field: FetchField.create(type: MilkType, data: MILKS, id_type: !types.ID)
-  field :dairy, field: SingletonField.create(type: DairyType, data: DAIRY)
-  field :fromSource, &SourceFieldDefn
-  field :favoriteEdible, FavoriteFieldDefn
-  field :cow, field: SingletonField.create(type: CowType, data: COW)
-  field :searchDairy do
-    description "Find dairy products matching a description"
-    type !DairyProductUnion
-    # This is a list just for testing 😬
-    argument :product, types[DairyProductInputType], default_value: [{"source" => "SHEEP"}]
-    resolve ->(t, args, c) {
-      source = args["product"][0][:source] # String or Sym is ok
-      products = CHEESES.values + MILKS.values
-      if !source.nil?
-        products = products.select { |pr| pr.source == source }
-      end
-      products.first
-    }
-  end
-
-  field :allDairy, types[DairyProductUnion] do
-    argument :executionErrorAtIndex, types.Int
-    resolve ->(obj, args, ctx) {
-      result = CHEESES.values + MILKS.values
-      result[args[:executionErrorAtIndex]] = GraphQL::ExecutionError.new("missing dairy") if args[:executionErrorAtIndex]
-      result
-    }
-  end
-
-  field :allEdible, types[EdibleInterface] do
-    resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
-  end
-
-  field :error do
-    description "Raise an error"
-    type GraphQL::STRING_TYPE
-    resolve ->(t, a, c) { raise("This error was raised on purpose") }
-  end
-
-  field :executionError do
-    type GraphQL::STRING_TYPE
-    resolve ->(t, a, c) { raise(GraphQL::ExecutionError, "There was an execution error") }
-  end
-
-  field :valueWithExecutionError do
-    type !GraphQL::INT_TYPE
-    resolve ->(t, a, c) {
-      c.add_error(GraphQL::ExecutionError.new("Could not fetch latest value"))
-      return 0
-    }
-  end
-
-  # To test possibly-null fields
-  field :maybeNull, MaybeNullType do
-    resolve ->(t, a, c) { OpenStruct.new(cheese: nil) }
-  end
-
-  field :deepNonNull, !DeepNonNullType do
-    resolve ->(o, a, c) { :deepNonNull }
-  end
-end
-
-GLOBAL_VALUES = []
-
-ReplaceValuesInputType = GraphQL::InputObjectType.define do
-  name "ReplaceValuesInput"
-  input_field :values, !types[!types.Int]
-end
-
-DairyAppMutationType = GraphQL::ObjectType.define do
-  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
-    resolve ->(o, args, ctx) {
-      GLOBAL_VALUES << args[:value]
-      GLOBAL_VALUES
-    }
-  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
-    }
-  end
-end
-
-SubscriptionType = GraphQL::ObjectType.define do
-  name "Subscription"
-  field :test, types.String do
-    resolve ->(o, a, c) { "Test" }
-  end
-end
-
-DummySchema = GraphQL::Schema.define do
-  query DairyAppQueryType
-  mutation DairyAppMutationType
-  subscription SubscriptionType
-  max_depth 5
-  orphan_types [HoneyType, BeverageUnion]
-
-  rescue_from(NoSuchDairyError) { |err| err.message  }
-
-  resolve_type ->(obj, ctx) {
-    DummySchema.types[obj.class.name]
-  }
-end