class HelloActorStreamTest {

    companion object {
        private val system = ActorSystem.create("TestSystem")
        private val materializer = ActorMaterializer.create(system)

        @JvmStatic
        @AfterClass
        fun teardown() {
            TestKit.shutdownActorSystem(system)
        }
    }

    @Test
    fun `should throttle and respond with world`() {
        object : TestKit(system) {
            init {
                val helloActor = system.actorOf(HelloActor.props())

                // Source.queue + throttle + ask pattern
                val (queue, done) = Source.queue<String>(10, OverflowStrategy.backpressure())
                    .throttle(3, JDuration.ofSeconds(1)) // 초당 3건
                    .mapAsync(1) { msg ->
                        akka.pattern.Patterns.ask(helloActor, msg, 1000).thenApply { it as String }
                    }
                    .toMat(Sink.foreach { response ->
                        println("응답 수신: $response")
                        expectMsgEquals("world")  // 테스트 검증
                    }, Keep.both())
                    .run(materializer)

                // 메시지 전송 (10건)
                for (i in 1..10) {
                    queue.offer("hello")
                }

                // 일부 응답 대기
                within(Duration.create(5, "seconds")) {
                    // 최소 3건은 들어왔는지 확인
                    for (i in 1..3) {
                        expectNoMessage()
                    }
                }
            }
        }
    }
}

                    +------------------+
                    |   Router (RoundRobinPool)   |
                    +------------------+
                    /        |        \
          HelloActor1  HelloActor2  HelloActor3

fun main() {
    val system = ActorSystem.create("RoundRobinSystem")

    // RoundRobinPool로 HelloActor 3개 구성
    val router = system.actorOf(
        RoundRobinPool(3).props(HelloActor.props()),
        "helloRouter"
    )

    println("=== 메시지 전송 시작 ===")
    for (i in 1..9) {
        val future = Patterns.ask(router, "hello $i", 1000)
        val result = Await.result(future, Duration.create(1, TimeUnit.SECONDS))
        println("응답 $i: $result")
    }

    system.terminate()
}

// Output
[helloRouter/$a] received: hello 1
응답 1: world
[helloRouter/$b] received: hello 2
응답 2: world
[helloRouter/$c] received: hello 3
응답 3: world
[helloRouter/$a] received: hello 4
응답 4: world
...