graphql 1.8.0 → 1.12.12

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::CatchallMiddleware do
-  let(:result) { Dummy::Schema.execute(query_string) }
-  let(:query_string) {%| query noMilk { error }|}
-
-  before do
-    Dummy::Schema.middleware << GraphQL::Schema::CatchallMiddleware
-  end
-
-  after do
-    Dummy::Schema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
-  end
-
-  describe "rescuing errors" do
-    let(:errors) { query.context.errors }
-
-    it "turns into error messages" do
-      expected = {
-        "data" => { "error" => nil },
-        "errors"=> [
-          {
-            "message"=>"Internal error",
-            "locations"=>[{"line"=>1, "column"=>17}],
-            "path"=>["error"]
-          },
-        ]
-      }
-      assert_equal(expected, result)
-    end
-  end
-
-end

data/spec/graphql/schema/enum_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Enum do
-  let(:enum) { Jazz::Family }
-  describe "type info" do
-    it "tells about the definition" do
-      assert_equal "Family", enum.graphql_name
-      assert_equal 29, enum.description.length
-      assert_equal 6, enum.values.size
-    end
-
-    it "inherits values and description" do
-      new_enum = Class.new(enum) do
-        value :Nonsense
-        value :PERCUSSION, "new description"
-      end
-
-      # Description was inherited
-      assert_equal 29, new_enum.description.length
-      # values were inherited without modifying the parent
-      assert_equal 6, enum.values.size
-      assert_equal 7, new_enum.values.size
-      perc_value = new_enum.values["PERCUSSION"]
-      assert_equal "new description", perc_value.description
-    end
-
-    it "accepts a block" do
-      assert_equal "Neither here nor there, really", enum.values["KEYS"].description
-    end
-
-    it "is the #owner of its values" do
-      value = enum.values["STRING"]
-      assert_equal enum, value.owner
-    end
-  end
-
-  it "uses a custom enum value class" do
-    enum_type = enum.to_graphql
-    value = enum_type.values["STRING"]
-    assert_equal 1, value.metadata[:custom_setting]
-  end
-
-  describe ".to_graphql" do
-    it "creates an EnumType" do
-      enum_type = enum.to_graphql
-      assert_equal "Family", enum_type.name
-      assert_equal "Groups of musical instruments", enum_type.description
-
-      string_val = enum_type.values["STRING"]
-      didg_val = enum_type.values["DIDGERIDOO"]
-      assert_equal "STRING", string_val.name
-      assert_equal :str, string_val.value
-      assert_equal "DIDGERIDOO", didg_val.name
-      assert_equal "Merged into BRASS", didg_val.deprecation_reason
-    end
-  end
-
-  describe "in queries" do
-    it "works as return values" do
-      query_str = "{ instruments { family } }"
-      expected_families = ["STRING", "WOODWIND", "BRASS", "KEYS", "KEYS", "PERCUSSION"]
-      result = Jazz::Schema.execute(query_str)
-      assert_equal expected_families, result["data"]["instruments"].map { |i| i["family"] }
-    end
-
-    it "works as input" do
-      query_str = "query($family: Family!) { instruments(family: $family) { name } }"
-      expected_names = ["Piano", "Organ"]
-      result = Jazz::Schema.execute(query_str, variables: { family: "KEYS" })
-      assert_equal expected_names, result["data"]["instruments"].map { |i| i["name"] }
-    end
-  end
-end

