Packages

class TestKit extends AnyRef

Java API: Test kit for testing actors. Inheriting from this class 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.

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); 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 the dilated method, which uses the TestKitExtension.Settings.TestTimeFactor settable via akka.conf entry "akka.test.timefactor".
Annotations
@nowarn()
Source
TestKit.scala
Linear Supertypes
AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TestKit
  2. AnyRef
  3. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new TestKit(system: ActorSystem)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from TestKit toany2stringadd[TestKit] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (TestKit, B)
    Implicit
    This member is added by an implicit conversion from TestKit toArrowAssoc[TestKit] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def awaitAssert[A](max: Duration, interval: Duration, a: Supplier[A]): A

    Evaluate the given assert every interval until it does not throw an exception.

    Evaluate the given assert every interval until it does not throw an exception. If the max timeout expires the last exception is thrown.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

    returns

    an arbitrary value that would be returned from awaitAssert if successful, if not interested in such value you can return null.

  8. def awaitAssert[A](max: Duration, a: Supplier[A]): A

    Evaluate the given assert every interval until it does not throw an exception and return the result.

    Evaluate the given assert every interval until it does not throw an exception and return the result.

    If the max timeout expires the last exception is thrown.

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  9. def awaitAssert[A](a: Supplier[A]): A

    Evaluate the given assert every interval until it does not throw an exception and return the result.

    Evaluate the given assert every interval until it does not throw an exception and return the result.

    If the max timeout expires the last exception is thrown.

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  10. def awaitCond(max: Duration, interval: Duration, message: String, p: Supplier[Boolean]): Unit

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

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

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  11. def awaitCond(max: Duration, interval: Duration, p: Supplier[Boolean]): Unit

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

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

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  12. def awaitCond(max: Duration, p: Supplier[Boolean]): Unit

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

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

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  13. def awaitCond(p: Supplier[Boolean]): Unit

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

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

    If no timeout is given, take it from the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor".

  14. def childActorOf(props: Props): ActorRef

    Spawns an actor as a child of this test actor with an auto-generated name and stopping supervisor strategy, returning the child's ActorRef.

  15. def childActorOf(props: Props, name: String): ActorRef

    Spawns an actor as a child of this test actor with a stopping supervisor strategy, and returns the child's ActorRef.

  16. def childActorOf(props: Props, supervisorStrategy: SupervisorStrategy): ActorRef

    Spawns an actor as a child of this test actor with an auto-generated name, and returns the child's ActorRef.

  17. def childActorOf(props: Props, name: String, supervisorStrategy: SupervisorStrategy): ActorRef

    Spawns an actor as a child of this test actor, and returns the child's ActorRef.

  18. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
  19. def dilated(duration: Duration): Duration

    Java timeouts (durations) during tests with the configured

  20. def duration(s: String): FiniteDuration
  21. def ensuring(cond: (TestKit) => Boolean, msg: => Any): TestKit
    Implicit
    This member is added by an implicit conversion from TestKit toEnsuring[TestKit] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  22. def ensuring(cond: (TestKit) => Boolean): TestKit
    Implicit
    This member is added by an implicit conversion from TestKit toEnsuring[TestKit] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  23. def ensuring(cond: Boolean, msg: => Any): TestKit
    Implicit
    This member is added by an implicit conversion from TestKit toEnsuring[TestKit] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  24. def ensuring(cond: Boolean): TestKit
    Implicit
    This member is added by an implicit conversion from TestKit toEnsuring[TestKit] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  27. def expectMsg[T](max: Duration, obj: T, hint: String): T

    Receive one message from the test actor and assert that it equals the given object.

    Receive one message from the test actor and assert that it equals the given object. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

  28. def expectMsg[T](max: Duration, obj: T): T

    Receive one message from the test actor and assert that it equals the given object.

    Receive one message from the test actor and assert that it equals the given object. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

  29. def expectMsg[T](obj: T): T

    Same as expectMsg(remainingOrDefault, obj), but correctly treating the timeFactor.

  30. def expectMsgAllOf[T](objs: T*): List[T]

    Same as expectMsgAllOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Same as expectMsgAllOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Annotations
    @varargs()
  31. def expectMsgAllOfWithin[T](max: Duration, objs: T*): List[T]

    Receive a number of messages from the test actor matching the given number of objects and assert that for each given object one is received which equals it and vice versa.

    Receive a number of messages from the test actor matching the given number of objects and assert that for each given object one is received which equals it and vice versa. This construct is useful when the order in which the objects are received is not fixed. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Annotations
    @varargs()
  32. def expectMsgAnyClassOf[T](max: Duration, objs: Class[_]*): T

    Receive one message from the test actor and assert that it conforms to one of the given classes.

    Receive one message from the test actor and assert that it conforms to one of the given classes. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Annotations
    @varargs()
  33. def expectMsgAnyClassOf[T](objs: Class[_]*): T

    Same as expectMsgAnyClassOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Same as expectMsgAnyClassOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Annotations
    @varargs()
  34. def expectMsgAnyOf[T](first: T, objs: T*): T

    Same as expectMsgAnyOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Same as expectMsgAnyOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

    Annotations
    @varargs()
  35. def expectMsgAnyOfWithin[T](max: Duration, objs: T*): T

    Receive one message from the test actor and assert that it equals one of the given objects.

    Receive one message from the test actor and assert that it equals one of the given objects. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Annotations
    @varargs()
  36. def expectMsgClass[T](max: Duration, c: Class[T]): T

    Receive one message from the test actor and assert that it conforms to the given class.

    Receive one message from the test actor and assert that it conforms to the given class. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

  37. def expectMsgClass[T](c: Class[T]): T

    Same as expectMsgClass(remainingOrDefault, c), but correctly treating the timeFactor.

  38. def expectMsgEquals[T](max: Duration, obj: T): T

    Receive one message from the test actor and assert that it equals the given object.

    Receive one message from the test actor and assert that it equals the given object. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    returns

    the received object

  39. def expectMsgEquals[T](obj: T): T

    Same as expectMsg(remainingOrDefault, obj), but correctly treating the timeFactor.

  40. def expectMsgPF[T](max: Duration, hint: String, f: Function[Any, T]): T

    Receive one message from the test actor and assert that the given partial function accepts it.

    Receive one message from the test actor and assert that the given partial function accepts it. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Use this variant to implement more complicated or conditional processing.

    Annotations
    @nowarn()
  41. def expectMsgPF[T](hint: String, f: Function[Any, T]): T

    Receive one message from the test actor and assert that the given partial function accepts it.

    Receive one message from the test actor and assert that the given partial function accepts it. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Use this variant to implement more complicated or conditional processing.

  42. def expectNoMessage(max: Duration): Unit

    Assert that no message is received for the specified time.

    Assert that no message is received for the specified time. Supplied value is not dilated.

  43. def expectNoMessage(): Unit

    Assert that no message is received.

    Assert that no message is received. Waits for the default period configured as akka.actor.testkit.expect-no-message-default. That timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  44. def expectTerminated(target: ActorRef): Terminated

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. Before calling this method, you have to watch the target actor ref. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    target

    the actor ref expected to be Terminated

    returns

    the received Terminated message

  45. def expectTerminated(max: Duration, target: ActorRef): Terminated

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. Before calling this method, you have to watch the target actor ref. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    max

    wait no more than max time, otherwise throw AssertionFailure

    target

    the actor ref expected to be Terminated

    returns

    the received Terminated message

  46. def fishForMessage(max: Duration, hint: String, f: Function[Any, Boolean]): Any

    Hybrid of expectMsgPF and receiveWhile: receive messages while the partial function matches and returns false.

    Hybrid of expectMsgPF and receiveWhile: receive messages while the partial function matches and returns false. Use it to ignore certain messages while waiting for a specific message.

    returns

    the last received message, i.e. the first one for which the partial function returned true

    Annotations
    @nowarn()
  47. def fishForSpecificMessage[T](max: Duration, hint: String, f: Function[Any, T]): T

    Same as fishForMessage, but gets a different partial function and returns properly typed message.

    Same as fishForMessage, but gets a different partial function and returns properly typed message.

    Annotations
    @nowarn()
  48. def forward(actor: ActorRef): Unit

    Forward this message as if in the TestActor's receive method with self.forward.

  49. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  50. def getLastSender: ActorRef

    Get the last sender of the TestProbe

  51. def getRef: ActorRef

    Shorthand to get the testActor.

  52. def getRemaining: Duration

    Obtain time remaining for execution of the innermost enclosing within block or throw an AssertionError if no within block surrounds this call.

  53. def getRemainingOr(duration: Duration): Duration

    Obtain time remaining for execution of the innermost enclosing within block or missing that it returns the given duration.

  54. def getRemainingOrDefault: Duration

    Obtain time remaining for execution of the innermost enclosing within block or missing that it returns the properly dilated default for this case from settings (key "akka.test.single-expect-default").

  55. def getSystem: ActorSystem
  56. def getTestActor: ActorRef

    ActorRef of the test actor.

    ActorRef of the test actor. Access is provided to enable e.g. registration as message target.

  57. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  58. def ignoreMsg(pf: Function[Any, Boolean]): Unit

    Ignore all messages in the test actor for which the given partial function returns true.

  59. def ignoreNoMsg(): Unit

    Stop ignoring messages in the test actor.

  60. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  61. def msgAvailable: Boolean

    Query queue status.

  62. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  63. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  64. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  65. def receiveN(n: Int, max: Duration): List[AnyRef]

    Receive N messages in a row before the given deadline.

  66. def receiveN(n: Int): List[AnyRef]

    Same as receiveN(n, remaining) but correctly taking into account Duration.timeFactor.

  67. def receiveOne(max: Duration): AnyRef

    Receive one message from the internal queue of the TestActor.

    Receive one message from the internal queue of the TestActor. If the given duration is zero, the queue is polled (non-blocking).

    This method does NOT automatically scale its Duration parameter!

  68. def receiveWhile[T](max: Duration, f: Function[AnyRef, T]): List[T]
  69. def receiveWhile[T](max: Duration, idle: Duration, messages: Int, f: Function[AnyRef, T]): List[T]

    Receive a series of messages until one does not match the given partial function or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed or expected messages count is reached.

    Receive a series of messages until one does not match the given partial function or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed or expected messages count is reached. Returns the sequence of messages.

    Note that it is not an error to hit the max duration in this case.

    One possible use of this method is for testing whether messages of certain characteristics are generated at a certain rate:

  70. def reply(msg: AnyRef): Unit

    Send message to the sender of the last dequeued message.

  71. def send(actor: ActorRef, msg: AnyRef): Unit

    Send message to an actor while using the probe's TestActor as the sender.

    Send message to an actor while using the probe's TestActor as the sender. Replies will be available for inspection with all of TestKit's assertion methods.

  72. def setAutoPilot(pilot: AutoPilot): Unit

    Install an AutoPilot to drive the testActor: the AutoPilot will be run for each received message and can be used to send or forward messages, etc.

    Install an AutoPilot to drive the testActor: the AutoPilot will be run for each received message and can be used to send or forward messages, etc. Each invocation must return the AutoPilot for the next round.

  73. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  74. def toString(): String
    Definition Classes
    AnyRef → Any
  75. def unwatch(ref: ActorRef): ActorRef

    Have the testActor stop watching someone (i.e.

    Have the testActor stop watching someone (i.e. context.unwatch(...)).

  76. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  77. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  78. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  79. def watch(ref: ActorRef): ActorRef

    Have the testActor watch someone (i.e.

    Have the testActor watch someone (i.e. context.watch(...)).

  80. def within[T](max: Duration, f: Supplier[T]): T

    Execute code block while bounding its execution time between min and max.

    Execute code block while bounding its execution time between min and max. within blocks may be nested. All methods in this trait which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor", while the min Duration is not.

    within(java.time.Duration.ofMillis(50), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});
  81. def within[T](min: Duration, max: Duration, f: Supplier[T]): T

    Execute code block while bounding its execution time between min and max.

    Execute code block while bounding its execution time between min and max. within blocks may be nested. All methods in this trait which take maximum wait times are available in a version which implicitly uses the remaining time governed by the innermost enclosing within block.

    Note that the timeout is scaled using Duration.dilated, which uses the configuration entry "akka.test.timefactor", while the min Duration is not.

    within(java.time.Duration.ofMillis(50), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});

