我已经在https://github.com/Zwackelmann/mockito-actor-test上发布了一个展示我的问题的最小项目
在我的项目中，我将几个组件从类重构为对象，在所有情况下，类都没有真正有意义的状态。由于其中一些对象建立了到需要模拟的外部服务的连接，我很高兴地看到mockito-scala引入了withObjectMocked上下文函数，它允许在函数范围内模拟对象。
这个特性对我来说非常有效，直到我在混合中引入了Actor，尽管在withObjectMocked上下文中，它会忽略被模拟的函数。
为了进一步解释我所做的，请查看上面的github示例项目，它已经准备好通过sbt run执行。
我的目标是模拟下面的doit函数。它不应该在测试过程中被调用，所以对于这个演示，它只是抛出一个RuntimeException。

object FooService {
  def doit(): String = {
    // I don't want this to be executed in my tests
    throw new RuntimeException(f"executed real impl!!!")
  }
}

FooService.doit函数只能从FooActor.handleDoit函数调用，该函数由FooActor在收到Doit消息后调用或直接调用。

object FooActor {
  val outcome: Promise[Try[String]] = Promise[Try[String]]()

  case object Doit

  def apply(): Behavior[Doit.type] = Behaviors.receiveMessage { _ =>
    handleDoit()
    Behaviors.same
  }

  // moved out actual doit behavior so I can compare calling it directly with calling it from the actor
  def handleDoit(): Unit = {
    try {
      // invoke `FooService.doit()` if mock works correctly it should return the "mock result"
      // otherwise the `RuntimeException` from the real implementation will be thrown
      val res = FooService.doit()
      outcome.success(Success(res))
    } catch {
      case ex: RuntimeException =>
        outcome.success(Failure(ex))
    }
  }
}

为了模拟Foo.doit，我使用了withObjectMocked，如下所示。下面的所有代码都在这个块中。为了确保块不会由于异步执行而离开，我Await返回FooActor.outcome Promise的结果。

withObjectMocked[FooService.type] {
  // mock `FooService.doit()`: The real method throws a `RuntimeException` and should never be called during tests
  FooService.doit() returns {
    "mock result"
  }
  // [...]
}

我现在有两个测试设置：第一个函数直接调用FooActor.handleDoit

def simpleSetup(): Try[String] = {
  FooActor.handleDoit()
  val result: Try[String] = Await.result(FooActor.outcome.future, 1.seconds)
  result
}

第二个设置通过Actor触发FooActor.handleDoit

def actorSetup(): Try[String] = {
  val system: ActorSystem[FooActor.Doit.type] = ActorSystem(FooActor(), "FooSystem")
  // trigger actor  to call `handleDoit`
  system ! FooActor.Doit
  // wait for `outcome` future. The 'real' `FooService.doit` impl results in a `Failure`
  val result: Try[String] = Await.result(FooActor.outcome.future, 1.seconds)
  system.terminate()
  result
}

两种设置都等待outcome承诺完成，然后退出块。
通过在simpleSetup和actorSetup之间切换，我可以测试这两种行为。由于这两种行为都是在withObjectMocked上下文中执行的，我希望这两种行为都触发模拟函数。但是actorSetup忽略模拟函数并调用真实的的方法。

val result: Try[String] = simpleSetup()
// val result: Try[String] = actorSetup()

result match {
  case Success(res) => println(f"finished with result: $res")
  case Failure(ex) => println(f"failed with exception: ${ex.getMessage}")
}

// simpleSetup prints: finished with result: mock result
// actorSetup prints: failed with exception: executed real impl!!!

有什么建议吗？