diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index 85149530..7ceaf9fe 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -24,3 +24,23 @@ jobs: restore-keys: ${{ runner.os }}-m2 - name: Build with Maven run: mvn --batch-mode --update-snapshots verify + + # The same jar has to work with the oldest supported graphql-java, so build and test against it too + graphql-java-25: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v7 + - name: Setup java + uses: actions/setup-java@v6 + with: + java-version: '11' + distribution: 'temurin' + - name: Cache Maven packages + uses: actions/cache@v6 + with: + path: ~/.m2 + key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-m2 + - name: Build with Maven + run: mvn --batch-mode --update-snapshots verify -Dgraphql-java.version=25.1 diff --git a/pom.xml b/pom.xml index c49370d1..98921e13 100644 --- a/pom.xml +++ b/pom.xml @@ -262,6 +262,11 @@ kotlin-maven-plugin org.jetbrains.kotlin ${kotlin.version} + + + -Werror + + compile @@ -286,8 +291,8 @@ maven-compiler-plugin 3.16.0 - 11 - 11 + 11 + true diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt index 229bac9c..c6549a50 100644 --- a/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt +++ b/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt @@ -234,8 +234,8 @@ internal class SchemaClassScanner( dictionary .filter { it.value.javaType != null - && it.value.typeClass() != java.lang.Object::class.java - && !java.util.Map::class.java.isAssignableFrom(it.value.typeClass()) + && it.value.typeClass() != Any::class.java + && !Map::class.java.isAssignableFrom(it.value.typeClass()) && it.key !is InputObjectTypeDefinition && it.key !is UnionTypeDefinition }.mapValuesTo(it) { it.value.javaType } @@ -355,7 +355,7 @@ internal class SchemaClassScanner( * Scan a new object for types that haven't been mapped yet. */ private fun scanQueueItemForPotentialMatches(item: QueueItem) { - val resolverInfo = if (item.clazz == Object::class.java) { + val resolverInfo = if (item.clazz == Any::class.java) { getResolverInfoFromTypeDictionary(item.type.name) ?: throw SchemaClassScannerError("The GraphQL schema type '${item.type.name}' maps to a field of type java.lang.Object however there is no matching entry for this type in the type dictionary. You may need to add this type to the dictionary before building the schema.") } else { @@ -391,7 +391,7 @@ internal class SchemaClassScanner( } private fun isResolverForSupertype(resolverInfo: NormalResolverInfo, dataClass: Class<*>) = - resolverInfo.dataClassType != Object::class.java && resolverInfo.dataClassType.isAssignableFrom(dataClass) + resolverInfo.dataClassType != Any::class.java && resolverInfo.dataClassType.isAssignableFrom(dataClass) private fun scanResolverInfoForPotentialMatches(type: ObjectTypeDefinition, resolverInfo: ResolverInfo) { type.getExtendedFieldDefinitions(extensionDefinitions).forEach { field -> @@ -428,7 +428,7 @@ internal class SchemaClassScanner( if (options.preferGraphQLResolver && realEntry.hasResolverRef()) { log.warn("The real entry ${realEntry.joinReferences()} is a GraphQLResolver so ignoring this one ${javaType.unwrap()} $reference") } else { - if (java.util.Map::class.java.isAssignableFrom(javaType.unwrap())) { + if (Map::class.java.isAssignableFrom(javaType.unwrap())) { throw SchemaClassScannerError("Two different property map classes used for type ${type.name}:\n${realEntry.joinReferences()}\n\n- ${javaType}:\n| ${reference.getDescription()}") } throw SchemaClassScannerError("Two different classes used for type ${type.name}:\n${realEntry.joinReferences()}\n\n- ${javaType.typeName}:\n| ${reference.getDescription()}") diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt index d2bbc5af..3e2a2115 100644 --- a/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt +++ b/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt @@ -12,7 +12,7 @@ import graphql.language.* import graphql.schema.* import graphql.schema.idl.RuntimeWiring import graphql.schema.idl.ScalarInfo -import graphql.schema.visibility.NoIntrospectionGraphqlFieldVisibility +import graphql.schema.visibility.BlockedFields import org.slf4j.LoggerFactory import kotlin.reflect.KClass @@ -69,7 +69,10 @@ class SchemaParser internal constructor( */ fun parseSchemaObjects(): SchemaObjects { if (!options.introspectionEnabled) { - codeRegistryBuilder.fieldVisibility(NoIntrospectionGraphqlFieldVisibility.NO_INTROSPECTION_FIELD_VISIBILITY) + // What the deprecated NoIntrospectionGraphqlFieldVisibility does. Its suggested replacement, + // Introspection.enabledJvmWide, would also turn introspection off for every other schema in the JVM. + // TODO deprecate introspectionEnabled and remove this in 15.0.0 (#858) + codeRegistryBuilder.fieldVisibility(BlockedFields.newBlock().addPattern("__.*").build()) } // this overrides the above introspection enabled setting obviously... todo: add documentation options.fieldVisibility?.let { codeRegistryBuilder.fieldVisibility(it) } @@ -433,6 +436,7 @@ class SchemaParser internal constructor( } // TODO remove this once directives are fully replaced with applied directives + @Suppress("DEPRECATION") // legacy directive argument values private fun buildDirectives( directives: List, directiveLocation: Introspection.DirectiveLocation @@ -535,7 +539,7 @@ class SchemaParser internal constructor( is NonNullType -> GraphQLNonNull(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects)) is InputObjectTypeDefinition -> { log.info("Create input object") - createInputObject(typeDefinition, inputObjects, referencingInputObjects as MutableSet) + createInputObject(typeDefinition, inputObjects, referencingInputObjects) } is TypeName -> { val scalarType = customScalars[typeDefinition.name] diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt index 8b0e0c60..d1c6a5e8 100644 --- a/src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt +++ b/src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt @@ -10,7 +10,6 @@ import graphql.schema.DataFetcher import graphql.schema.DataFetchingEnvironment import graphql.schema.visibility.GraphqlFieldVisibility import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.channels.ReceiveChannel import kotlinx.coroutines.reactive.publish import org.reactivestreams.Publisher @@ -45,7 +44,6 @@ data class SchemaParserOptions internal constructor( fun newOptions() = Builder() @JvmStatic - @ExperimentalCoroutinesApi fun defaultOptions() = Builder().build() } @@ -164,7 +162,6 @@ data class SchemaParserOptions internal constructor( this.allowUndeclaredDirectives = allowUndeclaredDirectives } - @ExperimentalCoroutinesApi fun build(): SchemaParserOptions { val coroutineContextProvider = coroutineContextProvider ?: DefaultCoroutineContextProvider(Dispatchers.Default) diff --git a/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt b/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt index b6e4096e..b24b7b04 100644 --- a/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt +++ b/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt @@ -68,7 +68,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map && realType.isArray -> match(potentialMatch, graphQLType.type, realType.componentType) // e.g. a property map value: the element type is unknown, so match it as Object too - realType == Object::class.java -> + realType == Any::class.java -> match(potentialMatch, graphQLType.type, realType) else -> throw error(potentialMatch, "Java class is not a List or generic type information was lost: $realType") diff --git a/src/main/kotlin/graphql/kickstart/tools/resolver/FieldResolverScanner.kt b/src/main/kotlin/graphql/kickstart/tools/resolver/FieldResolverScanner.kt index d787ef6d..34e5b282 100644 --- a/src/main/kotlin/graphql/kickstart/tools/resolver/FieldResolverScanner.kt +++ b/src/main/kotlin/graphql/kickstart/tools/resolver/FieldResolverScanner.kt @@ -56,7 +56,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) { } } - if (java.util.Map::class.java.isAssignableFrom(search.type.unwrap())) { + if (Map::class.java.isAssignableFrom(search.type.unwrap())) { return MapFieldResolver(field, search, options, search.type.unwrap()) } @@ -128,7 +128,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) { .filter { !Modifier.isPrivate(it.modifiers) } // discard any methods that are coming off the root of the class hierarchy // to avoid issues with duplicate method declarations - .filter { it.declaringClass != Object::class.java } + .filter { it.declaringClass != Any::class.java } // subscription resolvers must return a publisher .filter { !search.isSubscription || resolverMethodReturnsPublisher(it) } .toList() diff --git a/src/main/kotlin/graphql/kickstart/tools/resolver/MapFieldResolver.kt b/src/main/kotlin/graphql/kickstart/tools/resolver/MapFieldResolver.kt index 70c6d41b..0eea1c1d 100644 --- a/src/main/kotlin/graphql/kickstart/tools/resolver/MapFieldResolver.kt +++ b/src/main/kotlin/graphql/kickstart/tools/resolver/MapFieldResolver.kt @@ -36,7 +36,7 @@ internal class MapFieldResolver( val resolvedType = TypeResolver().resolve(mapClass) val typeParameters = resolvedType.typeParametersFor(Map::class.java) - return typeParameters.elementAtOrElse(1) { Object::class.java } + return typeParameters.elementAtOrElse(1) { Any::class.java } } override fun createDataFetcher(): DataFetcher<*> { diff --git a/src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt b/src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt index 0a9e65d6..3c222bc7 100644 --- a/src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt +++ b/src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt @@ -157,7 +157,7 @@ internal class MethodFieldResolver( is ListType -> List::class.java.isAssignableFrom(this.typeResolver.getRawClass(genericParameterType)) && isConcreteScalarType(environment, type.type, this.typeResolver.resolve(genericParameterType)) - is TypeName -> environment.graphQLSchema?.getType(type.name!!)?.let { isScalar(it) && type.name != "ID" } + is TypeName -> environment.graphQLSchema.getType(type.name!!)?.let { isScalar(it) && type.name != "ID" } ?: false is NonNullType -> isConcreteScalarType(environment, type.type, genericParameterType) diff --git a/src/main/kotlin/module-info.java b/src/main/kotlin/module-info.java index 2ec2dd1b..90ef1592 100644 --- a/src/main/kotlin/module-info.java +++ b/src/main/kotlin/module-info.java @@ -5,6 +5,8 @@ requires kotlinx.coroutines.reactive; requires com.graphqljava; + // graphql-java's nullability annotations, only needed at compile time + requires static org.jspecify; requires com.fasterxml.jackson.core; requires com.fasterxml.jackson.kotlin; diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt index 9539a7b1..85197516 100644 --- a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt @@ -79,7 +79,7 @@ class EndToEndTest { .graphQLContext(mapOf("newItem" to newItem)) .variables(mapOf())) - val data = result.getData() as Publisher + val data = checkNotNull(result.getData>()) val latch = CountDownLatch(1) data.subscribe(object : Subscriber { override fun onNext(item: ExecutionResult?) { @@ -117,7 +117,7 @@ class EndToEndTest { .graphQLContext(mapOf("newItem" to newItem)) .variables(mapOf())) - val data = result.getData() as Publisher + val data = checkNotNull(result.getData>()) val latch = CountDownLatch(1) data.subscribe(object : Subscriber { override fun onNext(item: ExecutionResult?) { @@ -639,7 +639,7 @@ class EndToEndTest { .graphQLContext(mapOf("newItem" to newItem)) .variables(mapOf())) - val data = result.getData() as Publisher + val data = checkNotNull(result.getData>()) val subscriber = TestEnvironment().newManualSubscriber(data) val subscriberResult = subscriber.requestNextElement() as ExecutionResultImpl @@ -667,7 +667,7 @@ class EndToEndTest { .graphQLContext(mapOf("newItem" to newItem)) .variables(mapOf())) - val data = result.getData() as Publisher + val data = checkNotNull(result.getData>()) val subscriber = TestEnvironment().newManualSubscriber(data) val subscriberResult = subscriber.requestNextElement() as ExecutionResultImpl diff --git a/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt index db917658..01c83fb1 100644 --- a/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt @@ -12,11 +12,9 @@ import graphql.relay.Connection import graphql.relay.DefaultConnection import graphql.relay.DefaultPageInfo import graphql.schema.DataFetchingEnvironment -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import java.util.* -@OptIn(ExperimentalCoroutinesApi::class) class FieldResolverScannerTest { private val options = defaultOptions() diff --git a/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt new file mode 100644 index 00000000..fa18e90d --- /dev/null +++ b/src/test/kotlin/graphql/kickstart/tools/IntrospectionTest.kt @@ -0,0 +1,60 @@ +package graphql.kickstart.tools + +import graphql.GraphQL +import graphql.validation.ValidationError +import graphql.validation.ValidationErrorType +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class IntrospectionTest { + + private fun graphQL(introspectionEnabled: Boolean): GraphQL { + val schema = SchemaParser.newParser() + .schemaString( + """ + type Query { + name: String! + } + """) + .resolvers(object : GraphQLQueryResolver { + fun name() = "tools" + }) + .options(SchemaParserOptions.newOptions().introspectionEnabled(introspectionEnabled).build()) + .build() + .makeExecutableSchema() + return GraphQL.newGraphQL(schema).build() + } + + @Test + fun `introspection is enabled by default`() { + val data = assertNoGraphQlErrors(graphQL(introspectionEnabled = true)) { + "{ __schema { queryType { name } } }" + } + + assertEquals(mapOf("queryType" to mapOf("name" to "Query")), data["__schema"]) + } + + @Test + fun `disabling introspection hides the fields of introspection types`() { + val gql = graphQL(introspectionEnabled = false) + + listOf("{ __schema { queryType { name } } }", "{ __type(name: \"Query\") { name } }").forEach { query -> + val result = gql.execute(query) + + assertNull(result.getData()) + assertEquals( + listOf(ValidationErrorType.FieldUndefined), + result.errors.map { (it as ValidationError).validationErrorType }) + } + } + + @Test + fun `disabling introspection keeps __typename`() { + val data = assertNoGraphQlErrors(graphQL(introspectionEnabled = false)) { + "{ name __typename }" + } + + assertEquals(mapOf("name" to "tools", "__typename" to "Query"), data) + } +} diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt index f163ee6b..14ff8b48 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt @@ -2,6 +2,7 @@ package graphql.kickstart.tools import graphql.ExecutionResult import graphql.GraphQLContext +import graphql.Scalars import graphql.execution.* import graphql.execution.instrumentation.SimplePerformantInstrumentation import graphql.kickstart.tools.resolver.FieldResolverError @@ -13,9 +14,11 @@ import graphql.language.TypeName import graphql.schema.DataFetcher import graphql.schema.DataFetchingEnvironment import graphql.schema.DataFetchingEnvironmentImpl +import graphql.schema.GraphQLObjectType +import graphql.schema.GraphQLSchema import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.Job import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.channels.ReceiveChannel @@ -26,11 +29,9 @@ import java.util.concurrent.CancellationException import java.util.concurrent.CompletableFuture import kotlin.coroutines.coroutineContext -@OptIn(ExperimentalCoroutinesApi::class) class MethodFieldResolverDataFetcherTest { @Test - @ExperimentalCoroutinesApi fun `data fetcher executes suspend function on coroutineContext defined by options`() { // setup val suspendClass = SuspendClass() @@ -47,7 +48,6 @@ class MethodFieldResolverDataFetcherTest { private val dispatcher = Dispatchers.IO private val job = Job() - @ExperimentalCoroutinesApi val options = SchemaParserOptions.Builder() .coroutineContext(dispatcher + job) .build() @@ -123,7 +123,7 @@ class MethodFieldResolverDataFetcherTest { } } - @ExperimentalCoroutinesApi + @OptIn(DelicateCoroutinesApi::class) @Test fun `canceling subscription Publisher also cancels underlying Kotlin coroutine channel`() { // setup @@ -236,7 +236,7 @@ class MethodFieldResolverDataFetcherTest { @Test fun `data fetcher passes environment if method has extra argument`() { val resolver = createFetcher("active", object : GraphQLResolver { - fun isActive(dataClass: DataClass, env: DataFetchingEnvironment): Boolean = env is DataFetchingEnvironment + fun isActive(dataClass: DataClass, env: DataFetchingEnvironment?): Boolean = env != null }) assertEquals(resolver.get(createEnvironment(DataClass())), true) @@ -246,7 +246,7 @@ class MethodFieldResolverDataFetcherTest { fun `data fetcher passes environment if method has extra argument even if context is specified`() { val context = GraphQLContext.newContext().build() val resolver = createFetcher("active", resolver = object : GraphQLResolver { - fun isActive(dataClass: DataClass, env: DataFetchingEnvironment): Boolean = env is DataFetchingEnvironment + fun isActive(dataClass: DataClass, env: DataFetchingEnvironment?): Boolean = env != null }) assertEquals(resolver.get(createEnvironment(DataClass(), context = context)), true) @@ -320,7 +320,7 @@ class MethodFieldResolverDataFetcherTest { @Test fun `data fetcher passes environment to extension function if method has extra argument`() { val resolver = createFetcher("active", object : GraphQLResolver { - fun DataClass.isActive(env: DataFetchingEnvironment): Boolean = env is DataFetchingEnvironment + fun DataClass.isActive(env: DataFetchingEnvironment?): Boolean = env != null }) assertEquals(resolver.get(createEnvironment(DataClass())), true) @@ -411,7 +411,7 @@ class MethodFieldResolverDataFetcherTest { } private fun createEnvironment( - source: Any = Object(), + source: Any = Any(), arguments: Map = emptyMap(), context: GraphQLContext = GraphQLContext.newContext().build(), legacyContext: Any? = null @@ -432,7 +432,11 @@ class MethodFieldResolverDataFetcherTest { } } val executionId = ExecutionId.from("executionId123") + val schema = GraphQLSchema.newSchema() + .query(GraphQLObjectType.newObject().name("Query").field { it.name("active").type(Scalars.GraphQLBoolean) }) + .build() return ExecutionContextBuilder.newExecutionContextBuilder() + .graphQLSchema(schema) .graphQLContext(context) .instrumentation(SimplePerformantInstrumentation.INSTANCE) .executionId(executionId) diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt index a59503df..70200a8e 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt @@ -11,14 +11,12 @@ import graphql.schema.Coercing import graphql.schema.CoercingParseLiteralException import graphql.schema.CoercingSerializeException import graphql.schema.GraphQLScalarType -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import java.lang.reflect.InvocationHandler import java.lang.reflect.Method import java.lang.reflect.Proxy import java.util.* -@OptIn(ExperimentalCoroutinesApi::class) class MethodFieldResolverTest { @Test @@ -51,7 +49,7 @@ class MethodFieldResolverTest { testNull(input: null) } """) - .root(Object())) + .root(Any())) assertEquals(result.getData(), mapOf( "testValue" to "Optional[test-value]", @@ -93,7 +91,7 @@ class MethodFieldResolverTest { testNull(input: null) } """) - .root(Object())) + .root(Any())) assertEquals(result.getData(), mapOf( "testValue" to "Optional[test-value]", @@ -128,7 +126,7 @@ class MethodFieldResolverTest { } """) .variables(mapOf("input" to "FooBar")) - .root(Object())) + .root(Any())) assertEquals(result.getData(), mapOf("test" to 6)) } @@ -159,7 +157,7 @@ class MethodFieldResolverTest { } """) .variables(mapOf("input" to listOf("Foo", "Bar"))) - .root(Object())) + .root(Any())) assertEquals(result.getData(), mapOf("test" to 6)) } @@ -206,7 +204,7 @@ class MethodFieldResolverTest { } """) .variables(mapOf("input" to listOf("Foo", "Bar"))) - .root(Object())) + .root(Any())) assertEquals(result.getData(), mapOf("test" to 6)) } diff --git a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt index 2f5321d2..c3727952 100644 --- a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt @@ -6,11 +6,9 @@ import graphql.kickstart.tools.resolver.MissingResolverDataFetcherProvider import graphql.language.FieldDefinition import graphql.schema.DataFetcher import graphql.schema.DataFetchingEnvironment -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import java.util.* -@OptIn(ExperimentalCoroutinesApi::class) class MissingFieldResolverTest { @Test(expected = FieldResolverError::class) diff --git a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt index c35e51b3..9531260c 100644 --- a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt @@ -7,7 +7,6 @@ import graphql.execution.AsyncExecutionStrategy import graphql.kickstart.tools.SchemaParser.Companion.newParser import graphql.kickstart.tools.SchemaParserOptions.Companion.newOptions import graphql.kickstart.tools.SchemaParserOptions.GenericWrapper -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import java.util.* import java.util.concurrent.CompletableFuture @@ -17,7 +16,6 @@ import java.util.concurrent.FutureTask //import io.reactivex.Single; //import io.reactivex.internal.operators.single.SingleJust; //import static io.reactivex.Maybe.just; -@OptIn(ExperimentalCoroutinesApi::class) class ReactiveTest { @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt index 24f0e662..c8b0af77 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt @@ -4,12 +4,10 @@ import graphql.GraphQLContext import graphql.execution.CoercedVariables import graphql.language.Value import graphql.schema.* -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import java.util.* import java.util.concurrent.CompletableFuture -@OptIn(ExperimentalCoroutinesApi::class) class SchemaClassScannerTest { @Test diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt index 3987d9c6..4017ba52 100644 --- a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt @@ -7,7 +7,6 @@ import graphql.parser.InvalidSyntaxException import graphql.schema.* import graphql.schema.idl.SchemaDirectiveWiring import graphql.schema.idl.SchemaDirectiveWiringEnvironment -import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.reactive.publish import org.junit.Assert.assertThrows @@ -23,7 +22,6 @@ import java.util.concurrent.CompletableFuture.completedStage import java.util.concurrent.CompletionStage import java.util.concurrent.Future -@OptIn(ExperimentalCoroutinesApi::class) class SchemaParserTest { private lateinit var builder: SchemaParserBuilder diff --git a/src/test/kotlin/graphql/kickstart/tools/TestUtils.kt b/src/test/kotlin/graphql/kickstart/tools/TestUtils.kt index 33da8b0b..7aa9a396 100644 --- a/src/test/kotlin/graphql/kickstart/tools/TestUtils.kt +++ b/src/test/kotlin/graphql/kickstart/tools/TestUtils.kt @@ -19,7 +19,7 @@ fun assertNoGraphQlErrors(gql: GraphQL, args: Map = mapOf(), contex throw AssertionError("GraphQL result contained errors!\n${result.errors.map { it.message }.joinToString("\n")}") } - return result.getData() as Map + return checkNotNull(result.getData>()) } fun assertEquals(actual: T, expected: T) { diff --git a/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt b/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt index d30f0b33..4fcb4b34 100644 --- a/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt @@ -6,7 +6,6 @@ import graphql.kickstart.tools.resolver.FieldResolverScanner import graphql.kickstart.tools.util.ParameterizedTypeImpl import graphql.language.* import graphql.language.Type -import kotlinx.coroutines.ExperimentalCoroutinesApi import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.Parameterized @@ -23,7 +22,6 @@ import java.util.concurrent.Future TypeClassMatcherTest.Suit3::class, TypeClassMatcherTest.Suit4::class ) -@OptIn(ExperimentalCoroutinesApi::class) class TypeClassMatcherTest { companion object { diff --git a/src/test/kotlin/graphql/kickstart/tools/util/PrimitivesTest.kt b/src/test/kotlin/graphql/kickstart/tools/util/PrimitivesTest.kt index 6856e838..1c227832 100644 --- a/src/test/kotlin/graphql/kickstart/tools/util/PrimitivesTest.kt +++ b/src/test/kotlin/graphql/kickstart/tools/util/PrimitivesTest.kt @@ -8,7 +8,7 @@ class PrimitivesTest { @Test fun `should wrap primitive Java class`() { val clazz = Primitives.wrap(Int::class.javaPrimitiveType) - Assert.assertEquals(Integer::class.java, clazz) + Assert.assertEquals(Int::class.javaObjectType, clazz) } @Test