在同一个 Spock 测试中执行所有断言，即使其中一个失败

Question

我试图在运行when-then-where 形式的多个测试用例的单个 Spock 方法的上下文中验证两个不同的输出。出于这个原因，我在then 块中使用了两个断言，如下例所示：

import spock.lang.*

@Unroll
class ExampleSpec extends Specification {

     def "Authentication test with empty credentials"() {
         when:
         def reportedErrorMessage, reportedErrorCode
         (reportedErrorMessage, reportedErrorCode) = userAuthentication(name, password)

         then:
         reportedErrorMessage == expectedErrorMessage
         reportedErrorCode    == expectedErrorCode

         where:
         name | password || expectedErrorMessage | expectedErrorCode
         ' '  | null     || 'Empty credentials!' | 10003
         ' '  | ' '      || 'Empty credentials!' | 10003
     }
}

代码是一个示例，其中设计要求是如果name 和password 是' ' 或null，那么我应该总是期望完全相同的expectedErrorMessage = 'Empty credentials!' 和expectedErrorCode = 10003。如果由于某种原因（可能是由于源代码中的错误）我得到expectedErrorMessage = Empty!（或'Empty credentials!' 以外的任何其他内容）和expectedErrorCode = 10001（或1003 以外的任何其他内容），这将不满足上述条件要求。

问题是，如果两个断言在同一测试中失败，我只会收到第一个断言的失败消息（这里是reportedErrorMessage）。是否可以在同一个测试中获得所有失败的断言的通知？

这里有一段代码演示了同样的问题，没有其他外部代码依赖。我知道在这种特殊情况下，将两个非常不同的测试捆绑在一起并不是一个好习惯，但我认为它仍然说明了问题。

import spock.lang.*

@Unroll
class ExampleSpec extends Specification {

    def "minimum of #a and #b is #c and maximum of #a and #b is #d"() {
        expect:
        Math.min(a, b) == c
        Math.max(a, b) == d

        where:
        a | b || c | d
        3 | 7 || 3 | 7
        5 | 4 || 5 | 4  // <--- both c and d fail here
        9 | 9 || 9 | 9
    }
}

Answer 1

基于 OP 的 latest comment，看起来与我之前的答案不同的解决方案会有所帮助。我将保留之前的答案，因为我觉得它仍然提供与问题相关的有用信息（特别是区分正面和负面测试）。

鉴于您想查看所有失败，而不仅仅是在第一个失败的断言中失败，我建议将所有内容连接到布尔 AND 操作中。不使用&& 快捷操作符，因为它只会运行到第一个不满足整个操作的检查。我建议使用&，以便进行所有检查，而不管之前是否有任何失败的检查。

鉴于上面的 max 和 min 示例，我会将 expect 块更改为：

Math.min(a, b) == c & Math.max(a, b) == d

当发生故障时，它会为您提供以下信息：

Math.min(a, b) == c & Math.max(a, b) == d
     |   |  |  |  | |      |   |  |  |  |
     4   5  4  |  5 false  5   5  4  |  4
               false                 false

这显示了失败断言的每个部分。相比之下，如果您使用&&，它只会向您显示第一次失败，如下所示：

Math.min(a, b) == c && Math.max(a, b) == d
     |   |  |  |  | |
     4   5  4  |  5 false
               false

如果您在一行上有两个以上的检查，这显然会很快变得混乱 - 但这是您可以在一行上的所有失败信息之间做出的权衡，而不是在修复每个人之后必须重新运行测试组件。

希望这会有所帮助！

Answer 2

我认为这里有两种不同的东西在起作用。

1. 在您的代码中包含失败的assert 将引发错误，这将停止执行代码。这就是为什么在一个测试中不能有两个失败的断言。 Spock 中 expect 或 then 块中的任何代码行前面都有一个隐含的 assert。
2. 您在同一个测试中混合了正面和负面的单元测试。我在自己之前遇到了这个问题，我阅读/观看了一些关于这个和 Spock 的内容（我相信来自创作者 Peter Niederwieser），并了解到这些应该分成不同的测试。不幸的是，我找不到那个参考。因此，基本上，您需要一项针对失败用例的测试，以及一项针对通过/成功用例的测试。

鉴于该信息，这是您的第二个示例代码，其中测试分开，第二个测试中出现失败的场景。

    @Unroll
    class ExampleSpec extends Specification {

        def "minimum of #a and #b is #c and maximum of #a and #b is #d - successes"() {
            expect:
            Math.min(a, b) == c
            Math.max(a, b) == d

            where:
            a | b || c | d
            3 | 7 || 3 | 7
            9 | 9 || 9 | 9
        }

        def "minimum of #a and #b is #c and maximum of #a and #b is #d - failures"() {
            expect:
            Math.min(a, b) != c
            Math.max(a, b) != d

            where:
            a | b || c | d
            5 | 4 || 5 | 4
        }
    }

至于您对 MongoDB 测试用例的评论 - 我不确定那里的意图是什么，但我猜他们正在做出几个都通过的断言，而不是验证某些事情失败了。