graphql 1.13.10 → 2.0.0

data/lib/graphql/compatibility/lazy_execution_specification/lazy_schema.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Compatibility
-    module LazyExecutionSpecification
-      module LazySchema
-        class LazyPush
-          attr_reader :value
-          def initialize(ctx, value)
-            if value == 13
-              @value = nil
-            elsif value == 14
-              @value = GraphQL::ExecutionError.new("oops!")
-            elsif value == 15
-              @skipped = true
-              @value = ctx.skip
-            else
-              @value = value
-            end
-            @context = ctx
-            pushes = @context[:lazy_pushes] ||= []
-            if !@skipped
-              pushes << @value
-            end
-          end
-
-          def push
-            if @skipped
-              @value
-            else
-              if @context[:lazy_pushes].include?(@value)
-                @context[:lazy_instrumentation] && @context[:lazy_instrumentation] << "PUSH"
-                @context[:pushes] << @context[:lazy_pushes]
-                @context[:lazy_pushes] = []
-              end
-              # Something that _behaves_ like this object, but isn't registered lazy
-              OpenStruct.new(value: @value)
-            end
-          end
-        end
-
-        class LazyPushCollection
-          def initialize(ctx, values)
-            @ctx = ctx
-            @values = values
-          end
-
-          def push
-            @values.map { |v| LazyPush.new(@ctx, v) }
-          end
-
-          def value
-            @values
-          end
-        end
-
-        module LazyInstrumentation
-          def self.instrument(type, field)
-            prev_lazy_resolve = field.lazy_resolve_proc
-            field.redefine {
-              lazy_resolve ->(o, a, c) {
-                result = prev_lazy_resolve.call(o, a, c)
-                c[:lazy_instrumentation] && c[:lazy_instrumentation].push("#{type.name}.#{field.name}: #{o.value}")
-                result
-              }
-            }
-          end
-        end
-
-        def self.build(execution_strategy)
-          lazy_push_type = GraphQL::ObjectType.define do
-            name "LazyPush"
-            field :value, !types.Int
-            field :push, !lazy_push_type do
-              argument :value, types.Int
-              resolve ->(o, a, c) {
-                LazyPush.new(c, a[:value])
-              }
-            end
-          end
-
-          query_type = GraphQL::ObjectType.define do
-            name "Query"
-            field :push, !lazy_push_type do
-              argument :value, types.Int
-              resolve ->(o, a, c) {
-                LazyPush.new(c, a[:value])
-              }
-            end
-
-            connection :pushes, lazy_push_type.connection_type do
-              argument :values, types[types.Int], method_access: false
-              resolve ->(o, a, c) {
-                LazyPushCollection.new(c, a[:values])
-              }
-            end
-          end
-
-          GraphQL::Schema.define do
-            query(query_type)
-            mutation(query_type)
-            query_execution_strategy(execution_strategy)
-            mutation_execution_strategy(execution_strategy)
-            lazy_resolve(LazyPush, :push)
-            lazy_resolve(LazyPushCollection, :push)
-            instrument(:field, LazyInstrumentation)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-require "graphql/compatibility/lazy_execution_specification/lazy_schema"
-
-module GraphQL
-  module Compatibility
-    module LazyExecutionSpecification
-      # @param execution_strategy [<#new, #execute>] An execution strategy class
-      # @return [Class<Minitest::Test>] A test suite for this execution strategy
-      def self.build_suite(execution_strategy)
-        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
-
-        Class.new(Minitest::Test) do
-          class << self
-            attr_accessor :lazy_schema
-          end
-
-          self.lazy_schema = LazySchema.build(execution_strategy)
-
-          def test_it_resolves_lazy_values
-            pushes = []
-            query_str = %|
-            {
-              p1: push(value: 1) {
-                value
-              }
-              p2: push(value: 2) {
-                push(value: 3) {
-                  value
-                  push(value: 21) {
-                    value
-                  }
-                }
-              }
-              p3: push(value: 4) {
-                push(value: 5) {
-                  value
-                  push(value: 22) {
-                    value
-                  }
-                }
-              }
-            }
-            |
-            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
-
-            expected_data = {
-              "p1"=>{"value"=>1},
-              "p2"=>{"push"=>{"value"=>3, "push"=>{"value"=>21}}},
-              "p3"=>{"push"=>{"value"=>5, "push"=>{"value"=>22}}},
-            }
-            assert_equal expected_data, res["data"]
-
-            expected_pushes = [
-              [1,2,4], # first level
-              [3,5], # second level
-              [21, 22],
-            ]
-            assert_equal expected_pushes, pushes
-          end
-
-          def test_it_maintains_path
-            query_str = %|
-            {
-              push(value: 2) {
-                push(value: 3) {
-                  fail1: push(value: 14) {
-                    value
-                  }
-                  fail2: push(value: 14) {
-                    value
-                  }
-                }
-              }
-            }
-            |
-            res = self.class.lazy_schema.execute(query_str, context: {pushes: []})
-            assert_equal nil, res["data"]
-            # The first fail causes the second field to never resolve
-            assert_equal 1, res["errors"].length
-            assert_equal ["push", "push", "fail1", "value"], res["errors"][0]["path"]
-          end
-
-          def test_it_resolves_mutation_values_eagerly
-            pushes = []
-            query_str = %|
-            mutation {
-              p1: push(value: 1) {
-                value
-              }
-              p2: push(value: 2) {
-                push(value: 3) {
-                  value
-                }
-              }
-              p3: push(value: 4) {
-                p5: push(value: 5) {
-                  value
-                }
-                p6: push(value: 6) {
-                  value
-                }
-              }
-            }
-            |
-            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
-
-            expected_data = {
-              "p1"=>{"value"=>1},
-              "p2"=>{"push"=>{"value"=>3}},
-              "p3"=>{"p5"=>{"value"=>5},"p6"=>{"value"=>6}},
-            }
-            assert_equal expected_data, res["data"]
-
-            expected_pushes = [
-              [1],        # first operation
-              [2], [3],   # second operation
-              [4], [5, 6], # third operation
-            ]
-            assert_equal expected_pushes, pushes
-          end
-
-          def test_it_resolves_lazy_connections
-            pushes = []
-            query_str = %|
-            {
-              pushes(values: [1,2,3]) {
-                edges {
-                  node {
-                    value
-                    push(value: 4) {
-                      value
-                    }
-                  }
-                }
-              }
-            }
-            |
-            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
-
-            expected_edges = [
-              {"node"=>{"value"=>1, "push"=>{"value"=>4}}},
-              {"node"=>{"value"=>2, "push"=>{"value"=>4}}},
-              {"node"=>{"value"=>3, "push"=>{"value"=>4}}},
-            ]
-            assert_equal expected_edges, res["data"]["pushes"]["edges"]
-            assert_equal [[1, 2, 3], [4, 4, 4]], pushes
-          end
-
-          def test_it_calls_lazy_resolve_instrumentation
-            query_str = %|
-            {
-              p1: push(value: 1) {
-                value
-              }
-              p2: push(value: 2) {
-                push(value: 3) {
-                  value
-                }
-              }
-              pushes(values: [1,2,3]) {
-                edges {
-                  node {
-                    value
-                    push(value: 4) {
-                      value
-                    }
-                  }
-                }
-              }
-            }
-            |
-
-            log = []
-            self.class.lazy_schema.execute(query_str, context: {lazy_instrumentation: log, pushes: []})
-            expected_log = [
-              "PUSH",
-              "Query.push: 1",
-              "Query.push: 2",
-              "Query.pushes: [1, 2, 3]",
-              "PUSH",
-              "LazyPush.push: 3",
-              "LazyPushEdge.node: 1",
-              "LazyPushEdge.node: 2",
-              "LazyPushEdge.node: 3",
-              "PUSH",
-              "LazyPush.push: 4",
-              "LazyPush.push: 4",
-              "LazyPush.push: 4",
-            ]
-            assert_equal expected_log, log
-          end
-
-          def test_it_skips_ctx_skip
-            query_string = <<-GRAPHQL
-            {
-              p0: push(value: 15) { value }
-              p1: push(value: 1) { value }
-              p2: push(value: 2) {
-                value
-                p3: push(value: 15) {
-                  value
-                }
-              }
-            }
-            GRAPHQL
-            pushes = []
-            res = self.class.lazy_schema.execute(query_string, context: {pushes: pushes})
-            assert_equal [[1,2]], pushes
-            assert_equal({"data"=>{"p1"=>{"value"=>1}, "p2"=>{"value"=>2}}}, res)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Compatibility
-    module QueryParserSpecification
-      module ParseErrorSpecification
-        def assert_raises_parse_error(query_string)
-          assert_raises(GraphQL::ParseError) {
-            parse(query_string)
-          }
-        end
-
-        def test_it_includes_line_and_column
-          err = assert_raises_parse_error("
-            query getCoupons {
-              allCoupons: {data{id}}
-            }
-          ")
-
-          assert_includes(err.message, '{')
-          assert_equal(3, err.line)
-          assert_equal(27, err.col)
-        end
-
-        def test_it_rejects_unterminated_strings
-          assert_raises_parse_error('{ " }')
-          assert_raises_parse_error(%|{ "\n" }|)
-        end
-
-        def test_it_rejects_unexpected_ends
-          assert_raises_parse_error("query { stuff { thing }")
-        end
-
-        def assert_rejects_character(char)
-          err = assert_raises_parse_error("{ field#{char} }")
-          expected_char = char.inspect.gsub('"', '').downcase
-          msg_downcase = err.message.downcase
-          # Case-insensitive for UTF-8 printing
-          assert_includes(msg_downcase, expected_char, "The message includes the invalid character")
-        end
-
-        def test_it_rejects_invalid_characters
-          assert_rejects_character(";")
-          assert_rejects_character("\a")
-          assert_rejects_character("\xef")
-          assert_rejects_character("\v")
-          assert_rejects_character("\f")
-          assert_rejects_character("\xa0")
-        end
-
-        def test_it_rejects_bad_unicode
-          assert_raises_parse_error(%|{ field(arg:"\\x") }|)
-          assert_raises_parse_error(%|{ field(arg:"\\u1") }|)
-          assert_raises_parse_error(%|{ field(arg:"\\u0XX1") }|)
-          assert_raises_parse_error(%|{ field(arg:"\\uXXXX") }|)
-          assert_raises_parse_error(%|{ field(arg:"\\uFXXX") }|)
-          assert_raises_parse_error(%|{ field(arg:"\\uXXXF") }|)
-        end
-
-        def test_it_rejects_empty_inline_fragments
-          assert_raises_parse_error("
-            query {
-              viewer {
-                login {
-                  ... on String {
-
-                  }
-                }
-              }
-            }
-          ")
-        end
-
-        def test_it_rejects_blank_queries
-          assert_raises_parse_error("")
-          assert_raises_parse_error(" ")
-          assert_raises_parse_error("\t \t")
-          assert_raises_parse_error(" # comment ")
-        end
-
-        def test_it_restricts_on
-          assert_raises_parse_error("{ ...on }")
-          assert_raises_parse_error("fragment on on Type { field }")
-        end
-      end
-    end
-  end
-end

data/lib/graphql/compatibility/query_parser_specification/query_assertions.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Compatibility
-    module QueryParserSpecification
-      module QueryAssertions
-        def assert_valid_query(query)
-          assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-          assert_equal "getStuff", query.name
-          assert_equal "query", query.operation_type
-          assert_equal 2, query.variables.length
-          assert_equal 4, query.selections.length
-          assert_equal 1, query.directives.length
-          assert_equal [2, 13], [query.line, query.col]
-        end
-
-        def assert_valid_fragment(fragment_def)
-          assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-          assert_equal "moreNestedFields", fragment_def.name
-          assert_equal 1, fragment_def.selections.length
-          assert_equal "NestedType", fragment_def.type.name
-          assert_equal 1, fragment_def.directives.length
-          assert_equal [20, 13], fragment_def.position
-        end
-
-        def assert_valid_variable(variable)
-          assert_equal "someVar", variable.name
-          assert_equal "Int", variable.type.name
-          assert_equal 1, variable.default_value
-          assert_equal [2, 28], variable.position
-        end
-
-        def assert_valid_field(field)
-          assert_equal "someField", field.name
-          assert_equal "myField", field.alias
-          assert_equal 2, field.directives.length
-          assert_equal 2, field.arguments.length
-          assert_equal 0, field.selections.length
-          assert_equal [3, 15], field.position
-        end
-
-        def assert_valid_literal_argument(argument)
-          assert_equal "ok", argument.name
-          assert_equal 1.4, argument.value
-        end
-
-        def assert_valid_variable_argument(argument)
-          assert_equal "someArg", argument.name
-          assert_equal "someVar", argument.value.name
-        end
-
-        def assert_valid_fragment_spread(fragment_spread)
-          assert_equal "moreNestedFields", fragment_spread.name
-          assert_equal 1, fragment_spread.directives.length
-          assert_equal [7, 17], fragment_spread.position
-        end
-
-        def assert_valid_directive(directive)
-          assert_equal "skip", directive.name
-          assert_equal "if", directive.arguments.first.name
-          assert_equal 1, directive.arguments.length
-          assert_equal [3, 62], directive.position
-        end
-
-        def assert_valid_typed_inline_fragment(inline_fragment)
-          assert_equal "OtherType", inline_fragment.type.name
-          assert_equal 2, inline_fragment.selections.length
-          assert_equal 1, inline_fragment.directives.length
-          assert_equal [10, 15], inline_fragment.position
-        end
-
-        def assert_valid_typeless_inline_fragment(inline_fragment)
-          assert_equal nil, inline_fragment.type
-          assert_equal 1, inline_fragment.selections.length
-          assert_equal 0, inline_fragment.directives.length
-        end
-      end
-    end
-  end
-end