graphql 1.9.5 → 1.13.19

data/spec/graphql/schema/member/accepts_definition_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Member::AcceptsDefinition do
-  class AcceptsDefinitionSchema < GraphQL::Schema
-    accepts_definition :set_metadata
-    set_metadata :a, 999
-
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-
-    class BaseField < GraphQL::Schema::Field
-      class BaseField < GraphQL::Schema::Argument
-        accepts_definition :metadata
-      end
-      argument_class BaseField
-      accepts_definition :metadata
-    end
-
-    GraphQL::Schema::Object.accepts_definition(:metadata2)
-
-    class BaseObject < GraphQL::Schema::Object
-      field_class BaseField
-      accepts_definition :metadata
-    end
-
-    GraphQL::Schema::Interface.accepts_definition(:metadata2)
-
-    module BaseInterface
-      include GraphQL::Schema::Interface
-      field_class BaseField
-      accepts_definition :metadata
-    end
-
-    class Option < GraphQL::Schema::Enum
-      class EnumValue < GraphQL::Schema::EnumValue
-        accepts_definition :metadata
-      end
-      enum_value_class EnumValue
-      accepts_definition :metadata
-      metadata :a, 123
-      value "A", metadata: [:a, 456]
-      value "B"
-    end
-
-    module Thing
-      include BaseInterface
-      metadata :z, 888
-      metadata2 :a, :bc
-    end
-
-    module Thing2
-      include Thing
-    end
-
-    class SomeObject < BaseObject
-      metadata :a, :aaa
-    end
-
-    class SomeObject2 < SomeObject
-    end
-
-    class Query < BaseObject
-      metadata :a, :abc
-      metadata2 :xyz, :zyx
-
-      field :option, Option, null: false do
-        metadata :a, :def
-        argument :value, Integer, required: true, metadata: [:a, :ghi]
-      end
-
-      field :thing, Thing, null: false
-      field :thing2, Thing2, null: false
-      field :some_object, SomeObject, null: false
-      field :some_object2, SomeObject2, null: false
-    end
-
-    query(Query)
-  end
-
-  it "passes along configs for types" do
-    assert_equal [:a, 123], AcceptsDefinitionSchema::Option.metadata
-    assert_equal 123, AcceptsDefinitionSchema::Option.graphql_definition.metadata[:a]
-    assert_equal [:a, :abc], AcceptsDefinitionSchema::Query.metadata
-    assert_equal :abc, AcceptsDefinitionSchema::Query.graphql_definition.metadata[:a]
-    assert_equal :zyx, AcceptsDefinitionSchema::Query.graphql_definition.metadata[:xyz]
-
-    assert_equal [:z, 888], AcceptsDefinitionSchema::Thing.metadata
-    assert_equal 888, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:z]
-    assert_equal :bc, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:a]
-    # Interface inheritance
-    assert_equal [:z, 888], AcceptsDefinitionSchema::Thing2.metadata
-    assert_equal 888, AcceptsDefinitionSchema::Thing2.graphql_definition.metadata[:z]
-    assert_equal :bc, AcceptsDefinitionSchema::Thing2.graphql_definition.metadata[:a]
-
-    # Object inheritance
-    assert_equal :aaa, AcceptsDefinitionSchema::SomeObject.graphql_definition.metadata[:a]
-    assert_equal :aaa, AcceptsDefinitionSchema::SomeObject2.graphql_definition.metadata[:a]
-  end
-
-  it "passes along configs for fields and arguments" do
-    assert_equal :def, AcceptsDefinitionSchema.find("Query.option").metadata[:a]
-    assert_equal :ghi, AcceptsDefinitionSchema.find("Query.option.value").metadata[:a]
-  end
-
-  it "passes along configs for enum values" do
-    assert_equal 456, AcceptsDefinitionSchema.find("Option.A").metadata[:a]
-    assert_nil AcceptsDefinitionSchema.find("Option.B").metadata[:a]
-  end
-
-  it "passes along configs for schemas" do
-    assert_equal 999, AcceptsDefinitionSchema.graphql_definition.metadata[:a]
-  end
-end

