Actors testing is different from what you are used to. First, you have messages instead of calls, second, you have to deal with concurrency and all the consequences that it brings with it: * Thread.sleeps in tests; * Flakiness; * Green on laptop / red on jenkins; * Missed test cases. Fortunately Akka provides a TestKit which helps to avoid all these things when used properly. Let's take out and inspect tools from this kit and learn couple of useful patterns.

1. Blood, sweat and
tears
... or be smart when testing your Akka code

2. • PHP, NodeJS, AngularJS, Python, Java, Scala;
• Living in the Netherlands, working at
• Developing release automation product: XL
Release.
About me

3. github:mkotsur/restito

4. • TDD is great when done properly!
• Reactive complexity;
• Learned a lot during last 4 months.
Why testing?

6. • Tests;
• Better tests;
• Problem-less tests.

7. • Concurrency, parallelism, state.
• Not just messages;
• Willing to help you with the TestKit.

9. Not only messages

10. Not only messages

11. Not only messages

12. Not only messages

13. Not only messages

14. object IncrementorActorMessages {
case class Inc(i: Int)
}
class IncrementorActor extends Actor {
var sum: Int = 0
override def receive: Receive = {
case Inc(i) => sum = sum + i
}
}

15. Sync unit-testing
• Works with `CallingThreadDispatcher`;
• Supports either message-sending style, or direct
invocations.

