graphql 1.9.11 → 1.9.12

data/spec/integration/rails/graphql/tracing/active_support_notifications_tracing_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Tracing::ActiveSupportNotificationsTracing do
-  let(:schema) {
-    StarWars::Schema.redefine {
-      tracer GraphQL::Tracing::ActiveSupportNotificationsTracing
-    }
-  }
-
-  it "pushes through AS::N" do
-    traces = []
-
-    callback = ->(name, started, finished, id, data) {
-      path_str = if data.key?(:field)
-        " (#{data[:field].path})"
-      elsif data.key?(:context)
-        " (#{data[:context].irep_node.owner_type}.#{data[:context].field.name})"
-      else
-        ""
-      end
-      traces << "#{name}#{path_str}"
-    }
-
-    query_string = <<-GRAPHQL
-    query Bases($id1: ID!, $id2: ID!){
-      b1: batchedBase(id: $id1) { name }
-      b2: batchedBase(id: $id2) { name }
-    }
-    GRAPHQL
-    first_id = StarWars::Base.first.id
-    last_id = StarWars::Base.last.id
-
-    ActiveSupport::Notifications.subscribed(callback, /^graphql/) do
-      schema.execute(query_string, variables: {
-        "id1" => first_id,
-        "id2" => last_id,
-      })
-    end
-
-    expected_traces = [
-      "graphql.lex",
-      "graphql.parse",
-      "graphql.validate",
-      "graphql.analyze_query",
-      "graphql.analyze_multiplex",
-      "graphql.execute_field (Query.batchedBase)",
-      "graphql.execute_field (Query.batchedBase)",
-      "graphql.execute_query",
-      "graphql.lazy_loader",
-      "graphql.execute_field_lazy (Query.batchedBase)",
-      "graphql.execute_field (Base.name)",
-      "graphql.execute_field_lazy (Query.batchedBase)",
-      "graphql.execute_field (Base.name)",
-      "graphql.execute_field_lazy (Base.name)",
-      "graphql.execute_field_lazy (Base.name)",
-      "graphql.execute_query_lazy",
-      "graphql.execute_multiplex",
-    ]
-    assert_equal expected_traces, traces
-  end
-end

data/spec/integration/rails/spec_helper.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require "rake"
-require "rails/all"
-require "rails/generators"
-require "sequel"
-
-if ENV['DATABASE'] == 'POSTGRESQL'
-  require 'pg'
-else
-  require "jdbc/sqlite3" if RUBY_ENGINE == 'jruby'
-  require "sqlite3" if RUBY_ENGINE == 'ruby'
-end
-
-require_relative "generators/base_generator_test"
-require_relative "data"
-
-def with_active_record_log
-  io = StringIO.new
-  prev_logger = ActiveRecord::Base.logger
-  ActiveRecord::Base.logger = Logger.new(io)
-  yield
-  io.string
-ensure
-  ActiveRecord::Base.logger = prev_logger
-end

data/spec/spec_helper.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'bundler'
-Bundler.require
-
-# Print full backtrace for failiures:
-ENV["BACKTRACE"] = "1"
-# Set this env var to use Interpreter for fixture schemas.
-# Eventually, interpreter will be the default.
-TESTING_INTERPRETER = ENV["TESTING_INTERPRETER"]
-TESTING_RESCUE_FROM = !TESTING_INTERPRETER
-
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-
-require "graphql"
-require "rake"
-require "graphql/rake_task"
-require "benchmark"
-require "pry"
-require "minitest/autorun"
-require "minitest/focus"
-require "minitest/reporters"
-
-Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new(color: true)
-
-Minitest::Spec.make_my_diffs_pretty!
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-# This is for convenient access to metadata in test definitions
-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)
-GraphQL::EnumType::EnumValue.accepts_definitions(metadata: assign_metadata_key)
-
-# Can be used as a GraphQL::Schema::Warden for some purposes, but allows nothing
-module NothingWarden
-  def self.enum_values(enum_type)
-    []
-  end
-end
-
-# Use this when a schema requires a `resolve_type` hook
-# but you know it won't be called
-NO_OP_RESOLVE_TYPE = ->(type, obj, ctx) {
-  raise "this should never be called"
-}
-
-# Load dependencies
-['Mongoid', 'Rails'].each do |integration|
-  begin
-    Object.const_get(integration)
-    Dir["#{File.dirname(__FILE__)}/integration/#{integration.downcase}/**/*.rb"].each do |f|
-      require f
-    end
-  rescue NameError
-    # ignore
-  end
-end
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
-  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
-
-def with_bidirectional_pagination
-  prev_value = GraphQL::Relay::ConnectionType.bidirectional_pagination
-  GraphQL::Relay::ConnectionType.bidirectional_pagination = true
-  yield
-ensure
-  GraphQL::Relay::ConnectionType.bidirectional_pagination = prev_value
-end
-
-module TestTracing
-  class << self
-    def clear
-      traces.clear
-    end
-
-    def with_trace
-      clear
-      yield
-      traces
-    end
-
-    def traces
-      @traces ||= []
-    end
-
-    def trace(key, data)
-      data[:key] = key
-      data[:path] ||= data.key?(:context) ? data[:context].path : nil
-      result = yield
-      data[:result] = result
-      traces << data
-      result
-    end
-  end
-end