data/spec/graphql/schema/member/build_type_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Member::BuildType do
-  describe ".parse_type" do
-    it "resolves a string type from a string" do
-      assert_equal GraphQL::Types::String, GraphQL::Schema::Member::BuildType.parse_type("String", null: true)
-    end
-
-    it "resolves an integer type from a string" do
-      assert_equal GraphQL::Types::Int, GraphQL::Schema::Member::BuildType.parse_type("Integer", null: true)
-    end
-
-    it "resolves a float type from a string" do
-      assert_equal GraphQL::Types::Float, GraphQL::Schema::Member::BuildType.parse_type("Float", null: true)
-    end
-
-    it "resolves a boolean type from a string" do
-      assert_equal GraphQL::Types::Boolean, GraphQL::Schema::Member::BuildType.parse_type("Boolean", null: true)
-    end
-
-    it "resolves an interface type from a string" do
-      assert_equal Jazz::BaseInterface, GraphQL::Schema::Member::BuildType.parse_type("Jazz::BaseInterface", null: true)
-    end
-
-    it "resolves an object type from a class" do
-      assert_equal Jazz::BaseObject, GraphQL::Schema::Member::BuildType.parse_type(Jazz::BaseObject, null: true)
-    end
-
-    it "resolves an object type from a string" do
-      assert_equal Jazz::BaseObject, GraphQL::Schema::Member::BuildType.parse_type("Jazz::BaseObject", null: true)
-    end
-
-    it "resolves a nested object type from a string" do
-      assert_equal Jazz::Introspection::NestedType, GraphQL::Schema::Member::BuildType.parse_type("Jazz::Introspection::NestedType", null: true)
-    end
-
-    it "resolves a deeply nested object type from a string" do
-      assert_equal Jazz::Introspection::NestedType::DeeplyNestedType, GraphQL::Schema::Member::BuildType.parse_type("Jazz::Introspection::NestedType::DeeplyNestedType", null: true)
-    end
-
-    it "resolves a list type from an array of classes" do
-      assert_instance_of GraphQL::Schema::List, GraphQL::Schema::Member::BuildType.parse_type([Jazz::BaseObject], null: true)
-    end
-
-    it "resolves a list type from an array of strings" do
-      assert_instance_of GraphQL::Schema::List, GraphQL::Schema::Member::BuildType.parse_type(["Jazz::BaseObject"], null: true)
-    end
-  end
-
-  describe ".to_type_name" do
-    it "works with lists and non-nulls" do
-      t = Class.new(GraphQL::Schema::Object) do
-        graphql_name "T"
-      end
-
-      req_t = GraphQL::Schema::NonNull.new(t)
-      list_req_t = GraphQL::Schema::List.new(req_t)
-
-      assert_equal "T", GraphQL::Schema::Member::BuildType.to_type_name(list_req_t)
-    end
-  end
-end

