Question about non nullable fields (Kotlin) and data-fetcher tests

[jmbarroso]

Hi all,

I found a situation that I would like to get advice on. It is about using executeAndExtractJsonPathAsObject and the non-nullable fields in the Kotlin generated classes. The question is more to see if you have found similar situations and how you dealt with them (I don't think there is an issue with the framework)

Assume this schema

type Query {
    employers(nameFilter: String): [Employer]
}

type Employer {
    id: ID!
    name: String!
    employees: [Employee]
}

type Employee {
    id: ID!
    firstname: String!
    surname: String
    employer: Employer!
}

If I do a test to validate that I can get all the employees using executeAndExtractJsonPathAsObject, it fails if I don't ask about all the mandatory fields.

This fails:

val employers : List<Employer> = dgsQueryExecutor.executeAndExtractJsonPathAsObject(
               """
                   {
                        employers {
                            id
                            
                            employees {
                                id
                                firstname
                                surname
                            }
                        }    
                   }         
               """.trimIndent(), "data.employers[*]", object : TypeRef<List<Employer>>() {})

But this works:

val employers : List<Employer> = dgsQueryExecutor.executeAndExtractJsonPathAsObject(
               """
                   {
                        employers {
                            id
                            name
                            employees {
                                id
                                firstname
                                employer {
                                    id
                                    name
                                }
                            }
                        }    
                   }         
               """.trimIndent(), "data.employers[*]", object : TypeRef<List<Employer>>() {})

As you can see, I'm forced to bring extra data (employer name, and the employer in the employee) to fulfill Kotlin's non-nullable constraints. Some questions:

• Are you using your Kotlin/Java generated classes to test data-fetcher results? Any other strategy that is working for you?
• When modeling, are you using the pattern to link your parent? (e.g., Employee having an Employer field instead of just an EmployerId)

Thank you!

[srinivasankavitha]

While some of our users do use generated classes to test data fetcher results, I believe it's not common. And even then I think it's been mostly in Java, since our Kotlin user base is much smaller comparatively.

For schema modeling, we do come across such patterns, i.e. ones that introduce cycles in the schema. It's mostly left to the implementor's judgement though as to what makes the most sense to represent their data.

[jmbarroso]

Thanks for the answer.

Usually, I feel like doing asserts based on strings in complex objects is painful. If anyone has some other examples/patterns to validate test results, please chime in.

[srinivasankavitha]

I agree. It does seem useful to accommodate for this in the generated classes. Maybe it makes sense for Kotlin to just always make everything nullable? That way it can be more useful.