chore: clean codes

spring-graphql-rsocket-kotlin-co/src/main/kotlin/com/example/demo/gql/scalars/LocalDateTimeScalar.kt

@@ -1,33 +1,43 @@
 package com.example.demo.gql.scalars
 
+import graphql.GraphQLContext
+import graphql.execution.CoercedVariables
 import graphql.language.StringValue
+import graphql.language.Value
 import graphql.schema.Coercing
 import graphql.schema.CoercingParseLiteralException
-import graphql.schema.CoercingParseValueException
 import graphql.schema.CoercingSerializeException
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
+import java.util.*
 
 class LocalDateTimeScalar : Coercing<LocalDateTime, String> {
     @Throws(CoercingSerializeException::class)
-    override fun serialize(dataFetcherResult: Any): String? {
+    override fun serialize(dataFetcherResult: Any, graphQLContext: GraphQLContext, locale: Locale): String? {
         return when (dataFetcherResult) {
             is LocalDateTime -> dataFetcherResult.format(DateTimeFormatter.ISO_DATE_TIME)
             else -> throw CoercingSerializeException("Not a valid DateTime")
         }
     }
 
-    @Throws(CoercingParseValueException::class)
-    override fun parseValue(input: Any): LocalDateTime {
+    override fun parseValue(input: Any, graphQLContext: GraphQLContext, locale: Locale): LocalDateTime {
         return LocalDateTime.parse(input.toString(), DateTimeFormatter.ISO_DATE_TIME)
     }
 
-    @Throws(CoercingParseLiteralException::class)
-    override fun parseLiteral(input: Any): LocalDateTime {
+    override fun parseLiteral(
+        input: Value<*>,
+        variables: CoercedVariables,
+        graphQLContext: GraphQLContext,
+        locale: Locale
+    ): LocalDateTime {
         when (input) {
             is StringValue -> return LocalDateTime.parse(input.value, DateTimeFormatter.ISO_DATE_TIME)
             else -> throw CoercingParseLiteralException("Value is not a valid ISO date time")
         }
     }
 
+    override fun valueToLiteral(input: Any, graphQLContext: GraphQLContext, locale: Locale): Value<*> {
+        return StringValue(input.toString())
+    }
+
 }

spring-graphql-rsocket-kotlin-co/src/test/kotlin/com/example/demo/IntegrationTests.kt

@@ -3,7 +3,7 @@ package com.example.demo
 import com.example.demo.gql.types.Comment
 import com.example.demo.gql.types.Post
 import com.fasterxml.jackson.databind.ObjectMapper
-import io.kotest.assertions.timing.continually
+import io.kotest.assertions.nondeterministic.continually
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -25,7 +25,6 @@ import java.util.*
 import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.time.Duration.Companion.seconds
 
-@OptIn(ExperimentalCoroutinesApi::class)
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 internal class IntegrationTests {
     companion object {

spring-graphql-rsocket-kotlin-co/src/test/kotlin/com/example/demo/MutationTests.kt

@@ -0,0 +1,68 @@
+package com.example.demo
+
+import com.example.demo.gql.datafetchers.PostController
+import com.example.demo.gql.types.Post
+import com.ninjasquad.springmockk.MockkBean
+import io.mockk.coEvery
+import io.mockk.coVerify
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.graphql.GraphQlTest
+import org.springframework.graphql.test.tester.GraphQlTester
+import java.time.LocalDateTime
+import java.util.*
+
+@GraphQlTest(controllers = [PostController::class])
+internal class MutationTests {
+    companion object {
+        private val log = LoggerFactory.getLogger(MutationTests::class.java)
+    }
+
+    @Autowired
+    lateinit var graphQlTester: GraphQlTester
+
+    @MockkBean
+    lateinit var postService: PostService
+
+    @MockkBean
+    lateinit var authorService: AuthorService
+
+    @Test
+    fun createPosts() = runTest {
+        coEvery { postService.createPost(any()) } returns
+                Post(
+                    id = UUID.randomUUID(),
+                    title = "test title",
+                    content = "test content",
+                    status = PostStatus.DRAFT,
+                    createdAt = LocalDateTime.now()
+                )
+
+        val inputHolder = "\$input"
+        val query = """
+                mutation createPost($inputHolder: CreatePostInput!){
+                    createPost(createPostInput:$inputHolder){
+                        id, 
+                        title, 
+                        content
+                    }
+                }
+            """.trimIndent()
+        graphQlTester.document(query)
+            .variable(
+                "input",
+                mapOf(
+                    "title" to "test title",
+                    "content" to "test content"
+                )
+            )
+            .execute()
+            .path("data.createPost.title")
+            .entity(String::class.java)
+            .isEqualTo("TEST TITLE")
+
+        coVerify(exactly = 1) { postService.createPost(any()) }
+    }
+}

spring-graphql-rsocket-kotlin-co/src/test/kotlin/com/example/demo/QueryTests.kt

@@ -3,28 +3,23 @@ package com.example.demo
 import com.example.demo.gql.datafetchers.PostController
 import com.example.demo.gql.types.Post
 import com.ninjasquad.springmockk.MockkBean
-import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.ints.shouldBeGreaterThan
 import io.kotest.matchers.shouldBe
 import io.mockk.coEvery
 import io.mockk.coVerify
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
 import org.junit.jupiter.api.Test
 import org.slf4j.LoggerFactory
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.graphql.GraphQlTest
-import org.springframework.context.annotation.Import
 import org.springframework.graphql.ResponseError
 import org.springframework.graphql.test.tester.GraphQlTester
 import java.time.LocalDateTime
 import java.util.*
 
-@OptIn(ExperimentalCoroutinesApi::class)
 @GraphQlTest(controllers = [PostController::class])
-@Import(ValidationConfig::class)
-internal class QueryTests {
+class QueryTests {
     companion object {
         private val log = LoggerFactory.getLogger(QueryTests::class.java)
     }
@@ -61,9 +56,9 @@ internal class QueryTests {
 //         graphQlTester.document(query).execute()
 //             .errors().satisfy { it.forEach { error -> log.debug("error message: ${error.message}") } }
         graphQlTester.document(query)
-           .execute()
-           .path("data.allPosts[*].title")
-           .entityList(String::class.java).hasSize(2).contains("POST 1", "POST 2")
+            .execute()
+            .path("data.allPosts[*].title")
+            .entityList(String::class.java).hasSize(2).contains("POST 1", "POST 2")
 
         coVerify(exactly = 1) { postService.allPosts() }
     }