Test errors, enum values, direct get_type and get_field calls

Author: rmosolgo

lib/graphql/schema.rb

@@ -368,7 +368,8 @@ def types(context = GraphQL::Query::NullContext.instance)
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
       def get_type(type_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
         if use_visibility_profile
-          return Visibility::Profile.from_context(context, self).type(type_name)
+          profile = Visibility::Profile.from_context(context, self)
+          return profile.type(type_name)
         end
         local_entry = own_types[type_name]
         type_defn = case local_entry
@@ -700,7 +701,21 @@ def type_from_ast(ast_node, context: self.query_class.new(self, "{ __typename }"
         GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
-      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
+      def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance, use_visibility_profile = use_visibility_profile?)
+        if use_visibility_profile
+          profile = Visibility::Profile.from_context(context, self)
+          parent_type = case type_or_name
+          when String
+            profile.type(type_or_name)
+          when Module
+            type_or_name
+          when LateBoundType
+            profile.type(type_or_name.name)
+          else
+            raise GraphQL::InvariantError, "Unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
+          end
+          return profile.field(parent_type, field_name)
+        end
         parent_type = case type_or_name
         when LateBoundType
           get_type(type_or_name.name, context)
@@ -1108,20 +1123,21 @@ def rescue_from(*err_classes, &handler_block)
         end
       end
 
-      NEW_HANDLER_HASH = ->(h, k) {
-        h[k] = {
-          class: k,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-         }
-      }
-
       def error_handlers
-        @error_handlers ||= {
-          class: nil,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-        }
+        @error_handlers ||= begin
+          new_handler_hash = ->(h, k) {
+            h[k] = {
+              class: k,
+              handler: nil,
+              subclass_handlers: Hash.new(&new_handler_hash),
+            }
+          }
+          {
+            class: nil,
+            handler: nil,
+            subclass_handlers: Hash.new(&new_handler_hash),
+          }
+        end
       end
 
       # @api private

lib/graphql/schema/ractor_shareable.rb

@@ -8,12 +8,28 @@ def self.extended(schema_class)
       end
 
       module SchemaExtension
+
+        def freeze_error_handlers(handlers)
+          handlers[:subclass_handlers].default_proc = nil
+          handlers[:subclass_handlers].each do |_class, subclass_handlers|
+            freeze_error_handlers(subclass_handlers)
+          end
+          Ractor.make_shareable(handlers)
+        end
+
         def freeze_schema
           # warm some ivars:
           default_analysis_engine
           default_execution_strategy
           GraphQL.default_parser
           default_logger
+          freeze_error_handlers(error_handlers)
+          # TODO: this freezes errors of parent classes which could cause trouble
+          parent_class = superclass
+          while parent_class.respond_to?(:error_handlers)
+            freeze_error_handlers(parent_class.error_handlers)
+            parent_class = parent_class.superclass
+          end
 
           own_tracers.freeze
           @frozen_tracers = tracers.freeze

lib/graphql/schema/visibility.rb

@@ -47,7 +47,7 @@ def initialize(schema, dynamic:, preload:, profiles:, migration_errors:)
 
       def freeze
         load_all
-        @visit = nil
+        @visit = true
         @interface_type_memberships.default_proc = nil
         @all_references.default_proc = nil
         super

lib/graphql/schema/visibility/profile.rb

@@ -320,6 +320,8 @@ def preload
               arguments(type_defn).each do |arg|
                 argument(type_defn, arg.graphql_name)
               end
+            elsif type_defn.kind.enum?
+              enum_values(type_defn)
             end
             # Lots more to do here
           end

spec/graphql/schema/ractor_shareable_spec.rb

@@ -4,20 +4,40 @@
 if RUN_RACTOR_TESTS
   describe GraphQL::Schema::RactorShareable do
     class RactorExampleSchema < GraphQL::Schema
+      class CustomError < RuntimeError; end
+
+      class SomeEnum < GraphQL::Schema::Enum
+        value :A
+        value :B
+      end
       class Query < GraphQL::Schema::Object
         field :i, Int, fallback_value: 1
+        field :e, SomeEnum, fallback_value: "A"
+
+        field :error_1, String
+
+        def error_1
+          raise GraphQL::ExecutionError, "Boom!"
+        end
+
+        field :error_2, String
+
+        def error_2
+          raise CustomError
+        end
       end
+
       query(Query)
       validate_timeout(nil) # Timeout doesn't work in non-main Ractors
       use GraphQL::Schema::Visibility, preload: true, profiles: { nil => {} }
-
+      rescue_from(CustomError) { "Something went wrong" }
       extend GraphQL::Schema::RactorShareable
     end
 
     it "can access some basic GraphQL objects" do
       ractor = Ractor.new do
         parent = Ractor.receive
-        query = GraphQL::Query.new(RactorExampleSchema, "{ __typename }" )
+        query = GraphQL::Query.new(RactorExampleSchema, "{ __typename i e }" )
         parent.send(query.class.name)
         result = query.result.to_h
         parent.send(result)
@@ -28,21 +48,63 @@ class Query < GraphQL::Schema::Object
       end
       ractor.send(Ractor.current)
       assert_equal "GraphQL::Query", Ractor.receive
-      assert_equal({"data" => {"__typename" => "Query"}}, Ractor.receive)
+      expected_result = {
+        "data" => {
+          "__typename" => "Query",
+          "i" => 1,
+          "e" => "A"
+        }
+      }
+      assert_graphql_equal expected_result, Ractor.receive
+    end
+
+    it "can handle runtime errors" do
+      ractor = Ractor.new do
+        parent = Ractor.receive
+        result = RactorExampleSchema.execute("{ error1 error2 }")
+        parent.send(result.to_h)
+      rescue StandardError => err
+        puts err.message
+        puts err.backtrace
+        parent.send(err)
+      end
+      ractor.send(Ractor.current)
+      expected_result = {
+        "errors" => [
+          {
+            "message" => "Boom!",
+            "locations" => [{"line" => 1, "column" => 3}],
+            "path" => ["error1"]
+          }
+        ],
+        "data" => {
+          "error1" => nil,
+          "error2" => "Something went wrong"
+        }
+      }
+      assert_graphql_equal expected_result, Ractor.receive
     end
 
     it "can get schema members by name" do
-      skip "Doesn't work yet"
       ractor = Ractor.new do
         parent = Ractor.receive
         parent.send(RactorExampleSchema.get_field("Query", "__typename").class.name)
+        parent.send(RactorExampleSchema.get_type("Query").class.name)
+        parent.send(RactorExampleSchema.get_field("Query", "i").class.name)
+        parent.send([
+          RactorExampleSchema.query.graphql_name,
+          RactorExampleSchema.mutation
+        ])
       rescue StandardError => err
         puts err.message
         puts err.backtrace
-        parent.send(err)
+        parent.send(err.message)
       end
       ractor.send(Ractor.current)
-      assert_equal "GraphQL::Field", Ractor.receive
+      assert_equal "GraphQL::Schema::Field", Ractor.receive
+      assert_equal "Class", Ractor.receive
+      assert_equal "GraphQL::Schema::Field", Ractor.receive
+      assert_equal ["Query", nil], Ractor.receive
     end
 
     it "can parse a schema string to ast" do