코틀린 순수 액터

AKKA 프레임워크를 사용한 비헤이버기반 액터모델을 코틀린이 지원하는 순수 액터모델로 변환을 시도
코프링을 이용한다면 로컬전용 이벤트 드리븐방식의 처리기를 만들때 액터모델이 필요할때 채택할수 있습니다. 

	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")

package com.example.kotlinbootlabs.kactor

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.cancel
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.launch

sealed class HelloKActorCommand
data class Hello(val message: String, val replyTo: kotlinx.coroutines.CompletableDeferred<HelloKActorResponse>) : HelloKActorCommand()
data class GetHelloCount(val replyTo: kotlinx.coroutines.CompletableDeferred<HelloKActorResponse>) : HelloKActorCommand()

sealed class HelloKActorResponse
data class HelloResponse(val message: String) : HelloKActorResponse()
data class HelloCountResponse(val count: Int) : HelloKActorResponse()

class HelloKActor {

    private val channel = Channel<HelloKActorCommand>()
    private var helloCount = 0
    private val scope = CoroutineScope(Dispatchers.Default)

    init {
        scope.launch {
            for (command in channel) {
                when (command) {
                    is Hello -> handleHello(command)
                    is GetHelloCount -> handleGetHelloCount(command)
                }
            }
        }
    }

    private fun handleHello(command: Hello) {
        if (command.message == "Hello") {
            helloCount++
            command.replyTo.complete(HelloResponse("Kotlin"))
        } else if (command.message == "InvalidMessage") {
            throw RuntimeException("Invalid message received!")
        }
    }

    private fun handleGetHelloCount(command: GetHelloCount) {
        command.replyTo.complete(HelloCountResponse(helloCount))
    }

    suspend fun send(command: HelloKActorCommand) {
        channel.send(command)
    }

    fun stop() {
        scope.cancel()
    }
}

package com.example.kotlinbootlabs.kactor
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class HelloKActorTest {
    companion object {
        private const val TIMEOUT_DURATION = 3000L // Timeout duration in milliseconds
    }

    private val actor = HelloKActor()

    @AfterEach
    fun tearDown() {
        actor.stop()
    }

    @Test
    fun testHelloCommand() = runBlocking {

        val response = CompletableDeferred<HelloKActorResponse>()
        actor.send(Hello("Hello", response))
        val result = withTimeout(TIMEOUT_DURATION) { response.await() } as HelloResponse

        //The response message should be 'Kotlin'
        assertEquals("Kotlin", result.message, "Kotlin")
    }

    @Test
    fun testGetHelloCountCommand() = runBlocking {

        val response1 = CompletableDeferred<HelloKActorResponse>()
        actor.send(Hello("Hello", response1))
        withTimeout(TIMEOUT_DURATION) { response1.await() }

        val response2 = CompletableDeferred<HelloKActorResponse>()
        actor.send(GetHelloCount(response2))
        val result = withTimeout(TIMEOUT_DURATION) { response2.await() } as HelloCountResponse
        assertEquals(1, result.count, "The hello count should be 1")
    }

    @Test
    fun testInvalidMessage() {

        val response = CompletableDeferred<HelloKActorResponse>()
        try {
            runBlocking {
                withTimeout(TIMEOUT_DURATION) {
                    actor.send(Hello("InvalidMessage", response))
                }
            }
        } catch (e: RuntimeException) {
            assertEquals("Invalid message received!", e.message, "The exception message should be 'Invalid message received!'")
        }
    }
}