graphql 1.9.5 → 1.13.19

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,347 +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
-
-      ensemble_class = Class.new(subclass) do
-        argument :ensemble_id, GraphQL::Types::ID, required: false, loads: Jazz::Ensemble
-      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 }
-      assert_equal ["String!", "Int!", "Int!", "ID"], ensemble_class.arguments.values.map { |a| a.type.to_type_signature }
-      assert_equal :ensemble, ensemble_class.arguments["ensembleId"].keyword
-    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: / loads: / 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
-        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
-        argument :danger, Integer, required: false, prepare: ->(val, ctx) { raise GraphQL::ExecutionError.new('boom!') }
-
-        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, input.instrument.name]
-        end
-      end
-
-      class Schema < GraphQL::Schema
-        query(Query)
-        if TESTING_INTERPRETER
-          use GraphQL::Execution::Interpreter
-        end
-
-        def self.object_from_id(id, ctx)
-          Jazz::GloballyIdentifiableType.find(id)
-        end
-
-        def self.resolve_type(type, obj, ctx)
-          type
-        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, instrumentId: "Instrument/Drum Kit" }) }
-      GRAPHQL
-
-      res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 })
-      expected_obj = [{ a: 1, b2: 2, c: 9, d2: 12, e2: 30, instrument: "Instrument/Drum Kit" }.inspect, "Drum Kit"]
-      assert_equal expected_obj, res["data"]["inputs"]
-    end
-
-    it "handles exceptions preparing variable input objects" do
-      query_str = <<-GRAPHQL
-      query($input: InputObj!){ inputs(input: $input) }
-      GRAPHQL
-
-      input = { "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "instrumentId" => "Instrument/Drum Kit", "danger" => 1 }
-      res = InputObjectPrepareTest::Schema.execute(query_str, context: { multiply_by: 3 },
-                                                   variables: { input: input})
-      assert_nil(res["data"])
-      assert_equal("Variable input of type InputObj! was provided invalid value", res["errors"][0]["message"])
-      assert_equal([{ "line" => 1, "column" => 13 }], res["errors"][0]["locations"])
-      assert_equal("boom!", res["errors"][0]["extensions"]["problems"][0]["explanation"])
-      assert_equal(input, res["errors"][0]["extensions"]["value"])
-    end
-  end
-
-  describe "loading application object(s)" do
-    module InputObjectLoadsTest
-      class SingleLoadInputObj < GraphQL::Schema::InputObject
-        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
-      end
-
-      class MultiLoadInputObj < GraphQL::Schema::InputObject
-        argument :instrument_ids, [ID], required: true, loads: Jazz::InstrumentType
-      end
-
-      class Query < GraphQL::Schema::Object
-        field :single_load_input, Jazz::InstrumentType, null: false do
-          argument :input, SingleLoadInputObj, required: true
-        end
-        field :multi_load_input, [Jazz::InstrumentType], null: false do
-          argument :input, MultiLoadInputObj, required: true
-        end
-
-        def single_load_input(input:)
-          input.instrument
-        end
-
-        def multi_load_input(input:)
-          input.instruments
-        end
-      end
-
-      class Schema < GraphQL::Schema
-        query(Query)
-        if TESTING_INTERPRETER
-          use GraphQL::Execution::Interpreter
-        end
-
-        def self.object_from_id(id, ctx)
-          Jazz::GloballyIdentifiableType.find(id)
-        end
-
-        def self.resolve_type(type, obj, ctx)
-          type
-        end
-      end
-    end
-
-    let(:single_query_str) {
-      <<-GRAPHQL
-        query($id: ID!) {
-          singleLoadInput(input: {instrumentId: $id}) {
-            id
-          }
-        }
-      GRAPHQL
-    }
-
-    let(:multi_query_str) {
-      <<-GRAPHQL
-        query($ids: [ID!]!) {
-          multiLoadInput(input: {instrumentIds: $ids}) {
-            id
-          }
-        }
-      GRAPHQL
-    }
-
-    it "loads arguments as objects of the given type and strips `_id` suffix off argument name" do
-      res = InputObjectLoadsTest::Schema.execute(single_query_str, variables: { id: "Ensemble/Robert Glasper Experiment" })
-      assert_equal "Ensemble/Robert Glasper Experiment", res["data"]["singleLoadInput"]["id"]
-    end
-
-    it "loads arguments as objects of the given type and strips `_ids` suffix off argument name and appends `s`" do
-      res = InputObjectLoadsTest::Schema.execute(multi_query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
-      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["multiLoadInput"].map { |e| e["id"] }
-    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"},
-          ensembleId: "Ensemble/Robert Glasper Experiment"
-        })
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str, context: { message: "hi" })
-      expected_info = [
-        "Jazz::InspectableInput",
-        "hi, ABC, 4, (hi, xyz, -, (-))",
-        "ABC",
-        "ABC",
-        "true",
-        "ABC",
-        Jazz::Models::Ensemble.new("Robert Glasper Experiment").to_s,
-        "true",
-      ]
-      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
-        argument :instrument_id, ID, required: true, loads: Jazz::InstrumentType
-      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, instrumentId: "Instrument/Drum Kit"}}
-
-      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, instrument: "Instrument/Drum Kit" } }, 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 ["ensembleId", "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 ["ensembleId", "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