MultiNodeSpec

abstract def initialParticipants: Int

TO BE DEFINED BY USER: Defines the number of participants required for starting the test.

def initialParticipants = 5

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (MultiNodeSpec, B)

final def ==(arg0: Any): Boolean

def afterTermination(): Unit

Override this method to do something when the whole test is terminating.

final def asInstanceOf[T0]: T0

def atStartup(): Unit

Override this method to do something when the whole test is starting up.

def attachConductor(tc: TestConductorExt): Unit

def awaitAssert[A](a: ⇒ A, max: Duration, interval: Duration): A

def awaitCond(p: ⇒ Boolean, max: Duration, interval: Duration, message: String): Unit

implicit def awaitHelper[T](w: Awaitable[T]): AwaitHelper[T]

Enrich .await() onto all Awaitables, using remaining duration from the innermost enclosing within block or QueryTimeout.

def childActorOf(props: Props): ActorRef

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

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

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

def clone(): AnyRef

def ensuring(cond: (MultiNodeSpec) ⇒ Boolean, msg: ⇒ Any): MultiNodeSpec

def ensuring(cond: (MultiNodeSpec) ⇒ Boolean): MultiNodeSpec

def ensuring(cond: Boolean, msg: ⇒ Any): MultiNodeSpec

def ensuring(cond: Boolean): MultiNodeSpec

def enterBarrier(name: String*): Unit

Enter the named barriers in the order given.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectMsg[T](max: FiniteDuration, hint: String, obj: T): T

def expectMsg[T](max: FiniteDuration, obj: T): T

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

def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllClassOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T]

def expectMsgAllOf[T](obj: T*): Seq[T]

def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C

def expectMsgAnyClassOf[C](obj: Class[_ <: C]*): C

def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T

def expectMsgAnyOf[T](obj: T*): T

def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C

def expectMsgClass[C](c: Class[C]): C

def expectMsgPF[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T

def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T

def expectMsgType[T](implicit t: ClassTag[T]): T

def expectNoMessage(): Unit

def expectNoMessage(max: FiniteDuration): Unit

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

def finalize(): Unit

def fishForMessage(max: Duration, hint: String)(f: PartialFunction[Any, Boolean]): Any

def fishForSpecificMessage[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def ignoreMsg(f: PartialFunction[Any, Boolean]): Unit

def ignoreNoMsg(): Unit

def injectDeployments(sys: ActorSystem, role: RoleName): Unit

final def isInstanceOf[T0]: Boolean

def isNode(nodes: RoleName*): Boolean

Verify that the running node matches one of the given nodes

def lastSender: ActorRef

val log: LoggingAdapter

def msgAvailable: Boolean

final def multiNodeSpecAfterAll(): Unit

Call this after the all test cases have run.

final def multiNodeSpecBeforeAll(): Unit

Call this before the start of the test run.

def muteDeadLetters(messageClasses: Class[_]*)(sys: ActorSystem = system): Unit

val myAddress: Address

val myself: RoleName

final def ne(arg0: AnyRef): Boolean

def node(role: RoleName): ActorPath

Query the controller for the transport address of the given node (by role name) and return that as an ActorPath for easy composition:

val serviceA = system.actorSelection(node("master") / "user" / "serviceA")

final def notify(): Unit

final def notifyAll(): Unit

def now: FiniteDuration

def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef]

def receiveN(n: Int): Seq[AnyRef]

def receiveOne(max: Duration): AnyRef

def receiveWhile[T](max: Duration, idle: Duration, messages: Int)(f: PartialFunction[AnyRef, T]): Seq[T]

def remaining: FiniteDuration

def remainingOr(duration: FiniteDuration): FiniteDuration

def remainingOrDefault: FiniteDuration

def roles: Seq[RoleName]

All registered roles

def runOn(nodes: RoleName*)(thunk: ⇒ Unit): Unit

Execute the given block of code only on the given nodes (names according to the roleMap).

def setAutoPilot(pilot: AutoPilot): Unit

def shutdown(actorSystem: ActorSystem, duration: Duration, verifySystemShutdown: Boolean): Unit

def shutdownTimeout: FiniteDuration

def startNewSystem(): ActorSystem

This method starts a new ActorSystem with the same configuration as the previous one on the current node, including deployments.

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val system: ActorSystem

val testActor: ActorRef

def testActorName: String

var testConductor: TestConductorExt

Access to the barriers, failure injection, etc.

val testKitSettings: TestKitSettings

def toString(): String

def unwatch(ref: ActorRef): ActorRef

def verifySystemShutdown: Boolean

Override this and return true to assert that the shutdown of the ActorSystem was done properly.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def watch(ref: ActorRef): ActorRef

def within[T](max: FiniteDuration)(f: ⇒ T): T

def within[T](min: FiniteDuration, max: FiniteDuration)(f: ⇒ T): T

def →[B](y: B): (MultiNodeSpec, B)

def expectNoMsg(max: FiniteDuration): Unit

def expectNoMsg(): Unit