TestKit实例(Scala)

这是Ray Roestenburg 在 他的博客 中的示例代码，作了改动以兼容 Akka 2.x。

1. import scala.util.Random

3. import org.scalatest.BeforeAndAfterAll
4. import org.scalatest.WordSpecLike
5. import org.scalatest.Matchers

7. import com.typesafe.config.ConfigFactory

9. import akka.actor.Actor
10. import akka.actor.ActorRef
11. import akka.actor.ActorSystem
12. import akka.actor.Props
13. import akka.testkit.{ TestActors, DefaultTimeout, ImplicitSender, TestKit }
14. import scala.concurrent.duration._
15. import scala.collection.immutable

17. /**
18. * a Test to show some TestKit examples
19. */
20. class TestKitUsageSpec
21. extends TestKit(ActorSystem("TestKitUsageSpec",
22. ConfigFactory.parseString(TestKitUsageSpec.config)))
23. with DefaultTimeout with ImplicitSender
24. with WordSpecLike with Matchers with BeforeAndAfterAll {
25. import TestKitUsageSpec._

27. val echoRef = system.actorOf(TestActors.echoActorProps)
28. val forwardRef = system.actorOf(Props(classOf[ForwardingActor], testActor))
29. val filterRef = system.actorOf(Props(classOf[FilteringActor], testActor))
30. val randomHead = Random.nextInt(6)
31. val randomTail = Random.nextInt(10)
32. val headList = immutable.Seq().padTo(randomHead, "0")
33. val tailList = immutable.Seq().padTo(randomTail, "1")
34. val seqRef =
35. system.actorOf(Props(classOf[SequencingActor], testActor, headList, tailList))

37. override def afterAll {
38. shutdown()
39. }

41. "An EchoActor" should {
42. "Respond with the same message it receives" in {
43. within(500 millis) {
44. echoRef ! "test"
45. expectMsg("test")
46. }
47. }
48. }
49. "A ForwardingActor" should {
50. "Forward a message it receives" in {
51. within(500 millis) {
52. forwardRef ! "test"
53. expectMsg("test")
54. }
55. }
56. }
57. "A FilteringActor" should {
58. "Filter all messages, except expected messagetypes it receives" in {
59. var messages = Seq[String]()
60. within(500 millis) {
61. filterRef ! "test"
62. expectMsg("test")
63. filterRef ! 1
64. expectNoMsg
65. filterRef ! "some"
66. filterRef ! "more"
67. filterRef ! 1
68. filterRef ! "text"
69. filterRef ! 1

71. receiveWhile(500 millis) {
72. case msg: String => messages = msg +: messages
73. }
74. }
75. messages.length should be(3)
76. messages.reverse should be(Seq("some", "more", "text"))
77. }
78. }
79. "A SequencingActor" should {
80. "receive an interesting message at some point " in {
81. within(500 millis) {
82. ignoreMsg {
83. case msg: String => msg != "something"
84. }
85. seqRef ! "something"
86. expectMsg("something")
87. ignoreMsg {
88. case msg: String => msg == "1"
89. }
90. expectNoMsg
91. ignoreNoMsg
92. }
93. }
94. }
95. }

97. object TestKitUsageSpec {
98. // Define your test specific configuration here
99. val config = """
100. akka {
101. loglevel = "WARNING"
102. }
103. """

105. /**
106. * An Actor that forwards every message to a next Actor
107. */
108. class ForwardingActor(next: ActorRef) extends Actor {
109. def receive = {
110. case msg => next ! msg
111. }
112. }

114. /**
115. * An Actor that only forwards certain messages to a next Actor
116. */
117. class FilteringActor(next: ActorRef) extends Actor {
118. def receive = {
119. case msg: String => next ! msg
120. case _           => None
121. }
122. }

124. /**
125. * An actor that sends a sequence of messages with a random head list, an
126. * interesting value and a random tail list. The idea is that you would
127. * like to test that the interesting value is received and that you cant
128. * be bothered with the rest
129. */
130. class SequencingActor(next: ActorRef, head: immutable.Seq[String],
131. tail: immutable.Seq[String]) extends Actor {
132. def receive = {
133. case msg => {
134. head foreach { next ! _ }
135. next ! msg
136. tail foreach { next ! _ }
137. }
138. }
139. }
140. }