Packages

abstract class TestProbe[M] extends AnyRef

Java API: * Create instances through the create factories in the TestProbe companion or via ActorTestKit#createTestProbe.

A test probe is essentially a queryable mailbox which can be used in place of an actor and the received messages can then be asserted etc.

Not for user extension

Annotations
@DoNotInherit()
Source
TestProbe.scala
Linear Supertypes
AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TestProbe
  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. All

Instance Constructors

  1. new TestProbe()

Abstract Value Members

  1. abstract def awaitAssert[A](supplier: Supplier[A]): A

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

    Evaluate the given assert every 100 milliseconds until it does not throw an exception and return the result. A max time is taken it from the innermost enclosing within block.

  2. abstract def awaitAssert[A](max: Duration, supplier: Supplier[A]): A

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

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

    If the max timeout expires the last exception is thrown.

    Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  3. abstract def awaitAssert[A](max: Duration, interval: Duration, supplier: 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.

    Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  4. abstract def expectMessage[T <: M](max: Duration, hint: String, 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 AssertionError being thrown in case of timeout.

    returns

    the received object

  5. abstract def expectMessage[T <: M](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 AssertionError being thrown in case of timeout.

    returns

    the received object

  6. abstract def expectMessage[T <: M](obj: T): T

    Same as expectMessage(remainingOrDefault, obj), but using the default timeout as deadline.

  7. abstract def expectMessageClass[T <: M](clazz: Class[T], max: Duration): T

    Wait for a message of type M and return it when it arrives, or fail if the max timeout is hit.

    Wait for a message of type M and return it when it arrives, or fail if the max timeout is hit.

    Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  8. abstract def expectMessageClass[T <: M](clazz: Class[T]): T

    Same as expectMessageType(clazz, remainingOrDefault),but using the default timeout as deadline.

  9. abstract 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.typed.expect-no-message-default. That timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  10. abstract 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.

  11. abstract def expectTerminated[U](actorRef: typed.ActorRef[U]): Unit

    Expect the given actor to be stopped or stop within the default timeout.

  12. abstract def expectTerminated[U](actorRef: typed.ActorRef[U], max: Duration): Unit

    Expect the given actor to be stopped or stop within the given timeout or throw an AssertionError.

    Expect the given actor to be stopped or stop within the given timeout or throw an AssertionError.

    Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  13. abstract def fishForMessage(max: Duration, hint: String, fisher: Function[M, FishingOutcome]): List[M]

    Same as the other fishForMessage but includes the provided hint in all error messages

  14. abstract def fishForMessage(max: Duration, fisher: Function[M, FishingOutcome]): List[M]

    Java API: Allows for flexible matching of multiple messages within a timeout, the fisher function is fed each incoming message, and returns one of the following effects to decide on what happens next:

    Java API: Allows for flexible matching of multiple messages within a timeout, the fisher function is fed each incoming message, and returns one of the following effects to decide on what happens next:

    * FishingOutcomes.continue() - continue with the next message given that the timeout has not been reached * FishingOutcomes.complete() - successfully complete and return the message * FishingOutcomes.fail(errorMsg) - fail the test with a custom message

    Additionally failures includes the list of messages consumed. If a message of type M but not of type T is received this will also fail the test, additionally if the fisher function throws a match error the error is decorated with some fishing details and the test is failed (making it convenient to use this method with a partial function).

    max

    Max total time without the fisher function returning CompleteFishing before failing. The timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

    returns

    The messages accepted in the order they arrived

  15. abstract 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.

  16. abstract def getRemainingOr(duration: Duration): Duration

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

  17. abstract 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.actor.testkit.typed.single-expect-default").

  18. abstract def receiveMessage(max: Duration): M

    Receive one message of type M.

    Receive one message of type M. Wait time is bounded by the max duration, with an AssertionError raised in case of timeout.

  19. abstract def receiveMessage(): M

    Receive one message of type M within the default timeout as deadline.

  20. abstract def receiveSeveralMessages(n: Int, max: Duration): List[M]

    Receive n messages in a row before the given deadline.

    Receive n messages in a row before the given deadline.

    Note that the timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor".

  21. abstract def receiveSeveralMessages(n: Int): List[M]

    Same as receiveSeveralMessages(n, remaining) but using the default timeout as deadline.

  22. abstract def ref: typed.ActorRef[M]

    ActorRef for this TestProbe

  23. abstract def stop(): Unit

    Stops the TestProbe.getRef, which is useful when testing watch and termination.

  24. abstract def within[T](max: Duration)(f: Supplier[T]): T

    Same as calling within(0 seconds, max)(f).

  25. abstract 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 max timeout is scaled using the configuration entry "akka.actor.testkit.typed.timefactor", while the min Duration is not.

    val ret = within(50 millis) {
  test ! Ping
  expectMessageType[Pong]
}

Concrete Value Members

  1. def getRef(): typed.ActorRef[M]

    ActorRef for this TestProbe