data/spec/graphql/schema/member/scoped_spec.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Member::Scoped do
-  class ScopeSchema < GraphQL::Schema
-    class BaseObject < GraphQL::Schema::Object
-    end
-
-    class Item < BaseObject
-      def self.scope_items(items, context)
-        if context[:french]
-          items.select { |i| i.name == "Trombone" }
-        elsif context[:english]
-          items.select { |i| i.name == "Paperclip" }
-        else
-          # boot everything
-          items.reject { true }
-        end
-      end
-
-      field :name, String, null: false
-    end
-
-    class FrenchItem < Item
-      def self.scope_items(items, context)
-        super(items, {french: true})
-      end
-    end
-
-    class Equipment < BaseObject
-      field :designation, String, null: false, method: :name
-    end
-
-    class BaseUnion < GraphQL::Schema::Union
-    end
-
-    class Thing < BaseUnion
-      def self.scope_items(items, context)
-        l = context.fetch(:first_letter)
-        items.select { |i| i.name.start_with?(l) }
-      end
-
-      possible_types Item, Equipment
-
-      def self.resolve_type(item, ctx)
-        if item.name == "Turbine"
-          Equipment
-        else
-          Item
-        end
-      end
-    end
-
-    class Query < BaseObject
-      field :items, [Item], null: false
-      field :unscoped_items, [Item], null: false,
-        scope: false,
-        resolver_method: :items
-
-      field :nil_items, [Item], null: true
-      def nil_items
-        nil
-      end
-
-      field :french_items, [FrenchItem], null: false,
-        resolver_method: :items
-      if TESTING_INTERPRETER
-        field :items_connection, Item.connection_type, null: false,
-          resolver_method: :items
-      else
-        field :items_connection, Item.connection_type, null: false, resolve: ->(obj, args, ctx) {
-          [
-            OpenStruct.new(name: "Trombone"),
-            OpenStruct.new(name: "Paperclip"),
-          ]
-        }
-      end
-
-      def items
-        [
-          OpenStruct.new(name: "Trombone"),
-          OpenStruct.new(name: "Paperclip"),
-        ]
-      end
-
-      if TESTING_INTERPRETER
-        field :things, [Thing], null: false
-        def things
-          items + [OpenStruct.new(name: "Turbine")]
-        end
-      else
-        # Make sure it works with resolve procs, too
-        field :things, [Thing], null: false, resolve: ->(obj, args, ctx) {
-          [
-            OpenStruct.new(name: "Trombone"),
-            OpenStruct.new(name: "Paperclip"),
-            OpenStruct.new(name: "Turbine"),
-          ]
-        }
-      end
-    end
-
-    query(Query)
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-  end
-
-  describe ".scope_items(items, ctx)" do
-    def get_item_names_with_context(ctx, field_name: "items")
-      query_str = "
-      {
-        #{field_name} {
-          name
-        }
-      }
-      "
-      res = ScopeSchema.execute(query_str, context: ctx)
-      res["data"][field_name].map { |i| i["name"] }
-    end
-
-    it "applies to lists when scope: true" do
-      assert_equal [], get_item_names_with_context({})
-      assert_equal ["Trombone"], get_item_names_with_context({french: true})
-      assert_equal ["Paperclip"], get_item_names_with_context({english: true})
-    end
-
-    it "is bypassed when scope: false" do
-      assert_equal ["Trombone", "Paperclip"], get_item_names_with_context({}, field_name: "unscopedItems")
-    end
-
-    it "returns null when the value is nil" do
-      query_str = "
-      {
-        nilItems {
-          name
-        }
-      }
-      "
-      res = ScopeSchema.execute(query_str)
-      refute res.key?("errors")
-      assert_nil res.fetch("data").fetch("nilItems")
-    end
-
-    it "is inherited" do
-      assert_equal ["Trombone"], get_item_names_with_context({}, field_name: "frenchItems")
-    end
-
-    it "is called for connection fields" do
-      query_str = "
-      {
-        itemsConnection {
-          edges {
-            node {
-              name
-            }
-          }
-        }
-      }
-      "
-      res = ScopeSchema.execute(query_str, context: {english: true})
-      names = res["data"]["itemsConnection"]["edges"].map { |e| e["node"]["name"] }
-      assert_equal ["Paperclip"], names
-
-      query_str = "
-      {
-        itemsConnection {
-          nodes {
-            name
-          }
-        }
-      }
-      "
-      res = ScopeSchema.execute(query_str, context: {english: true})
-      names = res["data"]["itemsConnection"]["nodes"].map { |e| e["name"] }
-      assert_equal ["Paperclip"], names
-    end
-
-    it "is called for abstract types" do
-      query_str = "
-      {
-        things {
-          ... on Item {
-            name
-          }
-          ... on Equipment {
-            designation
-          }
-        }
-      }
-      "
-      res = ScopeSchema.execute(query_str, context: {first_letter: "T"})
-      things = res["data"]["things"]
-      assert_equal [{ "name" => "Trombone" }, {"designation" => "Turbine"}], things
-    end
-  end
-
-  describe "Schema::Field.scoped?" do
-    it "prefers the override value" do
-      assert_equal false, ScopeSchema::Query.fields["unscopedItems"].scoped?
-    end
-
-    it "defaults to true for lists" do
-      assert_equal true, ScopeSchema::Query.fields["items"].type.list?
-      assert_equal true, ScopeSchema::Query.fields["items"].scoped?
-    end
-
-    it "defaults to true for connections" do
-      assert_equal true, ScopeSchema::Query.fields["itemsConnection"].connection?
-      assert_equal true, ScopeSchema::Query.fields["itemsConnection"].scoped?
-    end
-
-    it "defaults to false for others" do
-      assert_equal false, ScopeSchema::Item.fields["name"].scoped?
-    end
-  end
-end

