Jak przetestować, że aktor Akka został utworzony w Scali

Question

Próbuję napisać test, który sprawdzi, czy mój aktor poniżej tworzy heartBeatExpireWorker i heartBeatAcepter, ale nie mam pojęcia, jak to zrobić.

Po pierwsze pomyślałem, że mógłbym użyć makiety Mockhito lub szpiega zamiast kontekstu, a następnie zweryfikować, czy nazwałem actorOf, ale nie mogę wymyślić sposobu na wstrzyknięcie kontekstu bez łamania schematu testowania Akka.

Potem pomyślałem, że mogę wysłać wiadomość identyfikacyjną do pracowników, aby sprawdzić, czy istnieją. Ale przyszło mi do głowy, że to też nie zadziała, ponieważ Akka TestKit nie wydaje się tworzyć dzieci aktorów aktora w teście. Potrafi tylko przyjmować pakiety testowe, które mogą stać na sąsiednich aktorów.

class HeartBeatPumpWorker(chatService: ChatService, target: HeartBeatMessageCmd) extends Actor with ActorLogging with 
WorkersReference { 

    val heartBeatInterval = chatService.getHeartBeatInterval 

    val tick = context.system.scheduler.schedule(0 millis, heartBeatInterval millis, self, SendHeartBeat(target)) 

    override def postStop() = tick.cancel() 

    def receive = { 
    case SendHeartBeat(command: HeartBeatMessageCmd) => 
     log.debug("Sending heartbeat") 
     //Send heartbeat to GWT 
     val userTarget = NetworkWorker.buildEventUserTarget(command.getEventCode, command.getUser) 

     val uuid: String = UUID.randomUUID().toString 
     val freshCommand = new HeartBeatMessageCmd(command.getUser, command.getEventCode, uuid, command.getUserSession) 
     networkWorker ! NetworkBroadcast(userTarget, freshCommand) 

     val heartBeatId: String = freshCommand.getUuid 
     //create expirer 
     val heartBeatExpireWorkerRef = context.actorOf(HeartBeatExpireWorker.props(chatService, freshCommand), 
     HeartBeatExpireWorker.name(heartBeatId)) 
     val heartBeatAccepterRef = context 
     .actorOf(HeartBeatAcceptWorker.props(chatService, freshCommand), HeartBeatAcceptWorker.name(heartBeatId)) 

     //record heartbeat 
     chatService.saveSentHeartbeat(heartBeatId, freshCommand.getUserSession, freshCommand.getEventCode, 
      freshCommand.getUser, 
     freshCommand.getTimeCmdGenerated) 
    case _ => 
     log.error("Pumper received unknown message. This shouldn't happen " + sender.path.toString) 
     self ! PoisonPill 
    } 

} 


object HeartBeatPumpWorker { 
    def name(eventCode: String, user: String, sessionId: String) = f"HeartBeatPumpWorker-$eventCode-$user-$sessionId" 

    def path(eventCode: String, user: String, sessionId: String) : String = { 
    EventWorker.Path + "/" + name(eventCode, user, sessionId) 
    } 

    def props(chatService: ChatService, heartBeatMsgCmd: HeartBeatMessageCmd) = { 
    Props(classOf[HeartBeatPumpWorker], chatService, heartBeatMsgCmd) 
    } 
} 

Answer 1

wstrzyknąć Props dla dzieci (np HeartBeatAcceptWorker.props) w konstruktora rodzica HeartBeatPumpWorker. Przełóż dowolną liczbę z testu na Props. Pozwól rodzicowi utworzyć dzieci, podając Props. Interakcja z dziećmi. Ostatnia część zależy od przepływu danych. Na przykład, jeśli rodzic chroni cię przed dziećmi, ale przekazuje im wiadomości, wyślij wiadomość do rodzica. Jeśli dzieci rozmawiają ze sobą, użyj sond testowych lub czegoś podobnego.

Answer 2

Technika, której obecnie używam, polega na przechwytywaniu tworzenia aktorów i tworzeniu zestawów testowych. W moich aktorów mieszać w oddzielnym cechy ActorMaker:

trait ActorMaker { this: Actor => 
    def makeActor(props: Props) = context.actorOf(props) 
} 

i używać go w MyActor extends Actor with ActorMaker zamiast context.actorOf.

Dla testów mam TestProbeMaker który przechwytuje wszystkie stworzone aktorów i ich rekwizyty:

trait TestProbeMaker { this: Actor => 
    val probes = ListBuffer.empty[(Props, TestProbe)] 
    def makeActor(props: Props) = { val probe = TestProbe() 
    probes += (props -> probe) 
    probe.ref 
    } 
} 

I zmieszać go w trakcie badań

val actorUnderTest = TestActorRef(Props(new MyActor with TestProbeMaker)) 

ten sposób mogę dochodzić dokładnie jakie aktorów są tworzone. Mogę również użyć sondy.expectMsg, aby potwierdzić, że wiadomości są wysyłane do stworzonych aktorów.

Aby uzyskać dostęp do sond, użyj actorUnderTest.underlyingActor.asInstanceOf[TestProbeMaker]