graphql 1.9.11 → 1.9.12

data/spec/graphql/schema/instrumentation_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-module InstrumentationSpec
-  module SomeInterface
-    include GraphQL::Schema::Interface
-    field :never_called, String, null: false
-
-    def never_called
-      "should never be called"
-    end
-  end
-
-  class SomeType < GraphQL::Schema::Object
-    implements SomeInterface
-  end
-
-  class Query < GraphQL::Schema::Object
-    field :some_field, [SomeInterface], null: true
-
-    def some_field
-      nil
-    end
-  end
-
-  class Schema < GraphQL::Schema
-    query Query
-    orphan_types [SomeType]
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-  end
-end
-
-describe GraphQL::Schema::Member::Instrumentation do
-  describe "resolving nullable interface lists to nil" do
-    let(:query) { "query { someField { neverCalled } }"}
-    it "returns nil instead of failing" do
-      result = InstrumentationSpec::Schema.execute(query)
-      assert_nil(result["someField"])
-    end
-  end
-end

data/spec/graphql/schema/interface_spec.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Interface do
-  let(:interface) { Jazz::GloballyIdentifiableType }
-
-  describe ".path" do
-    it "is the name" do
-      assert_equal "GloballyIdentifiable", interface.path
-    end
-  end
-
-  describe "type info" do
-    it "tells its type info" do
-      assert_equal "GloballyIdentifiable", interface.graphql_name
-      assert_equal 2, interface.fields.size
-    end
-
-    module NewInterface1
-      include Jazz::GloballyIdentifiableType
-    end
-
-    module NewInterface2
-      include Jazz::GloballyIdentifiableType
-      def new_method
-      end
-    end
-
-    it "can override methods" do
-      new_object_1 = Class.new(GraphQL::Schema::Object) do
-        implements NewInterface1
-      end
-
-      assert_equal 2, new_object_1.fields.size
-      assert new_object_1.method_defined?(:id)
-
-      new_object_2 = Class.new(GraphQL::Schema::Object) do
-        graphql_name "XYZ"
-        implements NewInterface2
-        field :id, "ID", null: false, description: "The ID !!!!!"
-      end
-
-      assert_equal 2, new_object_2.fields.size
-      # It got the new method
-      assert new_object_2.method_defined?(:new_method)
-      # And the inherited method
-      assert new_object_2.method_defined?(:id)
-
-      # It gets an overridden description:
-      assert_equal "The ID !!!!!", new_object_2.graphql_definition.fields["id"].description
-    end
-  end
-
-  describe ".to_graphql" do
-    it "creates an InterfaceType" do
-      interface_type = interface.to_graphql
-      assert_equal "GloballyIdentifiable", interface_type.name
-      field = interface_type.all_fields.first
-      assert_equal "id", field.name
-      assert_equal GraphQL::ID_TYPE.to_non_null_type, field.type
-      assert_equal "A unique identifier for this object", field.description
-      assert_nil interface_type.resolve_type_proc
-      assert_empty interface_type.orphan_types
-    end
-
-    it "can specify a resolve_type method" do
-      interface = Module.new do
-        include GraphQL::Schema::Interface
-        graphql_name "MyInterface"
-
-        module self::DefinitionMethods # rubocop:disable Style/ClassAndModuleChildren
-          def resolve_type(_object, _context)
-            "MyType"
-          end
-        end
-      end
-
-      interface_type = interface.to_graphql
-      assert_equal "MyType", interface_type.resolve_type_proc.call(nil, nil)
-    end
-
-    it "can specify orphan types" do
-      interface = Module.new do
-        include GraphQL::Schema::Interface
-        graphql_name "MyInterface"
-        orphan_types Dummy::Cheese, Dummy::Honey
-      end
-
-      interface_type = interface.to_graphql
-      assert_equal [Dummy::Cheese, Dummy::Honey], interface_type.orphan_types
-    end
-  end
-
-  it 'supports global_id_field' do
-    object = Module.new do
-      include GraphQL::Schema::Interface
-      graphql_name 'GlobalIdFieldTest'
-      global_id_field :uuid
-    end.to_graphql
-
-    uuid_field = object.fields["uuid"]
-
-    assert_equal GraphQL::NonNullType, uuid_field.type.class
-    assert_equal GraphQL::ScalarType, uuid_field.type.unwrap.class
-    assert_equal(
-      GraphQL::Schema::Member::GraphQLTypeNames::ID,
-      uuid_field.type.unwrap.name
-    )
-  end
-
-  describe "using `include`" do
-    it "raises" do
-      err = assert_raises RuntimeError do
-        Class.new(GraphQL::Schema::Object) do
-          include(Jazz::GloballyIdentifiableType)
-        end
-      end
-
-      assert_includes err.message, "implements(Jazz::GloballyIdentifiableType)"
-    end
-  end
-
-  describe "in queries" do
-    it "works" do
-      query_str = <<-GRAPHQL
-      {
-        piano: find(id: "Instrument/Piano") {
-          id
-          upcasedId
-          ... on Instrument {
-            family
-          }
-        }
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      expected_piano = {
-        "id" => "Instrument/Piano",
-        "upcasedId" => "INSTRUMENT/PIANO",
-        "family" => "KEYS",
-      }
-      assert_equal(expected_piano, res["data"]["piano"])
-    end
-
-    it "applies custom field attributes" do
-      query_str = <<-GRAPHQL
-      {
-        find(id: "Ensemble/Bela Fleck and the Flecktones") {
-          upcasedId
-          ... on Ensemble {
-            name
-          }
-        }
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      expected_data = {
-        "upcasedId" => "ENSEMBLE/BELA FLECK AND THE FLECKTONES",
-        "name" => "Bela Fleck and the Flecktones"
-      }
-      assert_equal(expected_data, res["data"]["find"])
-    end
-  end
-
-  describe ':DefinitionMethods' do
-    module InterfaceA
-      include GraphQL::Schema::Interface
-
-      definition_methods do
-        def some_method
-          42
-        end
-      end
-    end
-
-    module InterfaceB
-      include GraphQL::Schema::Interface
-    end
-
-    module InterfaceC
-      include GraphQL::Schema::Interface
-    end
-
-    module InterfaceD
-      include InterfaceA
-
-      definition_methods do
-        def some_method
-          'not 42'
-        end
-      end
-    end
-
-    module InterfaceE
-      include InterfaceD
-    end
-
-    it "doesn't overwrite them when including multiple interfaces" do
-      def_methods = InterfaceC::DefinitionMethods
-
-      InterfaceC.module_eval do
-        include InterfaceA
-        include InterfaceB
-      end
-
-      assert_equal(InterfaceC::DefinitionMethods, def_methods)
-    end
-
-    it "follows the normal Ruby ancestor chain when including other interfaces" do
-      assert_equal('not 42', InterfaceE.some_method)
-    end
-  end
-end

data/spec/graphql/schema/introspection_system_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::IntrospectionSystem do
-  describe "custom introspection" do
-    it "serves custom fields on types" do
-      res = Jazz::Schema.execute("{ __schema { isJazzy } }")
-      assert_equal true, res["data"]["__schema"]["isJazzy"]
-    end
-
-    it "serves overridden fields on types" do
-      res = Jazz::Schema.execute(%|{ __type(name: "Ensemble") { name } }|)
-      assert_equal "ENSEMBLE", res["data"]["__type"]["name"]
-    end
-
-    it "serves custom entry points" do
-      res = Jazz::Schema.execute("{ __classname }", root_value: Set.new)
-      assert_equal "Set", res["data"]["__classname"]
-    end
-
-    it "calls authorization methods of those types" do
-      res = Jazz::Schema.execute(%|{ __type(name: "Ensemble") { name } }|)
-      assert_equal "ENSEMBLE", res["data"]["__type"]["name"]
-
-      unauth_res = Jazz::Schema.execute(%|{ __type(name: "Ensemble") { name } }|, context: { cant_introspect: true })
-      assert_nil unauth_res["data"].fetch("__type")
-      assert_equal ["You're not allowed to introspect here"], unauth_res["errors"].map { |e| e["message"] }
-    end
-
-    it "serves custom dynamic fields" do
-      res = Jazz::Schema.execute("{ nowPlaying { __typename __typenameLength __astNodeClass } }")
-      assert_equal "Ensemble", res["data"]["nowPlaying"]["__typename"]
-      assert_equal 8, res["data"]["nowPlaying"]["__typenameLength"]
-      assert_equal "GraphQL::Language::Nodes::Field", res["data"]["nowPlaying"]["__astNodeClass"]
-    end
-
-    it "doesn't affect other schemas" do
-      res = Dummy::Schema.execute("{ __schema { isJazzy } }")
-      assert_equal 1, res["errors"].length
-
-      res = Dummy::Schema.execute("{ __classname }", root_value: Set.new)
-      assert_equal 1, res["errors"].length
-
-      res = Dummy::Schema.execute("{ ensembles { __typenameLength } }")
-      assert_equal 1, res["errors"].length
-    end
-
-    it "runs the introspection query" do
-      res = Jazz::Schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-      assert res
-      query_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "QUERY" }
-      ensembles_field = query_type["fields"].find { |f| f["name"] == "ensembles" }
-      assert_equal [], ensembles_field["args"]
-    end
-  end
-
-  describe "#disable_introspection_entry_points" do
-    let(:schema) { Jazz::Schema }
-
-    it "allows entry point introspection by default" do
-      res = schema.execute("{ __schema { types { name } } }")
-      assert res
-
-      types = res["data"]["__schema"]["types"]
-      refute_empty types
-    end
-
-    describe "when entry points introspection is disabled" do
-      let(:schema) { Jazz::SchemaWithoutIntrospection }
-
-      it "returns error" do
-        res = schema.execute("{ __schema { types { name } } }")
-        assert res
-
-        assert_nil res["data"]
-        assert_equal ["Field '__schema' doesn't exist on type 'Query'"], res["errors"].map { |e| e["message"] }
-      end
-    end
-  end
-end

data/spec/graphql/schema/list_spec.rb

@@ -1,73 +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
-
-  describe "validation" do
-    class ListEnumValidationSchema < GraphQL::Schema
-      class Item < GraphQL::Schema::Enum
-        value "A"
-        value "B"
-      end
-
-      class Query < GraphQL::Schema::Object
-        field :echo, [Item], null: false do
-          argument :items, [Item], required: true
-        end
-
-        def echo(items:)
-          items
-        end
-      end
-
-      query(Query)
-    end
-
-    it "checks non-null lists of enums" do
-      res = ListEnumValidationSchema.execute "{ echo(items: [A, B, \"C\"]) }"
-      expected_error = "Argument 'items' on Field 'echo' has an invalid value. Expected type '[Item!]!'."
-      assert_equal [expected_error], res["errors"].map { |e| e["message"] }
-    end
-  end
-end

data/spec/graphql/schema/loader_spec.rb

@@ -1,350 +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 "doesnt warn about method conflicts (because it doesn't make method accesses)" do
-      assert_output "", "" do
-        GraphQL::Schema.from_introspection({
-          "data" => {
-            "__schema" => {
-              "queryType" => {
-                "name" => "Query"
-              },
-              "mutationType" => nil,
-              "subscriptionType" => nil,
-              "types" => [
-                {
-                  "kind" => "OBJECT",
-                  "name" => "Query",
-                  "description" => nil,
-                  "fields" => [
-                    {
-                      "name" => "int",
-                      "description" => nil,
-                      "args" => [
-                        {
-                          "name" => "method",
-                          "description" => nil,
-                          "type" => {
-                            "kind" => "SCALAR",
-                            "name" => "Int",
-                            "ofType" => nil
-                          },
-                          "defaultValue" => nil
-                        }
-                      ],
-                      "type" => {
-                        "kind" => "SCALAR",
-                        "name" => "Int",
-                        "ofType" => nil
-                      },
-                      "isDeprecated" => false,
-                      "deprecationReason" => nil
-                    }
-                  ],
-                  "inputFields" => nil,
-                  "interfaces" => [
-
-                  ],
-                  "enumValues" => nil,
-                  "possibleTypes" => nil
-                },
-                {
-                  "kind" => "SCALAR",
-                  "name" => "Int",
-                  "description" => "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.",
-                  "fields" => nil,
-                  "inputFields" => nil,
-                  "interfaces" => nil,
-                  "enumValues" => nil,
-                  "possibleTypes" => nil
-                },
-              ]
-            }
-          }
-        })
-      end
-    end
-
-    it "sets correct default values `nil` 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