151 lines
3.7 KiB
Scala
151 lines
3.7 KiB
Scala
package docs.testkit
|
|
|
|
import org.scalatest.WordSpec
|
|
import org.scalatest.Matchers
|
|
import akka.testkit.TestKitBase
|
|
import akka.actor.ActorSystem
|
|
import akka.actor.Props
|
|
import akka.actor.Actor
|
|
import akka.actor.ActorRef
|
|
import akka.testkit.ImplicitSender
|
|
import akka.testkit.TestProbe
|
|
import akka.actor.ActorRefFactory
|
|
import akka.testkit.TestKit
|
|
import org.scalatest.BeforeAndAfterAll
|
|
|
|
/**
|
|
* Parent-Child examples
|
|
*/
|
|
|
|
//#test-example
|
|
class Parent extends Actor {
|
|
val child = context.actorOf(Props[Child], "child")
|
|
var ponged = false
|
|
|
|
def receive = {
|
|
case "pingit" ⇒ child ! "ping"
|
|
case "pong" ⇒ ponged = true
|
|
}
|
|
}
|
|
|
|
class Child extends Actor {
|
|
def receive = {
|
|
case "ping" ⇒ context.parent ! "pong"
|
|
}
|
|
}
|
|
//#test-example
|
|
|
|
//#test-dependentchild
|
|
class DependentChild(parent: ActorRef) extends Actor {
|
|
def receive = {
|
|
case "ping" ⇒ parent ! "pong"
|
|
}
|
|
}
|
|
//#test-dependentchild
|
|
|
|
//#test-dependentparent
|
|
class DependentParent(childProps: Props, probe: ActorRef) extends Actor {
|
|
val child = context.actorOf(childProps, "child")
|
|
|
|
def receive = {
|
|
case "pingit" ⇒ child ! "ping"
|
|
case "pong" ⇒ probe ! "ponged"
|
|
}
|
|
}
|
|
|
|
class GenericDependentParent(childMaker: ActorRefFactory ⇒ ActorRef) extends Actor {
|
|
val child = childMaker(context)
|
|
var ponged = false
|
|
|
|
def receive = {
|
|
case "pingit" ⇒ child ! "ping"
|
|
case "pong" ⇒ ponged = true
|
|
}
|
|
}
|
|
//#test-dependentparent
|
|
|
|
/**
|
|
* Test specification
|
|
*/
|
|
|
|
class MockedChild extends Actor {
|
|
def receive = {
|
|
case "ping" ⇒ sender ! "pong"
|
|
}
|
|
}
|
|
|
|
class ParentChildSpec extends WordSpec with Matchers with TestKitBase with BeforeAndAfterAll {
|
|
implicit lazy val system = ActorSystem("ParentChildSpec")
|
|
|
|
override def afterAll(): Unit = {
|
|
TestKit.shutdownActorSystem(system)
|
|
}
|
|
|
|
"A DependentChild" should {
|
|
"be tested without its parent" in {
|
|
val probe = TestProbe()
|
|
val child = system.actorOf(Props(new DependentChild(probe.ref)))
|
|
probe.send(child, "ping")
|
|
probe.expectMsg("pong")
|
|
}
|
|
}
|
|
|
|
"A DependentParent" should {
|
|
"be tested with custom props" in {
|
|
val probe = TestProbe()
|
|
val childProps = Props(new MockedChild())
|
|
val parent = system.actorOf(Props(new DependentParent(childProps, probe.ref)))
|
|
probe.send(parent, "pingit")
|
|
// test some parent state change
|
|
probe.expectMsg("ponged")
|
|
}
|
|
}
|
|
|
|
"A GenericDependentParent" should {
|
|
"be tested with a child probe" in {
|
|
val probe = TestProbe()
|
|
//#child-maker-test
|
|
val maker = (_: ActorRefFactory) ⇒ probe.ref
|
|
val parent = system.actorOf(Props(new GenericDependentParent(maker)))
|
|
//#child-maker-test
|
|
probe.send(parent, "pingit")
|
|
probe.expectMsg("ping")
|
|
}
|
|
|
|
"demonstrate production version of child creator" in {
|
|
//#child-maker-prod
|
|
val maker = (f: ActorRefFactory) ⇒ f.actorOf(Props(new Child))
|
|
val parent = system.actorOf(Props(new GenericDependentParent(maker)))
|
|
//#child-maker-prod
|
|
}
|
|
}
|
|
|
|
//#test-TestProbe-parent
|
|
"A TestProbe serving as parent" should {
|
|
"test its child responses" in {
|
|
val parent = TestProbe()
|
|
val child = parent.childActorOf(Props(new Child))
|
|
parent.send(child, "ping")
|
|
parent.expectMsg("pong")
|
|
}
|
|
}
|
|
//#test-TestProbe-parent
|
|
|
|
//#test-fabricated-parent
|
|
"A fabricated parent" should {
|
|
"test its child responses" in {
|
|
val proxy = TestProbe()
|
|
val parent = system.actorOf(Props(new Actor {
|
|
val child = context.actorOf(Props(new Child), "child")
|
|
def receive = {
|
|
case x if sender == child ⇒ proxy.ref forward x
|
|
case x ⇒ child forward x
|
|
}
|
|
}))
|
|
|
|
proxy.send(parent, "ping")
|
|
proxy.expectMsg("pong")
|
|
}
|
|
}
|
|
//#test-fabricated-parent
|
|
}
|