graphql 1.7.6 → 1.8.0

data/spec/graphql/schema/finder_spec.rb

@@ -0,0 +1,135 @@
+# 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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::InputObject do
+  let(:input_object) { Jazz::EnsembleInput }
+  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_s }
+    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)
+      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
+end

data/spec/graphql/schema/instrumentation_spec.rb

@@ -0,0 +1,40 @@
+# 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]
+  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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Interface do
+  let(:interface) { Jazz::GloballyIdentifiableType }
+
+  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::CheeseType, Dummy::HoneyType
+      end
+
+      interface_type = interface.to_graphql
+      assert_equal [Dummy::CheeseType, Dummy::HoneyType], 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
+    end
+
+    module InterfaceB
+      include GraphQL::Schema::Interface
+    end
+
+    module InterfaceC
+      include GraphQL::Schema::Interface
+    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
+  end
+end

data/spec/graphql/schema/introspection_system_spec.rb

@@ -0,0 +1,39 @@
+# 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
+  end
+end

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

@@ -0,0 +1,111 @@
+# 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
+
+    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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Member::BuildType do
+  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