graphql 1.9.5 → 1.13.19

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -1,35 +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
-
-  if TESTING_RESCUE_FROM
-    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
-end

data/spec/graphql/schema/directive/feature_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Directive::Feature do
-  class FeatureSchema < GraphQL::Schema
-    class Feature < GraphQL::Schema::Directive::Feature
-      def self.enabled?(flag_name, obj, ctx)
-        !!ctx[flag_name.to_sym]
-      end
-    end
-
-    class Query < GraphQL::Schema::Object
-      field :int, Integer, null: false
-
-      def int
-        context[:int] ||= 0
-        context[:int] += 1
-      end
-    end
-
-    directive(Feature)
-    query(Query)
-    # only supported by the interpreter
-    use GraphQL::Execution::Interpreter
-    use GraphQL::Analysis::AST
-  end
-
-
-  it "skips or runs fields" do
-    str = '{
-      int1: int
-      int2: int @feature(flag: "flag1")
-      int3: int @feature(flag: "flag2")
-    }'
-
-    res = FeatureSchema.execute(str, context: { flag2: true })
-    # Int2 was not called, so `int3` is actually 2
-    assert_equal({"int1" => 1, "int3" => 2}, res["data"])
-  end
-
-  it "skips or runs fragment spreads" do
-    str = '{
-      ...F1
-      ...F2 @feature(flag: "flag1")
-      ...F3 @feature(flag: "flag2")
-      int4: int
-    }
-
-    fragment F1 on Query { int1: int }
-    fragment F2 on Query { int2: int }
-    fragment F3 on Query { int3: int }
-    '
-
-    res = FeatureSchema.execute(str, context: { flag1: true })
-    # `int3` was skipped
-    assert_equal({"int1" => 1, "int2" => 2, "int4" => 3}, res["data"])
-  end
-  it "skips or runs inline fragments" do
-    str = '{
-      ... { int1: int }
-      ... @feature(flag: "flag1") { int2: int }
-      ... @feature(flag: "flag2") { int3: int }
-      int4: int
-    }
-    '
-
-    res = FeatureSchema.execute(str, context: { flag2: true })
-    # `int2` was skipped
-    assert_equal({"int1" => 1, "int3" => 2, "int4" => 3}, res["data"])
-  end
-
-  it "returns an error if it's in the wrong place" do
-    str = '
-    query @feature(flag: "x") {
-      int
-    }
-    '
-    res = FeatureSchema.execute(str)
-    assert_equal ["'@feature' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)"], res["errors"].map { |e| e["message"] }
-  end
-end

data/spec/graphql/schema/directive/transform_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Directive::Transform do
-  class TransformSchema < GraphQL::Schema
-    class Query < GraphQL::Schema::Object
-      field :echo, String, null: false do
-        argument :input, String, required: true
-      end
-
-      def echo(input:)
-        input
-      end
-    end
-
-    directive(GraphQL::Schema::Directive::Transform)
-
-    query(Query)
-    # only supported by the interpreter
-    use GraphQL::Execution::Interpreter
-    use GraphQL::Analysis::AST
-  end
-
-  it "transforms when applicable" do
-    str = '{
-      normal: echo(input: "Hello")
-      upcased: echo(input: "Hello") @transform(by: "upcase")
-      downcased: echo(input: "Hello") @transform(by: "downcase")
-      nonsense: echo(input: "Hello") @transform(by: "nonsense")
-    }'
-
-    res = TransformSchema.execute(str)
-
-    assert_equal "Hello", res["data"]["normal"]
-    assert_equal "HELLO", res["data"]["upcased"]
-    assert_equal "hello", res["data"]["downcased"]
-    assert_equal "Hello", res["data"]["nonsense"]
-  end
-end

