TestKit Example
Ray Roestenburg's example code from his blog adapted to work with Akka 2.x.
- import scala.util.Random
-
- import org.scalatest.BeforeAndAfterAll
- import org.scalatest.WordSpecLike
- import org.scalatest.Matchers
-
- import com.typesafe.config.ConfigFactory
-
- import akka.actor.Actor
- import akka.actor.ActorRef
- import akka.actor.ActorSystem
- import akka.actor.Props
- import akka.testkit.{ TestActors, DefaultTimeout, ImplicitSender, TestKit }
- import scala.concurrent.duration._
- import scala.collection.immutable
-
- /**
- * a Test to show some TestKit examples
- */
- class TestKitUsageSpec
- extends TestKit(ActorSystem(
- "TestKitUsageSpec",
- ConfigFactory.parseString(TestKitUsageSpec.config)))
- with DefaultTimeout with ImplicitSender
- with WordSpecLike with Matchers with BeforeAndAfterAll {
- import TestKitUsageSpec._
-
- val echoRef = system.actorOf(TestActors.echoActorProps)
- val forwardRef = system.actorOf(Props(classOf[ForwardingActor], testActor))
- val filterRef = system.actorOf(Props(classOf[FilteringActor], testActor))
- val randomHead = Random.nextInt(6)
- val randomTail = Random.nextInt(10)
- val headList = immutable.Seq().padTo(randomHead, "0")
- val tailList = immutable.Seq().padTo(randomTail, "1")
- val seqRef =
- system.actorOf(Props(classOf[SequencingActor], testActor, headList, tailList))
-
- override def afterAll {
- shutdown()
- }
-
- "An EchoActor" should {
- "Respond with the same message it receives" in {
- within(500 millis) {
- echoRef ! "test"
- expectMsg("test")
- }
- }
- }
- "A ForwardingActor" should {
- "Forward a message it receives" in {
- within(500 millis) {
- forwardRef ! "test"
- expectMsg("test")
- }
- }
- }
- "A FilteringActor" should {
- "Filter all messages, except expected messagetypes it receives" in {
- var messages = Seq[String]()
- within(500 millis) {
- filterRef ! "test"
- expectMsg("test")
- filterRef ! 1
- expectNoMsg
- filterRef ! "some"
- filterRef ! "more"
- filterRef ! 1
- filterRef ! "text"
- filterRef ! 1
-
- receiveWhile(500 millis) {
- case msg: String => messages = msg +: messages
- }
- }
- messages.length should be(3)
- messages.reverse should be(Seq("some", "more", "text"))
- }
- }
- "A SequencingActor" should {
- "receive an interesting message at some point " in {
- within(500 millis) {
- ignoreMsg {
- case msg: String => msg != "something"
- }
- seqRef ! "something"
- expectMsg("something")
- ignoreMsg {
- case msg: String => msg == "1"
- }
- expectNoMsg
- ignoreNoMsg
- }
- }
- }
- }
-
- object TestKitUsageSpec {
- // Define your test specific configuration here
- val config = """
- akka {
- loglevel = "WARNING"
- }
- """
-
- /**
- * An Actor that forwards every message to a next Actor
- */
- class ForwardingActor(next: ActorRef) extends Actor {
- def receive = {
- case msg => next ! msg
- }
- }
-
- /**
- * An Actor that only forwards certain messages to a next Actor
- */
- class FilteringActor(next: ActorRef) extends Actor {
- def receive = {
- case msg: String => next ! msg
- case _ => None
- }
- }
-
- /**
- * An actor that sends a sequence of messages with a random head list, an
- * interesting value and a random tail list. The idea is that you would
- * like to test that the interesting value is received and that you cant
- * be bothered with the rest
- */
- class SequencingActor(next: ActorRef, head: immutable.Seq[String],
- tail: immutable.Seq[String]) extends Actor {
- def receive = {
- case msg => {
- head foreach { next ! _ }
- next ! msg
- tail foreach { next ! _ }
- }
- }
- }
- }