data/spec/graphql/schema/member/type_system_helpers_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Member::TypeSystemHelpers do
-  let(:object) {
-    Class.new(GraphQL::Schema::Object) do
-      graphql_name "Thing"
-
-      field :int, Integer, null: true
-      field :int2, Integer, null: false
-      field :int_list, [Integer], null: true
-      field :int_list2, [Integer], null: false
-    end
-  }
-
-  let(:int_field) { object.fields["int"] }
-  let(:int2_field) { object.fields["int2"] }
-  let(:int_list_field) { object.fields["intList"] }
-  let(:int_list2_field) { object.fields["intList2"] }
-
-  describe "#list?" do
-    it "is true for lists, including non-null lists, otherwise false" do
-      assert int_list_field.type.list?
-      assert int_list2_field.type.list?
-      refute int_field.type.list?
-      refute int2_field.type.list?
-    end
-  end
-
-  describe "#non_null?" do
-    it "is true for required types" do
-      assert int2_field.type.non_null?
-      assert int_list2_field.type.non_null?
-      refute int_field.type.non_null?
-      refute int_list_field.type.non_null?
-    end
-  end
-
-  describe "#kind" do
-    let(:pairs) {{
-      GraphQL::Schema::Object => "OBJECT",
-      GraphQL::Schema::Union => "UNION",
-      GraphQL::Schema::Interface => "INTERFACE",
-      GraphQL::Schema::Enum => "ENUM",
-      GraphQL::Schema::InputObject => "INPUT_OBJECT",
-      GraphQL::Schema::Scalar => "SCALAR",
-    }}
-    it "returns the TypeKind instance" do
-      pairs.each do |type_class, type_kind_name|
-        type = if type_class.is_a?(Class)
-          Class.new(type_class)
-        else
-          Module.new { include(type_class) }
-        end
-
-        assert_equal type_kind_name, type.kind.name
-      end
-
-      assert_equal "LIST", GraphQL::Schema::Object.to_list_type.kind.name
-      assert_equal "NON_NULL", GraphQL::Schema::Object.to_non_null_type.kind.name
-    end
-  end
-end

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::MiddlewareChain do
-  let(:step_1) { ->(step_values, &next_step) { step_values << 1; next_step.call } }
-  let(:step_2) { ->(step_values, &next_step) { step_values << 2; next_step.call } }
-  let(:step_3) { ->(step_values, &next_step) { step_values << 3; :return_value } }
-  let(:steps) { [step_1, step_2, step_3] }
-  let(:step_values) { [] }
-  let(:arguments) { [step_values] }
-  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps)}
-
-  describe "#invoke" do
-    it "runs steps in order" do
-      middleware_chain.invoke(arguments)
-      assert_equal([1,2,3], step_values)
-    end
-
-    it "returns the value of the last middleware" do
-      assert_equal(:return_value, middleware_chain.invoke(arguments))
-    end
-
-    describe "when there is a final step" do
-      let(:final_step) { ->(step_values) { step_values << :final; :final_value } }
-      let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2], final_step: final_step) }
-
-      it "calls the final step" do
-        middleware_chain.invoke(arguments)
-        assert_equal([1, 2, :final], step_values)
-      end
-
-      it "returns the value from the final step" do
-        assert_equal(:final_value, middleware_chain.invoke(arguments))
-      end
-    end
-
-    describe "when a step returns early" do
-      let(:early_return_step) { ->(step_values, &next_step) { :early_return } }
-      it "doesn't continue the chain" do
-        steps.insert(2, early_return_step)
-        assert_equal(:early_return, middleware_chain.invoke(arguments))
-        assert_equal([1,2], step_values)
-      end
-    end
-
-    describe "when a step provides alternate arguments" do
-      it "passes the new arguments to the next step" do
-        step_1 = ->(test_arg, &next_step) { assert_equal(test_arg, 'HELLO'); next_step.call(['WORLD']) }
-        step_2 = ->(test_arg, &next_step) { assert_equal(test_arg, 'WORLD'); test_arg }
-
-        chain = GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2])
-        result = chain.invoke(['HELLO'])
-        assert_equal(result, 'WORLD')
-      end
-    end
-  end
-end

