graphql 1.9.0 → 2.1.1

data/spec/graphql/schema/list_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe GraphQL::Schema::List do
-  let(:of_type) { Jazz::Musician }
-  let(:list_type) { GraphQL::Schema::List.new(of_type) }
-
-  it "returns list? to be true" do
-    assert list_type.list?
-  end
-
-  it "returns non_null? to be false" do
-    refute list_type.non_null?
-  end
-
-  it "returns kind to be GraphQL::TypeKinds::LIST" do
-    assert_equal GraphQL::TypeKinds::LIST, list_type.kind
-  end
-
-  it "returns correct type signature" do
-    assert_equal "[Musician]", list_type.to_type_signature
-  end
-
-  describe "comparison operator" do
-    it "will return false if list types 'of_type' are different" do
-      new_of_type = Jazz::InspectableKey
-      new_list_type = GraphQL::Schema::List.new(new_of_type)
-
-      refute_equal list_type, new_list_type
-    end
-
-    it "will return true if list types 'of_type' are the same" do
-      new_of_type = Jazz::Musician
-      new_list_type = GraphQL::Schema::List.new(new_of_type)
-      
-      assert_equal list_type, new_list_type
-    end
-  end
-
-  describe "to_graphql" do
-    it "will return a list type" do
-      assert_kind_of GraphQL::ListType, list_type.to_graphql
-    end
-  end
-end

