graphql 1.13.14 → 2.0.0

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

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

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