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: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def atStartup(): Unit

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

def atTermination(): Unit

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

def awaitCond(p: ⇒ Boolean, max: Duration, interval: Duration): 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 clone(): AnyRef

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, 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 expectNoMsg(max: FiniteDuration): Unit

def expectNoMsg(): Unit

def finalize(): Unit

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

final def getClass(): Class[_]

def hashCode(): Int

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

def ignoreNoMsg(): 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.

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.actorFor(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 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

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

implicit val system: ActorSystem

val testActor: ActorRef

val 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