data/spec/support/dummy/data.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-module Dummy
-  module Data
-    Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source) do
-      def ==(other)
-        # This is buggy on purpose -- it shouldn't be called during execution.
-        other.id == id
-      end
-
-      # Alias for when this is treated as milk in EdibleAsMilkInterface
-      def fatContent # rubocop:disable Naming/MethodName
-        fat_content
-      end
-    end
-
-    Milk = Struct.new(:id, :fat_content, :origin, :source, :flavors)
-    Cow = Struct.new(:id, :name, :last_produced_dairy)
-    Goat = Struct.new(:id, :name, :last_produced_dairy)
-  end
-
-  CHEESES = {
-    1 => Data::Cheese.new(1, "Brie", "France", 0.19, 1),
-    2 => Data::Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
-    3 => Data::Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
-  }
-
-  MILKS = {
-    1 => Data::Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
-  }
-
-  DAIRY = OpenStruct.new(
-    id: 1,
-    cheese: CHEESES[1],
-    milks: [MILKS[1]]
-  )
-
-  COWS = {
-    1 => Data::Cow.new(1, "Billy", MILKS[1])
-  }
-
-  GOATS = {
-    1 => Data::Goat.new(1, "Gilly", MILKS[1]),
-  }
-end

data/spec/support/dummy/schema.rb

