GraphQlTester should go by the schema when serializing variables

[david-kubecka]

Motivation

My output types in the schema are the same as my input types except the latter ones don't have id field. For conciseness reasons, I use the same underlying DTO with nullable id for both types. This works well in the main code flow because id is set to null on input while it has some value on the output.

In the tests, though, I want to use my DTOs as input variables, e.g.

graphQlTester
            .document(SOME_QUERY)
            .variable("var", SomeDtoWithIdField)
            .execute()

Now I obviously don't want the variable var to contain the id field because it's not defined in the input type corresponding to SomeDtoWithIdField. I was thinking about how to drop the id from the serialized var and thought that the following code surely wouldn't work because "GraphQL does not use Jackson annotations to drive JSON serialization/deserialization".

class SomeDtoWithIdField {
    @get:JsonIgnore
    var id: Long? = null
}

But my colleague tried that anyway and to my surprise, it worked :-) That is, in my test case the id is not serialized into var while in the main flow the id is serialized to the output type. My hypothesis is that while in the normal flow spring-grqphql uses some custom serializer, GraphQlTester uses Jackson.

Questions

• Is this expected behavior? Shouldn't rather GraphQlTester use the same serializer as the main flow?
• If both flows should indeed behave consistently, then how could I achieve my use case? Is it somehow possible to hook into the serialization process?

(This question can be read as a sort of reverse of #521)

[rstoyanchev]

Not sure what you mean by normal flow because serialization happens on the client side and it could be any client, any language, and this is completely independent of anything GraphQL Java does on the server side which involves only deserialization for request input.

GraphQlTester is a client, and it delegates to GraphQlTransport, just like GraphQlClient does, and it passes a GraphQlRequest to it with maps of data. If the transport is WebTestClientTransport then will be serialized to JSON via Jackson. This is all expected.

[david-kubecka]

serialization happens on the client side

I don't understand this. GraphQL Java must somehow convert/serialize the return types of the queries/mutations to JSON and custom scalar converters must be taken into account, i.e. generic mappers like Jackson cannot be used.

OTOH I understand that WebTestClientTransport uses Jackson to serialize the variable objects. Is there any way how to use the "native" GraphQL serializer in tests? If yes how would I achieve my use case of ignoring the id field?

My motivation basically is that while the approach with @get:JsonIgnore works for me that's only because I don't need any custom scalar converters in this particular case, so I would like to know what the generic solution would be.

[rstoyanchev]

No, GraphQL Java doesn't serialize anything to JSON. It goes field by field and assembles the output map.

I'm not really sure what's going on from this level of detail. Something less than obvious perhaps. The only other suggestion I have is that maybe @JsonInclude(Include.NON_NULL) could work better for what you're describing.

[david-kubecka]

It goes field by field and assembles the output map

Is this method also used if the transport is WebTestClientTransport? If yes then I got something wrong in my configuration as the JsonIgnore shouldn't actually work. If not is there any way how to obtain this output map also in the testing use case?

(Perhaps there's just a misunderstanding of what serialization really means in this case. Creating the map out of the object is IMO also part of the serialization process...)

[rstoyanchev]

Is this method also used if the transport is WebTestClientTransport?

No, that's apples and oranges.

What I talked about is GraphQL Java on the server side returning an ExecutionResult with a map of data and errors assembled field by field. This is then written out to JSON by our server HTTP transport, but it's just writing the Map to JSON, there are no higher level Objects involved.

What you're asking about is WebTestClientTransport which is on the client side, and that has nothing to do with what GraphQL Java does on the server side.

[rstoyanchev]

Is it possible to provide a small sample that demonstrates a concrete issue?

[rstoyanchev]

Re-reading the description again, I think I'm beginning to understand.

I think your expectation is that GraphQlTester will compare SomeDtoWithIdField to the corresponding GraphQL schema input type and prepare maps of data that contain only the fields that exist in the schema type, and therefore the id field should not be in the resulting output.

GraphQL Java indeed does something similar, but that's on the server side and it's for responses, and it's slightly different because it's checking against the field selection set rather than directly against the schema types. In any case, it's not something that can be re-used on the client side.

It's a valid potential enhancement, assuming I've got it right, for GraphQlClient and GraphQlTester to turn variables into maps of data, by looking at the corresponding schema input and taking only what's needed, before passing that down to the transport to serialize to JSON.

[rstoyanchev]

I've improved that documentation note in 089c754, based on this conversation.

[david-kubecka]

I think your expectation is

Exactly! I think, though, the problem has two parts:

• an ability to turn variables into maps of data on the client side according to the schema
• ignoring some keys in the map based on the required input type
  These could be treated separately (or rather incrementally) if that would simplify things.

Anyway, I'm glad that you consider this as an enhancement. This would greatly improve code reuse in tests because typically you have very similar fixtures for asserting server output as for providing server input (on the client side).