graphql_cody 1.13.0

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

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

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

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

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