akka.testkit
Class TestKit

java.lang.Object
  akka.testkit.TestKit

All Implemented Interfaces:

TestKitBase

Direct Known Subclasses:

AkkaSpec, DurableMailboxSpec, MultiNodeSpec, TestProbe

public class TestKit
extends java.lang.Object
implements TestKitBase

Test kit for testing actors. Inheriting from this trait enables reception of replies from actors, which are queued by an internal actor and can be examined using the expectMsg... methods. Assertions and bounds concerning timing are available in the form of within blocks.

 class Test extends TestKit(ActorSystem()) {
     try {

       val test = system.actorOf(Props[SomeActor]

       within (1 second) {
         test ! SomeWork
         expectMsg(Result1) // bounded to 1 second
         expectMsg(Result2) // bounded to the remainder of the 1 second
       }

     } finally {
       system.shutdown()
     }
 }
 

Beware of two points:

- the ActorSystem passed into the constructor needs to be shutdown, otherwise thread pools and memory will be leaked - this trait is not thread-safe (only one actor with one queue, one stack of within blocks); it is expected that the code is executed from a constructor as shown above, which makes this a non-issue, otherwise take care not to run tests within a single test class instance in parallel.

It should be noted that for CI servers and the like all maximum Durations are scaled using their Duration.dilated method, which uses the TestKitExtension.Settings.TestTimeFactor settable via akka.conf entry "akka.test.timefactor".

Since:

1.1

Constructor Summary

TestKit(ActorSystem _system)

Method Summary

static boolean	awaitCond(scala.Function0<java.lang.Object> p, scala.concurrent.duration.Duration max, scala.concurrent.duration.Duration interval, boolean noThrow) Await until the given condition evaluates to true or the timeout expires, whichever comes first.
static scala.concurrent.duration.Duration	dilated(scala.concurrent.duration.Duration duration, ActorSystem system) Java API: Scale timeouts (durations) during tests with the configured 'akka.test.timefactor'.
static scala.concurrent.duration.Duration	now() Obtain current timestamp as Duration for relative measurements (using System.nanoTime).
static void	shutdownActorSystem(ActorSystem actorSystem, scala.concurrent.duration.Duration duration, boolean verifySystemShutdown) Shut down an actor system and wait for termination.
ActorSystem	system()
static java.util.concurrent.atomic.AtomicInteger	testActorId()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface akka.testkit.TestKitBase

awaitAssert, awaitCond, checkMissingAndUnexpected, end, expectMsg_internal, expectMsg, expectMsg, expectMsg, expectMsgAllClassOf, expectMsgAllClassOf, expectMsgAllConformingOf, expectMsgAllConformingOf, expectMsgAllOf_internal, expectMsgAllOf, expectMsgAllOf, expectMsgAnyClassOf_internal, expectMsgAnyClassOf, expectMsgAnyClassOf, expectMsgAnyOf_internal, expectMsgAnyOf, expectMsgAnyOf, expectMsgClass_internal, expectMsgClass, expectMsgClass, expectMsgPF, expectMsgType, expectMsgType, expectNoMsg_internal, expectNoMsg, expectNoMsg, expectTerminated, fishForMessage, format, ignoreMsg, ignoreNoMsg, internalExpectMsgAllClassOf, internalExpectMsgAllConformingOf, lastMessage, lastSender, lastWasNoMsg, msgAvailable, now, queue, receiveN_internal, receiveN, receiveN, receiveOne, receiveWhile, remaining, remainingOr, remainingOrDilated, setAutoPilot, shutdown, testActor, testKitSettings, unwatch, watch, within, within

Constructor Detail

TestKit

public TestKit(ActorSystem _system)

Method Detail

testActorId

public static java.util.concurrent.atomic.AtomicInteger testActorId()

awaitCond

public static boolean awaitCond(scala.Function0<java.lang.Object> p,
                                scala.concurrent.duration.Duration max,
                                scala.concurrent.duration.Duration interval,
                                boolean noThrow)

Await until the given condition evaluates to true or the timeout expires, whichever comes first.

Parameters:

p - (undocumented)

max - (undocumented)

interval - (undocumented)

noThrow - (undocumented)

Returns:

(undocumented)

now

public static scala.concurrent.duration.Duration now()

Obtain current timestamp as Duration for relative measurements (using System.nanoTime).

Returns:

(undocumented)

dilated

public static scala.concurrent.duration.Duration dilated(scala.concurrent.duration.Duration duration,
                                                         ActorSystem system)

Java API: Scale timeouts (durations) during tests with the configured 'akka.test.timefactor'.

Parameters:

duration - (undocumented)

system - (undocumented)

Returns:

(undocumented)

shutdownActorSystem

public static void shutdownActorSystem(ActorSystem actorSystem,
                                       scala.concurrent.duration.Duration duration,
                                       boolean verifySystemShutdown)

Shut down an actor system and wait for termination. On failure debug output will be logged about the remaining actors in the system.

If verifySystemShutdown is true, then an exception will be thrown on failure.

Parameters:

actorSystem - (undocumented)

duration - (undocumented)

verifySystemShutdown - (undocumented)

system

public ActorSystem system()

Specified by:

system in interface TestKitBase