data/spec/graphql/schema/enum_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Enum do
-  let(:enum) { Jazz::Family }
-
-  describe ".path" do
-    it "is the name" do
-      assert_equal "Family", enum.path
-    end
-  end
-
-  describe "type info" do
-    it "tells about the definition" do
-      assert_equal "Family", enum.graphql_name
-      assert_equal 29, enum.description.length
-      assert_equal 7, 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 7, enum.values.size
-      assert_equal 8, 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"]
-      silence_val = enum_type.values["SILENCE"]
-      assert_equal "STRING", string_val.name
-      assert_equal :str, string_val.value
-      assert_equal false, silence_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/enum_value_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::EnumValue do
-  describe "#path" do
-    it "Has the owner name too" do
-      enum = Class.new(GraphQL::Schema::Enum) do
-        graphql_name "Abc"
-        value(:XYZ)
-      end
-
-      assert_equal "Abc.XYZ", enum.values["XYZ"].path
-    end
-  end
-
-  describe "#deprecation_reason" do
-    it "can be written and read" do
-      enum_value = GraphQL::Schema::EnumValue.new(:x, owner: nil)
-      assert_nil enum_value.deprecation_reason
-      enum_value.deprecation_reason = "No good!"
-      assert_equal "No good!", enum_value.deprecation_reason
-    end
-  end
-end

data/spec/graphql/schema/field_extension_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::FieldExtension do
-  module FilterTestSchema
-    class DoubleFilter < GraphQL::Schema::FieldExtension
-      def after_resolve(object:, value:, arguments:, context:, memo:)
-        value * 2
-      end
-    end
-
-    class PowerOfFilter < GraphQL::Schema::FieldExtension
-      def after_resolve(object:, value:, arguments:, context:, memo:)
-        value**options.fetch(:power, 2)
-      end
-    end
-
-    class MultiplyByOption < GraphQL::Schema::FieldExtension
-      def after_resolve(object:, value:, arguments:, context:, memo:)
-        value * options[:factor]
-      end
-    end
-
-    class MultiplyByArgument < GraphQL::Schema::FieldExtension
-      def apply
-        field.argument(:factor, Integer, required: true)
-      end
-
-      def resolve(object:, arguments:, context:)
-        factor = arguments.delete(:factor)
-        yield(object, arguments, factor)
-      end
-
-      def after_resolve(object:, value:, arguments:, context:, memo:)
-        value * memo
-      end
-    end
-
-    class MultiplyByArgumentUsingResolve < GraphQL::Schema::FieldExtension
-      def apply
-        field.argument(:factor, Integer, required: true)
-      end
-
-      # `yield` returns the user-returned value
-      # This method's return value is passed along
-      def resolve(object:, arguments:, context:)
-        factor = arguments.delete(:factor)
-        yield(object, arguments) * factor
-      end
-    end
-
-    class BaseObject < GraphQL::Schema::Object
-    end
-
-    class Query < BaseObject
-      field :doubled, Integer, null: false, resolver_method: :pass_thru do
-        extension(DoubleFilter)
-        argument :input, Integer, required: true
-      end
-
-      field :square, Integer, null: false, resolver_method: :pass_thru, extensions: [PowerOfFilter] do
-        argument :input, Integer, required: true
-      end
-
-      field :cube, Integer, null: false, resolver_method: :pass_thru do
-        extension(PowerOfFilter, power: 3)
-        argument :input, Integer, required: true
-      end
-
-      field :tripled_by_option, Integer, null: false, resolver_method: :pass_thru do
-        extension(MultiplyByOption, factor: 3)
-        argument :input, Integer, required: true
-      end
-
-      field :multiply_input, Integer, null: false, resolver_method: :pass_thru, extensions: [MultiplyByArgument] do
-        argument :input, Integer, required: true
-      end
-
-      field :multiply_input2, Integer, null: false, resolver_method: :pass_thru, extensions: [MultiplyByArgumentUsingResolve] do
-        argument :input, Integer, required: true
-      end
-
-      def pass_thru(input:, **args)
-        input # return it as-is, it will be modified by extensions
-      end
-    end
-
-    class Schema < GraphQL::Schema
-      query(Query)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-  end
-
-  def exec_query(query_str, **kwargs)
-    FilterTestSchema::Schema.execute(query_str, **kwargs)
-  end
-
-  describe "reading" do
-    it "has a reader method" do
-      field = FilterTestSchema::Query.fields["multiplyInput"]
-      assert_equal 1, field.extensions.size
-      assert_instance_of FilterTestSchema::MultiplyByArgument, field.extensions.first
-    end
-  end
-
-  describe "modifying return values" do
-    it "returns the modified value" do
-      res = exec_query("{ doubled(input: 5) }")
-      assert_equal 10, res["data"]["doubled"]
-    end
-
-    it "returns the modified value from `yield`" do
-      res = exec_query("{ multiplyInput2(input: 5, factor: 5) }")
-      assert_equal 25, res["data"]["multiplyInput2"]
-    end
-
-    it "has access to config options" do
-      # The factor of three came from an option
-      res = exec_query("{ tripledByOption(input: 4) }")
-      assert_equal 12, res["data"]["tripledByOption"]
-    end
-
-    it "provides an empty hash as default options" do 
-      res = exec_query("{ square(input: 4) }")
-      assert_equal 16, res["data"]["square"]
-      res = exec_query("{ cube(input: 4) }")
-      assert_equal 64, res["data"]["cube"]
-    end
-
-    it "can hide arguments from resolve methods" do
-      res = exec_query("{ multiplyInput(input: 3, factor: 5) }")
-      assert_equal 15, res["data"]["multiplyInput"]
-    end
-  end
-end

