在 Scala 中，如何正确地对调用其他 class 方法的 class 方法进行单元测试？

Question

我有一个案例 class，它代表一个电话号码，并提供了一些在代码中其他地方使用的辅助方法。 这些方法之一调用同一 class 中的其他方法：

case class PhoneNumber {

  // class data and methods

  def isPossiblyUsable(): Boolean = {
    // both methods return a Boolean
    this.isUsable() || this.usabilityUnknown()
  }
}

我想对这种方法进行单元测试，但我不确定最好的方法是什么。 来自 Python 的背景，我认为可以简单地模拟PhoneNumber.isUsable和PhoneNumber.usabilityUnknown ，但基于对这个问题的一些答案，听起来你不能部分模拟 class。我决定尝试一下：

"PhoneNumber.isPossiblyUsable" should "return true when usable" in {
  val m = mock[PhoneNumber]

  (m.isUsable _).expects().returning(true)
  (m.usabilityUnknown _).expects().returning(false)

  assert(m.isPossiblyUsable() == true)
}

这失败并显示消息：

[info] PhoneNumber.isPossiblyUsable
[info] - should return true when usable *** FAILED ***
[info]   Unexpected call: <mock-1> PhoneNumber.isPossiblyUsable()
[info]   
[info]   Expected:
[info]   inAnyOrder {
[info]     <mock-1> PhoneNumber.isUsable() once (never called - UNSATISFIED)
[info]     <mock-1> PhoneNumber.usabilityUnknown() once (never called - UNSATISFIED)
[info]   }
[info]   
[info]   Actual:
[info]     <mock-1> PhoneNumber.isPossiblyUsable() (Option.scala:201)

听起来isPossiblyUsable没有在测试中被调用。 有没有办法实际调用它？ 还是我的方法完全关闭了？

Answer 1

您可以“部分模拟”class（它被称为“间谍”）：

   val p = spy(PhoneNumber("5551212"))
   when(p.isUsable).thenReturn(true)
   when(p.usabilityUnknown).thenReturn(false)
   p.possibleUseable shouldBe true

但你真的不应该这样做。 “间谍”通常是糟糕设计的标志，因为它违反了单一责任原则：你正在测试的单元应该只有一个责任，所以，你要么 mock it，要么测试它的整体。

此外，模拟/监视案例类通常也不是一个好主意。 案例类旨在成为一个简单的数据容器，没有通常需要模拟的外部依赖项。

在您的情况下，如果isUsable和usabilityUnknown是实际数字的简单函数，那么您根本不应该是 mocking 它们，只需提供使它们返回所需值的数据即可。

例如：

    def isUsable() = phone.length=10
    def usabilityUnknown = phone.length=7

然后你就可以做

PhoneNumber("9415551212").possiblyUsable shouldBe true
PhoneNumber("5551212").possiblyUsable shouldBe true
PhoneNumber("foo").possiblyUsable shouldBe false

根本不需要嘲笑任何东西。

另一种可能性是您有一些外部“黑盒”组件来确定电话号码的可用性。

在那种情况下，这些呼叫可能不应该是PhoneNumber class 的一部分。 相反，它应该依赖于该服务，然后您可以模拟它。 像这样：

case class PhoneNumber(phone: String, usability: PhoneUsabilityService = PhoneUsabilityService) { 
    def possiblyUsable = usability.isUsable(this) || usability.usabilityUnknown(this)
}

现在你可以做类似的事情

val u = mock[PhoneUsabilityService]
when(u.isUsable(any)).thenReturn(true)
PhoneNumber("foo", u).possiblyUsable() shouldBe true

此外，您还可以确保以正确的顺序检查条件：

verify(u).isUsable(Phone("foo", u))
verifyNoMoreInteractions(u)

将外部组件仅提供给方法本身（可能作为隐式参数）而不是提供给 class 也可能有意义。对我个人而言，这似乎更清晰一些，因为它提供了该外部服务所在位置的更好指示class内使用：

case class PhoneService(phone: String) {
  def possiblyUsable(implicit u: PhoneUsabilityService) = 
    u.isUsable(this) || u.usabilityUnknown(this)
}

PhoneNumber("foo").possiblyUsable(u) shouldBe true