data/spec/graphql/schema/mutation_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-# Make sure that `!` has no effect
-using GraphQL::DeprecatedDSL
-
-describe GraphQL::Schema::Mutation do
-  let(:mutation) { Jazz::AddInstrument }
-  after do
-    Jazz::Models.reset
-  end
-
-  it "Doesn't override !" do
-    assert_equal false, !mutation
-  end
-
-  describe "definition" do
-    it "passes along description" do
-      assert_equal "Register a new musical instrument in the database", mutation.field_options[:description]
-      assert_equal "Autogenerated return type of AddInstrument", mutation.payload_type.description
-    end
-  end
-
-  describe "argument prepare" do
-    it "calls methods on the mutation, uses `as:`" do
-      query_str = "mutation { prepareInput(input: 4) }"
-      res = Jazz::Schema.execute(query_str)
-      assert_equal 16, res["data"]["prepareInput"], "It's squared by the prepare method"
-    end
-  end
-
-  describe "a derived field" do
-    it "has a reference to the mutation" do
-      f = GraphQL::Schema::Field.from_options(name: "x", **mutation.field_options)
-      assert_equal mutation, f.mutation
-
-      # Make sure it's also present in the schema
-      f2 = Jazz::Schema.find("Mutation.addInstrument")
-      assert_equal mutation, f2.mutation
-    end
-  end
-
-  describe ".payload_type" do
-    it "has a reference to the mutation" do
-      assert_equal mutation, mutation.payload_type.mutation
-    end
-  end
-
-  describe ".field" do
-    it "raises a nice error when called without args" do
-      err = assert_raises(ArgumentError) { mutation.field }
-      assert_includes err.message, "Use `mutation: Jazz::AddInstrument` to attach this mutation instead."
-    end
-  end
-
-  describe ".object_class" do
-    it "can override & inherit the parent class" do
-      obj_class = Class.new(GraphQL::Schema::Object)
-      mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        object_class(obj_class)
-      end
-      mutation_subclass = Class.new(mutation_class)
-
-      assert_equal(GraphQL::Schema::Object, GraphQL::Schema::Mutation.object_class)
-      assert_equal(obj_class, mutation_class.object_class)
-      assert_equal(obj_class, mutation_subclass.object_class)
-    end
-  end
-
-  describe ".argument_class" do
-    it "can override & inherit the parent class" do
-      arg_class = Class.new(GraphQL::Schema::Argument)
-      mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        argument_class(arg_class)
-      end
-
-      mutation_subclass = Class.new(mutation_class)
-
-      assert_equal(GraphQL::Schema::Argument, GraphQL::Schema::Mutation.argument_class)
-      assert_equal(arg_class, mutation_class.argument_class)
-      assert_equal(arg_class, mutation_subclass.argument_class)
-    end
-  end
-
-  describe "evaluation" do
-    it "runs mutations" do
-      query_str = <<-GRAPHQL
-      mutation {
-        addInstrument(name: "Trombone", family: BRASS) {
-          instrument {
-            name
-            family
-          }
-          entries {
-            name
-          }
-          ee
-        }
-      }
-      GRAPHQL
-
-      response = Jazz::Schema.execute(query_str)
-      assert_equal "Trombone", response["data"]["addInstrument"]["instrument"]["name"]
-      assert_equal "BRASS", response["data"]["addInstrument"]["instrument"]["family"]
-      errors_class = TESTING_INTERPRETER ? "GraphQL::Execution::Interpreter::ExecutionErrors" : "GraphQL::Query::Context::ExecutionErrors"
-      assert_equal errors_class, response["data"]["addInstrument"]["ee"]
-      assert_equal 7, response["data"]["addInstrument"]["entries"].size
-    end
-  end
-
-  describe ".null" do
-    it "overrides whether or not the field can be null" do
-      non_nullable_mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        graphql_name "Thing1"
-        null(false)
-      end
-
-      nullable_mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        graphql_name "Thing2"
-        null(true)
-      end
-
-      default_mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        graphql_name "Thing3"
-      end
-
-      assert default_mutation_class.field_options[:null]
-      assert nullable_mutation_class.field_options[:null]
-      refute non_nullable_mutation_class.field_options[:null]
-    end
-
-    it "should inherit and override in subclasses" do
-      base_mutation = Class.new(GraphQL::Schema::Mutation) do
-        null(false)
-      end
-
-      inheriting_mutation = Class.new(base_mutation) do
-        graphql_name "Thing"
-      end
-
-      override_mutation = Class.new(base_mutation) do
-        graphql_name "Thing2"
-        null(true)
-      end
-
-      assert_equal false, inheriting_mutation.field_options[:null]
-      assert override_mutation.field_options[:null]
-    end
-  end
-end