웹소켓을 모킹없이 수신메시지를 검사하는 방법을 먼저알아보고

웹소켓 핸들러에 연결된 액터모델만 테스트하기 위해 웹소켓만 모킹을 한후 액터모델 수신메시지 검사를 하는방법을 알아보겠습니다.

class SocketActorHandlerTest {
    companion object {
        private lateinit var client: OkHttpClient
        private lateinit var request: Request
        private val receivedMessages = mutableListOf<String>()

        @BeforeAll
        @JvmStatic
        fun setup() {
            client = OkHttpClient()
            request = Request.Builder().url("ws://localhost:8080/ws-actor").build()
        }
    }

    fun assertContainsText(text: String) {
        val objectMapper = jacksonObjectMapper()
        val messages = receivedMessages.map { objectMapper.readValue<Map<String, Any>>(it)["message"] as String }
        if (messages.any { it.contains(text) }) {
            return
        }
        throw AssertionError("The list does not contain the text '$text'")
    }

    @Test
    fun testWebSocketConnection() {
        val latch = CountDownLatch(1) // 1초동안 수신대기목적
        val listener = object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
                webSocket.send("hello")
            }

            override fun onMessage(webSocket: WebSocket, text: String) {
                println("Received message: $text")
                receivedMessages.add(text)
                latch.countDown()
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                t.printStackTrace()
                latch.countDown()
            }
        }

        client.newWebSocket(request, listener)
        latch.await(10, TimeUnit.SECONDS)

        assertContainsText("You are connected")
    }

class SessionManagerActorTest {

    companion object {
        private val testKit = ActorTestKit.create()

        @BeforeAll
        @JvmStatic
        fun setup() {
            // Setup code if needed
        }

        @AfterAll
        @JvmStatic
        fun tearDown() {
            testKit.shutdownTestKit()
        }
    }

    @Test
    fun testAddSession() {
        val sessionManagerActor: ActorRef<UserSessionCommand> = testKit.spawn(SessionManagerActor.create(), "session-manager-actor")
        val probe: TestProbe<UserSessionCommandResponse> = testKit.createTestProbe()

        val session = Mockito.mock(WebSocketSession::class.java)
        Mockito.`when`(session.id).thenReturn("session1")
        val message = Mockito.mock(WebSocketMessage::class.java)
        Mockito.`when`(session.textMessage(Mockito.anyString())).thenReturn(message)
        Mockito.`when`(session.send(Mockito.any())).thenReturn(Mono.empty())

        sessionManagerActor.tell(UserSessionCommand.AddSession(session, probe.ref))

        probe.expectMessage(Information("Session added session1"))

    }

class SampleActorTest : WordSpec({
    val testKit = ActorTestKit.create()
    val probe = testKit.createTestProbe<String>()
    
    "SampleActor" should {
        "reply with expected message" {
            val sampleActor = testKit.spawn(SampleActor())

            sampleActor.tell("ping", probe.ref)

            probe.expectMessage("pong")
        }
    }

    afterTest {
        testKit.shutdownTestKit()
    }
})

val responseFuture = testKit.spawn(SampleActor()).ask { replyTo -> 
    SampleActor.Message("ping", replyTo)
}

val response = responseFuture.await()
assertEquals("pong", response)

val probe = testKit.createTestProbe<String>()
val scheduler = testKit.scheduler()
scheduler.scheduleOnce(100.milliseconds, probe.ref) { "delayed-message" }

probe.expectMessage("delayed-message") // 100ms 후 메시지가 도착하는지 검증