Jinhyuk Kim

object TestActor {
    case class Message(data: String)
    case class GetState(receiver: ActorRef)
}

class TestActor extends Actor {
    import TestActor._

    val internalState = Vector[String]() // 외부에서 확인 불가

    def receive = {
        case Message(data) => internalState = internalState :+ data
        case GetState(receiver) => receiver ! internalState
    }

    def state = internalState
}

class ActorTest01 extends TestKit(ActorSystem("testSystem"))
    with WordSpecLike
    with MustMatchers
    with StopSystemAfterAll {

    "단일 스레드 환경에서 메시지를 받으면 내부 상태를 변경한다" in {
        import TestActor._

        val testActor = TestActorRef[TestActor]

        testActor ! Message("메시지 전송")
        testActor.underlyingActor.state must (contains("메시지 전송"))
    }
}

class ActorTest02 extends TestKit(ActorSystem("testSystem"))
    with WordSpecLike
    with MustMatchers
    with StopSystemAfterAll {

    "다중 스레드 환경에서 메시지를 받으면 내부 상태를 변경한다" in {
        import TestActor._

        val actor = system.actorOf(Props[TestActor], "testActor")
        actor ! Message("첫번째 메시지 전송")
        actor ! Message("두번째 메시지 전송")
        actor ! GetState(testActor) // TestKit의 testActor가 메시지를 받게 한다.
        expectMsg(Vector("첫번째 메시지 전송", "두번째 메시지 전송"))
    }
}

"메시지를 받아 전송하는 액터" must {
    "메시지를 받아 처리해서 다른 액터에게 메시지를 보낸다" in {
        import SortingActor._

        val props = SortingActor.props(testActor)
        val sortingActor = system.actorOf(props, "sortingActor")

        // 정렬되지 않은 리스트를 전송한다.
        val unsortedList = (0 until 10000).map { _ =>
            Random.nextInt(100000)
        }.toVector
        sortingActor ! Sort(unsortedList)

        // expectMsgPF 함수를 사용해 정확하게 매치할 수 없는 결과를 확인한다.
        expectMsgPF() {
            case Sorted(sortedList) =>
                sortedList.size must be(size)
                unsortedList.sorted must be (sortedList)
        }
    }
}

object SortingActor {
    def props(receiver: ActorRef) = Props(new SortingActor(receiver))

    case class Sort(unsortedList: Vector[Int])
    case class Sorted(sortedList: Vector[Int])
}

class SortingActor(receiver: ActorRef) extends Actor {
    import SortingActor._
    def receive = {
        case Sort(unsortedList) => receiver ! Sorted(unsortedList.sorted)
    }
}

"receiveWhile과 expectNoMsg를 이용해 짝수일 때만 메시지를 보내는지 확인한다" in {
    import FilteringActor._

    val props = FilteringActor.props(testActor)
    val filter = system.actorOf(props, "filter")

    filter ! Number(1)
    filter ! Number(2)
    filter ! Number(3)
    filter ! Number(4)
    filter ! Number(5)
    filter ! Number(6)
    val numbers = receiveWhile() {
        case Number(number) if number < 6 => number
    }
    numbers numst be(List(2, 4))
    expectMsg(Number(6))

    filter ! Number(1)
    expectNoMsg
    filter ! Number(2)
    expectMsg(Number(2))
    filter ! Number(3)
    expectNoMsg
    filter ! Number(4)
    expectMsg(Number(4))
}

object FilteringActor {
    def props(nextActor: ActorRef) = Props(new FilteringActor(nextActor))
    case class Number(number: Long)
}

class FilteringActor(nextActor: ActorRef) extends Actor {
    import FilteringActor._

    def receive = {
        case msg: Number =>
            if (msg.number % 2 == 0) {
                nextActor ! msg
            }
    }
}

object LoggingActorTest {
    val testSystem = {
        // ConfigFactory는 문자열을 파싱해서 설정 정보를 얻을 수 있다.
        val config = ConfigFactory.parseString(
            // TestEventListener는 로그에 기록되는 모든 이벤트를 처리할 수 있다.
            """
                akka.loggers = [akka.testkit.TestEventListener]
            """
        )
    }
}

import LoggingActorTest._

class LoggingActorTest extends TestKit(testSystem) with WordSpecLike with StopSystemAfterAll {
    "LoggingActor" must {
        "로그에 남길 메시지를 보내면 로그로 남긴다" in {
            // 로그 이벤트를 검사하기 위해 단일 스레드 환경에서 테스트를 실행한다.
            val dispatcherId = CallingThreadDispatcher.id
            val props = Props[Greeter].withDispatcher(dispatcherId)
            
            val loggingActor = system.actorOf(props)
            EventFilter.info(message = "[LOG] 로그 테스트", occurances = 1).intercept {
                loggingActor ! Log("로그 테스트")
            }
        }
    }
}

object LoggingActor {
    case class Log(message: String)
}

class LoggingActor extends Actor with ActorLogging {
    def receive = {
        case Log(message) => log.info(s"[LOG] $message")
    }
}