@@ -1,519 +0,0 @@
-# frozen_string_literal: true
-require "graphql"
-require_relative "./data"
-module Dummy
-  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))
-
-  class BaseField < GraphQL::Schema::Field
-    accepts_definition :joins
-  end
-
-  class AdminField < GraphQL::Schema::Field
-    def visible?(context)
-      context[:admin] == true
-    end
-  end
-
-  module BaseInterface
-    include GraphQL::Schema::Interface
-  end
-
-  class BaseObject < GraphQL::Schema::Object
-    field_class BaseField
-    accepts_definition :class_names
-  end
-
-  class BaseUnion < GraphQL::Schema::Union
-  end
-
-  class BaseEnum < GraphQL::Schema::Enum
-  end
-
-  class BaseInputObject < GraphQL::Schema::InputObject
-  end
-
-  class BaseScalar < GraphQL::Schema::Scalar
-  end
-
-  module LocalProduct
-    include BaseInterface
-    description "Something that comes from somewhere"
-    field :origin, String, null: false,
-      description: "Place the thing comes from"
-  end
-
-  module Edible
-    include BaseInterface
-    description "Something you can eat, yum"
-    field :fat_content, Float, null: false, description: "Percentage which is fat"
-    field :origin, String, null: false, description: "Place the edible comes from"
-    field :self_as_edible, Edible, null: true
-    def self_as_edible
-      object
-    end
-  end
-
-  module EdibleAsMilk
-    include Edible
-    description "Milk :+1:"
-    def self.resolve_type(obj, ctx)
-      Milk
-    end
-  end
-
-  class DairyAnimal < BaseEnum
-    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
-
-  module AnimalProduct
-    include BaseInterface
-    description "Comes from an animal, no joke"
-    field :source, DairyAnimal, "Animal which produced this product", null: false
-  end
-
-  class Cheese < BaseObject
-    class_names ["Cheese"]
-    description "Cultured dairy product"
-    implements Edible
-    implements EdibleAsMilk
-    implements AnimalProduct
-    implements LocalProduct
-
-    field :id, Int, "Unique identifier", null: false
-    field :flavor, String, "Kind of Cheese", null: false
-    field :origin, String, "Place the cheese comes from", null: false
-
-    field :source, DairyAnimal,
-      "Animal which produced the milk for this cheese",
-      null: false
-
-    field :similar_cheese, Cheese, "Cheeses like this one", null: true  do
-      # metadata test
-      joins [:cheeses, :milks]
-      argument :source, [DairyAnimal], required: true
-      argument :nullableSource, [DairyAnimal], required: false, default_value: [1]
-    end
-
-    def similar_cheese(source:, nullable_source:)
-      # get the strings out:
-      sources = source
-      if sources.include?("YAK")
-        raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
-      else
-        CHEESES.values.find { |cheese| sources.include?(cheese.source) }
-      end
-    end
-
-    field :nullable_cheese, Cheese, "Cheeses like this one", null: true do
-      argument :source, [DairyAnimal], required: false
-    end
-    def nullable_cheese; raise("NotImplemented"); end
-
-    field :deeply_nullable_cheese, Cheese, "Cheeses like this one", null: true do
-      argument :source, [[DairyAnimal, null: true], null: true], required: false
-    end
-    def deeply_nullable_cheese; raise("NotImplemented"); end
-
-    # Keywords can be used for definition methods
-    field :fat_content,
-      type: GraphQL::FLOAT_TYPE,
-      null: false,
-      description: "Percentage which is milkfat",
-      deprecation_reason: "Diet fashion has changed"
-  end
-
-  class Milk < BaseObject
-    description "Dairy beverage"
-    implements Edible
-    implements EdibleAsMilk
-    implements AnimalProduct
-    implements LocalProduct
-
-    field :id, ID, null: false
-    field :source, DairyAnimal, null: false, description: "Animal which produced this milk"
-    field :origin, String, null: false, description: "Place the milk comes from"
-    field :flavors, [String, null: true], null: true, description: "Chocolate, Strawberry, etc" do
-      argument :limit, Int, required: false
-    end
-
-    def flavors(limit: nil)
-      limit ? object.flavors.first(limit) : object.flavors
-    end
-
-    field :execution_error, String, null: true
-    def execution_error; raise(GraphQL::ExecutionError, "There was an execution error"); end
-
-    field :all_dairy, ["Dummy::DairyProduct", null: true], null: true
-    def all_dairy; CHEESES.values + MILKS.values; end
-  end
-
-  class Beverage < BaseUnion
-    description "Something you can drink"
-    possible_types Milk
-  end
-
-  module Sweetener
-    include BaseInterface
-    field :sweetness, Integer, null: true
-  end
-
-  # No actual data; This type is an "orphan", only accessible through Interfaces
-  class Honey < BaseObject
-    description "Sweet, dehydrated bee barf"
-    field :flower_type, String, "What flower this honey came from", null: true
-    implements Edible
-    implements AnimalProduct
-    implements Sweetener
-  end
-
-  class Dairy < BaseObject
-    description "A farm where milk is harvested and cheese is produced"
-    field :id, ID, null: false
-    field :cheese, Cheese, null: true
-    field :milks, [Milk, null: true], null: true
-  end
-
-  class MaybeNull < BaseObject
-    description "An object whose fields return nil"
-    field :cheese, Cheese, null: true
-  end
-
-  class TracingScalar < BaseObject
-    description "An object which has traced scalars"
-
-    field :trace_nil, Integer, null: true
-    field :trace_false, Integer, null: true, trace: false
-    field :trace_true, Integer, null: true, trace: true
-  end
-
-  class DairyProduct < BaseUnion
-    description "Kinds of food made from milk"
-    # Test that these forms of declaration still work:
-    possible_types "Dummy::Milk", Cheese
-  end
-
-  class Cow < BaseObject
-    description "A bovine animal that produces milk"
-    field :id, ID, null: false
-    field :name, String, null: true
-    field :last_produced_dairy, DairyProduct, null: true
-
-    field :cant_be_null_but_is, String, null: false
-    def cant_be_null_but_is; nil; end
-
-    field :cant_be_null_but_raises_execution_error, String, null: false
-    def cant_be_null_but_raises_execution_error; raise(GraphQL::ExecutionError, "BOOM"); end
-  end
-
-  class Goat < BaseObject
-    description "An caprinae animal that produces milk"
-    field :id, ID, null: false
-    field :name, String, null: true
-    field :last_produced_dairy, DairyProduct, null: true
-  end
-
-  class Animal < BaseUnion
-    description "Species of living things"
-    possible_types Cow, Goat
-  end
-
-  class AnimalAsCow < BaseUnion
-    description "All animals go mooooo!"
-    possible_types Cow
-    def self.resolve_type(obj, ctx)
-      Cow
-    end
-  end
-
-  class ResourceOrder < BaseInputObject
-    graphql_name "ResourceOrderType"
-    description "Properties used to determine ordering"
-
-    argument :direction, String, required: true, description: "ASC or DESC"
-  end
-
-  class DairyProductInput < BaseInputObject
-    description "Properties for finding a dairy product"
-    argument :source, DairyAnimal, required: true, description: "Where it came from"
-    argument :origin_dairy, String, required: false, description: "Dairy which produced it", default_value: "Sugar Hollow Dairy"
-    argument :fat_content, Float, required: false, description: "How much fat it has", default_value: 0.3
-    argument :organic, Boolean, required: false, default_value: false
-    argument :order_by, ResourceOrder, required: false, default_value: { direction: "ASC" }, camelize: false
-  end
-
-  class DeepNonNull < BaseObject
-    field :non_null_int, Integer, null: false do
-      argument :returning, Integer, required: false
-    end
-    def non_null_int(returning: nil)
-      returning
-    end
-
-    field :deep_non_null, DeepNonNull, null: false
-    def deep_non_null; :deep_non_null; end
-  end
-
-  class Time < BaseScalar
-    description "Time since epoch in seconds"
-
-    def self.coerce_input(value, ctx)
-      Time.at(Float(value))
-    rescue ArgumentError
-      raise GraphQL::CoercionError, 'cannot coerce to Float'
-    end
-
-    def self.coerce_result(value, ctx)
-      value.to_f
-    end
-  end
-
-  class FetchItem < GraphQL::Schema::Resolver
-    class << self
-      attr_accessor :data
-    end
-
-    def self.build(type:, data:, id_type: "Int")
-      Class.new(self) do
-        self.data = data
-        type(type, null: true)
-        description("Find a #{type.name} by id")
-        argument :id, id_type, required: true
-      end
-    end
-
-    def resolve(id:)
-      id_string = id.to_s # Cheese has Int type, Milk has ID type :(
-      _id, item = self.class.data.find { |item_id, _item| item_id.to_s == id_string }
-      item
-    end
-  end
-
-  class GetSingleton < GraphQL::Schema::Resolver
-    class << self
-      attr_accessor :data
-    end
-
-    def self.build(type:, data:)
-      Class.new(self) do
-        description("Find the only #{type.name}")
-        type(type, null: true)
-        self.data = data
-      end
-    end
-
-    def resolve
-      self.class.data
-    end
-  end
-
-  class DairyAppQuery < BaseObject
-    graphql_name "Query"
-    description "Query root of the system"
-    # Returns `root_value:`
-    field :root, String, null: true
-    def root
-      object
-    end
-    field :cheese, resolver: FetchItem.build(type: Cheese, data: CHEESES)
-    field :milk, resolver: FetchItem.build(type: Milk, data: MILKS, id_type: "ID")
-    field :dairy, resolver: GetSingleton.build(type: Dairy, data: DAIRY)
-    field :from_source, [Cheese, null: true], null: true, description: "Cheese from source" do
-      argument :source, DairyAnimal, required: false, default_value: 1
-    end
-    def from_source(source:)
-      CHEESES.values.select { |c| c.source == source }
-    end
-
-    field :favorite_edible, Edible, null: true, description: "My favorite food"
-    def favorite_edible
-      MILKS[1]
-    end
-
-    field :cow, resolver: GetSingleton.build(type: Cow, data: COWS[1])
-    field :search_dairy, DairyProduct, null: false do
-      description "Find dairy products matching a description"
-      # This is a list just for testing 😬
-      argument :product, [DairyProductInput, null: true], required: false, default_value: [{source: "SHEEP"}]
-      argument :expires_after, Time, required: false
-    end
-
-    def search_dairy(product:, expires_after: nil)
-      source = product[0][:source]
-      products = CHEESES.values + MILKS.values
-      if !source.nil?
-        products = products.select { |pr| pr.source == source }
-      end
-      products.first
-    end
-
-    field :all_animal, [Animal, null: true], null: false
-    def all_animal
-      COWS.values + GOATS.values
-    end
-
-    field :all_animal_as_cow, [AnimalAsCow, null: true], null: false, resolver_method: :all_animal
-
-    field :all_dairy, [DairyProduct, null: true], null: true do
-      argument :execution_error_at_index, Integer, required: false
-    end
-    def all_dairy(execution_error_at_index: nil)
-      result = CHEESES.values + MILKS.values
-      if execution_error_at_index
-        result[execution_error_at_index] = GraphQL::ExecutionError.new("missing dairy")
-      end
-      result
-    end
-
-    field :all_edible, [Edible, null: true], null: true
-    def all_edible
-      CHEESES.values + MILKS.values
-    end
-
-    field :all_edible_as_milk, [EdibleAsMilk, null: true], null: true, resolver_method: :all_edible
-
-    field :error, String, null: true, description: "Raise an error"
-    def error
-      raise("This error was raised on purpose")
-    end
-
-    field :execution_error, String, null: true
-    def execution_error
-      raise(GraphQL::ExecutionError, "There was an execution error")
-    end
-
-    field :value_with_execution_error, Integer, null: false, extras: [:execution_errors]
-    def value_with_execution_error(execution_errors:)
-      execution_errors.add("Could not fetch latest value")
-      0
-    end
-
-    field :multiple_errors_on_non_nullable_field, String, null: false
-    def multiple_errors_on_non_nullable_field
-      [
-        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 :multiple_errors_on_non_nullable_list_field, [String], null: false
-    def multiple_errors_on_non_nullable_list_field
-      [
-        GraphQL::ExecutionError.new("The first error message for a field defined to return a list of strings."),
-        GraphQL::ExecutionError.new("The second error message for a field defined to return a list of strings.")
-      ]
-    end
-
-    field :execution_error_with_options, Integer, null: true
-    def execution_error_with_options
-      GraphQL::ExecutionError.new("Permission Denied!", options: { "code" => "permission_denied" })
-    end
-
-    field :execution_error_with_extensions, Integer, null: true
-    def execution_error_with_extensions
-      GraphQL::ExecutionError.new("Permission Denied!", extensions: { "code" => "permission_denied" })
-    end
-
-    # To test possibly-null fields
-    field :maybe_null, MaybeNull, null: true
-    def maybe_null
-      OpenStruct.new(cheese: nil)
-    end
-
-    field :tracing_scalar, TracingScalar, null: true
-    def tracing_scalar
-      OpenStruct.new(
-        trace_nil: 2,
-        trace_false: 3,
-        trace_true: 5,
-      )
-    end
-
-    field :deep_non_null, DeepNonNull, null: false
-    def deep_non_null; :deep_non_null; end
-  end
-
-  class AdminDairyAppQuery < BaseObject
-    field_class AdminField
-
-    field :admin_only_message, String, null: true
-    def admin_only_message
-      "This field is only visible to admin"
-    end
-  end
-
-  GLOBAL_VALUES = []
-
-  class ReplaceValuesInput < BaseInputObject
-    argument :values, [Integer], required: true, method_access: false
-  end
-
-  class DairyAppMutation < BaseObject
-    graphql_name "Mutation"
-    description "The root for mutations in this schema"
-    field :push_value, [Integer], null: false, description: "Push a value onto a global array :D" do
-      argument :value, Integer, required: true, as: :val
-    end
-    def push_value(val:)
-      GLOBAL_VALUES << val
-      GLOBAL_VALUES
-    end
-
-    field :replaceValues, [Integer], "Replace the global array with new values", null: false do
-      argument :input, ReplaceValuesInput, required: true
-    end
-
-    def replace_values(input:)
-      GLOBAL_VALUES.clear
-      GLOBAL_VALUES.concat(input[:values])
-      GLOBAL_VALUES
-    end
-  end
-
-  class Subscription < BaseObject
-    field :test, String, null: true
-    def test; "Test"; end
-  end
-
-  class Schema < GraphQL::Schema
-    query DairyAppQuery
-    mutation DairyAppMutation
-    subscription Subscription
-    max_depth 5
-    # TODO why is `.graphql_definition` required here?
-    orphan_types Honey, Beverage.graphql_definition
-
-    rescue_from(NoSuchDairyError) { |err| err.message  }
-
-    def self.resolve_type(type, obj, ctx)
-      Schema.types[obj.class.name.split("::").last]
-    end
-
-    # This is used to confirm that the hook is called:
-    MAGIC_INT_COERCE_VALUE = -1
-
-    def self.type_error(err, ctx)
-      if err.is_a?(GraphQL::IntegerEncodingError) && err.integer_value == 99**99
-        MAGIC_INT_COERCE_VALUE
-      else
-        super
-      end
-    end
-
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-  end
-
-  class AdminSchema < GraphQL::Schema
-    query AdminDairyAppQuery
-  end
-end