发送到"TestProbe"的测试消息是否有可能在"TestActor.SetAutoPi

Question

Akka TestkitAutoPilot文档示例表明，我们可以在调用setAutoPilot后立即向TestProbe发送消息：

probe.setAutoPilot(new TestActor.AutoPilot {
def run(sender: ActorRef, msg: Any): TestActor.AutoPilot =
msg match {
case "stop" ⇒ TestActor.NoAutoPilot
case x      ⇒ testActor.tell(x, sender); TestActor.KeepRunning
}
})
//#autopilot
probe.ref ! "hallo"

另一方面，setAutoPilot已实现为向testActor发送消息：

def setAutoPilot(pilot: TestActor.AutoPilot): Unit = testActor ! TestActor.SetAutoPilot(pilot)

根据Akka消息接收订单保证，testActor(probe.ref(无法在TestActor.SetAutoPilot(pilot)之前接收"hallo"，因为两者都是从同一来源发送的。

但是，如果我们使用第三个 actor(使用system.actorOf(...)创建(向probe.ref发送"hello"，

在某些情况下，它是否可能被probe.ref收到，然后TestActor.SetAutoPilot(pilot)最终被忽略？

Answer 1

理论上 - 是的，绝对 - 这基本上是你自己对这个问题的回答。实际上，这不太可能，因为另一条消息的路径更长，因此需要发生一些非常不寻常的事情才能更早到达。

由于围绕这一点进行理论化不会给出任何可行的答案，因此我写了一个测试来进行实证观察：

Build.sbt：

libraryDependencies ++= Seq(
"com.typesafe.akka" %% "akka-actor" % "2.5.17"
)
libraryDependencies ++= Seq(
"com.typesafe.akka" %% "akka-testkit" % "2.5.17",
"org.scalactic" %% "scalactic" % "3.0.5",
"org.scalatest" %% "scalatest" % "3.0.5",
"org.scalacheck" %% "scalacheck" % "1.14.0"
) map (_ % "test")

测试：

import scala.concurrent.duration.DurationInt
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.pattern.ask
import akka.testkit.{TestActor, TestKit, TestProbe}
import akka.util.Timeout
import org.scalatest.{Matchers, PropSpecLike}
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.prop.PropertyChecks
class AutopilotTest extends TestKit(ActorSystem("test"))
with PropSpecLike with PropertyChecks with ScalaFutures with Matchers {
private implicit val askTimeout: Timeout = Timeout(100.millis)
property("Test probe receives autopilot before any other message from same origin") {
forAll(minSuccessful(1000)) { msg: String =>
val probe = TestProbe()
probe.setAutoPilot((sender: ActorRef, msg: Any) => msg match {
case x => sender ! x; TestActor.KeepRunning
})
whenReady((probe.ref ? msg).mapTo[String]) {_ shouldBe msg}
}
}
private class ProxyActor(target: ActorRef) extends Actor {
override def receive: Receive = { case msg: Any => target forward msg }
}
private object ProxyActor { def props(target: ActorRef): Props = Props(new ProxyActor(target)) }
property("Test probe receives autopilot before any other message from other origin") {
// set minSuccessuful to as high as you want, but note that current version takes ~38 seconds on my laptop to run
forAll(minSuccessful(1000)) { msg: String =>
val probe = TestProbe()
val proxy = system.actorOf(ProxyActor.props(probe.ref))
val result = (proxy ? msg).mapTo[String]
probe.setAutoPilot((sender: ActorRef, msg: Any) => msg match {
case x => sender ! x; TestActor.KeepRunning
})
whenReady(result) {_ shouldBe msg}
}
}
}

实际上，我在第二次测试中一直重复了 10000 次，并且测试总是通过 - 此外，我还确保如果在向代理发送消息后设置了自动驾驶仪，或者如果 testProbe 没有响应，它就会失败。

所以，我想说你描述的潜在问题要么根本不发生，要么极不可能。当然，这个测试非常简单，所以在其他条件下(即阻塞、并行测试执行、CI 等(观察结果可能会有所不同，但至少它为最常见/最简单的情况提供了一些证据。