graphql 1.9.0 → 2.1.1

data/spec/graphql/schema/finder_spec.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Finder do
-  let(:finder) { GraphQL::Schema::Finder.new(Jazz::Schema) }
-
-  describe "#find" do
-    it "finds a valid object type" do
-      type = finder.find("Ensemble")
-      assert_equal "Ensemble", type.name
-    end
-
-    it "raises when finding an invalid object type" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("DoesNotExist")
-      end
-
-      assert_match /Could not find type `DoesNotExist` in schema./, exception.message
-    end
-
-    it "finds a valid directive" do
-      directive = finder.find("@include")
-      assert_equal "include", directive.name
-    end
-
-    it "raises when finding an invalid directive" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("@yolo")
-      end
-
-      assert_match /Could not find directive `@yolo` in schema./, exception.message
-    end
-
-    it "finds a valid field" do
-      field = finder.find("Ensemble.musicians")
-      assert_equal "musicians", field.name
-    end
-
-    it "finds a meta field" do
-      field = finder.find("Ensemble.__typename")
-      assert_equal "__typename", field.name
-    end
-
-    it "raises when finding an in valid field" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("Ensemble.nope")
-      end
-
-      assert_match /Could not find field `nope` on object type `Ensemble`./, exception.message
-    end
-
-    it "finds a valid argument" do
-      arg = finder.find("Query.find.id")
-      assert_equal "id", arg.name
-    end
-
-    it "raises when finding an invalid argument" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("Query.find.thisArgumentIsInvalid")
-      end
-
-      assert_match /Could not find argument `thisArgumentIsInvalid` on field `find`./, exception.message
-    end
-
-    it "raises when selecting on an argument" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("Query.find.id.whyYouDoThis")
-      end
-
-      assert_match /Cannot select member `whyYouDoThis` on a field./, exception.message
-    end
-
-    it "finds a valid interface" do
-      type = finder.find("NamedEntity")
-      assert_equal "NamedEntity", type.name
-    end
-
-    it "finds a valid input type" do
-      type = finder.find("LegacyInput")
-      assert_equal "LegacyInput", type.name
-    end
-
-    it "finds a valid input field" do
-      input_field = finder.find("LegacyInput.intValue")
-      assert_equal "intValue", input_field.name
-    end
-
-    it "raises when finding an invalid input field" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("LegacyInput.wat")
-      end
-
-      assert_match /Could not find input field `wat` on input object type `LegacyInput`./, exception.message
-    end
-
-    it "finds a valid union type" do
-      type = finder.find("PerformingAct")
-      assert_equal "PerformingAct", type.name
-    end
-
-    it "raises when selecting a possible type" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("PerformingAct.Musician")
-      end
-
-      assert_match /Cannot select union possible type `Musician`. Select the type directly instead./, exception.message
-    end
-
-    it "finds a valid enum type" do
-      type = finder.find("Family")
-      assert_equal "Family", type.name
-    end
-
-    it "finds a valid enum value" do
-      value = finder.find("Family.BRASS")
-      assert_equal "BRASS", value.name
-    end
-
-    it "raises when finding an invalid enum value" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("Family.THISISNOTASTATUS")
-      end
-
-      assert_match /Could not find enum value `THISISNOTASTATUS` on enum type `Family`./, exception.message
-    end
-
-    it "raises when selecting on an enum value" do
-      exception = assert_raises GraphQL::Schema::Finder::MemberNotFoundError do
-        finder.find("Family.BRASS.wat")
-      end
-
-      assert_match /Cannot select member `wat` on an enum value./, exception.message
-    end
-  end
-end

