2381ec54d0
- remove global Config
- pull everything which depended on it into new AkkaApplication
- leave EventHandler alone for the moment: that evil sucker gets his
very own AkkaApplication("akka-reference.conf") until we have settled
on an acceptable logging API without globals
- make akka-actor and akka-testkit compile
- TestKit uses implicit AkkaApplication passing for maximum convenience
- Actor object nearly completely removed, actor creation possible via
ActorRefFactory interface which is implemented by AkkaApplication and
ActorContext
- serialization of ActorRef is probably broken, and so is the reflective
RemoteSupport (now needs AkkaApplication constructor arg)
- everything else is still broken, including akka-actor-tests, so this
is of course all not runtime-tested
66 lines
3.1 KiB
Scala
66 lines
3.1 KiB
Scala
/**
|
|
* Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
|
|
*/
|
|
|
|
package akka.testkit
|
|
|
|
import akka.actor._
|
|
import akka.util.ReflectiveAccess
|
|
import akka.event.EventHandler
|
|
import com.eaio.uuid.UUID
|
|
import akka.actor.Props._
|
|
import akka.AkkaApplication
|
|
|
|
/**
|
|
* This special ActorRef is exclusively for use during unit testing in a single-threaded environment. Therefore, it
|
|
* overrides the dispatcher to CallingThreadDispatcher and sets the receiveTimeout to None. Otherwise,
|
|
* it acts just like a normal ActorRef. You may retrieve a reference to the underlying actor to test internal logic.
|
|
*
|
|
* @author Roland Kuhn
|
|
* @since 1.1
|
|
*/
|
|
class TestActorRef[T <: Actor](application: AkkaApplication, props: Props, address: String)
|
|
extends LocalActorRef(application, props.withDispatcher(CallingThreadDispatcher.global), address, false) {
|
|
/**
|
|
* Directly inject messages into actor receive behavior. Any exceptions
|
|
* thrown will be available to you, while still being able to use
|
|
* become/unbecome and their message counterparts.
|
|
*/
|
|
def apply(o: Any) { underlyingActorInstance.apply(o) }
|
|
|
|
/**
|
|
* Retrieve reference to the underlying actor, where the static type matches the factory used inside the
|
|
* constructor. Beware that this reference is discarded by the ActorRef upon restarting the actor (should this
|
|
* reference be linked to a supervisor). The old Actor may of course still be used in post-mortem assertions.
|
|
*/
|
|
def underlyingActor: T = underlyingActorInstance.asInstanceOf[T]
|
|
|
|
override def toString = "TestActor[" + address + ":" + uuid + "]"
|
|
|
|
override def equals(other: Any) = other.isInstanceOf[TestActorRef[_]] && other.asInstanceOf[TestActorRef[_]].uuid == uuid
|
|
}
|
|
|
|
object TestActorRef {
|
|
|
|
def apply[T <: Actor](factory: ⇒ T)(implicit application: AkkaApplication): TestActorRef[T] = apply[T](Props(factory), new UUID().toString)
|
|
|
|
def apply[T <: Actor](factory: ⇒ T, address: String)(implicit application: AkkaApplication): TestActorRef[T] = apply[T](Props(factory), address)
|
|
|
|
def apply[T <: Actor](props: Props)(implicit application: AkkaApplication): TestActorRef[T] = apply[T](props, new UUID().toString)
|
|
|
|
def apply[T <: Actor](props: Props, address: String)(implicit application: AkkaApplication): TestActorRef[T] = new TestActorRef(application, props, address)
|
|
|
|
def apply[T <: Actor](implicit m: Manifest[T], application: AkkaApplication): TestActorRef[T] = apply[T](new UUID().toString)
|
|
|
|
def apply[T <: Actor](address: String)(implicit m: Manifest[T], application: AkkaApplication): TestActorRef[T] = apply[T](Props({
|
|
import ReflectiveAccess.{ createInstance, noParams, noArgs }
|
|
createInstance[T](m.erasure, noParams, noArgs) match {
|
|
case Right(value) ⇒ value
|
|
case Left(exception) ⇒ throw new ActorInitializationException(
|
|
"Could not instantiate Actor" +
|
|
"\nMake sure Actor is NOT defined inside a class/trait," +
|
|
"\nif so put it outside the class/trait, f.e. in a companion object," +
|
|
"\nOR try to change: 'actorOf[MyActor]' to 'actorOf(new MyActor)'.", exception)
|
|
}
|
|
}), address)
|
|
}
|