data/spec/graphql/schema/field_spec.rb

@@ -1,301 +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"] }
-
-    describe "path" do
-      it "is the object/interface and field name" do
-        assert_equal "Query.inspectInput", field.path
-        assert_equal "GloballyIdentifiable.id", Jazz::GloballyIdentifiableType.fields["id"].path
-      end
-    end
-
-    it "uses the argument class" do
-      arg_defn = field.graphql_definition.arguments.values.first
-      assert_equal :ok, arg_defn.metadata[:custom]
-    end
-
-    it "can add argument directly with add_argument" do
-      argument = Jazz::Query.fields["instruments"].arguments["family"]
-
-      field.add_argument(argument)
-
-      assert_equal "family", field.arguments["family"].name
-      assert_equal Jazz::Family, field.arguments["family"].type
-    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 "works with arbitrary hash keys" do
-      result = Jazz::Schema.execute "{ complexHashKey }", root_value: { :'foo bar/fizz-buzz' => "OK!"}
-      hash_val = result["data"]["complexHashKey"]
-      assert_equal "OK!", hash_val, "It looked up the hash key"
-    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 a block for defintion and yields the field if the block has an arity of one" do
-      object = Class.new(Jazz::BaseObject) do
-        graphql_name "JustAName"
-
-        field :test, String, null: true do |field|
-          field.argument :test, String, required: true
-          field.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
-
-      it "can get methods from the field instance" do
-        query_str = <<-GRAPHQL
-        {
-          upcaseCheck1
-          upcaseCheck2
-          upcaseCheck3
-          upcaseCheck4
-        }
-        GRAPHQL
-        res = Jazz::Schema.execute(query_str)
-        assert_equal "nil", res["data"].fetch("upcaseCheck1")
-        assert_equal "false", res["data"]["upcaseCheck2"]
-        assert_equal "TRUE", res["data"]["upcaseCheck3"]
-        assert_equal "\"WHY NOT?\"", res["data"]["upcaseCheck4"]
-      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
-      err = assert_raises ArgumentError do
-        Class.new(GraphQL::Schema::Object) do
-          graphql_name "Thing"
-          # False might come from an invalid `!`
-          field :stuff, false, null: false
-        end
-      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
-
-  describe '#deprecation_reason' do
-    it "reads and writes" do
-      object_class = Class.new(GraphQL::Schema::Object) do
-        graphql_name "Thing"
-        field :stuff, String, null: false, deprecation_reason: "Broken"
-      end
-      field = object_class.fields["stuff"]
-      assert_equal "Broken", field.deprecation_reason
-      field.deprecation_reason += "!!"
-      assert_equal "Broken!!", field.deprecation_reason
-    end
-  end
-
-  describe "#original_name" do
-    it "is exactly the same as the passed in name" do
-      field = GraphQL::Schema::Field.from_options(
-        :my_field,
-        String,
-        null: false,
-        camelize: true
-      )
-
-      assert_equal :my_field, field.original_name
-    end
-  end
-end