How to test a field's resolve function in v1.13.25?

[tomwang57]

I am upgrade the graphql gem from 1.8 to the latest version of 1.x(currently is 1.13.25). The current codebase has a lot of test cases to test a single field's resolve function such as:

field = object_type.fields[field_name]
field_value = flyer_field.resolve(object, args, ctx)

But now the resolve function on longer works in v1.13.25. I notice that v2.x has some helper methods for it: https://graphql-ruby.org/testing/helper. But is there something similar in v1.13?

[rmosolgo]

Hey, I'm happy to try to find something that works here.

When you say it "no longer works," do you mean that it doesn't return the expected value? If so, what did it used to return, and what does it return now? Or, do you mean that it now raises an error? If so, could you please share the full error message and backtrace?

There aren't any dedicated testing helpers in 1.13.x -- the only supported way to test GraphQL execution was via GraphQL queries. But, I see that some .resolve methods were in place in that version:

graphql-ruby/lib/graphql/field.rb

Line 135 in e2fcb24

def resolve(object, arguments, context)

graphql-ruby/lib/graphql/schema/field.rb

Line 721 in e2fcb24

def resolve(object, args, ctx)

So, I would have guessed that this still worked 🤔 . If you can share some more details about what's "not working", maybe we can find some clues to keep digging.

[tomwang57]

Hi, thx for reply. By "no longer works", i mean the first parameter object is now wrapped by another layer internally by the gem, NOT the object create by the application:

graphql-ruby/lib/graphql/schema/field.rb

Line 727 in e2fcb24

application_object = object.object

So say that the test is as follows:

let(:object_type) { MySchema.types["Subscription"] }
let(:object) { create(:subscription) }

...

field = object_type.fields['available_credit']
available_credit = field.resolve(object, nil, ctx)

It will failed with error:

NoMethodError:
       undefined method `object' for #<Subscription id= ...>

It worked before. But now i've no idea how to create the first object to be passed to the resolve function. There are really a quite lot of test cases written this way before 😭.

[rmosolgo]

Taking a quick look at the code, I think it only requires that the passed in object responds to .object, returning the "real" (application) value for field resolution. So I think you could do something like:

mock_graphql_object = OpenStruct.new(object: object)
field.resolve(mock_graphql_object, nil, ctx)

That might get a little wordy so you could create a helper method:

def resolve_field(obj_type, field_name, object, args, ctx)
  field_defn = obj_type.fields[field_name]
  graphql_object = OpenStruct.new(object: object)
  field_defn.resolve(graphql_object, args, ctx)
end 

Then use that in places where fields were manually fetched and called. You could probably even use a fancy regex to catch most of them, if it's usually two lines in a row. For example, in VS Code:

• Find: \w+ = (\w+)\.fields\[('\w+')\]\n\s*(\w+) = \w+\.resolve\((\w+), (\w+), (\w+)\)
• Replace: $3 = resolve_field($1, $2, $4, $5, $6)

Produces:

- field = object_type.fields['available_credit']
- available_credit = field.resolve(object, nil, ctx)
+ available_credit = resolve_field(object_type, 'available_credit', object, nil, ctx)

Does that kind of wrapper help in this case?

[tomwang57]

Hi, I tried this method and found another problem about the ctx parameter. I set it as a hash value like:

ctx = {
  current_user: xxx
}

And passed it to the resolve function. But the following error occurred:

Error resolving field 'activity_feed_item_content': undefined method `schema' for {:current_user=>#<User id: "9341704a-7e60-41a0-9ff3-a5e8896d98ea" xxx>}

graphql-ruby/lib/graphql/schema/field.rb

Line 731 in e2fcb24

ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|

So maybe the ctx is also wrapped someway, not just an application hash.

[rmosolgo]

Oh, yep, you could mock it with an openstruct, too:

def resolve_field(obj_type, field_name, object, args, ctx)
  # ...
  graphql_context = OpenStruct.new(schema: MySchema, **ctx)
  field_defn.resolve(graphql_object, args, graphql_context)
end 

OpenStruct is nice because both context.schema and context[:current_user] will still work. It's also possible to make a "real" GraphQL::Query::Context instance if you need one, see #5040 (comment).

[tomwang57]

Oh, the openstruct way for the application object still does not work. It can't It cannot meet the requirements of internal logic of field resolve:

graphql-ruby/lib/graphql/schema/field.rb

Lines 830 to 865 in e2fcb24

	# Find a way to resolve this field, checking:
	#
	# - A method on the type instance;
	# - Hash keys, if the wrapped object is a hash or responds to `#[]`
	# - A method on the wrapped object;
	# - Or, raise not implemented.
	#
	if obj.respond_to?(@resolver_method)
	method_to_call = @resolver_method
	method_receiver = obj
	# Call the method with kwargs, if there are any
	if ruby_kwargs.any?
	obj.public_send(@resolver_method, **ruby_kwargs)
	else
	obj.public_send(@resolver_method)
	end
	elsif obj.object.is_a?(Hash)
	inner_object = obj.object
	if @dig_keys
	inner_object.dig(*@dig_keys)
	elsif inner_object.key?(@method_sym)
	inner_object[@method_sym]
	else
	inner_object[@method_str]
	end
	elsif defined?(@hash_key) && obj.object.respond_to?(:[])
	obj.object[@hash_key]
	elsif obj.object.respond_to?(@method_sym)
	method_to_call = @method_sym
	method_receiver = obj.object
	if ruby_kwargs.any?
	obj.object.public_send(@method_sym, **ruby_kwargs)
	else
	obj.object.public_send(@method_sym)
	end
	else

Now i understand what we need is to create a instance of the graphql type(it also wraps object and make it available internally, but it has more than it, not just OpenStruct.new(object: object)), likeTypes::FooType:

class Types::FooType < Types::BaseObject
  field :bar
  def bar
    object.bar(context[:current_user])
  end
end

So the problem is how to create such a instance manually and make it behave like the one created by the gem.