From f645a46b61fb36744c0a7774de0798c8437e08f1 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:09:14 -0400 Subject: [PATCH 01/14] Add a test helper that queries every field of a schema --- .../kickstart/tools/EveryFieldResolves.kt | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt diff --git a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt new file mode 100644 index 00000000..8eb9828c --- /dev/null +++ b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt @@ -0,0 +1,150 @@ +package graphql.kickstart.tools + +import graphql.ExecutionInput +import graphql.ExecutionResult +import graphql.GraphQL +import graphql.Scalars +import graphql.schema.* +import graphql.schema.GraphQLTypeUtil.isNonNull +import graphql.schema.GraphQLTypeUtil.unwrapAll +import org.reactivestreams.Publisher +import org.reactivestreams.Subscriber +import org.reactivestreams.Subscription +import java.util.concurrent.CompletableFuture +import java.util.concurrent.ExecutionException +import java.util.concurrent.TimeUnit +import java.util.concurrent.TimeoutException + +/** + * Runs one operation per root field that selects every field reachable from it, and fails on any error. + * + * Arguments without a default get a made-up value. Fields ("Type.field") and arguments ("Type.field(arg:)") named in + * [except] are left out. So is a field with a required argument that's left out or is a custom scalar, which has no + * value to make up. [input] adds to every operation, e.g. a context or a data loader registry. + */ +@JvmOverloads +fun assertEveryFieldResolves(schema: GraphQLSchema, except: Set = setOf(), input: ExecutionInput.Builder.() -> Unit = {}) { + val gql = GraphQL.newGraphQL(schema).build() + val query = EveryFieldQuery(schema, except) + val roots = mapOf("query" to schema.queryType, "mutation" to schema.mutationType, "subscription" to schema.subscriptionType) + val errors = roots.flatMap { (operation, root) -> + if (root == null) return@flatMap listOf() + query.fields(root).flatMap { field -> + val document = "$operation { $field }" + execute(gql, ExecutionInput.newExecutionInput(document).apply(input).build()).map { "$document\n $it" } + } + } + if (errors.isNotEmpty()) { + throw AssertionError("Querying every field returned errors:\n${errors.joinToString("\n")}") + } +} + +private const val MAX_DEPTH = 6 + +private class EveryFieldQuery(private val schema: GraphQLSchema, private val except: Set) { + private val visibility = schema.codeRegistry.fieldVisibility + + fun fields(type: GraphQLFieldsContainer, path: List = listOf()): List = + visibility.getFieldDefinitions(type) + .filter { "${type.name}.${it.name}" !in except } + .mapNotNull { field(type, it, path + type.name) } + + private fun field(parent: GraphQLFieldsContainer, field: GraphQLFieldDefinition, path: List): String? { + val type = unwrapAll(field.type) + // a type can repeat once on a path, so a field that refers back to its own type still runs + if (type !is GraphQLScalarType && type !is GraphQLEnumType && (path.size >= MAX_DEPTH || path.count { it == type.name } >= 2)) { + return null + } + val arguments = field.arguments.filter { !it.hasSetDefaultValue() }.mapNotNull { argument -> + val value = if ("${parent.name}.${field.name}(${argument.name}:)" in except) null else value(argument.type, setOf()) + when { + value != null -> "${argument.name}: $value" + isNonNull(argument.type) -> return null + else -> null + } + } + val argumentList = if (arguments.isEmpty()) "" else arguments.joinToString(", ", "(", ")") + // aliased so fields with the same name but different types can sit side by side in fragments + return "${parent.name}_${field.name}: ${field.name}$argumentList ${selection(type, path)}" + } + + private fun selection(type: GraphQLNamedType, path: List): String = when (type) { + is GraphQLObjectType -> "{ __typename ${fields(type, path).joinToString(" ")} }" + is GraphQLInterfaceType -> fragments(schema.getImplementations(type) ?: listOf(), path) + is GraphQLUnionType -> fragments(type.types, path) + else -> "" + } + + private fun fragments(types: List, path: List) = + "{ __typename ${types.joinToString(" ") { "... on ${it.name} ${selection(it, path)}" }} }" + + private fun value(type: GraphQLInputType, path: Set): String? = when (type) { + is GraphQLNonNull -> value(type.wrappedType as GraphQLInputType, path) + is GraphQLList -> value(type.wrappedType as GraphQLInputType, path)?.let { "[$it]" } + is GraphQLEnumType -> type.values.first().name + is GraphQLInputObjectType -> inputObject(type, path) + Scalars.GraphQLString -> "\"a\"" + Scalars.GraphQLID -> "\"1\"" + Scalars.GraphQLInt -> "1" + Scalars.GraphQLFloat -> "1.5" + Scalars.GraphQLBoolean -> "true" + else -> null + } + + private fun inputObject(type: GraphQLInputObjectType, path: Set): String? { + if (type.name in path) return null + val fields = type.fieldDefinitions.filter { !it.hasSetDefaultValue() }.mapNotNull { field -> + val value = value(field.type, path + type.name) + when { + value != null -> "${field.name}: $value" + isNonNull(field.type) -> return null + else -> null + } + } + // a @oneOf input takes exactly one field + return (if (type.isOneOf) fields.take(1) else fields).joinToString(", ", "{ ", " }") + } +} + +private fun execute(gql: GraphQL, input: ExecutionInput): List { + // a resolver that never completes fails here instead of hanging the build + val result = try { + gql.executeAsync(input).get(5, TimeUnit.SECONDS) + } catch (e: TimeoutException) { + return listOf("Timed out") + } + val events = result.getData() as? Publisher<*> ?: return result.errors.map { it.message } + return result.errors.map { it.message } + firstEventErrors(events) +} + +private fun firstEventErrors(events: Publisher<*>): List { + val first = CompletableFuture() + var subscription: Subscription? = null + events.subscribe(object : Subscriber { + override fun onSubscribe(s: Subscription) { + subscription = s + s.request(1) + } + + override fun onNext(event: Any?) { + first.complete(event as ExecutionResult) + } + + override fun onError(t: Throwable) { + first.completeExceptionally(t) + } + + override fun onComplete() { + first.complete(null) + } + }) + return try { + first.get(1, TimeUnit.SECONDS)?.errors?.map { it.message } ?: listOf() + } catch (e: TimeoutException) { + listOf() + } catch (e: ExecutionException) { + listOf("Subscription failed: ${e.cause}") + } finally { + subscription?.cancel() + } +} From d02913c4e6940793b526a68af1aaaeac38736def Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:13:19 -0400 Subject: [PATCH 02/14] Query every field of the schemas in the input type tests --- .../kickstart/tools/CustomScalarInputTest.kt | 3 ++- .../kickstart/tools/GenericInputTypesTest.kt | 5 +++++ .../kickstart/tools/NestedInputTypesTest.kt | 12 ++++++++-- .../tools/UnmappedInputFieldsTest.kt | 22 +++++++++++++++++-- 4 files changed, 37 insertions(+), 5 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt index 04b20e0e..f1130937 100644 --- a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt @@ -191,6 +191,7 @@ class CustomScalarInputTest { .options(options) .build() .makeExecutableSchema() + assertEveryFieldResolves(graphQLSchema) return GraphQL.newGraphQL(graphQLSchema).build() } @@ -265,7 +266,7 @@ class CustomScalarInputTest { fun optionalEvent(input: Optional): String = input.map { event(it) }.orElse("empty") fun message(input: MessageInput): String = "${input.name}: ${(listOfNotNull(input.file) + input.files).joinToString(" ") { it.content() }}" fun label(input: LabelInput): String = "${input.date} ${input.opaque}" - fun dateNode(input: ObjectNode): String = (input["date"] as POJONode).pojo.let { "${it.javaClass.simpleName} $it" } + fun dateNode(input: ObjectNode): String = (input["date"] as POJONode?)?.pojo?.let { "${it.javaClass.simpleName} $it" }.orEmpty() fun priceNode(input: ObjectNode): String = input.toString() fun payment(input: PaymentInput): String = listOfNotNull(input.price, input.reference, input.date, input.box).joinToString(" ") fun price(price: MoneyDto): String = price.toString() diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt index 6856a07f..56c35fb0 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt @@ -32,6 +32,7 @@ class GenericInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -68,6 +69,7 @@ class GenericInputTypesTest { .resolvers(InheritedQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -112,6 +114,7 @@ class GenericInputTypesTest { .resolvers(MultipleParameterizationsQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -153,6 +156,7 @@ class GenericInputTypesTest { .resolvers(NestedQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -186,6 +190,7 @@ class GenericInputTypesTest { .resolvers(InheritedListQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt index 4c20ae06..79b1380c 100644 --- a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt @@ -39,6 +39,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -89,6 +90,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -132,12 +134,13 @@ class NestedInputTypesTest { .resolvers(object : GraphQLQueryResolver { fun discountName(filter: Map): String? { val requestFilter = filter["requestFilter"] as Map<*, *> - val discountTypeFilter = (requestFilter["and"] as List<*>).single() as Map<*, *> - return (discountTypeFilter["discountTypeFilter"] as Map<*, *>)["name"] as String? + val discountTypeFilter = (requestFilter["and"] as List<*>?)?.single() as Map<*, *>? + return (discountTypeFilter?.get("discountTypeFilter") as Map<*, *>?)?.get("name") as String? } }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -190,6 +193,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -239,6 +243,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -281,6 +286,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -325,6 +331,7 @@ class NestedInputTypesTest { .dictionary("ShipmentLineInput", ShipmentLineInput::class.java) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -373,6 +380,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt index da8f5acd..535da0da 100644 --- a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt @@ -35,6 +35,8 @@ class UnmappedInputFieldsTest { @Test fun `misspelled property of an input class is reported`() { val (schema, warnings) = withWarnings { projectParser().makeExecutableSchema() } + // the input class misspells technologies, so createProject fails when queried + assertEveryFieldResolves(schema, except = setOf("Mutation.createProject")) assertEquals(warnings, listOf(TECHNOLOGIES_MESSAGE)) @@ -201,6 +203,7 @@ class UnmappedInputFieldsTest { .build() .makeExecutableSchema() } + assertEveryFieldResolves(schema) assertEquals(warnings, listOf(unmapped("GreetingInput.name", GreetingInput::class.java, "argument 'input' of field 'Query.greet'", "nmae", "drops the field's value, since the ObjectMapper ignores unknown properties"))) @@ -249,7 +252,10 @@ class UnmappedInputFieldsTest { } assertEquals(error.message, unmapped("NameInput.firstName", NameInput::class.java, "argument 'input' of field 'Query.snake'", "first_name")) - val gql = GraphQL.newGraphQL(parser(SchemaParserOptions.newOptions()).makeExecutableSchema()).build() + val schema = parser(SchemaParserOptions.newOptions()).makeExecutableSchema() + // the snake case ObjectMapper doesn't know firstName, so snake fails when queried + assertEveryFieldResolves(schema, except = setOf("Query.snake")) + val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute("query { snake(input: { firstName: \"Ada\" }) camel(input: { firstName: \"Ada\" }) }") assertContains(result.errors.single().message, "Unrecognized field \"firstName\"") assertEquals(result.getData>()!!["camel"], "Ada") @@ -373,9 +379,11 @@ class UnmappedInputFieldsTest { @Test fun `input classes are not checked if asked not to`() { - val (_, warnings) = withWarnings { + val (schema, warnings) = withWarnings { projectParser(SchemaParserOptions.newOptions().unmappedInputFields(UnmappedInputFields.IGNORE).build()).makeExecutableSchema() } + // the input class misspells technologies, so createProject fails when queried + assertEveryFieldResolves(schema, except = setOf("Mutation.createProject")) assertEquals(warnings, emptyList()) } @@ -459,6 +467,7 @@ class UnmappedInputFieldsTest { .build() .makeExecutableSchema() } + assertEveryFieldResolves(schema) assertEquals(warnings, emptyList()) @@ -550,6 +559,7 @@ class UnmappedInputFieldsTest { .options(failOptions().build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -643,6 +653,8 @@ class UnmappedInputFieldsTest { .build()) .build() .makeExecutableSchema() + // the made-up kind isn't one of the type ids Jackson knows + assertEveryFieldResolves(schema, except = setOf("Query.shape(input:)", "Query.animals(input:)", "Query.animal(input:)", "Query.zoo(input:)")) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -712,6 +724,12 @@ class UnmappedInputFieldsTest { .build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema, except = setOf( + // the input classes misspell name on purpose + "Query.injected", "Query.builder", + // MethodFieldResolver converts the argument with the unresolved type variable of the inherited parameter + "Query.generic" + )) val result = GraphQL.newGraphQL(schema).build().execute( """ From b7aef36e61144cf14abe5bfbf750d1fb904b4224 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:14:31 -0400 Subject: [PATCH 03/14] Query every field of the schemas in the directive and default value tests --- .../tools/DeprecatedDirectiveTest.kt | 57 +++++++++++++------ .../graphql/kickstart/tools/DirectiveTest.kt | 28 +++++++-- .../kickstart/tools/EnumDefaultValueTest.kt | 2 + .../kickstart/tools/EnumListParameterTest.kt | 5 ++ .../kickstart/tools/InputDefaultValueTest.kt | 5 ++ .../tools/SchemaClassScannerDirectiveTest.kt | 8 +++ 6 files changed, 84 insertions(+), 21 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt index 0acec3bb..3fefa663 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt @@ -35,6 +35,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -68,6 +69,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -108,6 +110,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -148,6 +151,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -178,9 +182,10 @@ class DeprecatedDirectiveTest { name: String } """) - .resolvers(UsersQueryResolver()) + .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -211,9 +216,10 @@ class DeprecatedDirectiveTest { name: String } """) - .resolvers(UsersQueryResolver()) + .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -249,6 +255,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -284,6 +291,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -318,9 +326,10 @@ class DeprecatedDirectiveTest { name: String } """) - .resolvers(UsersQueryResolver()) + .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -355,9 +364,10 @@ class DeprecatedDirectiveTest { name: String } """) - .resolvers(UsersQueryResolver()) + .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -395,9 +405,10 @@ class DeprecatedDirectiveTest { type: UserType @deprecated(reason: "custom") } """) - .resolvers(UsersQueryResolver()) + .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val name = (schema.getType("User") as GraphQLObjectType).getField("name") assertEquals("No longer supported", name.getAppliedDirective("deprecated").getArgument("reason")!!.getValue()) @@ -415,16 +426,30 @@ class DeprecatedDirectiveTest { } private class UsersQueryResolver : GraphQLQueryResolver { - fun users(env: DataFetchingEnvironment): Connection { - return SimpleListConnection(listOf(User(1L, "Luke Skywalker", "Luke", "Skywalker", UserType.JEDI))).get(env) - } - - private data class User( - val id: Long, - val name: String, - val firstName: String, - val lastName: String, - val type: UserType - ) + fun users(env: DataFetchingEnvironment): Connection = SimpleListConnection(users).get(env) + } + + private class UsersWithFirstQueryResolver : GraphQLQueryResolver { + fun users(first: Int?, env: DataFetchingEnvironment): Connection = SimpleListConnection(users).get(env) + } + + private class UsersWithConnectionInputQueryResolver : GraphQLQueryResolver { + fun users(connectionInput: ConnectionInput?, env: DataFetchingEnvironment): Connection = SimpleListConnection(users).get(env) + } + + data class ConnectionInput( + val first: Int? + ) + + private data class User( + val id: Long, + val name: String, + val firstName: String, + val lastName: String, + val type: UserType + ) + + companion object { + private val users = listOf(User(1L, "Luke Skywalker", "Luke", "Skywalker", UserType.JEDI)) } } diff --git a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt index b6503e34..d46d9d3d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt @@ -41,6 +41,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -93,6 +94,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -137,6 +139,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -179,6 +182,7 @@ class DirectiveTest { .directive("double", DoubleDirective()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -215,11 +219,14 @@ class DirectiveTest { name: String @auth @log } """) - .resolvers(NameResolver()) + .resolvers(object : GraphQLQueryResolver { + fun name(): String? = null + }) .directive("auth", DescriptionDirective("auth")) .directive("log", DescriptionDirective("log")) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.queryType.getField("name").description, "Name +auth +log") } @@ -236,11 +243,14 @@ class DirectiveTest { name: String @auth } """) - .resolvers(NameResolver()) + .resolvers(object : GraphQLQueryResolver { + fun name(): String? = null + }) .directive("auth", DescriptionDirective("auth")) .directiveWiring(DescriptionDirective("static")) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.queryType.getField("name").description, "Name +auth +static") } @@ -285,6 +295,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -337,6 +348,7 @@ class DirectiveTest { .dictionary(AllowedState::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -365,6 +377,7 @@ class DirectiveTest { .resolvers(BookQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val filter = schema.getType("BookFilter") as GraphQLInputObjectType assert(filter.isOneOf) @@ -404,6 +417,7 @@ class DirectiveTest { .directive("email", emailDirective) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val expectedMessages = mapOf( "contactEmail" to "{path} must be a valid email", @@ -427,7 +441,7 @@ class DirectiveTest { // ConfigInput is built for @meta and needs @option, whichever is declared first listOf("$meta\n$option", "$option\n$meta").forEach { directives -> val recorder = ArgumentTypeRecorder() - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ $directives @@ -452,6 +466,7 @@ class DirectiveTest { .directive("option", recorder) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val inputObject = listOf("GraphQLInputObjectType") val expectedTypes = mapOf("name" to inputObject, "ConfigInput" to inputObject, "level" to inputObject) @@ -490,6 +505,7 @@ class DirectiveTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assert(wiredFields == listOf("max")) { "$wiredFields with directives declared as $directives" } val limit = (schema.getType("BoundInput") as GraphQLInputObjectType).getField("max").getAppliedDirective("limit") @@ -531,6 +547,7 @@ class DirectiveTest { .dictionary(LinkPurpose::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.schemaAppliedDirectives.map { it.name }, listOf("contact", "link", "link")) assertEquals( @@ -594,6 +611,7 @@ class DirectiveTest { .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val link = schema.getSchemaAppliedDirective("link") assertEquals(link.getArgument("import")?.getValue>(), listOf("@key", "@shareable")) @@ -644,7 +662,7 @@ class DirectiveTest { fun book(filter: BookFilter): Book? = null } - private data class BookFilter( + data class BookFilter( val id: Int?, val name: String? ) @@ -655,7 +673,7 @@ class DirectiveTest { fun updatePerson(person: PersonInput?, state: AllowedState?): String? = null } - private data class PersonInput( + data class PersonInput( val email: String? ) diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt index 20f72c57..bdf08950 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt @@ -29,6 +29,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val ggl = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -64,6 +65,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val ggl = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt index d0b0c5cd..0517db5b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt @@ -48,6 +48,11 @@ class EnumListParameterTest { assertEquals((data["countries"]), emptyList()) } + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) + } + class QueryResolver : GraphQLQueryResolver { fun getCountries(regions: Set): Set { return setOf() diff --git a/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt index 74a02406..980db06d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt @@ -49,6 +49,11 @@ class InputDefaultValueTest { assertEquals(data["listWithEmptyDefault"], "size: 10, after: null") } + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) + } + class QueryResolver : GraphQLQueryResolver { fun list(listing: Listing): String = describe(listing) fun listWithEmptyDefault(listing: Listing): String = describe(listing) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt index 58bbdb8b..68cde932 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt @@ -33,6 +33,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -74,6 +75,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -105,6 +107,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -134,6 +137,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertNotNull(schema.directivesByName["doSomething"]?.getArgument("one")?.directivesByName?.get("somethingElse")) assertNotNull(schema.directivesByName["somethingElse"]?.getArgument("two")?.directivesByName?.get("doSomething")) @@ -147,6 +151,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() val schema = parser.makeExecutableSchema() + assertEveryFieldResolves(schema) val purpose = schema.getType("Purpose") as GraphQLEnumType assertEquals(purpose.values.map { it.value }, listOf("SECURITY", "EXECUTION")) @@ -172,6 +177,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION", "SECURITY")) assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { IntrospectionQuery.INTROSPECTION_QUERY } @@ -190,6 +196,7 @@ class SchemaClassScannerDirectiveTest { .dictionary(Purpose::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } @@ -209,6 +216,7 @@ class SchemaClassScannerDirectiveTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } From 5e5e4a7963a5627cbde1f5548a00b1de2121d6c8 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:15:00 -0400 Subject: [PATCH 04/14] Report an Error thrown by a resolver against its operation --- src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt index 8eb9828c..42385c10 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt @@ -112,6 +112,9 @@ private fun execute(gql: GraphQL, input: ExecutionInput): List { gql.executeAsync(input).get(5, TimeUnit.SECONDS) } catch (e: TimeoutException) { return listOf("Timed out") + } catch (e: ExecutionException) { + // graphql-java turns exceptions into GraphQL errors, but not an Error such as a failed assert + return listOf("Failed: ${e.cause}") } val events = result.getData() as? Publisher<*> ?: return result.errors.map { it.message } return result.errors.map { it.message } + firstEventErrors(events) From 6f56c8a97971807caeeb830736d56f6e410de15d Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:14:49 -0400 Subject: [PATCH 05/14] Query every field of the schemas in the resolver and type extension tests --- .../tools/InaccessibleFieldResolverTest.kt | 3 +++ .../tools/InheritedTypeVariablesTest.kt | 4 ++++ .../kickstart/tools/MethodFieldResolverTest.kt | 16 +++++++++++----- .../kickstart/tools/MissingFieldResolverTest.kt | 4 ++++ .../graphql/kickstart/tools/ReactiveTest.kt | 7 ++++++- .../graphql/kickstart/tools/TypeExtensionTest.kt | 15 ++++++++++++--- 6 files changed, 40 insertions(+), 9 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt index dc0d1814..a1ae6576 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt @@ -31,6 +31,8 @@ class InaccessibleFieldResolverTest { .resolvers(Query()) .build() .makeExecutableSchema() + // without LocaleResolver, languageTag reads the private field of Locale, which the module system blocks + assertEveryFieldResolves(schema, except = setOf("Locale.languageTag")) val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -68,6 +70,7 @@ class InaccessibleFieldResolverTest { .resolvers(Query(), LocaleResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() diff --git a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt index e2452304..4bebd185 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt @@ -33,6 +33,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -72,6 +73,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -119,6 +121,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -171,6 +174,7 @@ class InheritedTypeVariablesTest { .resolvers(RawGenericFixtures.QueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt index 70200a8e..9db3f956 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt @@ -38,6 +38,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -80,6 +81,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -112,10 +114,11 @@ class MethodFieldResolverTest { """) .scalars(customScalarType) .resolvers(object : GraphQLQueryResolver { - fun test(scalar: CustomScalar) = scalar.value.length + fun test(scalar: CustomScalar?) = scalar?.value?.length }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -143,10 +146,11 @@ class MethodFieldResolverTest { """) .scalars(customScalarType) .resolvers(object : GraphQLQueryResolver { - fun test(scalars: List) = scalars.map { it.value.length }.sum() + fun test(scalars: List?) = scalars?.map { it.value.length }?.sum() }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -165,12 +169,12 @@ class MethodFieldResolverTest { @Test fun `should handle proxies`() { val invocationHandler = object : InvocationHandler { - override fun invoke(proxy: Any, method: Method, args: Array): Any { + override fun invoke(proxy: Any, method: Method, args: Array): Any? { return when (method.name) { "toString" -> "Proxy$" + System.identityHashCode(this) "hashCode" -> System.identityHashCode(this) "equals" -> Proxy.isProxyClass(args[0].javaClass) - "test" -> (args[0] as List<*>).map { (it as CustomScalar).value.length }.sum() + "test" -> (args[0] as List<*>?)?.map { (it as CustomScalar).value.length }?.sum() else -> UnsupportedOperationException() } } @@ -194,6 +198,7 @@ class MethodFieldResolverTest { .resolvers(resolver) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -258,6 +263,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute(ExecutionInput.newExecutionInput().query( @@ -297,7 +303,7 @@ class MethodFieldResolverTest { } interface Resolver { - fun test(scalars: List): Int + fun test(scalars: List?): Int? } private val customScalarType: GraphQLScalarType = GraphQLScalarType.newScalar() diff --git a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt index a4962f67..0acf261f 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt @@ -48,6 +48,8 @@ class MissingFieldResolverTest { .build() .makeExecutableSchema() } + // missingField has no resolver, so querying it throws + assertEveryFieldResolves(schema, except = setOf("Query.missingField")) assertEquals(warnings, listOf( "Option 'allowUnimplementedResolvers' should only be set to true during development, as it can cause schema errors to be moved " + @@ -76,6 +78,7 @@ class MissingFieldResolverTest { .build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() @@ -116,6 +119,7 @@ class MissingFieldResolverTest { .options(options) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt index 9531260c..b8d4a838 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt @@ -31,6 +31,7 @@ class ReactiveTest { .options(options) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -91,7 +92,10 @@ class ReactiveTest { val options = newOptions() .genericWrappers(GenericWrapper.withTransformer(FutureTask::class, 0, { task -> task.get() })) .build() - val gql = GraphQL.newGraphQL(itemSchema(PlainFutureQuery(), options)).build() + val schema = itemSchema(PlainFutureQuery(), options) + // suspendCompletableItem is a suspend function that returns a future, which is rejected + assertEveryFieldResolves(schema, except = setOf("Query.suspendCompletableItem")) + val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { """ @@ -179,6 +183,7 @@ class ReactiveTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt index d89194f6..35572962 100644 --- a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt @@ -52,6 +52,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class, Item::class) scalars(GraphQLScalarType.newScalar().name("Date").coercing(Scalars.GraphQLString.coercing).build()) }.makeExecutableSchema() + assertEveryFieldResolves(schema) val fooBar = schema.getType("FooBar") as GraphQLUnionType val color = schema.getType("Color") as GraphQLEnumType @@ -107,6 +108,7 @@ class TypeExtensionTest { """) { dictionary(Foo::class, Bar::class, Baz::class) }.makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -130,6 +132,7 @@ class TypeExtensionTest { """) { dictionary(Item::class, Bar::class) }.makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Node") as GraphQLInterfaceType).fieldDefinitions.map { it.name }, listOf("id", "fooBar")) assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Foo", "Bar")) @@ -231,7 +234,7 @@ class TypeExtensionTest { type Item implements Node @tag(name: "Item") { id: ID! } extend type Item @tag(name: "Item extension") { name: String } - union FooBar @tag(name: "FooBar") = Foo + union FooBar @tag(name: "FooBar") = Baz extend union FooBar @tag(name: "FooBar extension") enum Color @tag(name: "Color") { RED GREEN } @@ -240,13 +243,14 @@ class TypeExtensionTest { input Filter @tag(name: "Filter") { id: ID } extend input Filter @tag(name: "Filter extension") @once(name: "Filter extension") - type Foo { foo: String } + type Baz { baz: String } """) { - dictionary(Item::class, Foo::class) + dictionary(Item::class, Baz::class) directive("tag", wiring) directive("once", wiring) }.makeExecutableSchema() } + assertEveryFieldResolves(schema) assertEquals(warnings, listOf("Directive @once isn't repeatable but an extension of type 'Query' applies it again, only the first one is kept.")) @@ -295,6 +299,7 @@ class TypeExtensionTest { """) { options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) }.makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.queryType.appliedDirectives.map { it.getArgument("fields")?.getValue() }, listOf("upc", "name")) } @@ -322,6 +327,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class) options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) }.makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -359,6 +365,7 @@ class TypeExtensionTest { dictionary(Item::class, Foo::class, Bar::class, Baz::class) }.makeExecutableSchema() } + assertEveryFieldResolves(schema) assertEquals(warnings, listOf( "Type 'Node' declares field 'id' more than once, only the first one is kept.", @@ -395,6 +402,7 @@ class TypeExtensionTest { dictionary(Item::class) }.makeExecutableSchema() } + assertEveryFieldResolves(schema) assertEquals(warnings, listOf( "Type 'Node' is defined as an interface, but extended as an object type. The extension is ignored.", @@ -450,6 +458,7 @@ class TypeExtensionTest { enum Purpose { SECURITY } extend enum Purpose { EXECUTION } """).makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, listOf("SECURITY", "EXECUTION")) assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION")) From a49c66ce2b2e51cbf60a40804be64f62171e97dd Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:15:09 -0400 Subject: [PATCH 06/14] Query every field of the schemas in the scanner tests --- ...SchemaClassScannerSealedJavaTypesTest.java | 1 + .../SchemaClassScannerInterfaceFieldTest.kt | 8 ++++ .../SchemaClassScannerSealedTypesTest.kt | 5 +++ .../kickstart/tools/SchemaClassScannerTest.kt | 41 +++++++++++++++---- .../tools/SchemaParserDictionaryTest.kt | 3 ++ 5 files changed, 50 insertions(+), 8 deletions(-) diff --git a/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java b/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java index 8880db03..de5022b0 100644 --- a/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java +++ b/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java @@ -50,6 +50,7 @@ interface Animal { .resolvers(new PetQuery(), new AnimalQuery()) .build() .makeExecutableSchema(); + EveryFieldResolvesKt.assertEveryFieldResolves(schema); ExecutionResult result = GraphQL.newGraphQL(schema).build().execute(ExecutionInput.newExecutionInput().query(""" query { diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt index e3b8d5d7..e52841c3 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt @@ -41,6 +41,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyUnion.TestInterfaceImpl::class, InterfaceOnlyUnion.TestUnion2::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val testUnion = schema.getType("TestUnion") as GraphQLUnionType assertEquals(testUnion.types.map { it.name }.toSet(), setOf("TestUnion1", "TestUnion2")) @@ -124,6 +125,7 @@ class SchemaClassScannerInterfaceFieldTest { .resolvers(SingleMemberUnions()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Result") as GraphQLUnionType).types.map { it.name }, listOf("Node")) assertEquals((schema.getType("SortResponse") as GraphQLUnionType).types.map { it.name }, listOf("NodeSortResponse")) @@ -182,6 +184,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(ChainedInterfaceUnion.Box::class, ChainedInterfaceUnion.Image::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -246,6 +249,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(NestedInterfaceOnlyUnion.Book::class, NestedInterfaceOnlyUnion.Image::class, NestedInterfaceOnlyUnion.RichCaption::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Caption") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("PlainCaption", "RichCaption")) } @@ -295,6 +299,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyInterface.Box::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assert(schema.getType("Entry") is GraphQLInterfaceType) } @@ -348,6 +353,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableUnion.Book::class, DictionaryReachableUnion.Holder::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -409,6 +415,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableInterface.Shelf::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.getImplementations(schema.getType("Item") as GraphQLInterfaceType)!!.map { it.name }.toSet(), setOf("Book", "Magazine")) } @@ -467,6 +474,7 @@ class SchemaClassScannerInterfaceFieldTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image", "Caption")) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt index 9fa50c27..d88561fe 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt @@ -47,6 +47,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedClassUnion()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } @@ -93,6 +94,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedInterfaceImplementors()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -153,6 +155,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(GenericSealedClass()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -208,6 +211,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(MemberReachableThroughSealedSubclass()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals((schema.getType("SearchResult") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Book", "Author")) @@ -254,6 +258,7 @@ class SchemaClassScannerSealedTypesTest { .dictionary("WeirdPet", DictionaryOverridesSealedSubclass.ClassifiedWeirdPet::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt index ac998242..bc86d584 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt @@ -1,5 +1,6 @@ package graphql.kickstart.tools +import com.fasterxml.jackson.annotation.JsonProperty import graphql.GraphQL import graphql.GraphQLContext import graphql.Scalars @@ -14,7 +15,7 @@ class SchemaClassScannerTest { @Test fun `scanner handles futures and immediate return types`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .resolvers(FutureImmediateQuery()) .schemaString( """ @@ -24,6 +25,8 @@ class SchemaClassScannerTest { } """) .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) } private class FutureImmediateQuery : GraphQLQueryResolver { @@ -35,7 +38,7 @@ class SchemaClassScannerTest { @Test fun `scanner handles primitive and boxed return types`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .resolvers(PrimitiveBoxedQuery()) .schemaString( """ @@ -45,17 +48,19 @@ class SchemaClassScannerTest { } """) .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) } private class PrimitiveBoxedQuery : GraphQLQueryResolver { fun primitive(): Int = 1 - fun boxed(): Int? = null + fun boxed(): Int? = 1 } @Test fun `scanner handles different scalars with same java class`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .resolvers(ScalarDuplicateQuery()) .schemaString( """ @@ -65,6 +70,8 @@ class SchemaClassScannerTest { } """) .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) } private class ScalarDuplicateQuery : GraphQLQueryResolver { @@ -88,6 +95,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val interfaceType = schema.additionalTypes.find { it is GraphQLInterfaceType } assertNotNull(interfaceType) @@ -121,6 +129,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val inputTypeCount = schema.additionalTypes.count { it is GraphQLInputType } assertEquals(inputTypeCount, 3) @@ -133,7 +142,9 @@ class SchemaClassScannerTest { class FirstInput { var id: String? = null - fun second(): SecondInput = SecondInput() + @field:JsonProperty + private var second = SecondInput() + fun second(): SecondInput = second var third: ThirdInput? = null } @@ -148,7 +159,7 @@ class SchemaClassScannerTest { @Test fun `scanner ignores fluent setters when finding input field types`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .resolvers(FluentSetterMutation(), object : GraphQLQueryResolver { fun test(): Boolean = true }) @@ -177,6 +188,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } private class FluentSetterMutation : GraphQLMutationResolver { @@ -186,6 +198,7 @@ class SchemaClassScannerTest { class RepairApply { var id: String? = null var repairMan: RepairMan? = null + @field:JsonProperty private var reviewer: RepairMan? = null @JvmField var approver: RepairMan? = null @@ -216,7 +229,7 @@ class SchemaClassScannerTest { @Test fun `scanner finds input field types through getters with arguments`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .resolvers(GetterWithArgumentsQuery()) .schemaString( """ @@ -242,6 +255,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } private class GetterWithArgumentsQuery : GraphQLQueryResolver { @@ -291,6 +305,7 @@ class SchemaClassScannerTest { ) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val inputTypeExtensionCount = schema.additionalTypes .filterIsInstance() @@ -322,6 +337,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assert(schema.typeMap.containsKey("UUID")) } @@ -360,6 +376,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 2) @@ -408,6 +425,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 1) @@ -435,7 +453,7 @@ class SchemaClassScannerTest { val schema = SchemaParser.newParser() .resolvers(object : GraphQLQueryResolver { - fun hasRawScalar(rawScalar: Map): Boolean = true + fun hasRawScalar(rawScalar: Map?): Boolean = true fun hasMapField(mapField: HasMapField): Boolean = true }) .scalars(customMap) @@ -454,6 +472,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assert(schema.typeMap.containsKey("customMap")) } @@ -496,6 +515,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -531,6 +551,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 2) @@ -569,6 +590,7 @@ class SchemaClassScannerTest { .dictionary(NestedInterfaceTypeQuery.Dog::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 3) @@ -631,6 +653,7 @@ class SchemaClassScannerTest { .scalars(fieldSetScalar, linkImportScalar) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val objectTypes = schema.additionalTypes.filterIsInstance() assert(objectTypes.any { it.name == "User" }) @@ -723,6 +746,7 @@ class SchemaClassScannerTest { .dictionary(Unused::class, Implementation::class, SomeEnum::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val objectTypes = schema.additionalTypes.filterIsInstance() val interfaceTypes = schema.additionalTypes.filterIsInstance() @@ -764,6 +788,7 @@ class SchemaClassScannerTest { .dictionary(SomeEnum::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assert(schema.queryType.getFieldDefinition("preview").getArgument("value").type is GraphQLEnumType) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt index b5938d96..2b152e1b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt @@ -45,6 +45,7 @@ class SchemaParserDictionaryTest { .dictionary("NestedB", ObjectNode::class.java) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -92,6 +93,7 @@ class SchemaParserDictionaryTest { .dictionary(dictionary.getDictionary()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val field = schema.queryType.getFieldDefinition("test") assertEquals(field.getAppliedDirective("a").getArgument("arg")?.getValue>(), mapOf("x" to 1)) @@ -128,6 +130,7 @@ class SchemaParserDictionaryTest { .dictionary("DogInput", LabradorRetriever::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val field = schema.queryType.getFieldDefinition("dog") assertEquals(field.getAppliedDirective("d").getArgument("arg")?.getValue>(), mapOf("name" to "z")) From 4f8429bd23e95b043c79f235e4d6c695383655d5 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:15:38 -0400 Subject: [PATCH 07/14] Query every field of the schemas in SchemaParserTest --- .../kickstart/tools/SchemaParserTest.kt | 326 ++++++++++-------- 1 file changed, 173 insertions(+), 153 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt index 0eaa8aef..8960a443 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt @@ -43,11 +43,13 @@ class SchemaParserTest { @Test fun `builder doesn't throw FileNotFound exception when file is present`() { - SchemaParser.newParser().file("Test.graphqls") + val schema = SchemaParser.newParser().file("Test.graphqls") .resolvers(object : GraphQLQueryResolver { fun getId(): String = "1" }) .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test(expected = SchemaClassScannerError::class) @@ -71,7 +73,7 @@ class SchemaParserTest { @Test fun `parser should parse correctly when Query resolver is given`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -83,11 +85,12 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test fun `parser should parse correctly when multiple query resolvers are given`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Obj { @@ -110,11 +113,12 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test fun `parser should parse correctly when multiple resolvers for the same data type are given`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type RootObj { @@ -149,29 +153,31 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test fun `parser should allow setting custom generic wrappers`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { one: Object! two: Object! } - + type Object { name: String! } """) .resolvers(object : GraphQLQueryResolver { - fun one(): CustomGenericWrapper? = null - fun two(): Obj? = null + fun one(): CustomGenericWrapper = CustomGenericWrapper(Obj()) + fun two(): Obj = Obj() }) - .options(SchemaParserOptions.newOptions().genericWrappers(SchemaParserOptions.GenericWrapper(CustomGenericWrapper::class, 1)).build()) + .options(SchemaParserOptions.newOptions().genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(CustomGenericWrapper::class, 1, { wrapper: CustomGenericWrapper<*, *> -> wrapper.value })).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test(expected = SchemaClassScannerError::class) @@ -290,7 +296,7 @@ class SchemaParserTest { @Test fun `parser should build type that was never reached by the scanner when including unused types`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .file("UnreachedType.graphqls") .resolvers(object : GraphQLQueryResolver { fun pet(): Pet? = null @@ -299,6 +305,7 @@ class SchemaParserTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test @@ -358,13 +365,13 @@ class SchemaParserTest { @Test fun `parser handles enums with overridden toString method`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ enum CustomEnum { FOO } - + type Query { customEnum: CustomEnum } @@ -374,6 +381,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test @@ -388,6 +396,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -405,6 +414,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -472,6 +482,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -484,7 +495,7 @@ class SchemaParserTest { @Test fun `support enum types if only used as input type`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { test: Boolean } @@ -503,20 +514,18 @@ class SchemaParserTest { """) .resolvers(object : GraphQLMutationResolver { fun save(input: SaveInput): Boolean = false - inner class SaveInput { - var type: EnumType? = null - } }, object : GraphQLQueryResolver { fun test(): Boolean = false }) .dictionary(EnumType::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test fun `support enum types if only used in input Map`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { test: Boolean } @@ -542,11 +551,12 @@ class SchemaParserTest { .dictionary(EnumType::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test fun `support enum types used in input Map if their class is found elsewhere`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -568,6 +578,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } @Test @@ -645,7 +656,7 @@ class SchemaParserTest { @Test fun `allow circular relations in input objects`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ input A { @@ -667,21 +678,6 @@ class SchemaParserTest { } """) .resolvers(object : GraphQLMutationResolver { - inner class A { - var id: String? = null - var b: B? = null - } - - inner class B { - var id: String? = null - var a: A? = null - } - - inner class C { - var id: String? = null - var c: C? = null - } - fun test(a: A): Boolean { return true } @@ -694,6 +690,22 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) + } + + class A { + var id: String? = null + var b: B? = null + } + + class B { + var id: String? = null + var a: A? = null + } + + class C { + var id: String? = null + var c: C? = null } @Test @@ -729,6 +741,7 @@ class SchemaParserTest { .resolvers(MultiLevelInterfaceResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val traitInterface = schema.getType("Trait") as GraphQLInterfaceType val animalInterface = schema.getType("Animal") as GraphQLInterfaceType val mammalTraitInterface = schema.getType("MammalTrait") as GraphQLInterfaceType @@ -800,6 +813,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val testNonNullableArgument = schema.getObjectType("Query")!! .getFieldDefinition("testNonNullable") @@ -815,7 +829,7 @@ class SchemaParserTest { @Test fun `input objects behind list and non-null input fields should resolve to GraphQLInputObjectType during directive wiring`() { val wiredFieldTypes = mutableMapOf() - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -849,6 +863,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) // parent points back at NestedFilter while it's still being built, so it stays a type reference until the schema is built assertEquals(wiredFieldTypes, mapOf( @@ -1005,6 +1020,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) assertEquals(schema.queryType.name, "SubstituteQuery") assertEquals(schema.mutationType?.name, "SubstituteMutation") @@ -1015,14 +1031,18 @@ class SchemaParserTest { TEST } + class SaveInput { + var type: EnumType? = null + } + class SaveInputMap : HashMap() class QueryWithIdResolver : GraphQLQueryResolver { - fun getId(): String? = null + fun getId(): String = "1" } class Filter { - fun filter(): String? = null + var filter: String? = null } data class NestedFilter(val subs: List?, val other: OtherFilter) @@ -1031,10 +1051,10 @@ class SchemaParserTest { data class OtherFilter(val name: String?) - class CustomGenericWrapper + class CustomGenericWrapper(val value: V) class Obj { - fun name() = null + fun name() = "name" } class AnotherObj { @@ -1142,30 +1162,30 @@ class SchemaParserTest { fun onItemAdded(): Publisher = StringPublisher("added") } - val gql = GraphQL.newGraphQL( - SchemaParser.newParser() - .schemaString( - """ - type Query { - test: String - } + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + test: String + } - type Mutation { - addItem(name: String!): String! - } + type Mutation { + addItem(name: String!): String! + } - type Subscription { - onItemAdded: String! - } - """ - ) - .resolvers( - MutationAndSubscription(), - object : GraphQLQueryResolver { fun test() = "test" } - ) - .build() - .makeExecutableSchema() - ).build() + type Subscription { + onItemAdded: String! + } + """ + ) + .resolvers( + MutationAndSubscription(), + object : GraphQLQueryResolver { fun test() = "test" } + ) + .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) + val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { """mutation { addItem(name: "item") }""" } @@ -1180,23 +1200,23 @@ class SchemaParserTest { fun onItemAdded(): Publisher = StringPublisher("added") } - val gql = GraphQL.newGraphQL( - SchemaParser.newParser() - .schemaString( - """ - type Query { - item: String! - } + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + item: String! + } - type Subscription { - onItemAdded: String! - } - """ - ) - .resolvers(QueryAndSubscription()) - .build() - .makeExecutableSchema() - ).build() + type Subscription { + onItemAdded: String! + } + """ + ) + .resolvers(QueryAndSubscription()) + .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) + val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { "{ item }" } @@ -1283,32 +1303,32 @@ class SchemaParserTest { override fun onOverriddenPublisher() = SingleEventPublisher("onOverriddenPublisher") } - val gql = GraphQL.newGraphQL( - SchemaParser.newParser() - .schemaString( - """ - type Query { - test: String - } + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + test: String + } - type Subscription { - onCustomPublisher: Event! - onConcretePublisher: Event! - onOverriddenPublisher: Event! - } + type Subscription { + onCustomPublisher: Event! + onConcretePublisher: Event! + onOverriddenPublisher: Event! + } - type Event { - name: String! - } - """ - ) - .resolvers( - Subscription(), - object : GraphQLQueryResolver { fun test() = "test" } - ) - .build() - .makeExecutableSchema() - ).build() + type Event { + name: String! + } + """ + ) + .resolvers( + Subscription(), + object : GraphQLQueryResolver { fun test() = "test" } + ) + .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) + val gql = GraphQL.newGraphQL(schema).build() listOf("onCustomPublisher", "onConcretePublisher", "onOverriddenPublisher").forEach { field -> assertEquals(gql.firstSubscriptionEvent("subscription { $field { name } }"), mapOf(field to mapOf("name" to field))) @@ -1325,34 +1345,34 @@ class SchemaParserTest { fun onWildcardPublisherFuture(): CompletionStage> = completedStage(SingleEventPublisher("onWildcardPublisherFuture")) } - val gql = GraphQL.newGraphQL( - SchemaParser.newParser() - .schemaString( - """ - type Query { - test: String - } + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + test: String + } - type Subscription { - onCompletableFuture: Event! - onCompletionStage: Event! - onFuture: Event! - onConcretePublisherFuture: Event! - onWildcardPublisherFuture: Event! - } + type Subscription { + onCompletableFuture: Event! + onCompletionStage: Event! + onFuture: Event! + onConcretePublisherFuture: Event! + onWildcardPublisherFuture: Event! + } - type Event { - name: String! - } - """ - ) - .resolvers( - Subscription(), - object : GraphQLQueryResolver { fun test() = "test" } - ) - .build() - .makeExecutableSchema() - ).build() + type Event { + name: String! + } + """ + ) + .resolvers( + Subscription(), + object : GraphQLQueryResolver { fun test() = "test" } + ) + .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) + val gql = GraphQL.newGraphQL(schema).build() listOf("onCompletableFuture", "onCompletionStage", "onFuture", "onConcretePublisherFuture", "onWildcardPublisherFuture").forEach { field -> assertEquals(gql.firstSubscriptionEvent("subscription { $field { name } }"), mapOf(field to mapOf("name" to field))) @@ -1365,33 +1385,33 @@ class SchemaParserTest { fun onChannel(): Channel = Channel(1).also { it.trySend("onChannel") } } - val gql = GraphQL.newGraphQL( - SchemaParser.newParser() - .schemaString( - """ - type Query { - test: String - } + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + test: String + } - type Subscription { - onChannel: String! - } - """ - ) - .resolvers( - Subscription(), - object : GraphQLQueryResolver { fun test() = "test" } - ) - .options( - SchemaParserOptions.newOptions() - .genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(Channel::class, 0, { channel: Channel<*> -> - publish { for (item in channel) send(item) } - })) - .build() - ) - .build() - .makeExecutableSchema() - ).build() + type Subscription { + onChannel: String! + } + """ + ) + .resolvers( + Subscription(), + object : GraphQLQueryResolver { fun test() = "test" } + ) + .options( + SchemaParserOptions.newOptions() + .genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(Channel::class, 0, { channel: Channel<*> -> + publish { for (item in channel) send(item) } + })) + .build() + ) + .build() + .makeExecutableSchema() + assertEveryFieldResolves(schema) + val gql = GraphQL.newGraphQL(schema).build() assertEquals(gql.firstSubscriptionEvent("subscription { onChannel }"), mapOf("onChannel" to "onChannel")) } From f2dcb3d6b377863de97b9ce06d4fe7e00ba9ce38 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:17:14 -0400 Subject: [PATCH 08/14] Query every field of the end-to-end schema and the remaining test schemas --- .../graphql/kickstart/tools/BuiltInIdTest.kt | 6 ++++++ .../tools/DeepGenericsHierarchyTest.kt | 1 + .../kickstart/tools/EndToEndSpecHelper.kt | 2 +- .../graphql/kickstart/tools/EndToEndTest.kt | 9 +++++++++ .../kickstart/tools/GenericObjectTypesTest.kt | 2 ++ .../kickstart/tools/GenericResolverTest.kt | 7 +++++-- .../kickstart/tools/IntrospectionTest.kt | 1 + .../kickstart/tools/MultiResolverTest.kt | 5 +++++ .../tools/ParameterizedGetterTest.kt | 5 +++++ .../kickstart/tools/PropertyMapListTest.kt | 2 ++ .../kickstart/tools/RelayConnectionTest.kt | 4 ++++ .../kickstart/tools/SuperclassResolverTest.kt | 3 ++- .../kickstart/tools/SupertypeResolverTest.kt | 5 +++++ .../tools/SuspendFunctionDataLoaderTest.kt | 19 +++++++++++++------ 14 files changed, 61 insertions(+), 10 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt b/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt index 38f1d150..3ff03218 100644 --- a/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt @@ -33,6 +33,12 @@ class BuiltInIdTest { .queryExecutionStrategy(AsyncExecutionStrategy()) .build() + @Test + fun `every field resolves`() { + // the made-up ID "1" isn't a UUID + assertEveryFieldResolves(schema, except = setOf("Query.itemByUuidId(id:)", "Query.itemsByUuidIds(ids:)")) + } + @Test fun `supports Long as ID as input`() { val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt index 7707f2bc..a8048115 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt @@ -12,6 +12,7 @@ class PlaceTest { .file("Place.graphqls") .resolvers(PlaceQuery()) .build().makeExecutableSchema() + assertEveryFieldResolves(schema) val graphql = GraphQL.newGraphQL(schema).build() val query = "query { places1 { id } places2 { id } }" diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt index 305ef636..0d4a05a6 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt @@ -292,7 +292,7 @@ class Query : GraphQLQueryResolver, ListListResolver() { fun itemsWithOptionalInput(input: ItemSearchInput?) = if (input == null) items else items(input) fun itemsWithOptionalInputExplicit(input: Optional?) = if (input?.isPresent == true) items(input.get()) else items fun enumInputType(type: Type) = type - fun customScalarMapInputType(customScalarMap: Map) = customScalarMap + fun customScalarMapInputType(customScalarMap: Map?) = customScalarMap fun itemWithGenericProperties() = ItemWithGenericProperties(listOf("A", "B")) fun defaultArgument(arg: Boolean) = arg diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt index 85197516..ddaa9f61 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt @@ -21,6 +21,15 @@ class EndToEndTest { .queryExecutionStrategy(AsyncExecutionStrategy()) .build() + @Test + fun `every field resolves`() { + val newItem = Item(1, "item", Type.TYPE_1, UUID.randomUUID(), listOf()) + // throws on purpose to test that the original exception is passed on + assertEveryFieldResolves(schema, except = setOf("Query.throwsIllegalArgumentException")) { + graphQLContext(mapOf("newItem" to newItem)) + } + } + @Test fun `schema comments are used as descriptions`() { val type = schema.allTypesAsList.find { it.name == "Type" } as GraphQLEnumType diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt index c59e07a0..c677e865 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt @@ -32,6 +32,7 @@ class GenericObjectTypesTest { .resolvers(EntityMatchQueryResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -89,6 +90,7 @@ class GenericObjectTypesTest { .dictionary(Human::class, Droid::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt index 0fc34a45..36e3207f 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt @@ -9,7 +9,7 @@ class GenericResolverTest { @Test fun `methods from generic resolvers are resolved`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -23,6 +23,7 @@ class GenericResolverTest { .resolvers(QueryResolver1(), BarResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } class QueryResolver1 : GraphQLQueryResolver { @@ -41,7 +42,7 @@ class GenericResolverTest { @Test fun `methods from generic inherited resolvers are resolved`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -54,6 +55,7 @@ class GenericResolverTest { .resolvers(QueryResolver2(), CarResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } class QueryResolver2 : GraphQLQueryResolver { @@ -132,6 +134,7 @@ class GenericResolverTest { .resolvers(QueryResolver3(), resolver) .build() .makeExecutableSchema() + .also { assertEveryFieldResolves(it) } class QueryResolver3 : GraphQLQueryResolver { fun getPage(): Page = Page(listOf(Item("item"))) diff --git a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt index fa18e90d..c62e5cb8 100644 --- a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt @@ -23,6 +23,7 @@ class IntrospectionTest { .options(SchemaParserOptions.newOptions().introspectionEnabled(introspectionEnabled).build()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) return GraphQL.newGraphQL(schema).build() } diff --git a/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt index dcb6f8c1..e54e8b88 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt @@ -30,6 +30,11 @@ class MultiResolverTest { .queryExecutionStrategy(AsyncExecutionStrategy()) .build() + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) + } + @Test fun `multiple resolvers for one data class should resolve methods with arguments`() { val data = assertNoGraphQlErrors(gql, mapOf("friendName" to "name")) { diff --git a/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt b/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt index 2f6cc754..a9efe06d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt @@ -30,6 +30,11 @@ class ParameterizedGetterTest { .queryExecutionStrategy(AsyncExecutionStrategy()) .build() + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) + } + @Test fun `parameterized query is resolved on data type instead of on its resolver`() { val data = assertNoGraphQlErrors(gql, mapOf("limit" to 10)) { diff --git a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt index 936c7c82..29912673 100644 --- a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt @@ -40,6 +40,7 @@ class PropertyMapListTest { .dictionary("Key", HashMap::class) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -83,6 +84,7 @@ class PropertyMapListTest { }) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt index 0906a90e..52728610 100644 --- a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt @@ -52,6 +52,8 @@ class RelayConnectionTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() + // the made-up cursor "a" isn't a valid cursor + assertEveryFieldResolves(schema, except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -106,6 +108,8 @@ class RelayConnectionTest { .dictionary(User::class.java) .build() .makeExecutableSchema() + // the made-up cursor "a" isn't a valid cursor + assertEveryFieldResolves(schema, except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) diff --git a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt index c1f24ae9..2486ad8f 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt @@ -6,7 +6,7 @@ class SuperclassResolverTest { @Test fun `methods from generic resolvers are resolved`() { - SchemaParser.newParser() + val schema = SchemaParser.newParser() .schemaString( """ type Query { @@ -25,6 +25,7 @@ class SuperclassResolverTest { .resolvers(QueryResolver(), BarResolver()) .build() .makeExecutableSchema() + assertEveryFieldResolves(schema) } class QueryResolver : GraphQLQueryResolver { diff --git a/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt index f3d1ef1d..c6d52042 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt @@ -41,6 +41,11 @@ class SupertypeResolverTest { .queryExecutionStrategy(AsyncExecutionStrategy()) .build() + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) + } + @Test fun `resolvers for a superclass or interface should resolve fields of subclasses`() { val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt b/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt index 20b8a4e7..7a75e317 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt @@ -30,6 +30,11 @@ class SuspendFunctionDataLoaderTest { .makeExecutableSchema() private val gql = GraphQL.newGraphQL(schema).build() + @Test + fun `every field resolves`() { + assertEveryFieldResolves(schema) { dataLoaderRegistry(registry()) } + } + @Test fun `root suspend function can await a data loader`() { repeat(20) { @@ -52,19 +57,21 @@ class SuspendFunctionDataLoaderTest { } private fun execute(query: String): Any? { - val userLoader = DataLoaderFactory.newDataLoader { ids -> - CompletableFuture.supplyAsync { ids.map { User(it) } } - } - val registry = DataLoaderRegistry.newRegistry().register("user", userLoader).build() - // a resolver that awaits a load before it is dispatched hangs, so don't wait forever - val result = gql.executeAsync(ExecutionInput.newExecutionInput(query).dataLoaderRegistry(registry)) + val result = gql.executeAsync(ExecutionInput.newExecutionInput(query).dataLoaderRegistry(registry())) .get(5, TimeUnit.SECONDS) assert(result.errors.isEmpty()) { result.errors.joinToString { it.message } } return result.getData() } + private fun registry(): DataLoaderRegistry { + val userLoader = DataLoaderFactory.newDataLoader { ids -> + CompletableFuture.supplyAsync { ids.map { User(it) } } + } + return DataLoaderRegistry.newRegistry().register("user", userLoader).build() + } + class Query : GraphQLQueryResolver { fun user(id: Int): User = User(id) From 7722fb9afe7a2257261724278fdfc96c171eb479 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:18:35 -0400 Subject: [PATCH 09/14] Query every field of the schemas in the Java resolver test --- pom.xml | 3 ++- .../kotlin/graphql/kickstart/tools/ResolverMethodsTest.java | 4 ++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 92d32921..653ae2a2 100644 --- a/pom.xml +++ b/pom.xml @@ -276,8 +276,9 @@ + test-compile - test-compile + process-test-sources test-compile diff --git a/src/test/kotlin/graphql/kickstart/tools/ResolverMethodsTest.java b/src/test/kotlin/graphql/kickstart/tools/ResolverMethodsTest.java index 864e8c69..17416eca 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ResolverMethodsTest.java +++ b/src/test/kotlin/graphql/kickstart/tools/ResolverMethodsTest.java @@ -9,6 +9,7 @@ import java.util.List; import java.util.Map; +import static graphql.kickstart.tools.EveryFieldResolvesKt.assertEveryFieldResolves; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -26,6 +27,7 @@ public void testOmittedBooleanArgument() { .resolvers(new Resolver()) .build() .makeExecutableSchema(); + assertEveryFieldResolves(schema); GraphQL gql = GraphQL.newGraphQL(schema).build(); @@ -63,6 +65,7 @@ public String name(Product product) { }) .build() .makeExecutableSchema(); + assertEveryFieldResolves(schema); GraphQL gql = GraphQL.newGraphQL(schema).build(); @@ -85,6 +88,7 @@ public void testRawResolverForParameterizedDataClass() { .resolvers(new PageQueryResolver(), new RawPageResolver()) .build() .makeExecutableSchema(); + assertEveryFieldResolves(schema); GraphQL gql = GraphQL.newGraphQL(schema).build(); From 3481eb25466c00c104c564b23d0cfcec33d57323 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:19:40 -0400 Subject: [PATCH 10/14] Skip the check where only a placeholder field is left --- .../graphql/kickstart/tools/UnmappedInputFieldsTest.kt | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt index 535da0da..65111091 100644 --- a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt @@ -35,8 +35,6 @@ class UnmappedInputFieldsTest { @Test fun `misspelled property of an input class is reported`() { val (schema, warnings) = withWarnings { projectParser().makeExecutableSchema() } - // the input class misspells technologies, so createProject fails when queried - assertEveryFieldResolves(schema, except = setOf("Mutation.createProject")) assertEquals(warnings, listOf(TECHNOLOGIES_MESSAGE)) @@ -379,11 +377,9 @@ class UnmappedInputFieldsTest { @Test fun `input classes are not checked if asked not to`() { - val (schema, warnings) = withWarnings { + val (_, warnings) = withWarnings { projectParser(SchemaParserOptions.newOptions().unmappedInputFields(UnmappedInputFields.IGNORE).build()).makeExecutableSchema() } - // the input class misspells technologies, so createProject fails when queried - assertEveryFieldResolves(schema, except = setOf("Mutation.createProject")) assertEquals(warnings, emptyList()) } @@ -727,7 +723,7 @@ class UnmappedInputFieldsTest { assertEveryFieldResolves(schema, except = setOf( // the input classes misspell name on purpose "Query.injected", "Query.builder", - // MethodFieldResolver converts the argument with the unresolved type variable of the inherited parameter + // fails when queried, because the type variable of the inherited parameter isn't resolved "Query.generic" )) From c574e2eeba94566f8e5abb1eef9753b9f286a397 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 18:32:51 -0400 Subject: [PATCH 11/14] Fail on subscriptions without an event and stop repeating types through unions --- .../kickstart/tools/EveryFieldResolves.kt | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt index 42385c10..27011ece 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt @@ -16,7 +16,8 @@ import java.util.concurrent.TimeUnit import java.util.concurrent.TimeoutException /** - * Runs one operation per root field that selects every field reachable from it, and fails on any error. + * Runs one operation per root field that selects every field reachable from it, and fails on any error. A + * subscription has to send an event, and that event's errors count too. * * Arguments without a default get a made-up value. Fields ("Type.field") and arguments ("Type.field(arg:)") named in * [except] are left out. So is a field with a required argument that's left out or is a custom scalar, which has no @@ -52,7 +53,7 @@ private class EveryFieldQuery(private val schema: GraphQLSchema, private val exc private fun field(parent: GraphQLFieldsContainer, field: GraphQLFieldDefinition, path: List): String? { val type = unwrapAll(field.type) // a type can repeat once on a path, so a field that refers back to its own type still runs - if (type !is GraphQLScalarType && type !is GraphQLEnumType && (path.size >= MAX_DEPTH || path.count { it == type.name } >= 2)) { + if (type is GraphQLCompositeType && (path.size >= MAX_DEPTH || repeated(type, path))) { return null } val arguments = field.arguments.filter { !it.hasSetDefaultValue() }.mapNotNull { argument -> @@ -76,7 +77,9 @@ private class EveryFieldQuery(private val schema: GraphQLSchema, private val exc } private fun fragments(types: List, path: List) = - "{ __typename ${types.joinToString(" ") { "... on ${it.name} ${selection(it, path)}" }} }" + "{ __typename ${types.filter { !repeated(it, path) }.joinToString(" ") { "... on ${it.name} ${selection(it, path)}" }} }" + + private fun repeated(type: GraphQLNamedType, path: List) = path.count { it == type.name } >= 2 private fun value(type: GraphQLInputType, path: Set): String? = when (type) { is GraphQLNonNull -> value(type.wrappedType as GraphQLInputType, path) @@ -102,7 +105,8 @@ private class EveryFieldQuery(private val schema: GraphQLSchema, private val exc } } // a @oneOf input takes exactly one field - return (if (type.isOneOf) fields.take(1) else fields).joinToString(", ", "{ ", " }") + if (type.isOneOf) return fields.firstOrNull()?.let { "{ $it }" } + return fields.joinToString(", ", "{ ", " }") } } @@ -121,7 +125,7 @@ private fun execute(gql: GraphQL, input: ExecutionInput): List { } private fun firstEventErrors(events: Publisher<*>): List { - val first = CompletableFuture() + val first = CompletableFuture() var subscription: Subscription? = null events.subscribe(object : Subscriber { override fun onSubscribe(s: Subscription) { @@ -138,13 +142,13 @@ private fun firstEventErrors(events: Publisher<*>): List { } override fun onComplete() { - first.complete(null) + first.completeExceptionally(IllegalStateException("completed without an event")) } }) return try { - first.get(1, TimeUnit.SECONDS)?.errors?.map { it.message } ?: listOf() + first.get(5, TimeUnit.SECONDS).errors.map { it.message } } catch (e: TimeoutException) { - listOf() + listOf("Subscription sent no event") } catch (e: ExecutionException) { listOf("Subscription failed: ${e.cause}") } finally { From 9b443f98fee6c73d373280966cfdd2e9542560f9 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 19:07:56 -0400 Subject: [PATCH 12/14] Point the generic exclusion at its issue --- .../kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt index 65111091..ad82d169 100644 --- a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt @@ -723,7 +723,7 @@ class UnmappedInputFieldsTest { assertEveryFieldResolves(schema, except = setOf( // the input classes misspell name on purpose "Query.injected", "Query.builder", - // fails when queried, because the type variable of the inherited parameter isn't resolved + // TODO query generic once the type variable of its inherited parameter is resolved (#880) "Query.generic" )) From 3ef90b8a41167c2db9ad0899c4a4f6b3eaf56b8b Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 19:12:09 -0400 Subject: [PATCH 13/14] Make assertEveryFieldResolves an extension on the schema --- .../graphql/kickstart/tools/BuiltInIdTest.kt | 2 +- .../kickstart/tools/CustomScalarInputTest.kt | 2 +- .../tools/DeepGenericsHierarchyTest.kt | 2 +- .../tools/DeprecatedDirectiveTest.kt | 22 ++++----- .../graphql/kickstart/tools/DirectiveTest.kt | 28 +++++------ .../graphql/kickstart/tools/EndToEndTest.kt | 2 +- .../kickstart/tools/EnumDefaultValueTest.kt | 4 +- .../kickstart/tools/EnumListParameterTest.kt | 2 +- .../kickstart/tools/EveryFieldResolves.kt | 8 ++-- .../kickstart/tools/GenericInputTypesTest.kt | 10 ++-- .../kickstart/tools/GenericObjectTypesTest.kt | 4 +- .../kickstart/tools/GenericResolverTest.kt | 6 +-- .../tools/InaccessibleFieldResolverTest.kt | 4 +- .../tools/InheritedTypeVariablesTest.kt | 8 ++-- .../kickstart/tools/InputDefaultValueTest.kt | 2 +- .../kickstart/tools/IntrospectionTest.kt | 2 +- .../tools/MethodFieldResolverTest.kt | 12 ++--- .../tools/MissingFieldResolverTest.kt | 6 +-- .../kickstart/tools/MultiResolverTest.kt | 2 +- .../kickstart/tools/NestedInputTypesTest.kt | 16 +++---- .../tools/ParameterizedGetterTest.kt | 2 +- .../kickstart/tools/PropertyMapListTest.kt | 4 +- .../graphql/kickstart/tools/ReactiveTest.kt | 6 +-- .../kickstart/tools/RelayConnectionTest.kt | 4 +- .../tools/SchemaClassScannerDirectiveTest.kt | 16 +++---- .../SchemaClassScannerInterfaceFieldTest.kt | 16 +++---- .../SchemaClassScannerSealedTypesTest.kt | 10 ++-- .../kickstart/tools/SchemaClassScannerTest.kt | 36 +++++++-------- .../tools/SchemaParserDictionaryTest.kt | 6 +-- .../kickstart/tools/SchemaParserTest.kt | 46 +++++++++---------- .../kickstart/tools/SuperclassResolverTest.kt | 2 +- .../kickstart/tools/SupertypeResolverTest.kt | 2 +- .../tools/SuspendFunctionDataLoaderTest.kt | 2 +- .../kickstart/tools/TypeExtensionTest.kt | 18 ++++---- .../tools/UnmappedInputFieldsTest.kt | 12 ++--- 35 files changed, 163 insertions(+), 163 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt b/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt index 3ff03218..9a094a71 100644 --- a/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt @@ -36,7 +36,7 @@ class BuiltInIdTest { @Test fun `every field resolves`() { // the made-up ID "1" isn't a UUID - assertEveryFieldResolves(schema, except = setOf("Query.itemByUuidId(id:)", "Query.itemsByUuidIds(ids:)")) + schema.assertEveryFieldResolves(except = setOf("Query.itemByUuidId(id:)", "Query.itemsByUuidIds(ids:)")) } @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt index f1130937..b9f6951a 100644 --- a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt @@ -191,7 +191,7 @@ class CustomScalarInputTest { .options(options) .build() .makeExecutableSchema() - assertEveryFieldResolves(graphQLSchema) + graphQLSchema.assertEveryFieldResolves() return GraphQL.newGraphQL(graphQLSchema).build() } diff --git a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt index a8048115..ffa34c9b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt @@ -12,7 +12,7 @@ class PlaceTest { .file("Place.graphqls") .resolvers(PlaceQuery()) .build().makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val graphql = GraphQL.newGraphQL(schema).build() val query = "query { places1 { id } places2 { id } }" diff --git a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt index 3fefa663..937f7fc6 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt @@ -35,7 +35,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -69,7 +69,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -110,7 +110,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -151,7 +151,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -185,7 +185,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -219,7 +219,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -255,7 +255,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -291,7 +291,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -329,7 +329,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -367,7 +367,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -408,7 +408,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val name = (schema.getType("User") as GraphQLObjectType).getField("name") assertEquals("No longer supported", name.getAppliedDirective("deprecated").getArgument("reason")!!.getValue()) diff --git a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt index d46d9d3d..1c9928ca 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt @@ -41,7 +41,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -94,7 +94,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -139,7 +139,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -182,7 +182,7 @@ class DirectiveTest { .directive("double", DoubleDirective()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -226,7 +226,7 @@ class DirectiveTest { .directive("log", DescriptionDirective("log")) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.queryType.getField("name").description, "Name +auth +log") } @@ -250,7 +250,7 @@ class DirectiveTest { .directiveWiring(DescriptionDirective("static")) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.queryType.getField("name").description, "Name +auth +static") } @@ -295,7 +295,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -348,7 +348,7 @@ class DirectiveTest { .dictionary(AllowedState::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -377,7 +377,7 @@ class DirectiveTest { .resolvers(BookQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val filter = schema.getType("BookFilter") as GraphQLInputObjectType assert(filter.isOneOf) @@ -417,7 +417,7 @@ class DirectiveTest { .directive("email", emailDirective) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val expectedMessages = mapOf( "contactEmail" to "{path} must be a valid email", @@ -466,7 +466,7 @@ class DirectiveTest { .directive("option", recorder) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val inputObject = listOf("GraphQLInputObjectType") val expectedTypes = mapOf("name" to inputObject, "ConfigInput" to inputObject, "level" to inputObject) @@ -505,7 +505,7 @@ class DirectiveTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assert(wiredFields == listOf("max")) { "$wiredFields with directives declared as $directives" } val limit = (schema.getType("BoundInput") as GraphQLInputObjectType).getField("max").getAppliedDirective("limit") @@ -547,7 +547,7 @@ class DirectiveTest { .dictionary(LinkPurpose::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.schemaAppliedDirectives.map { it.name }, listOf("contact", "link", "link")) assertEquals( @@ -611,7 +611,7 @@ class DirectiveTest { .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val link = schema.getSchemaAppliedDirective("link") assertEquals(link.getArgument("import")?.getValue>(), listOf("@key", "@shareable")) diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt index ddaa9f61..e6f37c3a 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt @@ -25,7 +25,7 @@ class EndToEndTest { fun `every field resolves`() { val newItem = Item(1, "item", Type.TYPE_1, UUID.randomUUID(), listOf()) // throws on purpose to test that the original exception is passed on - assertEveryFieldResolves(schema, except = setOf("Query.throwsIllegalArgumentException")) { + schema.assertEveryFieldResolves(except = setOf("Query.throwsIllegalArgumentException")) { graphQLContext(mapOf("newItem" to newItem)) } } diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt index bdf08950..cd9e992c 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt @@ -29,7 +29,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val ggl = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -65,7 +65,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val ggl = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt index 0517db5b..89809617 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EnumListParameterTest.kt @@ -50,7 +50,7 @@ class EnumListParameterTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class QueryResolver : GraphQLQueryResolver { diff --git a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt index 27011ece..ad8a7d90 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt @@ -24,10 +24,10 @@ import java.util.concurrent.TimeoutException * value to make up. [input] adds to every operation, e.g. a context or a data loader registry. */ @JvmOverloads -fun assertEveryFieldResolves(schema: GraphQLSchema, except: Set = setOf(), input: ExecutionInput.Builder.() -> Unit = {}) { - val gql = GraphQL.newGraphQL(schema).build() - val query = EveryFieldQuery(schema, except) - val roots = mapOf("query" to schema.queryType, "mutation" to schema.mutationType, "subscription" to schema.subscriptionType) +fun GraphQLSchema.assertEveryFieldResolves(except: Set = setOf(), input: ExecutionInput.Builder.() -> Unit = {}) { + val gql = GraphQL.newGraphQL(this).build() + val query = EveryFieldQuery(this, except) + val roots = mapOf("query" to queryType, "mutation" to mutationType, "subscription" to subscriptionType) val errors = roots.flatMap { (operation, root) -> if (root == null) return@flatMap listOf() query.fields(root).flatMap { field -> diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt index 56c35fb0..cf05c1a9 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt @@ -32,7 +32,7 @@ class GenericInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -69,7 +69,7 @@ class GenericInputTypesTest { .resolvers(InheritedQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -114,7 +114,7 @@ class GenericInputTypesTest { .resolvers(MultipleParameterizationsQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -156,7 +156,7 @@ class GenericInputTypesTest { .resolvers(NestedQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -190,7 +190,7 @@ class GenericInputTypesTest { .resolvers(InheritedListQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt index c677e865..ffea2cd6 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt @@ -32,7 +32,7 @@ class GenericObjectTypesTest { .resolvers(EntityMatchQueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -90,7 +90,7 @@ class GenericObjectTypesTest { .dictionary(Human::class, Droid::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt index 36e3207f..13814a3d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt @@ -23,7 +23,7 @@ class GenericResolverTest { .resolvers(QueryResolver1(), BarResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class QueryResolver1 : GraphQLQueryResolver { @@ -55,7 +55,7 @@ class GenericResolverTest { .resolvers(QueryResolver2(), CarResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class QueryResolver2 : GraphQLQueryResolver { @@ -134,7 +134,7 @@ class GenericResolverTest { .resolvers(QueryResolver3(), resolver) .build() .makeExecutableSchema() - .also { assertEveryFieldResolves(it) } + .also { it.assertEveryFieldResolves() } class QueryResolver3 : GraphQLQueryResolver { fun getPage(): Page = Page(listOf(Item("item"))) diff --git a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt index a1ae6576..2874b31b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt @@ -32,7 +32,7 @@ class InaccessibleFieldResolverTest { .build() .makeExecutableSchema() // without LocaleResolver, languageTag reads the private field of Locale, which the module system blocks - assertEveryFieldResolves(schema, except = setOf("Locale.languageTag")) + schema.assertEveryFieldResolves(except = setOf("Locale.languageTag")) val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -70,7 +70,7 @@ class InaccessibleFieldResolverTest { .resolvers(Query(), LocaleResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() diff --git a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt index 4bebd185..74f3cf11 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt @@ -33,7 +33,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -73,7 +73,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -121,7 +121,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -174,7 +174,7 @@ class InheritedTypeVariablesTest { .resolvers(RawGenericFixtures.QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt index 980db06d..80c0f86d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InputDefaultValueTest.kt @@ -51,7 +51,7 @@ class InputDefaultValueTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class QueryResolver : GraphQLQueryResolver { diff --git a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt index c62e5cb8..4a096135 100644 --- a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt @@ -23,7 +23,7 @@ class IntrospectionTest { .options(SchemaParserOptions.newOptions().introspectionEnabled(introspectionEnabled).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() return GraphQL.newGraphQL(schema).build() } diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt index 9db3f956..4db8aab7 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt @@ -38,7 +38,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -81,7 +81,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -118,7 +118,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -150,7 +150,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -198,7 +198,7 @@ class MethodFieldResolverTest { .resolvers(resolver) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -263,7 +263,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute(ExecutionInput.newExecutionInput().query( diff --git a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt index 0acf261f..0c995bf5 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt @@ -49,7 +49,7 @@ class MissingFieldResolverTest { .makeExecutableSchema() } // missingField has no resolver, so querying it throws - assertEveryFieldResolves(schema, except = setOf("Query.missingField")) + schema.assertEveryFieldResolves(except = setOf("Query.missingField")) assertEquals(warnings, listOf( "Option 'allowUnimplementedResolvers' should only be set to true during development, as it can cause schema errors to be moved " + @@ -78,7 +78,7 @@ class MissingFieldResolverTest { .build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -119,7 +119,7 @@ class MissingFieldResolverTest { .options(options) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt index e54e8b88..0a91997a 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MultiResolverTest.kt @@ -32,7 +32,7 @@ class MultiResolverTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt index 79b1380c..359d8b10 100644 --- a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt @@ -39,7 +39,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -90,7 +90,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -140,7 +140,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -193,7 +193,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -243,7 +243,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -286,7 +286,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -331,7 +331,7 @@ class NestedInputTypesTest { .dictionary("ShipmentLineInput", ShipmentLineInput::class.java) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -380,7 +380,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt b/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt index a9efe06d..075895b0 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ParameterizedGetterTest.kt @@ -32,7 +32,7 @@ class ParameterizedGetterTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt index 29912673..d071c05f 100644 --- a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt @@ -40,7 +40,7 @@ class PropertyMapListTest { .dictionary("Key", HashMap::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -84,7 +84,7 @@ class PropertyMapListTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt index b8d4a838..50430865 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt @@ -31,7 +31,7 @@ class ReactiveTest { .options(options) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -94,7 +94,7 @@ class ReactiveTest { .build() val schema = itemSchema(PlainFutureQuery(), options) // suspendCompletableItem is a suspend function that returns a future, which is rejected - assertEveryFieldResolves(schema, except = setOf("Query.suspendCompletableItem")) + schema.assertEveryFieldResolves(except = setOf("Query.suspendCompletableItem")) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -183,7 +183,7 @@ class ReactiveTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt index 52728610..d2844ecb 100644 --- a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt @@ -53,7 +53,7 @@ class RelayConnectionTest { .build() .makeExecutableSchema() // the made-up cursor "a" isn't a valid cursor - assertEveryFieldResolves(schema, except = setOf("Query.users(after:)")) + schema.assertEveryFieldResolves(except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -109,7 +109,7 @@ class RelayConnectionTest { .build() .makeExecutableSchema() // the made-up cursor "a" isn't a valid cursor - assertEveryFieldResolves(schema, except = setOf("Query.users(after:)")) + schema.assertEveryFieldResolves(except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt index 68cde932..ad7fdbe6 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt @@ -33,7 +33,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -75,7 +75,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -107,7 +107,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -137,7 +137,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertNotNull(schema.directivesByName["doSomething"]?.getArgument("one")?.directivesByName?.get("somethingElse")) assertNotNull(schema.directivesByName["somethingElse"]?.getArgument("two")?.directivesByName?.get("doSomething")) @@ -151,7 +151,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() val schema = parser.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val purpose = schema.getType("Purpose") as GraphQLEnumType assertEquals(purpose.values.map { it.value }, listOf("SECURITY", "EXECUTION")) @@ -177,7 +177,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION", "SECURITY")) assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { IntrospectionQuery.INTROSPECTION_QUERY } @@ -196,7 +196,7 @@ class SchemaClassScannerDirectiveTest { .dictionary(Purpose::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } @@ -216,7 +216,7 @@ class SchemaClassScannerDirectiveTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt index e52841c3..067fc4b2 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt @@ -41,7 +41,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyUnion.TestInterfaceImpl::class, InterfaceOnlyUnion.TestUnion2::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val testUnion = schema.getType("TestUnion") as GraphQLUnionType assertEquals(testUnion.types.map { it.name }.toSet(), setOf("TestUnion1", "TestUnion2")) @@ -125,7 +125,7 @@ class SchemaClassScannerInterfaceFieldTest { .resolvers(SingleMemberUnions()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Result") as GraphQLUnionType).types.map { it.name }, listOf("Node")) assertEquals((schema.getType("SortResponse") as GraphQLUnionType).types.map { it.name }, listOf("NodeSortResponse")) @@ -184,7 +184,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(ChainedInterfaceUnion.Box::class, ChainedInterfaceUnion.Image::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -249,7 +249,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(NestedInterfaceOnlyUnion.Book::class, NestedInterfaceOnlyUnion.Image::class, NestedInterfaceOnlyUnion.RichCaption::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Caption") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("PlainCaption", "RichCaption")) } @@ -299,7 +299,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyInterface.Box::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assert(schema.getType("Entry") is GraphQLInterfaceType) } @@ -353,7 +353,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableUnion.Book::class, DictionaryReachableUnion.Holder::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -415,7 +415,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableInterface.Shelf::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.getImplementations(schema.getType("Item") as GraphQLInterfaceType)!!.map { it.name }.toSet(), setOf("Book", "Magazine")) } @@ -474,7 +474,7 @@ class SchemaClassScannerInterfaceFieldTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image", "Caption")) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt index d88561fe..e3ef30f2 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt @@ -47,7 +47,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedClassUnion()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } @@ -94,7 +94,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedInterfaceImplementors()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -155,7 +155,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(GenericSealedClass()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -211,7 +211,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(MemberReachableThroughSealedSubclass()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("SearchResult") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Book", "Author")) @@ -258,7 +258,7 @@ class SchemaClassScannerSealedTypesTest { .dictionary("WeirdPet", DictionaryOverridesSealedSubclass.ClassifiedWeirdPet::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt index bc86d584..1e358808 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt @@ -26,7 +26,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } private class FutureImmediateQuery : GraphQLQueryResolver { @@ -49,7 +49,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } private class PrimitiveBoxedQuery : GraphQLQueryResolver { @@ -71,7 +71,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } private class ScalarDuplicateQuery : GraphQLQueryResolver { @@ -95,7 +95,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val interfaceType = schema.additionalTypes.find { it is GraphQLInterfaceType } assertNotNull(interfaceType) @@ -129,7 +129,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val inputTypeCount = schema.additionalTypes.count { it is GraphQLInputType } assertEquals(inputTypeCount, 3) @@ -188,7 +188,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } private class FluentSetterMutation : GraphQLMutationResolver { @@ -255,7 +255,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } private class GetterWithArgumentsQuery : GraphQLQueryResolver { @@ -305,7 +305,7 @@ class SchemaClassScannerTest { ) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val inputTypeExtensionCount = schema.additionalTypes .filterIsInstance() @@ -337,7 +337,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assert(schema.typeMap.containsKey("UUID")) } @@ -376,7 +376,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 2) @@ -425,7 +425,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 1) @@ -472,7 +472,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assert(schema.typeMap.containsKey("customMap")) } @@ -515,7 +515,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -551,7 +551,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 2) @@ -590,7 +590,7 @@ class SchemaClassScannerTest { .dictionary(NestedInterfaceTypeQuery.Dog::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 3) @@ -653,7 +653,7 @@ class SchemaClassScannerTest { .scalars(fieldSetScalar, linkImportScalar) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val objectTypes = schema.additionalTypes.filterIsInstance() assert(objectTypes.any { it.name == "User" }) @@ -746,7 +746,7 @@ class SchemaClassScannerTest { .dictionary(Unused::class, Implementation::class, SomeEnum::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val objectTypes = schema.additionalTypes.filterIsInstance() val interfaceTypes = schema.additionalTypes.filterIsInstance() @@ -788,7 +788,7 @@ class SchemaClassScannerTest { .dictionary(SomeEnum::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assert(schema.queryType.getFieldDefinition("preview").getArgument("value").type is GraphQLEnumType) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt index 2b152e1b..341316b5 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt @@ -45,7 +45,7 @@ class SchemaParserDictionaryTest { .dictionary("NestedB", ObjectNode::class.java) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -93,7 +93,7 @@ class SchemaParserDictionaryTest { .dictionary(dictionary.getDictionary()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val field = schema.queryType.getFieldDefinition("test") assertEquals(field.getAppliedDirective("a").getArgument("arg")?.getValue>(), mapOf("x" to 1)) @@ -130,7 +130,7 @@ class SchemaParserDictionaryTest { .dictionary("DogInput", LabradorRetriever::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val field = schema.queryType.getFieldDefinition("dog") assertEquals(field.getAppliedDirective("d").getArgument("arg")?.getValue>(), mapOf("name" to "z")) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt index 8960a443..30c234de 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt @@ -49,7 +49,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test(expected = SchemaClassScannerError::class) @@ -85,7 +85,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -113,7 +113,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -153,7 +153,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -177,7 +177,7 @@ class SchemaParserTest { .options(SchemaParserOptions.newOptions().genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(CustomGenericWrapper::class, 1, { wrapper: CustomGenericWrapper<*, *> -> wrapper.value })).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test(expected = SchemaClassScannerError::class) @@ -305,7 +305,7 @@ class SchemaParserTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -381,7 +381,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -396,7 +396,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -414,7 +414,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -482,7 +482,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -520,7 +520,7 @@ class SchemaParserTest { .dictionary(EnumType::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -551,7 +551,7 @@ class SchemaParserTest { .dictionary(EnumType::class) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -578,7 +578,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test @@ -690,7 +690,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class A { @@ -741,7 +741,7 @@ class SchemaParserTest { .resolvers(MultiLevelInterfaceResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val traitInterface = schema.getType("Trait") as GraphQLInterfaceType val animalInterface = schema.getType("Animal") as GraphQLInterfaceType val mammalTraitInterface = schema.getType("MammalTrait") as GraphQLInterfaceType @@ -813,7 +813,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val testNonNullableArgument = schema.getObjectType("Query")!! .getFieldDefinition("testNonNullable") @@ -863,7 +863,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() // parent points back at NestedFilter while it's still being built, so it stays a type reference until the schema is built assertEquals(wiredFieldTypes, mapOf( @@ -1020,7 +1020,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.queryType.name, "SubstituteQuery") assertEquals(schema.mutationType?.name, "SubstituteMutation") @@ -1184,7 +1184,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { """mutation { addItem(name: "item") }""" } @@ -1215,7 +1215,7 @@ class SchemaParserTest { .resolvers(QueryAndSubscription()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { "{ item }" } @@ -1327,7 +1327,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() listOf("onCustomPublisher", "onConcretePublisher", "onOverriddenPublisher").forEach { field -> @@ -1371,7 +1371,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() listOf("onCompletableFuture", "onCompletionStage", "onFuture", "onConcretePublisherFuture", "onWildcardPublisherFuture").forEach { field -> @@ -1410,7 +1410,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() assertEquals(gql.firstSubscriptionEvent("subscription { onChannel }"), mapOf("onChannel" to "onChannel")) diff --git a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt index 2486ad8f..0a5d47fe 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt @@ -25,7 +25,7 @@ class SuperclassResolverTest { .resolvers(QueryResolver(), BarResolver()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } class QueryResolver : GraphQLQueryResolver { diff --git a/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt index c6d52042..efab89c8 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SupertypeResolverTest.kt @@ -43,7 +43,7 @@ class SupertypeResolverTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() } @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt b/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt index 7a75e317..a3d95e8b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SuspendFunctionDataLoaderTest.kt @@ -32,7 +32,7 @@ class SuspendFunctionDataLoaderTest { @Test fun `every field resolves`() { - assertEveryFieldResolves(schema) { dataLoaderRegistry(registry()) } + schema.assertEveryFieldResolves() { dataLoaderRegistry(registry()) } } @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt index 35572962..c8117172 100644 --- a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt @@ -52,7 +52,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class, Item::class) scalars(GraphQLScalarType.newScalar().name("Date").coercing(Scalars.GraphQLString.coercing).build()) }.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val fooBar = schema.getType("FooBar") as GraphQLUnionType val color = schema.getType("Color") as GraphQLEnumType @@ -108,7 +108,7 @@ class TypeExtensionTest { """) { dictionary(Foo::class, Bar::class, Baz::class) }.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -132,7 +132,7 @@ class TypeExtensionTest { """) { dictionary(Item::class, Bar::class) }.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Node") as GraphQLInterfaceType).fieldDefinitions.map { it.name }, listOf("id", "fooBar")) assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Foo", "Bar")) @@ -250,7 +250,7 @@ class TypeExtensionTest { directive("once", wiring) }.makeExecutableSchema() } - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(warnings, listOf("Directive @once isn't repeatable but an extension of type 'Query' applies it again, only the first one is kept.")) @@ -299,7 +299,7 @@ class TypeExtensionTest { """) { options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) }.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(schema.queryType.appliedDirectives.map { it.getArgument("fields")?.getValue() }, listOf("upc", "name")) } @@ -327,7 +327,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class) options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) }.makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -365,7 +365,7 @@ class TypeExtensionTest { dictionary(Item::class, Foo::class, Bar::class, Baz::class) }.makeExecutableSchema() } - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(warnings, listOf( "Type 'Node' declares field 'id' more than once, only the first one is kept.", @@ -402,7 +402,7 @@ class TypeExtensionTest { dictionary(Item::class) }.makeExecutableSchema() } - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(warnings, listOf( "Type 'Node' is defined as an interface, but extended as an object type. The extension is ignored.", @@ -458,7 +458,7 @@ class TypeExtensionTest { enum Purpose { SECURITY } extend enum Purpose { EXECUTION } """).makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, listOf("SECURITY", "EXECUTION")) assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION")) diff --git a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt index ad82d169..7f17d42d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt @@ -201,7 +201,7 @@ class UnmappedInputFieldsTest { .build() .makeExecutableSchema() } - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(warnings, listOf(unmapped("GreetingInput.name", GreetingInput::class.java, "argument 'input' of field 'Query.greet'", "nmae", "drops the field's value, since the ObjectMapper ignores unknown properties"))) @@ -252,7 +252,7 @@ class UnmappedInputFieldsTest { val schema = parser(SchemaParserOptions.newOptions()).makeExecutableSchema() // the snake case ObjectMapper doesn't know firstName, so snake fails when queried - assertEveryFieldResolves(schema, except = setOf("Query.snake")) + schema.assertEveryFieldResolves(except = setOf("Query.snake")) val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute("query { snake(input: { firstName: \"Ada\" }) camel(input: { firstName: \"Ada\" }) }") assertContains(result.errors.single().message, "Unrecognized field \"firstName\"") @@ -463,7 +463,7 @@ class UnmappedInputFieldsTest { .build() .makeExecutableSchema() } - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() assertEquals(warnings, emptyList()) @@ -555,7 +555,7 @@ class UnmappedInputFieldsTest { .options(failOptions().build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema) + schema.assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -650,7 +650,7 @@ class UnmappedInputFieldsTest { .build() .makeExecutableSchema() // the made-up kind isn't one of the type ids Jackson knows - assertEveryFieldResolves(schema, except = setOf("Query.shape(input:)", "Query.animals(input:)", "Query.animal(input:)", "Query.zoo(input:)")) + schema.assertEveryFieldResolves(except = setOf("Query.shape(input:)", "Query.animals(input:)", "Query.animal(input:)", "Query.zoo(input:)")) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -720,7 +720,7 @@ class UnmappedInputFieldsTest { .build()) .build() .makeExecutableSchema() - assertEveryFieldResolves(schema, except = setOf( + schema.assertEveryFieldResolves(except = setOf( // the input classes misspell name on purpose "Query.injected", "Query.builder", // TODO query generic once the type variable of its inherited parameter is resolved (#880) From b78416c3e63fac69a9e4a0b8c8323b2bc507f271 Mon Sep 17 00:00:00 2001 From: Oryan Date: Sun, 18 Oct 2026 19:16:59 -0400 Subject: [PATCH 14/14] Return the schema from assertEveryFieldResolves so it can end the builder chain --- .../kickstart/tools/CustomScalarInputTest.kt | 2 +- .../tools/DeepGenericsHierarchyTest.kt | 2 +- .../tools/DeprecatedDirectiveTest.kt | 22 +++--- .../graphql/kickstart/tools/DirectiveTest.kt | 30 ++++---- .../kickstart/tools/EnumDefaultValueTest.kt | 4 +- .../kickstart/tools/EveryFieldResolves.kt | 3 +- .../kickstart/tools/GenericInputTypesTest.kt | 10 +-- .../kickstart/tools/GenericObjectTypesTest.kt | 4 +- .../kickstart/tools/GenericResolverTest.kt | 10 +-- .../tools/InaccessibleFieldResolverTest.kt | 6 +- .../tools/InheritedTypeVariablesTest.kt | 8 +-- .../kickstart/tools/IntrospectionTest.kt | 2 +- .../tools/MethodFieldResolverTest.kt | 12 ++-- .../tools/MissingFieldResolverTest.kt | 4 +- .../kickstart/tools/NestedInputTypesTest.kt | 16 ++--- .../kickstart/tools/PropertyMapListTest.kt | 4 +- .../graphql/kickstart/tools/ReactiveTest.kt | 8 +-- .../kickstart/tools/RelayConnectionTest.kt | 8 +-- .../tools/SchemaClassScannerDirectiveTest.kt | 16 ++--- .../SchemaClassScannerInterfaceFieldTest.kt | 16 ++--- .../SchemaClassScannerSealedTypesTest.kt | 10 +-- .../kickstart/tools/SchemaClassScannerTest.kt | 46 ++++++------- .../tools/SchemaParserDictionaryTest.kt | 6 +- .../kickstart/tools/SchemaParserTest.kt | 68 +++++++++---------- .../kickstart/tools/SuperclassResolverTest.kt | 4 +- .../kickstart/tools/TypeExtensionTest.kt | 12 ++-- .../tools/UnmappedInputFieldsTest.kt | 22 +++--- 27 files changed, 178 insertions(+), 177 deletions(-) diff --git a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt index b9f6951a..f4311f80 100644 --- a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt @@ -191,7 +191,7 @@ class CustomScalarInputTest { .options(options) .build() .makeExecutableSchema() - graphQLSchema.assertEveryFieldResolves() + .assertEveryFieldResolves() return GraphQL.newGraphQL(graphQLSchema).build() } diff --git a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt index ffa34c9b..22effb4d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt @@ -12,7 +12,7 @@ class PlaceTest { .file("Place.graphqls") .resolvers(PlaceQuery()) .build().makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val graphql = GraphQL.newGraphQL(schema).build() val query = "query { places1 { id } places2 { id } }" diff --git a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt index 937f7fc6..acb96b54 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt @@ -35,7 +35,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -69,7 +69,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val userType = schema.getType("User") as GraphQLObjectType val nameDefinition = userType.getField("name") @@ -110,7 +110,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -151,7 +151,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val userTypeEnum = schema.getType("UserType") as GraphQLEnumType val droidValue = userTypeEnum.getValue("DROID") @@ -185,7 +185,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -219,7 +219,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val usersQuery = schema.queryType.getField("users") val firstArgument = usersQuery.getArgument("first") @@ -255,7 +255,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -291,7 +291,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val directive = schema.getDirective("uppercase") val argument = directive!!.getArgument("firstCharacterOnly") @@ -329,7 +329,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -367,7 +367,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithConnectionInputQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType val firstField = connectionInputType.getField("first") @@ -408,7 +408,7 @@ class DeprecatedDirectiveTest { .resolvers(UsersWithFirstQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val name = (schema.getType("User") as GraphQLObjectType).getField("name") assertEquals("No longer supported", name.getAppliedDirective("deprecated").getArgument("reason")!!.getValue()) diff --git a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt index 1c9928ca..39f4fe4b 100644 --- a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt @@ -41,7 +41,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -94,7 +94,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -139,7 +139,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -182,7 +182,7 @@ class DirectiveTest { .directive("double", DoubleDirective()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -226,7 +226,7 @@ class DirectiveTest { .directive("log", DescriptionDirective("log")) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.queryType.getField("name").description, "Name +auth +log") } @@ -250,7 +250,7 @@ class DirectiveTest { .directiveWiring(DescriptionDirective("static")) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.queryType.getField("name").description, "Name +auth +static") } @@ -295,7 +295,7 @@ class DirectiveTest { .directive("uppercase", UppercaseDirective()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -348,7 +348,7 @@ class DirectiveTest { .dictionary(AllowedState::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -377,7 +377,7 @@ class DirectiveTest { .resolvers(BookQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val filter = schema.getType("BookFilter") as GraphQLInputObjectType assert(filter.isOneOf) @@ -417,7 +417,7 @@ class DirectiveTest { .directive("email", emailDirective) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val expectedMessages = mapOf( "contactEmail" to "{path} must be a valid email", @@ -441,7 +441,7 @@ class DirectiveTest { // ConfigInput is built for @meta and needs @option, whichever is declared first listOf("$meta\n$option", "$option\n$meta").forEach { directives -> val recorder = ArgumentTypeRecorder() - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ $directives @@ -466,7 +466,7 @@ class DirectiveTest { .directive("option", recorder) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val inputObject = listOf("GraphQLInputObjectType") val expectedTypes = mapOf("name" to inputObject, "ConfigInput" to inputObject, "level" to inputObject) @@ -505,7 +505,7 @@ class DirectiveTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assert(wiredFields == listOf("max")) { "$wiredFields with directives declared as $directives" } val limit = (schema.getType("BoundInput") as GraphQLInputObjectType).getField("max").getAppliedDirective("limit") @@ -547,7 +547,7 @@ class DirectiveTest { .dictionary(LinkPurpose::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.schemaAppliedDirectives.map { it.name }, listOf("contact", "link", "link")) assertEquals( @@ -611,7 +611,7 @@ class DirectiveTest { .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val link = schema.getSchemaAppliedDirective("link") assertEquals(link.getArgument("import")?.getValue>(), listOf("@key", "@shareable")) diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt index cd9e992c..69fc6b83 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt @@ -29,7 +29,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val ggl = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -65,7 +65,7 @@ class EnumDefaultValueTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val ggl = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt index ad8a7d90..c8661be6 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EveryFieldResolves.kt @@ -24,7 +24,7 @@ import java.util.concurrent.TimeoutException * value to make up. [input] adds to every operation, e.g. a context or a data loader registry. */ @JvmOverloads -fun GraphQLSchema.assertEveryFieldResolves(except: Set = setOf(), input: ExecutionInput.Builder.() -> Unit = {}) { +fun GraphQLSchema.assertEveryFieldResolves(except: Set = setOf(), input: ExecutionInput.Builder.() -> Unit = {}): GraphQLSchema { val gql = GraphQL.newGraphQL(this).build() val query = EveryFieldQuery(this, except) val roots = mapOf("query" to queryType, "mutation" to mutationType, "subscription" to subscriptionType) @@ -38,6 +38,7 @@ fun GraphQLSchema.assertEveryFieldResolves(except: Set = setOf(), input: if (errors.isNotEmpty()) { throw AssertionError("Querying every field returned errors:\n${errors.joinToString("\n")}") } + return this } private const val MAX_DEPTH = 6 diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt index cf05c1a9..8d812b71 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericInputTypesTest.kt @@ -32,7 +32,7 @@ class GenericInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -69,7 +69,7 @@ class GenericInputTypesTest { .resolvers(InheritedQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -114,7 +114,7 @@ class GenericInputTypesTest { .resolvers(MultipleParameterizationsQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -156,7 +156,7 @@ class GenericInputTypesTest { .resolvers(NestedQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -190,7 +190,7 @@ class GenericInputTypesTest { .resolvers(InheritedListQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt index ffea2cd6..27c23466 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericObjectTypesTest.kt @@ -32,7 +32,7 @@ class GenericObjectTypesTest { .resolvers(EntityMatchQueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -90,7 +90,7 @@ class GenericObjectTypesTest { .dictionary(Human::class, Droid::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt index 13814a3d..faf96990 100644 --- a/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/GenericResolverTest.kt @@ -9,7 +9,7 @@ class GenericResolverTest { @Test fun `methods from generic resolvers are resolved`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -23,7 +23,7 @@ class GenericResolverTest { .resolvers(QueryResolver1(), BarResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } class QueryResolver1 : GraphQLQueryResolver { @@ -42,7 +42,7 @@ class GenericResolverTest { @Test fun `methods from generic inherited resolvers are resolved`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -55,7 +55,7 @@ class GenericResolverTest { .resolvers(QueryResolver2(), CarResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } class QueryResolver2 : GraphQLQueryResolver { @@ -134,7 +134,7 @@ class GenericResolverTest { .resolvers(QueryResolver3(), resolver) .build() .makeExecutableSchema() - .also { it.assertEveryFieldResolves() } + .assertEveryFieldResolves() class QueryResolver3 : GraphQLQueryResolver { fun getPage(): Page = Page(listOf(Item("item"))) diff --git a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt index 2874b31b..3edbf524 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InaccessibleFieldResolverTest.kt @@ -31,8 +31,8 @@ class InaccessibleFieldResolverTest { .resolvers(Query()) .build() .makeExecutableSchema() - // without LocaleResolver, languageTag reads the private field of Locale, which the module system blocks - schema.assertEveryFieldResolves(except = setOf("Locale.languageTag")) + // without LocaleResolver, languageTag reads the private field of Locale, which the module system blocks + .assertEveryFieldResolves(except = setOf("Locale.languageTag")) val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -70,7 +70,7 @@ class InaccessibleFieldResolverTest { .resolvers(Query(), LocaleResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql: GraphQL = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() diff --git a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt index 74f3cf11..606a5733 100644 --- a/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/InheritedTypeVariablesTest.kt @@ -33,7 +33,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -73,7 +73,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -121,7 +121,7 @@ class InheritedTypeVariablesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -174,7 +174,7 @@ class InheritedTypeVariablesTest { .resolvers(RawGenericFixtures.QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt index 4a096135..44b97f95 100644 --- a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt @@ -23,7 +23,7 @@ class IntrospectionTest { .options(SchemaParserOptions.newOptions().introspectionEnabled(introspectionEnabled).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() return GraphQL.newGraphQL(schema).build() } diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt index 4db8aab7..b630d0da 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt @@ -38,7 +38,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -81,7 +81,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -118,7 +118,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -150,7 +150,7 @@ class MethodFieldResolverTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -198,7 +198,7 @@ class MethodFieldResolverTest { .resolvers(resolver) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -263,7 +263,7 @@ class MethodFieldResolverTest { .build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute(ExecutionInput.newExecutionInput().query( diff --git a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt index 0c995bf5..3959216c 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt @@ -78,7 +78,7 @@ class MissingFieldResolverTest { .build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() @@ -119,7 +119,7 @@ class MissingFieldResolverTest { .options(options) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt index 359d8b10..4c1ea779 100644 --- a/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/NestedInputTypesTest.kt @@ -39,7 +39,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -90,7 +90,7 @@ class NestedInputTypesTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) .build() @@ -140,7 +140,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -193,7 +193,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -243,7 +243,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -286,7 +286,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -331,7 +331,7 @@ class NestedInputTypesTest { .dictionary("ShipmentLineInput", ShipmentLineInput::class.java) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -380,7 +380,7 @@ class NestedInputTypesTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt index d071c05f..ed1ad899 100644 --- a/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/PropertyMapListTest.kt @@ -40,7 +40,7 @@ class PropertyMapListTest { .dictionary("Key", HashMap::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -84,7 +84,7 @@ class PropertyMapListTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { diff --git a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt index 50430865..6ef9f762 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt @@ -31,7 +31,7 @@ class ReactiveTest { .options(options) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -93,8 +93,8 @@ class ReactiveTest { .genericWrappers(GenericWrapper.withTransformer(FutureTask::class, 0, { task -> task.get() })) .build() val schema = itemSchema(PlainFutureQuery(), options) - // suspendCompletableItem is a suspend function that returns a future, which is rejected - schema.assertEveryFieldResolves(except = setOf("Query.suspendCompletableItem")) + // suspendCompletableItem is a suspend function that returns a future, which is rejected + .assertEveryFieldResolves(except = setOf("Query.suspendCompletableItem")) val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -183,7 +183,7 @@ class ReactiveTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() diff --git a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt index d2844ecb..97598d7d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/RelayConnectionTest.kt @@ -52,8 +52,8 @@ class RelayConnectionTest { .resolvers(QueryResolver()) .build() .makeExecutableSchema() - // the made-up cursor "a" isn't a valid cursor - schema.assertEveryFieldResolves(except = setOf("Query.users(after:)")) + // the made-up cursor "a" isn't a valid cursor + .assertEveryFieldResolves(except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) @@ -108,8 +108,8 @@ class RelayConnectionTest { .dictionary(User::class.java) .build() .makeExecutableSchema() - // the made-up cursor "a" isn't a valid cursor - schema.assertEveryFieldResolves(except = setOf("Query.users(after:)")) + // the made-up cursor "a" isn't a valid cursor + .assertEveryFieldResolves(except = setOf("Query.users(after:)")) val gql = GraphQL.newGraphQL(schema) .queryExecutionStrategy(AsyncExecutionStrategy()) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt index ad7fdbe6..d4be4579 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerDirectiveTest.kt @@ -33,7 +33,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -75,7 +75,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -107,7 +107,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val value = schema.queryType.getFieldDefinition("string") .getAppliedDirective("doSomething") @@ -137,7 +137,7 @@ class SchemaClassScannerDirectiveTest { .scalars(customValueScalar) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertNotNull(schema.directivesByName["doSomething"]?.getArgument("one")?.directivesByName?.get("somethingElse")) assertNotNull(schema.directivesByName["somethingElse"]?.getArgument("two")?.directivesByName?.get("doSomething")) @@ -151,7 +151,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() val schema = parser.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val purpose = schema.getType("Purpose") as GraphQLEnumType assertEquals(purpose.values.map { it.value }, listOf("SECURITY", "EXECUTION")) @@ -177,7 +177,7 @@ class SchemaClassScannerDirectiveTest { .resolvers(helloResolver) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION", "SECURITY")) assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { IntrospectionQuery.INTROSPECTION_QUERY } @@ -196,7 +196,7 @@ class SchemaClassScannerDirectiveTest { .dictionary(Purpose::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } @@ -216,7 +216,7 @@ class SchemaClassScannerDirectiveTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, Purpose.entries) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt index 067fc4b2..de4c06b0 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerInterfaceFieldTest.kt @@ -41,7 +41,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyUnion.TestInterfaceImpl::class, InterfaceOnlyUnion.TestUnion2::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val testUnion = schema.getType("TestUnion") as GraphQLUnionType assertEquals(testUnion.types.map { it.name }.toSet(), setOf("TestUnion1", "TestUnion2")) @@ -125,7 +125,7 @@ class SchemaClassScannerInterfaceFieldTest { .resolvers(SingleMemberUnions()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Result") as GraphQLUnionType).types.map { it.name }, listOf("Node")) assertEquals((schema.getType("SortResponse") as GraphQLUnionType).types.map { it.name }, listOf("NodeSortResponse")) @@ -184,7 +184,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(ChainedInterfaceUnion.Box::class, ChainedInterfaceUnion.Image::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -249,7 +249,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(NestedInterfaceOnlyUnion.Book::class, NestedInterfaceOnlyUnion.Image::class, NestedInterfaceOnlyUnion.RichCaption::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Caption") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("PlainCaption", "RichCaption")) } @@ -299,7 +299,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(InterfaceOnlyInterface.Box::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assert(schema.getType("Entry") is GraphQLInterfaceType) } @@ -353,7 +353,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableUnion.Book::class, DictionaryReachableUnion.Holder::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image")) } @@ -415,7 +415,7 @@ class SchemaClassScannerInterfaceFieldTest { .dictionary(DictionaryReachableInterface.Shelf::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.getImplementations(schema.getType("Item") as GraphQLInterfaceType)!!.map { it.name }.toSet(), setOf("Book", "Magazine")) } @@ -474,7 +474,7 @@ class SchemaClassScannerInterfaceFieldTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Content") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Text", "Image", "Caption")) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt index e3ef30f2..222c3af1 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerSealedTypesTest.kt @@ -47,7 +47,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedClassUnion()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } @@ -94,7 +94,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(SealedInterfaceImplementors()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -155,7 +155,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(GenericSealedClass()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -211,7 +211,7 @@ class SchemaClassScannerSealedTypesTest { .resolvers(MemberReachableThroughSealedSubclass()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("SearchResult") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Book", "Author")) @@ -258,7 +258,7 @@ class SchemaClassScannerSealedTypesTest { .dictionary("WeirdPet", DictionaryOverridesSealedSubclass.ClassifiedWeirdPet::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { petsQuery } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt index 1e358808..563a1556 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt @@ -15,7 +15,7 @@ class SchemaClassScannerTest { @Test fun `scanner handles futures and immediate return types`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .resolvers(FutureImmediateQuery()) .schemaString( """ @@ -26,7 +26,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } private class FutureImmediateQuery : GraphQLQueryResolver { @@ -38,7 +38,7 @@ class SchemaClassScannerTest { @Test fun `scanner handles primitive and boxed return types`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .resolvers(PrimitiveBoxedQuery()) .schemaString( """ @@ -49,7 +49,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } private class PrimitiveBoxedQuery : GraphQLQueryResolver { @@ -60,7 +60,7 @@ class SchemaClassScannerTest { @Test fun `scanner handles different scalars with same java class`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .resolvers(ScalarDuplicateQuery()) .schemaString( """ @@ -71,7 +71,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } private class ScalarDuplicateQuery : GraphQLQueryResolver { @@ -95,7 +95,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val interfaceType = schema.additionalTypes.find { it is GraphQLInterfaceType } assertNotNull(interfaceType) @@ -129,7 +129,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val inputTypeCount = schema.additionalTypes.count { it is GraphQLInputType } assertEquals(inputTypeCount, 3) @@ -159,7 +159,7 @@ class SchemaClassScannerTest { @Test fun `scanner ignores fluent setters when finding input field types`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .resolvers(FluentSetterMutation(), object : GraphQLQueryResolver { fun test(): Boolean = true }) @@ -188,7 +188,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } private class FluentSetterMutation : GraphQLMutationResolver { @@ -229,7 +229,7 @@ class SchemaClassScannerTest { @Test fun `scanner finds input field types through getters with arguments`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .resolvers(GetterWithArgumentsQuery()) .schemaString( """ @@ -255,7 +255,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } private class GetterWithArgumentsQuery : GraphQLQueryResolver { @@ -305,7 +305,7 @@ class SchemaClassScannerTest { ) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val inputTypeExtensionCount = schema.additionalTypes .filterIsInstance() @@ -337,7 +337,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assert(schema.typeMap.containsKey("UUID")) } @@ -376,7 +376,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 2) @@ -425,7 +425,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val interfaceTypeCount = schema.additionalTypes.count { it is GraphQLInterfaceType } assertEquals(interfaceTypeCount, 1) @@ -472,7 +472,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assert(schema.typeMap.containsKey("customMap")) } @@ -515,7 +515,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -551,7 +551,7 @@ class SchemaClassScannerTest { """) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 2) @@ -590,7 +590,7 @@ class SchemaClassScannerTest { .dictionary(NestedInterfaceTypeQuery.Dog::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val typeCount = schema.additionalTypes.count() assertEquals(typeCount, 3) @@ -653,7 +653,7 @@ class SchemaClassScannerTest { .scalars(fieldSetScalar, linkImportScalar) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val objectTypes = schema.additionalTypes.filterIsInstance() assert(objectTypes.any { it.name == "User" }) @@ -746,7 +746,7 @@ class SchemaClassScannerTest { .dictionary(Unused::class, Implementation::class, SomeEnum::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val objectTypes = schema.additionalTypes.filterIsInstance() val interfaceTypes = schema.additionalTypes.filterIsInstance() @@ -788,7 +788,7 @@ class SchemaClassScannerTest { .dictionary(SomeEnum::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assert(schema.queryType.getFieldDefinition("preview").getArgument("value").type is GraphQLEnumType) } diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt index 341316b5..9a5f70c1 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserDictionaryTest.kt @@ -45,7 +45,7 @@ class SchemaParserDictionaryTest { .dictionary("NestedB", ObjectNode::class.java) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { @@ -93,7 +93,7 @@ class SchemaParserDictionaryTest { .dictionary(dictionary.getDictionary()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val field = schema.queryType.getFieldDefinition("test") assertEquals(field.getAppliedDirective("a").getArgument("arg")?.getValue>(), mapOf("x" to 1)) @@ -130,7 +130,7 @@ class SchemaParserDictionaryTest { .dictionary("DogInput", LabradorRetriever::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val field = schema.queryType.getFieldDefinition("dog") assertEquals(field.getAppliedDirective("d").getArgument("arg")?.getValue>(), mapOf("name" to "z")) diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt index 30c234de..e70da4bf 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt @@ -43,13 +43,13 @@ class SchemaParserTest { @Test fun `builder doesn't throw FileNotFound exception when file is present`() { - val schema = SchemaParser.newParser().file("Test.graphqls") + SchemaParser.newParser().file("Test.graphqls") .resolvers(object : GraphQLQueryResolver { fun getId(): String = "1" }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test(expected = SchemaClassScannerError::class) @@ -73,7 +73,7 @@ class SchemaParserTest { @Test fun `parser should parse correctly when Query resolver is given`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -85,12 +85,12 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test fun `parser should parse correctly when multiple query resolvers are given`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Obj { @@ -113,12 +113,12 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test fun `parser should parse correctly when multiple resolvers for the same data type are given`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type RootObj { @@ -153,12 +153,12 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test fun `parser should allow setting custom generic wrappers`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -177,7 +177,7 @@ class SchemaParserTest { .options(SchemaParserOptions.newOptions().genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(CustomGenericWrapper::class, 1, { wrapper: CustomGenericWrapper<*, *> -> wrapper.value })).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test(expected = SchemaClassScannerError::class) @@ -296,7 +296,7 @@ class SchemaParserTest { @Test fun `parser should build type that was never reached by the scanner when including unused types`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .file("UnreachedType.graphqls") .resolvers(object : GraphQLQueryResolver { fun pet(): Pet? = null @@ -305,7 +305,7 @@ class SchemaParserTest { .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test @@ -365,7 +365,7 @@ class SchemaParserTest { @Test fun `parser handles enums with overridden toString method`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ enum CustomEnum { @@ -381,7 +381,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test @@ -396,7 +396,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -414,7 +414,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -482,7 +482,7 @@ class SchemaParserTest { .resolvers(QueryWithIdResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val sourceLocation = schema.getObjectType("Query")!! .getFieldDefinition("id") @@ -495,7 +495,7 @@ class SchemaParserTest { @Test fun `support enum types if only used as input type`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { test: Boolean } @@ -520,12 +520,12 @@ class SchemaParserTest { .dictionary(EnumType::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test fun `support enum types if only used in input Map`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { test: Boolean } @@ -551,12 +551,12 @@ class SchemaParserTest { .dictionary(EnumType::class) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test fun `support enum types used in input Map if their class is found elsewhere`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -578,7 +578,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } @Test @@ -656,7 +656,7 @@ class SchemaParserTest { @Test fun `allow circular relations in input objects`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ input A { @@ -690,7 +690,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } class A { @@ -741,7 +741,7 @@ class SchemaParserTest { .resolvers(MultiLevelInterfaceResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val traitInterface = schema.getType("Trait") as GraphQLInterfaceType val animalInterface = schema.getType("Animal") as GraphQLInterfaceType val mammalTraitInterface = schema.getType("MammalTrait") as GraphQLInterfaceType @@ -813,7 +813,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val testNonNullableArgument = schema.getObjectType("Query")!! .getFieldDefinition("testNonNullable") @@ -863,7 +863,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() // parent points back at NestedFilter while it's still being built, so it stays a type reference until the schema is built assertEquals(wiredFieldTypes, mapOf( @@ -1020,7 +1020,7 @@ class SchemaParserTest { }) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.queryType.name, "SubstituteQuery") assertEquals(schema.mutationType?.name, "SubstituteMutation") @@ -1184,7 +1184,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { """mutation { addItem(name: "item") }""" } @@ -1215,7 +1215,7 @@ class SchemaParserTest { .resolvers(QueryAndSubscription()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() val data = assertNoGraphQlErrors(gql) { "{ item }" } @@ -1327,7 +1327,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() listOf("onCustomPublisher", "onConcretePublisher", "onOverriddenPublisher").forEach { field -> @@ -1371,7 +1371,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() listOf("onCompletableFuture", "onCompletionStage", "onFuture", "onConcretePublisherFuture", "onWildcardPublisherFuture").forEach { field -> @@ -1410,7 +1410,7 @@ class SchemaParserTest { ) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val gql = GraphQL.newGraphQL(schema).build() assertEquals(gql.firstSubscriptionEvent("subscription { onChannel }"), mapOf("onChannel" to "onChannel")) diff --git a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt index 0a5d47fe..41eaa0a5 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SuperclassResolverTest.kt @@ -6,7 +6,7 @@ class SuperclassResolverTest { @Test fun `methods from generic resolvers are resolved`() { - val schema = SchemaParser.newParser() + SchemaParser.newParser() .schemaString( """ type Query { @@ -25,7 +25,7 @@ class SuperclassResolverTest { .resolvers(QueryResolver(), BarResolver()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() } class QueryResolver : GraphQLQueryResolver { diff --git a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt index c8117172..0e86778d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/TypeExtensionTest.kt @@ -52,7 +52,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class, Item::class) scalars(GraphQLScalarType.newScalar().name("Date").coercing(Scalars.GraphQLString.coercing).build()) }.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val fooBar = schema.getType("FooBar") as GraphQLUnionType val color = schema.getType("Color") as GraphQLEnumType @@ -108,7 +108,7 @@ class TypeExtensionTest { """) { dictionary(Foo::class, Bar::class, Baz::class) }.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -132,7 +132,7 @@ class TypeExtensionTest { """) { dictionary(Item::class, Bar::class) }.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Node") as GraphQLInterfaceType).fieldDefinitions.map { it.name }, listOf("id", "fooBar")) assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }.toSet(), setOf("Foo", "Bar")) @@ -299,7 +299,7 @@ class TypeExtensionTest { """) { options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build()) }.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals(schema.queryType.appliedDirectives.map { it.getArgument("fields")?.getValue() }, listOf("upc", "name")) } @@ -327,7 +327,7 @@ class TypeExtensionTest { dictionary(Foo::class, Bar::class, Baz::class) options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build()) }.makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("FooBar") as GraphQLUnionType).types.map { it.name }, listOf("Foo", "Bar", "Baz")) } @@ -458,7 +458,7 @@ class TypeExtensionTest { enum Purpose { SECURITY } extend enum Purpose { EXECUTION } """).makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() assertEquals((schema.getType("Purpose") as GraphQLEnumType).values.map { it.value }, listOf("SECURITY", "EXECUTION")) assertEquals(schema.getSchemaAppliedDirectives("link").map { it.getArgument("for")?.getValue() }, listOf("EXECUTION")) diff --git a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt index 7f17d42d..949e252d 100644 --- a/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/UnmappedInputFieldsTest.kt @@ -251,8 +251,8 @@ class UnmappedInputFieldsTest { assertEquals(error.message, unmapped("NameInput.firstName", NameInput::class.java, "argument 'input' of field 'Query.snake'", "first_name")) val schema = parser(SchemaParserOptions.newOptions()).makeExecutableSchema() - // the snake case ObjectMapper doesn't know firstName, so snake fails when queried - schema.assertEveryFieldResolves(except = setOf("Query.snake")) + // the snake case ObjectMapper doesn't know firstName, so snake fails when queried + .assertEveryFieldResolves(except = setOf("Query.snake")) val gql = GraphQL.newGraphQL(schema).build() val result = gql.execute("query { snake(input: { firstName: \"Ada\" }) camel(input: { firstName: \"Ada\" }) }") assertContains(result.errors.single().message, "Unrecognized field \"firstName\"") @@ -555,7 +555,7 @@ class UnmappedInputFieldsTest { .options(failOptions().build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves() + .assertEveryFieldResolves() val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -649,8 +649,8 @@ class UnmappedInputFieldsTest { .build()) .build() .makeExecutableSchema() - // the made-up kind isn't one of the type ids Jackson knows - schema.assertEveryFieldResolves(except = setOf("Query.shape(input:)", "Query.animals(input:)", "Query.animal(input:)", "Query.zoo(input:)")) + // the made-up kind isn't one of the type ids Jackson knows + .assertEveryFieldResolves(except = setOf("Query.shape(input:)", "Query.animals(input:)", "Query.animal(input:)", "Query.zoo(input:)")) val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { """ @@ -720,12 +720,12 @@ class UnmappedInputFieldsTest { .build()) .build() .makeExecutableSchema() - schema.assertEveryFieldResolves(except = setOf( - // the input classes misspell name on purpose - "Query.injected", "Query.builder", - // TODO query generic once the type variable of its inherited parameter is resolved (#880) - "Query.generic" - )) + .assertEveryFieldResolves(except = setOf( + // the input classes misspell name on purpose + "Query.injected", "Query.builder", + // TODO query generic once the type variable of its inherited parameter is resolved (#880) + "Query.generic" + )) val result = GraphQL.newGraphQL(schema).build().execute( """