graphql 1.9.11 → 1.9.12

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