data/spec/graphql/schema/loader_spec.rb

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Loader do
-  let(:schema) {
-    node_type = GraphQL::InterfaceType.define do
-      name "Node"
-
-      field :id, !types.ID
-    end
-
-    choice_type = GraphQL::EnumType.define do
-      name "Choice"
-
-      value "FOO", value: :foo
-      value "BAR"
-    end
-
-    sub_input_type = GraphQL::InputObjectType.define do
-      name "Sub"
-      input_field :string, types.String
-    end
-
-    big_int_type = GraphQL::ScalarType.define do
-      name "BigInt"
-      coerce_input ->(value, _ctx) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result ->(value, _ctx) { value.to_s }
-    end
-
-    variant_input_type = GraphQL::InputObjectType.define do
-      name "Varied"
-      input_field :id, types.ID
-      input_field :int, types.Int
-      input_field :bigint, big_int_type, default_value: 2**54
-      input_field :float, types.Float
-      input_field :bool, types.Boolean
-      input_field :enum, choice_type
-      input_field :sub, types[sub_input_type]
-    end
-
-    variant_input_type_with_nulls = GraphQL::InputObjectType.define do
-      name "VariedWithNulls"
-      input_field :id, types.ID, default_value: nil
-      input_field :int, types.Int, default_value: nil
-      input_field :bigint, big_int_type, default_value: nil
-      input_field :float, types.Float, default_value: nil
-      input_field :bool, types.Boolean, default_value: nil
-      input_field :enum, choice_type, default_value: nil
-      input_field :sub, types[sub_input_type], default_value: nil
-    end
-
-    comment_type = GraphQL::ObjectType.define do
-      name "Comment"
-      description "A blog comment"
-      interfaces [node_type]
-
-      field :body, !types.String
-
-      field :fieldWithArg, types.Int do
-        argument :bigint, big_int_type, default_value: 2**54
-      end
-    end
-
-    media_type = GraphQL::InterfaceType.define do
-      name "Media"
-      description "!!!"
-      field :type, !types.String
-    end
-
-    video_type = GraphQL::ObjectType.define do
-      name "Video"
-      interfaces [media_type]
-    end
-
-    audio_type = GraphQL::ObjectType.define do
-      name "Audio"
-      interfaces [media_type]
-    end
-
-    post_type = GraphQL::ObjectType.define do
-      name "Post"
-      description "A blog post"
-
-      field :id, !types.ID
-      field :title, !types.String
-      field :body, !types.String
-      field :comments, types[!comment_type]
-      field :attachment, media_type
-    end
-
-    content_type = GraphQL::UnionType.define do
-      name "Content"
-      description "A post or comment"
-      possible_types [post_type, comment_type]
-    end
-
-    query_root = GraphQL::ObjectType.define do
-      name "Query"
-      description "The query root of this schema"
-
-      field :post do
-        type post_type
-        argument :id, !types.ID
-        argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }
-        argument :variedWithNull, variant_input_type_with_nulls, default_value: { id: nil, int: nil, float: nil, enum: nil, sub: nil, bigint: nil, bool: nil }
-        argument :variedArray, types[variant_input_type], default_value: [{ id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }]
-        argument :enum, choice_type, default_value: :foo
-        argument :array, types[!types.String], default_value: ["foo", "bar"]
-      end
-
-      field :content do
-        type content_type
-      end
-    end
-
-    ping_mutation = GraphQL::Relay::Mutation.define do
-      name "Ping"
-    end
-
-    mutation_root = GraphQL::ObjectType.define do
-      name "Mutation"
-      field :ping, field: ping_mutation.field
-    end
-
-    GraphQL::Schema.define(
-      query: query_root,
-      mutation: mutation_root,
-      orphan_types: [audio_type, video_type],
-      resolve_type: ->(a,b,c) { :pass },
-    )
-  }
-
-  let(:schema_json) {
-    schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-  }
-
-  describe "load" do
-    def assert_deep_equal(expected_type, actual_type)
-      assert_equal expected_type.class, actual_type.class
-
-      case actual_type
-      when Array
-        actual_type.each_with_index do |obj, index|
-          assert_deep_equal expected_type[index], obj
-        end
-
-      when GraphQL::Schema
-        assert_equal expected_type.query.name, actual_type.query.name
-        assert_equal expected_type.directives.keys.sort, actual_type.directives.keys.sort
-        assert_equal expected_type.types.keys.sort, actual_type.types.keys.sort
-        assert_deep_equal expected_type.types.values.sort_by(&:name), actual_type.types.values.sort_by(&:name)
-
-      when GraphQL::ObjectType, GraphQL::InterfaceType
-        assert_equal expected_type.name, actual_type.name
-        assert_equal expected_type.description, actual_type.description
-        assert_deep_equal expected_type.all_fields.sort_by(&:name), actual_type.all_fields.sort_by(&:name)
-
-      when GraphQL::Field
-        assert_equal expected_type.name, actual_type.name
-        assert_equal expected_type.description, actual_type.description
-        assert_equal expected_type.arguments.keys, actual_type.arguments.keys
-        assert_deep_equal expected_type.arguments.values, actual_type.arguments.values
-
-      when GraphQL::ScalarType
-        assert_equal expected_type.name, actual_type.name
-
-      when GraphQL::EnumType
-        assert_equal expected_type.name, actual_type.name
-        assert_equal expected_type.description, actual_type.description
-        assert_equal expected_type.values.keys, actual_type.values.keys
-        assert_deep_equal expected_type.values.values, actual_type.values.values
-
-      when GraphQL::EnumType::EnumValue
-        assert_equal expected_type.name, actual_type.name
-        assert_equal expected_type.description, actual_type.description
-
-      when GraphQL::Argument
-        assert_equal expected_type.name, actual_type.name
-        assert_equal expected_type.description, actual_type.description
-        assert_deep_equal expected_type.type, actual_type.type
-
-      when GraphQL::InputObjectType
-        assert_equal expected_type.arguments.keys, actual_type.arguments.keys
-        assert_deep_equal expected_type.arguments.values, actual_type.arguments.values
-
-      when GraphQL::NonNullType, GraphQL::ListType
-        assert_deep_equal expected_type.of_type, actual_type.of_type
-
-      else
-        assert_equal expected_type, actual_type
-      end
-    end
-
-    let(:loaded_schema) { GraphQL::Schema::Loader.load(schema_json) }
-
-    it "returns the schema" do
-      assert_deep_equal(schema, loaded_schema)
-    end
-
-    it "can export the loaded schema" do
-      assert loaded_schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-    end
-
-    it "has no-op coerce functions" do
-      custom_scalar = loaded_schema.types["BigInt"]
-      assert_equal true, custom_scalar.valid_isolated_input?("anything")
-      assert_equal true, custom_scalar.valid_isolated_input?(12345)
-    end
-
-    it "sets correct default values on custom scalar arguments" do
-      type = loaded_schema.types["Comment"]
-      field = type.fields['fieldWithArg']
-      arg = field.arguments['bigint']
-
-      assert_equal((2**54).to_s, arg.default_value)
-    end
-
-    it "sets correct default values on custom scalar input fields" do
-      type = loaded_schema.types["Varied"]
-      field = type.input_fields['bigint']
-
-      assert_equal((2**54).to_s, field.default_value)
-    end
-
-    it "sets correct default values for complex field arguments" do
-      type = loaded_schema.types['Query']
-      field = type.fields['post']
-
-      varied = field.arguments['varied']
-      assert_equal varied.default_value, { 'id' => "123", 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }
-      assert !varied.default_value.key?('bool'), 'Omits default value for unspecified arguments'
-
-      variedArray = field.arguments['variedArray']
-      assert_equal variedArray.default_value, [{ 'id' => "123", 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }]
-      assert !variedArray.default_value.first.key?('bool'), 'Omits default value for unspecified arguments'
-
-      array = field.arguments['array']
-      assert_equal array.default_value, ["foo", "bar"]
-    end
-
-    it "does not set default value when there are none on input fields" do
-      type = loaded_schema.types['Varied']
-
-      assert !type.arguments['id'].default_value?
-      assert !type.arguments['int'].default_value?
-      assert type.arguments['bigint'].default_value?
-      assert !type.arguments['float'].default_value?
-      assert !type.arguments['bool'].default_value?
-      assert !type.arguments['enum'].default_value?
-      assert !type.arguments['sub'].default_value?
-    end
-
-    it "sets correct default values `null` on input fields" do
-      type = loaded_schema.types['VariedWithNulls']
-
-      assert type.arguments['id'].default_value?
-      assert type.arguments['id'].default_value.nil?
-
-      assert type.arguments['int'].default_value?
-      assert type.arguments['int'].default_value.nil?
-
-      assert type.arguments['bigint'].default_value?
-      assert type.arguments['bigint'].default_value.nil?
-
-      assert type.arguments['float'].default_value?
-      assert type.arguments['float'].default_value.nil?
-
-      assert type.arguments['bool'].default_value?
-      assert type.arguments['bool'].default_value.nil?
-
-      assert type.arguments['enum'].default_value?
-      assert type.arguments['enum'].default_value.nil?
-
-      assert type.arguments['sub'].default_value?
-      assert type.arguments['sub'].default_value.nil?
-    end
-
-    it "sets correct default values `null` on complex field arguments" do
-      type = loaded_schema.types['Query']
-      field = type.fields['post']
-      arg = field.arguments['variedWithNull']
-
-      assert_equal arg.default_value, { 'id' => nil, 'int' => nil, 'float' => nil, 'enum' => nil, 'sub' => nil, 'bool' => nil, 'bigint' => nil }
-    end
-  end
-end

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,177 +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
-          []
-        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 :french_items, [FrenchItem], null: false,
-        resolver_method: :items
-      field :items_connection, Item.connection_type, null: false,
-        resolver_method: :items
-
-      def items
-        [
-          OpenStruct.new(name: "Trombone"),
-          OpenStruct.new(name: "Paperclip"),
-        ]
-      end
-
-      field :things, [Thing], null: false
-      def things
-        items + [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 "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