16. class IncrementorActorTest extends
TestKit(ActorSystem(“test-system")) {
...
}

17. it("should have sum = 0 by default") {
val actorRef = TestActorRef[IncrementorActor]
actorRef.underlyingActor.sum shouldEqual 0
}

18. it("should increment on new messages") {
val actorRef = TestActorRef[IncrementorActor]
actorRef ! Inc(2)
actorRef.underlyingActor.sum shouldEqual 2
actorRef.underlyingActor.receive(Inc(3))
actorRef.underlyingActor.sum shouldEqual 5
}

19. class LazyIncrementorActor extends Actor {
var sum: Int = 0
override def receive: Receive = {
case Inc(i) =>
Future {
Thread.sleep(100)
sum = sum + i
}
}
}
Not good enough

21. Not only messages

22. object IncrementorActorMessages {
case class Inc(i: Int)
case object Result
}
class IncrementorActor extends Actor {
var sum: Int = 0
override def receive: Receive = {
case Inc(i) => sum = sum + i
case Result => sender() ! sum
}
}
New message

23. it("should have sum = 0 by default") {
val actorRef = system
.actorOf(Props(classOf[IncrementorActor]))
val probe = TestProbe()
actorRef.tell(Result, probe.ref)
probe.expectMsg(0)
}
Using TestProbe

24. it("should have sum = 0 by default") {
val actorRef = system
.actorOf(Props(classOf[IncrementorActor]))
actorRef ! Result
expectMsg(0)
}
Using TestProbe
... with ImplicitSender

25. it("should increment on new messages") {
val actorRef = system
.actorOf(Props(classOf[IncrementorActor]))
actorRef ! Inc(2)
actorRef ! Result
expectMsg(2)
actorRef ! Inc(3)
actorRef ! Result
expectMsg(5)
}
Using TestProbe

26. expectMsg*
def expectMsg[T](d: Duration, msg: T): T
def expectMsgPF[T](d: Duration)
(pf: PartialFunction[Any, T]): T
def expectMsgClass[T](d: Duration, c: Class[T]): T
def expectNoMsg(d: Duration) // blocks

27. Fishing
def receiveN(n: Int, d: Duration): Seq[AnyRef]
def receiveWhile[T](max: Duration, idle: Duration, n: Int)
(pf: PartialFunction[Any, T]): Seq[T]
def fishForMessage(max: Duration, hint: String)
(pf: PartialFunction[Any, Boolean]): Any

28. Awaits
def awaitCond(p: => Boolean, max: Duration,
interval: Duration)
def awaitAssert(a: => Any, max: Duration,
interval: Duration)
// from ScalaTest
def eventually[T](fun: => T)
(implicit config: PatienceConfig): T

29. Ignores
def ignoreMsg(pf: PartialFunction[AnyRef, Boolean])
def ignoreNoMsg()

30. Death watching
val probe = TestProbe()
probe watch target
target ! PoisonPill
probe.expectTerminated(target)

31. Test probes as
dependencies
class HappyParentActor(childMaker: ActorRefFactory
=> ActorRef) extends Actor {
val child: ActorRef = childMaker(context)
override def receive: Receive = {
case msg => child.forward(msg)
}
}

32. Event filter
class MyActor extends Actor with ActorLogging {
override def receive: Receive = {
case DoSideEffect =>
log.info("Hello World!")
}
}

33. Event filter
EventFilter.info(
message = "Hello World!",
occurrences = 1
).intercept {
myActor ! DoSomething
}
akka.loggers = ["akka.testkit.TestEventListener"]

34. Supervision
class MyActor extends Actor with ActorLogging {
override def supervisorStrategy: Unit =
OneForOneStrategy() {
case _: FatalException =>
SupervisorStrategy.Escalate
case _: ShitHappensException =>
SupervisorStrategy.Restart
}
}

35. Supervision
val actorRef = TestActorRef[MyActor](MyActor.props())
val pf = actorRef.underlyingActor
.supervisorStrategy.decider
pf(new FatalException()) should be (Escalate)
pf(new ShitHappensException()) should be (Restart)

36. • Tests;
• Better tests;
• Problem-less tests.

37. TestBase
class MyActorTest
extends TestKit(ActorSystem("test-system"))
with FunSpecLike {
override protected def afterAll(): Unit = {
super.afterAll()
system.shutdown()
system.awaitTermination()
}
}

38. TestBase
class MyActorTest extends TestKit(ActorSystem("my-
system"))
with AkkaTestBase {
...
}
trait AkkaTestBase
extends BeforeAndAfterAll
with FunSpecLike { this: TestKit with Suite =>
override protected def afterAll() {
super.afterAll()
system.shutdown()
system.awaitTermination()
}
}

39. TestBase: v2
class MyActorTest extends AkkaTestBase {
...
}
abstract class AkkaTestBase
extends TestKit(ActorSystem("test-system"))
with FunSpecLike
with BeforeAndAfterAll {
override protected def afterAll() {
super.afterAll()
system.shutdown()
}
}

40. Timeouts
akka.test.single-expect-default = 3 seconds
akka.test.timefactor = 10

41. Settings extension
class Settings(...) extends Extension {
object Jdbc {
val Driver = config.getString("app.jdbc.driver")
val Url = config.getString("app.jdbc.url")
}
}

42. Settings extension
class MyActor extends Actor {
val settings = Settings(context.system)
val connection = client.connect(
settings.Jdbc.Driver,
settings.Jdbc.Url
)
}

43. Settings extension
val config = ConfigFactory.parseString("""
app.jdbc.driver = "org.h2.Driver"
app.jdbc.url = "jdbc:h2:mem:repository"
""")
val system = ActorSystem("testsystem", config)

44. Dynamic actors
case class Identify(messageId: Any)
case class ActorIdentity(
correlationId: Any,
ref: Option[ActorRef]
)

47. • Continuous delivery;
• No dedicated QA engineers;
• 500+ Jenkins jobs.
We depend on tests

48. • Tests;
• Better tests;
• Problem-less tests.

49. Be careful with mocking.

50. Prefer checking messages over checking side-effects.

51. Single responsibility principle.

52. Run your tests on slow VM and different OS.

53. Extract *all* timeouts into conf files. So that you can easily
override them on Jenkins.

54. Don’t hesitate to rewrite test.

55. Don't hesitate to rewrite application code.

56. Don’t trust assertion errors, check logs.

57. Base your decisions on historical data.

60. Be humane and spread the word.

62. Questions?
github:mkotsur/akka-smart-testing