Deprecated Value Members

  1. def expectMsgPF[T](max: Duration, hint: String, f: Function[Any, T]): T

    Receive one message from the test actor and assert that the given partial function accepts it.

    Receive one message from the test actor and assert that the given partial function accepts it. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    Use this variant to implement more complicated or conditional processing.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.6.0) Use the overloaded one which accepts java.time.Duration instead.

  2. def expectTerminated(max: Duration, target: ActorRef): Terminated

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.

    Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. Before calling this method, you have to watch the target actor ref. Wait time is bounded by the given duration, with an AssertionFailure being thrown in case of timeout.

    max

    wait no more than max time, otherwise throw AssertionFailure

    target

    the actor ref expected to be Terminated

    returns

    the received Terminated message

    Annotations
    @deprecated
    Deprecated

    (Since version 2.6.0) Use the overloaded one which accepts java.time.Duration instead.

  3. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

  4. def fishForMessage(max: Duration, hint: String, f: Function[Any, Boolean]): Any

    Hybrid of expectMsgPF and receiveWhile: receive messages while the partial function matches and returns false.

    Hybrid of expectMsgPF and receiveWhile: receive messages while the partial function matches and returns false. Use it to ignore certain messages while waiting for a specific message.

    returns

    the last received message, i.e. the first one for which the partial function returned true

    Annotations
    @deprecated
    Deprecated

    (Since version 2.6.0) Use the overloaded one which accepts java.time.Duration instead.

  5. def fishForSpecificMessage[T](max: Duration, hint: String, f: Function[Any, T]): T

    Same as fishForMessage, but gets a different partial function and returns properly typed message.

    Same as fishForMessage, but gets a different partial function and returns properly typed message.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.6.0) Use the overloaded one which accepts java.time.Duration instead.

  6. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from TestKit toStringFormat[TestKit] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  7. def →[B](y: B): (TestKit, B)
    Implicit
    This member is added by an implicit conversion from TestKit toArrowAssoc[TestKit] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromTestKit to any2stringadd[TestKit]

Inherited by implicit conversion StringFormat fromTestKit to StringFormat[TestKit]

Inherited by implicit conversion Ensuring fromTestKit to Ensuring[TestKit]

Inherited by implicit conversion ArrowAssoc fromTestKit to ArrowAssoc[TestKit]

Ungrouped