graphql 1.9.11 → 1.9.12

data/spec/graphql/schema_spec.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema do
-  describe "inheritance" do
-    class DummyFeature1 < GraphQL::Schema::Directive::Feature
-
-    end
-
-    class DummyFeature2 < GraphQL::Schema::Directive::Feature
-
-    end
-
-    let(:base_schema) do
-      Class.new(GraphQL::Schema) do
-        query GraphQL::Schema::Object
-        mutation GraphQL::Schema::Object
-        subscription GraphQL::Schema::Object
-        max_complexity 1
-        max_depth 2
-        default_max_page_size 3
-        error_bubbling false
-        disable_introspection_entry_points
-        orphan_types Jazz::Ensemble
-        introspection Module.new
-        cursor_encoder Object.new
-        query_execution_strategy Object.new
-        mutation_execution_strategy Object.new
-        subscription_execution_strategy Object.new
-        context_class Class.new
-        directives [DummyFeature1]
-        tracer GraphQL::Tracing::DataDogTracing
-        query_analyzer Object.new
-        multiplex_analyzer Object.new
-        rescue_from(StandardError) { }
-        instrument :field, GraphQL::Relay::EdgesInstrumentation
-        middleware (Proc.new {})
-        use GraphQL::Backtrace
-      end
-    end
-
-    it "inherits configuration from its superclass" do
-      schema = Class.new(base_schema)
-      assert_equal base_schema.query, schema.query
-      assert_equal base_schema.mutation, schema.mutation
-      assert_equal base_schema.subscription, schema.subscription
-      assert_equal base_schema.introspection, schema.introspection
-      assert_equal base_schema.cursor_encoder, schema.cursor_encoder
-      assert_equal base_schema.query_execution_strategy, schema.query_execution_strategy
-      assert_equal base_schema.mutation_execution_strategy, schema.mutation_execution_strategy
-      assert_equal base_schema.subscription_execution_strategy, schema.subscription_execution_strategy
-      assert_equal base_schema.max_complexity, schema.max_complexity
-      assert_equal base_schema.max_depth, schema.max_depth
-      assert_equal base_schema.default_max_page_size, schema.default_max_page_size
-      assert_equal base_schema.error_bubbling, schema.error_bubbling
-      assert_equal base_schema.orphan_types, schema.orphan_types
-      assert_equal base_schema.context_class, schema.context_class
-      assert_equal base_schema.directives, schema.directives
-      assert_equal base_schema.tracers, schema.tracers
-      assert_equal base_schema.query_analyzers, schema.query_analyzers
-      assert_equal base_schema.multiplex_analyzers, schema.multiplex_analyzers
-      assert_equal base_schema.rescues, schema.rescues
-      assert_equal base_schema.instrumenters, schema.instrumenters
-      assert_equal base_schema.middleware.steps.size, schema.middleware.steps.size
-      assert_equal base_schema.disable_introspection_entry_points?, schema.disable_introspection_entry_points?
-      assert_equal [GraphQL::Backtrace], schema.plugins.map(&:first)
-    end
-
-    it "can override configuration from its superclass" do
-      schema = Class.new(base_schema)
-      query = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'Query'
-      end
-      schema.query(query)
-      mutation = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'Mutation'
-      end
-      schema.mutation(mutation)
-      subscription = Class.new(GraphQL::Schema::Object) do
-        graphql_name 'Subscription'
-      end
-      schema.subscription(subscription)
-      introspection = Module.new
-      schema.introspection(introspection)
-      cursor_encoder = Object.new
-      schema.cursor_encoder(cursor_encoder)
-      query_execution_strategy = Object.new
-      schema.query_execution_strategy(query_execution_strategy)
-      mutation_execution_strategy = Object.new
-      schema.mutation_execution_strategy(mutation_execution_strategy)
-      subscription_execution_strategy = Object.new
-      schema.subscription_execution_strategy(subscription_execution_strategy)
-      context_class = Class.new
-      schema.context_class(context_class)
-      schema.max_complexity(10)
-      schema.max_depth(20)
-      schema.default_max_page_size(30)
-      schema.error_bubbling(true)
-      schema.orphan_types(Jazz::InstrumentType)
-      schema.directives([DummyFeature2])
-      query_analyzer = Object.new
-      schema.query_analyzer(query_analyzer)
-      multiplex_analyzer = Object.new
-      schema.multiplex_analyzer(multiplex_analyzer)
-      schema.use(GraphQL::Execution::Interpreter)
-      schema.instrument(:field, GraphQL::Relay::ConnectionInstrumentation)
-      schema.rescue_from(GraphQL::ExecutionError)
-      schema.tracer(GraphQL::Tracing::NewRelicTracing)
-      schema.middleware(Proc.new {})
-
-      assert_equal query.graphql_definition, schema.query
-      assert_equal mutation.graphql_definition, schema.mutation
-      assert_equal subscription.graphql_definition, schema.subscription
-      assert_equal introspection, schema.introspection
-      assert_equal cursor_encoder, schema.cursor_encoder
-      assert_equal query_execution_strategy, schema.query_execution_strategy
-      assert_equal mutation_execution_strategy, schema.mutation_execution_strategy
-      assert_equal subscription_execution_strategy, schema.subscription_execution_strategy
-      assert_equal context_class, schema.context_class
-      assert_equal 10, schema.max_complexity
-      assert_equal 20, schema.max_depth
-      assert_equal 30, schema.default_max_page_size
-      assert schema.error_bubbling
-      assert_equal [Jazz::Ensemble, Jazz::InstrumentType], schema.orphan_types
-      assert_equal schema.directives, GraphQL::Schema.default_directives.merge(DummyFeature1.graphql_name => DummyFeature1, DummyFeature2.graphql_name => DummyFeature2)
-      assert_equal base_schema.query_analyzers + [query_analyzer], schema.query_analyzers
-      assert_equal base_schema.multiplex_analyzers + [multiplex_analyzer], schema.multiplex_analyzers
-      assert_equal [GraphQL::Backtrace, GraphQL::Execution::Interpreter], schema.plugins.map(&:first)
-      assert_equal [GraphQL::Relay::EdgesInstrumentation, GraphQL::Relay::ConnectionInstrumentation], schema.instrumenters[:field]
-      assert_equal [GraphQL::ExecutionError, StandardError], schema.rescues.keys.sort_by(&:name)
-      assert_equal [GraphQL::Tracing::DataDogTracing, GraphQL::Tracing::NewRelicTracing], schema.tracers
-      assert_equal 3, schema.middleware.steps.size
-    end
-  end
-
-  describe "when mixing define and class-based" do
-    module MixedSchema
-      class Query < GraphQL::Schema::Object
-        field :int, Int, null: false
-      end
-
-      class Mutation < GraphQL::Schema::Object
-        field :int, Int, null: false
-      end
-
-      class Subscription < GraphQL::Schema::Object
-        field :int, Int, null: false
-      end
-
-      Schema = GraphQL::Schema.define do
-        query(Query)
-        mutation(Mutation)
-        subscription(Subscription)
-      end
-    end
-
-    it "includes root types properly" do
-      res = MixedSchema::Schema.as_json
-      assert_equal "Query", res["data"]["__schema"]["queryType"]["name"]
-      assert_includes res["data"]["__schema"]["types"].map { |t| t["name"] }, "Query"
-
-      assert_equal "Mutation", res["data"]["__schema"]["mutationType"]["name"]
-      assert_includes res["data"]["__schema"]["types"].map { |t| t["name"] }, "Mutation"
-
-      assert_equal "Subscription", res["data"]["__schema"]["subscriptionType"]["name"]
-      assert_includes res["data"]["__schema"]["types"].map { |t| t["name"] }, "Subscription"
-    end
-  end
-end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -1,466 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
-  include StaticValidationHelpers
-  include ErrorBubblingHelpers
-
-  let(:query_string) {%|
-    query getCheese {
-      stringCheese: cheese(id: "aasdlkfj") { ...cheeseFields }
-      cheese(id: 1) { source @skip(if: "whatever") }
-      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { __typename }
-      badSource: searchDairy(product: {source: 1.1}) { __typename }
-      missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
-      listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
-      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese(source: 4.5) { __typename }
-    }
-  |}
-
-  describe "with error bubbling disabled" do
-    it "finds undefined or missing-required arguments to fields and directives" do
-      without_error_bubbling(schema) do
-        # `wacky` above is handled by ArgumentsAreDefined, missingSource is handled by RequiredInputObjectAttributesArePresent
-        # so only 4 are tested below
-        assert_equal(6, errors.length)
-
-        query_root_error = {
-          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
-          "locations"=>[{"line"=>3, "column"=>7}],
-          "path"=>["query getCheese", "stringCheese", "id"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
-        }
-        assert_includes(errors, query_root_error)
-
-        directive_error = {
-          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
-          "locations"=>[{"line"=>4, "column"=>30}],
-          "path"=>["query getCheese", "cheese", "source", "if"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
-        }
-        assert_includes(errors, directive_error)
-
-        input_object_field_error = {
-          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
-          "locations"=>[{"line"=>6, "column"=>39}],
-          "path"=>["query getCheese", "badSource", "product", 0, "source"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
-        }
-        assert_includes(errors, input_object_field_error)
-
-        fragment_error = {
-          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
-          "locations"=>[{"line"=>13, "column"=>7}],
-          "path"=>["fragment cheeseFields", "similarCheese", "source"],
-          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
-        }
-        assert_includes(errors, fragment_error)
-      end
-    end
-    it 'works with error bubbling enabled' do
-      with_error_bubbling(schema) do
-        assert_equal(9, errors.length)
-
-        query_root_error = {
-          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
-          "locations"=>[{"line"=>3, "column"=>7}],
-          "path"=>["query getCheese", "stringCheese", "id"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
-        }
-        assert_includes(errors, query_root_error)
-
-        directive_error = {
-          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
-          "locations"=>[{"line"=>4, "column"=>30}],
-          "path"=>["query getCheese", "cheese", "source", "if"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
-        }
-        assert_includes(errors, directive_error)
-
-        input_object_error = {
-          "message"=>"Argument 'product' on Field 'badSource' has an invalid value. Expected type '[DairyProductInput]'.",
-          "locations"=>[{"line"=>6, "column"=>7}],
-          "path"=>["query getCheese", "badSource", "product"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"},
-        }
-        assert_includes(errors, input_object_error)
-
-        input_object_field_error = {
-          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
-          "locations"=>[{"line"=>6, "column"=>39}],
-          "path"=>["query getCheese", "badSource", "product", 0, "source"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
-        }
-        assert_includes(errors, input_object_field_error)
-
-        missing_required_field_error = {
-          "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
-          "locations"=>[{"line"=>7, "column"=>7}],
-          "path"=>["query getCheese", "missingSource", "product"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"}
-        }
-        assert_includes(errors, missing_required_field_error)
-
-        fragment_error = {
-          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
-          "locations"=>[{"line"=>13, "column"=>7}],
-          "path"=>["fragment cheeseFields", "similarCheese", "source"],
-          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
-        }
-        assert_includes(errors, fragment_error)
-      end
-    end
-  end
-
-  describe "using input objects for enums it adds an error" do
-    let(:query_string) { <<-GRAPHQL
-      {
-        yakSource: searchDairy(product: [{source: {a: 1, b: 2}, fatContent: 1.1}]) { __typename }
-      }
-    GRAPHQL
-    }
-    it "works with error bubbling disabled" do
-      without_error_bubbling(schema) do
-        assert_equal 1, errors.length
-      end
-    end
-    it "works with error bubbling enabled" do
-      with_error_bubbling(schema) do
-        # TODO:
-        # It's annoying that this error cascades up, there should only be one:
-        assert_equal 2, errors.length
-      end
-    end
-  end
-
-  describe "null value" do
-    describe "nullable arg" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Int): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: null)
-        }
-      |}
-
-      it "finds no errors" do
-        assert_equal [], errors
-      end
-    end
-
-    describe "non-nullable arg" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Int!): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: null)
-        }
-      |}
-
-      it "finds error" do
-        assert_equal [{
-          "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Int!'.",
-          "locations"=>[{"line"=>3, "column"=>11}],
-          "path"=>["query", "field", "arg"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-        }], errors
-      end
-    end
-
-    describe "non-nullable array" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: [Int!]): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: [null])
-        }
-      |}
-
-      it "finds error" do
-        assert_equal [{
-          "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type '[Int!]'.",
-          "locations"=>[{"line"=>3, "column"=>11}],
-          "path"=>["query", "field", "arg"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-        }], errors
-      end
-    end
-
-    describe "array with nullable values" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: [Int]): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: [null])
-        }
-      |}
-
-      it "finds no errors" do
-        assert_equal [], errors
-      end
-    end
-
-    describe "input object" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Input): Int
-          }
-
-          input Input {
-            a: Int
-            b: Int!
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: {a: null, b: null})
-        }
-      |}
-
-      describe "it finds errors" do
-        it "works with error bubbling disabled" do
-          without_error_bubbling(schema) do
-            assert_equal 1, errors.length
-            refute_includes errors, {
-              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
-              "locations"=>[{"line"=>3, "column"=>11}],
-              "path"=>["query", "field", "arg"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-            }
-            assert_includes errors, {
-              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-              "locations"=>[{"line"=>3, "column"=>22}],
-              "path"=>["query", "field", "arg", "b"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
-            }
-          end
-        end
-        it "works with error bubbling enabled" do
-          with_error_bubbling(schema) do
-            assert_equal 2, errors.length
-            assert_includes errors, {
-              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
-              "locations"=>[{"line"=>3, "column"=>11}],
-              "path"=>["query", "field", "arg"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-            }
-
-            assert_includes errors, {
-              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-              "locations"=>[{"line"=>3, "column"=>22}],
-              "path"=>["query", "field", "arg", "b"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
-            }
-          end
-        end
-      end
-    end
-  end
-
-  describe "dynamic fields" do
-    let(:query_string) {"
-      query {
-        __type(name: 1) { name }
-      }
-    "}
-
-    it "finds invalid argument types" do
-      assert_includes(errors, {
-        "message"=>"Argument 'name' on Field '__type' has an invalid value. Expected type 'String!'.",
-        "locations"=>[{"line"=>3, "column"=>9}],
-        "path"=>["query", "__type", "name"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"name"}
-      })
-    end
-  end
-
-  describe "custom error messages" do
-    let(:schema) {
-      CoerceTestTimeType ||= GraphQL::ScalarType.define do
-        name "Time"
-        description "Time since epoch in seconds"
-
-        coerce_input ->(value, ctx) do
-          begin
-            Time.at(Float(value))
-          rescue ArgumentError
-            raise GraphQL::CoercionError, 'cannot coerce to Float'
-          end
-        end
-
-        coerce_result ->(value, ctx) { value.to_f }
-      end
-
-      CoerceTestDeepTimeType ||= GraphQL::InputObjectType.define do
-        name "range"
-        description "Time range"
-        argument :from, !CoerceTestTimeType
-        argument :to, !CoerceTestTimeType
-      end
-
-      CoerceTestQueryType ||= GraphQL::ObjectType.define do
-        name "Query"
-        description "The query root of this schema"
-
-        field :time do
-          type CoerceTestTimeType
-          argument :value, CoerceTestTimeType
-          argument :range, CoerceTestDeepTimeType
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-
-      GraphQL::Schema.define do
-        query CoerceTestQueryType
-      end
-    }
-
-    let(:query_string) {%|
-      query {
-        time(value: "a")
-      }
-    |}
-
-    describe "with a shallow coercion" do
-      it "sets error message from a CoercionError if raised" do
-        assert_equal 1, errors.length
-
-        assert_includes errors, {
-          "message"=> "cannot coerce to Float",
-          "locations"=>[{"line"=>3, "column"=>9}],
-          "path"=>["query", "time", "value"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"}
-        }
-      end
-    end
-
-    describe "with a deep coercion" do
-      let(:query_string) {%|
-        query {
-          time(range: { from: "a", to: "b" })
-        }
-      |}
-
-      from_error = {
-        "message"=>"cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>23}],
-        "path"=>["query", "time", "range", "from"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      to_error = {
-        "message"=>"cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>23}],
-        "path"=>["query", "time", "range", "to"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      bubbling_error = {
-        "message"=>"cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>11}],
-        "path"=>["query", "time", "range"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      describe "sets deep error message from a CoercionError if raised" do
-        it "works with error bubbling enabled" do
-          with_error_bubbling(schema) do
-            assert_equal 3, errors.length
-            assert_includes(errors, from_error)
-            assert_includes(errors, to_error)
-            assert_includes(errors, bubbling_error)
-          end
-        end
-
-        it "works without error bubbling enabled" do
-          without_error_bubbling(schema) do
-            assert_equal 2, errors.length
-            assert_includes(errors, from_error)
-            assert_includes(errors, to_error)
-            refute_includes(errors, bubbling_error)
-          end
-        end
-      end
-    end
-  end
-
-  describe "custom error extensions" do
-    let(:schema) {
-      CoerceTestEmailType ||= GraphQL::ScalarType.define do
-        name "Email"
-        description "Email address"
-
-        coerce_input ->(value, ctx) do
-          if URI::MailTo::EMAIL_REGEXP.match(value)
-            value
-          else
-            raise GraphQL::CoercionError.new("Invalid email address", extensions: { "code" => "invalid_email_address" })
-          end
-        end
-
-        coerce_result ->(value, ctx) { value.to_f }
-      end
-
-      CoerceTestEmailQueryType ||= GraphQL::ObjectType.define do
-        name "Query"
-        description "The query root of this schema"
-
-        field :email do
-          type CoerceTestEmailType
-          argument :value, CoerceTestEmailType
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-      GraphQL::Schema.define do
-        query CoerceTestEmailQueryType
-      end
-    }
-
-    let(:query_string) {%|
-      query {
-        email(value: "a")
-      }
-    |}
-
-    describe "with a shallow coercion" do
-      it "sets error extensions code from a CoercionError if raised" do
-        assert_equal 1, errors.length
-
-        assert_includes errors, {
-          "message"=> "Invalid email address",
-          "locations"=>[{"line"=>3, "column"=>9}],
-          "path"=>["query", "email", "value"],
-          "extensions"=>{"code"=>"invalid_email_address", "typeName"=>"CoercionError"}
-        }
-      end
-    end
-  end
-end