graphql_cody 1.13.0

data/lib/graphql/compatibility/execution_specification/counter_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module GraphQL
+  module Compatibility
+    module ExecutionSpecification
+      module CounterSchema
+        def self.build(execution_strategy)
+          counter_type = nil
+          schema = nil
+
+          has_count_interface = GraphQL::InterfaceType.define do
+            name "HasCount"
+            field :count, types.Int
+            field :counter, ->{ has_count_interface }
+          end
+
+          counter_type = GraphQL::ObjectType.define do
+            name "Counter"
+            interfaces [has_count_interface]
+            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          alt_counter_type = GraphQL::ObjectType.define do
+            name "AltCounter"
+            interfaces [has_count_interface]
+            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          has_counter_interface = GraphQL::InterfaceType.define do
+            name "HasCounter"
+            field :counter, has_count_interface
+          end
+
+          query_type = GraphQL::ObjectType.define do
+            name "Query"
+            interfaces [has_counter_interface]
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          schema = GraphQL::Schema.define(
+            query: query_type,
+            resolve_type: ->(t, o, c) { o == :counter ? counter_type : nil },
+            orphan_types: [alt_counter_type, counter_type],
+            query_execution_strategy: execution_strategy,
+          )
+          schema.metadata[:count] = 0
+          schema
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+module GraphQL
+  module Compatibility
+    module ExecutionSpecification
+      module SpecificationSchema
+        BOGUS_NODE = OpenStruct.new({ bogus: true })
+
+        DATA = {
+          "1001" => OpenStruct.new({
+            name: "Fannie Lou Hamer",
+            birthdate: Time.new(1917, 10, 6),
+            organization_ids: [],
+          }),
+          "1002" => OpenStruct.new({
+            name: "John Lewis",
+            birthdate: Time.new(1940, 2, 21),
+            organization_ids: ["2001"],
+          }),
+          "1003" => OpenStruct.new({
+            name: "Diane Nash",
+            birthdate: Time.new(1938, 5, 15),
+            organization_ids: ["2001", "2002"],
+          }),
+          "1004" => OpenStruct.new({
+            name: "Ralph Abernathy",
+            birthdate: Time.new(1926, 3, 11),
+            organization_ids: ["2002"],
+          }),
+          "2001" => OpenStruct.new({
+            name: "SNCC",
+            leader_id: nil, # fail on purpose
+          }),
+          "2002" => OpenStruct.new({
+            name: "SCLC",
+            leader_id: "1004",
+          }),
+          "2003" => BOGUS_NODE,
+        }
+
+        # A list object must implement #each
+        class CustomCollection
+          def initialize(storage)
+            @storage = storage
+          end
+
+          def each(&block)
+            @storage.each(&block)
+          end
+        end
+
+        module TestMiddleware
+          def self.call(parent_type, parent_object, field_definition, field_args, query_context, &next_middleware)
+            query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
+            next_middleware.call
+          end
+        end
+
+        def self.build(execution_strategy)
+          organization_type = nil
+
+          timestamp_type = GraphQL::ScalarType.define do
+            name "Timestamp"
+            coerce_input ->(value, _ctx) { Time.at(value.to_i) }
+            coerce_result ->(value, _ctx) { value.to_i }
+          end
+
+          named_entity_interface_type = GraphQL::InterfaceType.define do
+            name "NamedEntity"
+            field :name, !types.String
+          end
+
+          person_type = GraphQL::ObjectType.define do
+            name "Person"
+            interfaces [named_entity_interface_type]
+            field :name, !types.String
+            field :birthdate, timestamp_type
+            field :age, types.Int do
+              argument :on, !timestamp_type
+              resolve ->(obj, args, ctx) {
+                if obj.birthdate.nil?
+                  nil
+                else
+                  age_on = args[:on]
+                  age_years = age_on.year - obj.birthdate.year
+                  this_year_birthday = Time.new(age_on.year, obj.birthdate.month, obj.birthdate.day)
+                  if this_year_birthday > age_on
+                    age_years -= 1
+                  end
+                end
+                age_years
+              }
+            end
+            field :organizations, types[organization_type] do
+              resolve ->(obj, args, ctx) {
+                CustomCollection.new(obj.organization_ids.map { |id| DATA[id] })
+              }
+            end
+            field :first_organization, !organization_type do
+              resolve ->(obj, args, ctx) {
+                DATA[obj.organization_ids.first]
+              }
+            end
+          end
+
+          organization_type = GraphQL::ObjectType.define do
+            name "Organization"
+            interfaces [named_entity_interface_type]
+            field :name, !types.String
+            field :leader, !person_type do
+              resolve ->(obj, args, ctx) {
+                DATA[obj.leader_id] || (ctx[:return_error] ? ExecutionError.new("Error on Nullable") : nil)
+              }
+            end
+            field :returnedError, types.String do
+              resolve ->(o, a, c) {
+                GraphQL::ExecutionError.new("This error was returned")
+              }
+            end
+            field :raisedError, types.String do
+              resolve ->(o, a, c) {
+                raise GraphQL::ExecutionError.new("This error was raised")
+              }
+            end
+
+            field :nodePresence, !types[!types.Boolean] do
+              resolve ->(o, a, ctx) {
+                [
+                  ctx.irep_node.is_a?(GraphQL::InternalRepresentation::Node),
+                  ctx.ast_node.is_a?(GraphQL::Language::Nodes::AbstractNode),
+                  false, # just testing
+                ]
+              }
+            end
+          end
+
+          node_union_type = GraphQL::UnionType.define do
+            name "Node"
+            possible_types [person_type, organization_type]
+          end
+
+          query_type = GraphQL::ObjectType.define do
+            name "Query"
+            field :node, node_union_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                obj[args[:id]]
+              }
+            end
+
+            field :requiredNode, node_union_type.to_non_null_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                obj[args[:id]]
+              }
+            end
+
+            field :organization, !organization_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                if args[:id].start_with?("2")
+                  obj[args[:id]]
+                else
+                  # test context.skip
+                  ctx.skip
+                end
+              }
+            end
+
+            field :organizations, types[organization_type] do
+              resolve ->(obj, args, ctx) {
+                [obj["2001"], obj["2002"]]
+              }
+            end
+          end
+
+          GraphQL::Schema.define do
+            query_execution_strategy execution_strategy
+            query query_type
+
+            resolve_type ->(type, obj, ctx) {
+              if obj.respond_to?(:birthdate)
+                person_type
+              elsif obj.respond_to?(:leader_id)
+                organization_type
+              else
+                nil
+              end
+            }
+
+            type_error ->(err, ctx) {
+              ctx[:type_errors] && (ctx[:type_errors] << err.value)
+              ctx[:gobble] || GraphQL::Schema::DefaultTypeError.call(err, ctx)
+            }
+            middleware(TestMiddleware)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/execution_specification.rb

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+require "graphql/compatibility/execution_specification/counter_schema"
+require "graphql/compatibility/execution_specification/specification_schema"
+
+module GraphQL
+  module Compatibility
+    # Test an execution strategy. This spec is not meant as a development aid.
+    # Rather, when the strategy _works_, run it here to see if it has any differences
+    # from the built-in strategy.
+    #
+    # - Custom scalar input / output
+    # - Null propagation
+    # - Query-level masking
+    # - Directive support
+    # - Typecasting
+    # - Error handling (raise / return GraphQL::ExecutionError)
+    # - Provides Irep & AST node to resolve fn
+    # - Skipping fields
+    #
+    # Some things are explicitly _not_ tested here, because they're handled
+    # by other parts of the system:
+    #
+    # - Schema definition (including types and fields)
+    # - Parsing & parse errors
+    # - AST -> IRep transformation (eg, fragment merging)
+    # - Query validation and analysis
+    # - Relay features
+    #
+    module ExecutionSpecification
+      # Make a minitest suite for this execution strategy, making sure it
+      # fulfills all the requirements of this library.
+      # @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 :counter_schema, :specification_schema
+          end
+
+          self.specification_schema = SpecificationSchema.build(execution_strategy)
+          self.counter_schema = CounterSchema.build(execution_strategy)
+
+          def execute_query(query_string, **kwargs)
+            kwargs[:root_value] = SpecificationSchema::DATA
+            self.class.specification_schema.execute(query_string, **kwargs)
+          end
+
+          def test_it_fetches_data
+            query_string = %|
+            query getData($nodeId: ID = "1001") {
+              flh: node(id: $nodeId) {
+                __typename
+                ... on Person {
+                  name @include(if: true)
+                  skippedName: name @skip(if: true)
+                  birthdate
+                  age(on: 1477660133)
+                }
+
+                ... on NamedEntity {
+                  ne_tn: __typename
+                  ne_n: name
+                }
+
+                ... on Organization {
+                  org_n: name
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+
+            assert_equal nil, res["errors"], "It doesn't have an errors key"
+
+            flh = res["data"]["flh"]
+            assert_equal "Fannie Lou Hamer", flh["name"], "It returns values"
+            assert_equal Time.new(1917, 10, 6).to_i, flh["birthdate"], "It returns custom scalars"
+            assert_equal 99, flh["age"], "It runs resolve functions"
+            assert_equal "Person", flh["__typename"], "It serves __typename"
+            assert_equal "Person", flh["ne_tn"], "It serves __typename on interfaces"
+            assert_equal "Fannie Lou Hamer", flh["ne_n"], "It serves interface fields"
+            assert_equal false, flh.key?("skippedName"), "It obeys @skip"
+            assert_equal false, flh.key?("org_n"), "It doesn't apply other type fields"
+          end
+
+          def test_it_iterates_over_each
+            query_string = %|
+              query getData($nodeId: ID = "1002") {
+                node(id: $nodeId) {
+                  ... on Person {
+                    organizations { name }
+                  }
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+            assert_equal ["SNCC"], res["data"]["node"]["organizations"].map { |o| o["name"] }
+          end
+
+          def test_it_skips_skipped_fields
+            query_str = <<-GRAPHQL
+            {
+              o3001: organization(id: "3001")  { name }
+              o2001: organization(id: "2001")  { name }
+            }
+            GRAPHQL
+
+            res = execute_query(query_str)
+            assert_equal ["o2001"], res["data"].keys
+            assert_equal false, res.key?("errors")
+          end
+
+          def test_it_propagates_nulls_to_field
+            query_string = %|
+            query getOrg($id: ID = "2001"){
+              failure: node(id: $id) {
+                ... on Organization {
+                  name
+                  leader { name }
+                }
+              }
+              success: node(id: $id) {
+                ... on Organization {
+                  name
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+
+            failure = res["data"]["failure"]
+            success = res["data"]["success"]
+
+            assert_equal nil, failure, "It propagates nulls to the next nullable field"
+            assert_equal({"name" => "SNCC"}, success, "It serves the same object if no invalid null is encountered")
+            assert_equal 1, res["errors"].length , "It returns an error for the invalid null"
+          end
+
+          def test_it_propages_nulls_to_operation
+            query_string = %|
+              {
+                foundOrg: organization(id: "2001") {
+                  name
+                }
+                organization(id: "2999") {
+                  name
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+            assert_equal nil, res["data"]
+            assert_equal 1, res["errors"].length
+          end
+
+          def test_it_exposes_raised_and_returned_user_execution_errors
+            query_string = %|
+              {
+                organization(id: "2001") {
+                  name
+                  returnedError
+                  raisedError
+                }
+                organizations {
+                  returnedError
+                  raisedError
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+
+            assert_equal "SNCC", res["data"]["organization"]["name"], "It runs the rest of the query"
+
+            expected_errors = [
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>5, "column"=>19}],
+                "path"=>["organization", "returnedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>6, "column"=>19}],
+                "path"=>["organization", "raisedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>10, "column"=>19}],
+                "path"=>["organizations", 0, "raisedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>10, "column"=>19}],
+                "path"=>["organizations", 1, "raisedError"]
+              },
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>9, "column"=>19}],
+                "path"=>["organizations", 0, "returnedError"]
+              },
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>9, "column"=>19}],
+                "path"=>["organizations", 1, "returnedError"]
+              },
+            ]
+
+            expected_errors.each do |expected_err|
+              assert_includes res["errors"], expected_err
+            end
+          end
+
+          def test_it_applies_masking
+            no_org = ->(member, ctx) { member.name == "Organization" }
+            query_string = %|
+            {
+              node(id: "2001") {
+                __typename
+              }
+            }|
+
+            err = assert_raises(GraphQL::UnresolvedTypeError) {
+              execute_query(query_string, except: no_org)
+            }
+
+            query_string = %|
+            {
+              organization(id: "2001") { name }
+            }|
+
+            res = execute_query(query_string, except: no_org)
+
+            assert_equal nil, res["data"]
+            assert_equal 1, res["errors"].length
+            assert_equal "SNCC", err.value.name
+            assert_equal GraphQL::Relay::Node.interface, err.field.type
+            assert_equal 1, err.possible_types.length
+            assert_equal "Organization", err.resolved_type.name
+            assert_equal "Query", err.parent_type.name
+
+            query_string = %|
+            {
+              __type(name: "Organization") { name }
+            }|
+
+            res = execute_query(query_string, except: no_org)
+
+            assert_equal nil, res["data"]["__type"]
+            assert_equal nil, res["errors"]
+          end
+
+          def test_it_provides_nodes_to_resolve
+            query_string = %|
+            {
+              organization(id: "2001") {
+                name
+                nodePresence
+              }
+            }|
+
+            res = execute_query(query_string)
+            assert_equal "SNCC", res["data"]["organization"]["name"]
+            assert_equal [true, true, false], res["data"]["organization"]["nodePresence"]
+          end
+
+          def test_it_runs_the_introspection_query
+            execute_query(GraphQL::Introspection::INTROSPECTION_QUERY)
+          end
+
+          def test_it_propagates_deeply_nested_nulls
+            query_string = %|
+            {
+              node(id: "1001") {
+                ... on Person {
+                  name
+                  first_organization {
+                    leader {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+            assert_equal nil, res["data"]["node"]
+            assert_equal 1, res["errors"].length
+          end
+
+          def test_it_doesnt_add_errors_for_invalid_nulls_from_execution_errors
+            query_string = %|
+            query getOrg($id: ID = "2001"){
+              failure: node(id: $id) {
+                ... on Organization {
+                  name
+                  leader { name }
+                }
+              }
+            }
+            |
+            res = execute_query(query_string, context: {return_error: true})
+            error_messages = res["errors"].map { |e| e["message"] }
+            assert_equal ["Error on Nullable"], error_messages
+          end
+
+          def test_it_only_resolves_fields_once_on_typed_fragments
+            res = self.class.counter_schema.execute("
+            {
+              counter { count }
+              ... on HasCounter {
+                counter { count }
+              }
+            }
+            ")
+
+            expected_data = {
+              "counter" => { "count" => 1 }
+            }
+            assert_equal expected_data, res["data"]
+            assert_equal 1, self.class.counter_schema.metadata[:count]
+
+            # Deep typed children are correctly distinguished:
+            res = self.class.counter_schema.execute("
+            {
+              counter {
+                ... on Counter {
+                  counter { count }
+                }
+                ... on AltCounter {
+                  counter { count, t: __typename }
+                }
+              }
+            }
+            ")
+
+            expected_data = {
+              "counter" => { "counter" => { "count" => 2 } }
+            }
+            assert_equal expected_data, res["data"]
+          end
+
+          def test_it_runs_middleware
+            log = []
+            query_string = %|
+            {
+              node(id: "2001") {
+                __typename
+              }
+            }|
+            execute_query(query_string, context: {middleware_log: log})
+            assert_equal ["node", "__typename"], log
+          end
+
+          def test_it_uses_type_error_hooks_for_invalid_nulls
+            log = []
+            query_string = %|
+            {
+              node(id: "1001") {
+                ... on Person {
+                  name
+                  first_organization {
+                    leader {
+                      name
+                    }
+                  }
+                }
+              }
+            }|
+
+            res = execute_query(query_string, context: { type_errors: log })
+            assert_equal nil, res["data"]["node"]
+            assert_equal [nil], log
+          end
+
+          def test_it_uses_type_error_hooks_for_failed_type_resolution
+            log = []
+            query_string = %|
+            {
+              node(id: "2003") {
+                __typename
+              }
+            }|
+
+            assert_raises(GraphQL::UnresolvedTypeError) {
+              execute_query(query_string, context: { type_errors: log })
+            }
+
+            assert_equal [SpecificationSchema::BOGUS_NODE], log
+          end
+
+          def test_it_treats_failed_type_resolution_like_nil
+            log = []
+            ctx = { type_errors: log, gobble: true }
+            query_string = %|
+            {
+              node(id: "2003") {
+                __typename
+              }
+            }|
+
+            res = execute_query(query_string, context: ctx)
+
+            assert_equal nil, res["data"]["node"]
+            assert_equal false, res.key?("errors")
+            assert_equal [SpecificationSchema::BOGUS_NODE], log
+
+            query_string_2 = %|
+            {
+              requiredNode(id: "2003") {
+                __typename
+              }
+            }|
+
+            res = execute_query(query_string_2, context: ctx)
+
+            assert_equal nil, res["data"]
+            assert_equal false, res.key?("errors")
+            assert_equal [SpecificationSchema::BOGUS_NODE, SpecificationSchema::BOGUS_NODE], log
+          end
+
+          def test_it_skips_connections
+            query_type = GraphQL::ObjectType.define do
+              name "Query"
+              connection :skipped, types[query_type], resolve: ->(o,a,c) { c.skip }
+            end
+            schema = GraphQL::Schema.define(query: query_type)
+            res = schema.execute("{ skipped { __typename } }")
+            assert_equal({"data" => nil}, res)
+          end
+        end
+      end
+    end
+  end
+end