data/spec/graphql/schema/field_spec.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Field do
-  describe "graphql definition" do
-    let(:object_class) { Jazz::Query }
-    let(:field) { object_class.fields["inspectInput"] }
-
-    it "uses the argument class" do
-      arg_defn = field.graphql_definition.arguments.values.first
-      assert_equal :ok, arg_defn.metadata[:custom]
-    end
-
-    it "attaches itself to its graphql_definition as type_class" do
-      assert_equal field, field.graphql_definition.metadata[:type_class]
-    end
-
-    it "camelizes the field name, unless camelize: false" do
-      assert_equal 'inspectInput', field.graphql_definition.name
-      assert_equal 'inspectInput', field.name
-
-      underscored_field = GraphQL::Schema::Field.from_options(:underscored_field, String, null: false, camelize: false, owner: nil) do
-        argument :underscored_arg, String, required: true, camelize: false
-      end
-
-      assert_equal 'underscored_field', underscored_field.to_graphql.name
-      arg_name, arg_defn = underscored_field.to_graphql.arguments.first
-      assert_equal 'underscored_arg', arg_name
-      assert_equal 'underscored_arg', arg_defn.name
-    end
-
-    it "exposes the method override" do
-      object = Class.new(Jazz::BaseObject) do
-        field :t, String, method: :tt, null: true
-      end
-      assert_equal :tt, object.fields["t"].method_sym
-      assert_equal "tt", object.fields["t"].method_str
-    end
-
-    it "accepts a block for definition" do
-      object = Class.new(Jazz::BaseObject) do
-        graphql_name "JustAName"
-
-        field :test, String, null: true do
-          argument :test, String, required: true
-          description "A Description."
-        end
-      end.to_graphql
-
-      assert_equal "test", object.fields["test"].arguments["test"].name
-      assert_equal "A Description.", object.fields["test"].description
-    end
-
-    it "accepts anonymous classes as type" do
-      type = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'MyType'
-      end
-      field = GraphQL::Schema::Field.from_options(:my_field, type, owner: nil, null: true)
-      assert_equal type.to_graphql, field.to_graphql.type
-    end
-
-    describe "extras" do
-      it "can get errors, which adds path" do
-        query_str = <<-GRAPHQL
-        query {
-          find(id: "Musician/Herbie Hancock") {
-            ... on Musician {
-              addError
-            }
-          }
-        }
-        GRAPHQL
-
-        res = Jazz::Schema.execute(query_str)
-        err = res["errors"].first
-        assert_equal "this has a path", err["message"]
-        assert_equal ["find", "addError"], err["path"]
-        assert_equal [{"line"=>4, "column"=>15}], err["locations"]
-      end
-    end
-
-    it "is the #owner of its arguments" do
-      field = Jazz::Query.fields["find"]
-      argument = field.arguments["id"]
-      assert_equal field, argument.owner
-    end
-
-    it "has a reference to the object that owns it with #owner" do
-      assert_equal Jazz::Query, field.owner
-    end
-
-    describe "type" do
-      it "tells the return type" do
-        assert_equal "[String!]!", field.type.graphql_definition.to_s
-      end
-
-      it "returns the type class" do
-        field = Jazz::Query.fields["nowPlaying"]
-        assert_equal Jazz::PerformingAct, field.type.of_type
-      end
-    end
-
-    describe "complexity" do
-      it "accepts a keyword argument" do
-        object = Class.new(Jazz::BaseObject) do
-          graphql_name "complexityKeyword"
-
-          field :complexityTest, String, null: true, complexity: 25
-        end.to_graphql
-
-        assert_equal 25, object.fields["complexityTest"].complexity
-      end
-
-      it "accepts a proc in the definition block" do
-        object = Class.new(Jazz::BaseObject) do
-          graphql_name "complexityKeyword"
-
-          field :complexityTest, String, null: true do
-            complexity ->(_ctx, _args, _child_complexity) { 52 }
-          end
-        end.to_graphql
-
-        assert_equal 52, object.fields["complexityTest"].complexity.call(nil, nil, nil)
-      end
-
-      it "accepts an integer in the definition block" do
-        object = Class.new(Jazz::BaseObject) do
-          graphql_name "complexityKeyword"
-
-          field :complexityTest, String, null: true do
-            complexity 38
-          end
-        end.to_graphql
-
-        assert_equal 38, object.fields["complexityTest"].complexity
-      end
-
-      it 'fails if the complexity is not numeric and not a proc' do
-        err = assert_raises(RuntimeError) do
-          Class.new(Jazz::BaseObject) do
-            graphql_name "complexityKeyword"
-
-            field :complexityTest, String, null: true do
-              complexity 'One hundred and eighty'
-            end
-          end.to_graphql
-        end
-
-        assert_match /^Invalid complexity:/, err.message
-      end
-
-      it 'fails if the proc does not accept 3 parameters' do
-        err = assert_raises(RuntimeError) do
-          Class.new(Jazz::BaseObject) do
-            graphql_name "complexityKeyword"
-
-            field :complexityTest, String, null: true do
-              complexity ->(one, two) { 52 }
-            end
-          end.to_graphql
-        end
-
-        assert_match /^A complexity proc should always accept 3 parameters/, err.message
-      end
-    end
-  end
-
-  describe "build type errors" do
-    it "includes the full name" do
-      thing = Class.new(GraphQL::Schema::Object) do
-        graphql_name "Thing"
-        # `Set` is a class but not a GraphQL type
-        field :stuff, Set, null: false
-      end
-
-      err = assert_raises ArgumentError do
-        thing.fields["stuff"].type
-      end
-
-      assert_includes err.message, "Thing.stuff"
-      assert_includes err.message, "Unexpected class/module"
-    end
-
-    it "makes a suggestion when the type is false" do
-      thing = Class.new(GraphQL::Schema::Object) do
-        graphql_name "Thing"
-        # False might come from an invalid `!`
-        field :stuff, false, null: false
-      end
-
-      err = assert_raises ArgumentError do
-        thing.fields["stuff"].type
-      end
-
-      assert_includes err.message, "Thing.stuff"
-      assert_includes err.message, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
-    end
-
-    it "makes a suggestion when the type is a GraphQL::Field" do
-      err = assert_raises ArgumentError do
-        Class.new(GraphQL::Schema::Object) do
-          graphql_name "Thing"
-          # Previously, field was a valid second argument
-          field :stuff, GraphQL::Relay::Node.field, null: false
-        end
-      end
-
-      assert_includes err.message, "use the `field:` keyword for this instead"
-    end
-  end
-
-  describe "mutation" do
-    it "passes when not including extra arguments" do
-      mutation_class = Class.new(GraphQL::Schema::Mutation) do
-        graphql_name "Thing"
-        field :stuff, String, null: false
-      end
-
-      obj = Class.new(GraphQL::Schema::Object) do
-        field(:my_field, mutation: mutation_class, null: true)
-      end
-      assert_equal obj.fields["myField"].mutation, mutation_class
-    end
-  end
-end

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

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