data/spec/graphql/schema/input_object_spec.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::InputObject do
-  let(:input_object) { Jazz::EnsembleInput }
-
-  describe ".path" do
-    it "is the name" do
-      assert_equal "EnsembleInput", input_object.path
-    end
-
-    it "is used in argument paths" do
-      assert_equal "EnsembleInput.name", input_object.arguments["name"].path
-    end
-  end
-
-  describe "type info" do
-    it "has it" do
-      assert_equal "EnsembleInput", input_object.graphql_name
-      assert_equal nil, input_object.description
-      assert_equal 1, input_object.arguments.size
-    end
-
-    it "is the #owner of its arguments" do
-      argument = input_object.arguments["name"]
-      assert_equal input_object, argument.owner
-    end
-
-    it "inherits arguments" do
-      base_class = Class.new(GraphQL::Schema::InputObject) do
-        argument :arg1, String, required: true
-        argument :arg2, String, required: true
-      end
-
-      subclass = Class.new(base_class) do
-        argument :arg2, Integer, required: true
-        argument :arg3, Integer, required: true
-      end
-
-      assert_equal 3, subclass.arguments.size
-      assert_equal ["arg1", "arg2", "arg3"], subclass.arguments.keys
-      assert_equal ["String!", "Int!", "Int!"], subclass.arguments.values.map { |a| a.type.to_type_signature }
-    end
-  end
-
-  describe ".to_graphql" do
-    it "assigns itself as the arguments_class" do
-      assert_equal input_object, input_object.to_graphql.arguments_class
-    end
-
-    it "accepts description: kwarg" do
-      input_obj_class = Jazz::InspectableInput
-      input_obj_type = input_obj_class.to_graphql
-      assert_equal "Test description kwarg", input_obj_type.arguments["stringValue"].description
-    end
-  end
-
-  describe "prepare: / as:" do
-    module InputObjectPrepareTest
-      class InputObj < GraphQL::Schema::InputObject
-        argument :a, Integer, required: true
-        argument :b, Integer, required: true, as: :b2
-        argument :c, Integer, required: true, prepare: :prep
-        argument :d, Integer, required: true, prepare: :prep, as: :d2
-        argument :e, Integer, required: true, prepare: ->(val, ctx) { val * ctx[:multiply_by] * 2 }, as: :e2
-
-        def prep(val)
-          val * context[:multiply_by]
-        end
-      end
-
-      class Query < GraphQL::Schema::Object
-        field :inputs, String, null: false do
-          argument :input, InputObj, required: true
-        end
-
-        def inputs(input:)
-          input.to_kwargs.inspect
-        end
-      end
-
-      class Schema < GraphQL::Schema
-        query(Query)
-        if TESTING_INTERPRETER
-          use GraphQL::Execution::Interpreter
-        end
-      end
-    end
-
-    it "calls methods on the input object" do
-      query_str = <<-GRAPHQL
-      { inputs(input: { a: 1, b: 2, c: 3, d: 4, e: 5 }) }
-      GRAPHQL
-
-      res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 })
-      expected_obj = { a: 1, b2: 2, c: 9, d2: 12, e2: 30 }.inspect
-      assert_equal expected_obj, res["data"]["inputs"]
-    end
-  end
-
-  describe "in queries" do
-    it "is passed to the field method" do
-      query_str = <<-GRAPHQL
-      {
-        inspectInput(input: {
-          stringValue: "ABC",
-          legacyInput: { intValue: 4 },
-          nestedInput: { stringValue: "xyz"}
-        })
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str, context: { message: "hi" })
-      expected_info = [
-        "Jazz::InspectableInput",
-        "hi, ABC, 4, (hi, xyz, -, (-))",
-        "ABC",
-        "ABC",
-        "true",
-        "ABC",
-      ]
-      assert_equal expected_info, res["data"]["inspectInput"]
-    end
-  end
-
-  describe "when used with default_value" do
-    it "comes as an instance" do
-      res = Jazz::Schema.execute("{ defaultValueTest }")
-      assert_equal "Jazz::InspectableInput -> {:string_value=>\"S\"}", res["data"]["defaultValueTest"]
-    end
-  end
-
-  describe "#to_h" do
-    module InputObjectToHTest
-      class TestInput1 < GraphQL::Schema::InputObject
-        graphql_name "TestInput1"
-        argument :d, Int, required: true
-        argument :e, Int, required: true
-      end
-
-      class TestInput2 < GraphQL::Schema::InputObject
-        graphql_name "TestInput2"
-        argument :a, Int, required: true
-        argument :b, Int, required: true
-        argument :c, TestInput1, as: :inputObject, required: true
-      end
-
-      TestInput1.to_graphql
-      TestInput2.to_graphql
-    end
-
-    it "returns a symbolized, aliased, ruby keyword style hash" do
-      arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
-
-      input_object = InputObjectToHTest::TestInput2.new(
-        arg_values,
-        context: nil,
-        defaults_used: Set.new
-      )
-
-      assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4 } }, input_object.to_h)
-    end
-  end
-
-  describe "#dig" do
-    module InputObjectDigTest
-      class TestInput1 < GraphQL::Schema::InputObject
-        graphql_name "TestInput1"
-        argument :d, Int, required: true
-        argument :e, Int, required: true
-      end
-
-      class TestInput2 < GraphQL::Schema::InputObject
-        graphql_name "TestInput2"
-        argument :a, Int, required: true
-        argument :b, Int, required: true
-        argument :c, TestInput1, as: :inputObject, required: true
-      end
-
-      TestInput1.to_graphql
-      TestInput2.to_graphql
-    end
-    arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
-
-    input_object = InputObjectDigTest::TestInput2.new(
-      arg_values,
-      context: nil,
-      defaults_used: Set.new
-    )
-    it "returns the value at that key" do
-      assert_equal 1, input_object.dig("a")
-      assert_equal 1, input_object.dig(:a)
-      assert input_object.dig("inputObject").is_a?(GraphQL::Schema::InputObject)
-    end
-
-    it "works with nested keys" do
-      assert_equal 3, input_object.dig("inputObject", "d")
-      assert_equal 3, input_object.dig(:inputObject, :d)
-      assert_equal 3, input_object.dig("inputObject", :d)
-      assert_equal 3, input_object.dig(:inputObject, "d")
-    end
-
-    it "returns nil for missing keys" do
-      assert_nil input_object.dig("z")
-      assert_nil input_object.dig(7)
-    end
-
-    it "handles underscored keys" do
-      # TODO - shouldn't this work too?
-      # assert_equal 3, input_object.dig('input_object', 'd')
-      assert_equal 3, input_object.dig(:input_object, :d)
-    end
-  end
-
-  describe "introspection" do
-    it "returns input fields" do
-      res = Jazz::Schema.execute('
-        {
-          __type(name: "InspectableInput") {
-            name
-            inputFields { name }
-          }
-          __schema {
-            types {
-              name
-              inputFields { name }
-            }
-          }
-        }')
-      # Test __type
-      assert_equal ["stringValue", "nestedInput", "legacyInput"], res["data"]["__type"]["inputFields"].map { |f| f["name"] }
-      # Test __schema { types }
-      # It's upcased to test custom introspection
-      input_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "INSPECTABLEINPUT" }
-      assert_equal ["stringValue", "nestedInput", "legacyInput"], input_type["inputFields"].map { |f| f["name"] }
-    end
-  end
-end

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,47 +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 "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
-end