Groovy 测试：Spock 框架

Spock 框架概述

Spock 是一个专为 Java 和 Groovy 应用设计的测试框架，它基于 JUnit 运行器，能够与主流构建工具和 IDE 无缝集成。与传统的 JUnit 测试相比，Spock 的最大优势在于其规范驱动的测试风格和声明式的测试结构。

Spock 测试的核心亮点体现在三个层面。首先是结构化语法——通过 given、when、then、expect、where 等代码块，将测试的准备工作、执行逻辑和断言验证清晰分离，使测试代码的可读性大幅提升。其次是数据驱动能力——内置的数据表和参数化测试机制，让编写多场景测试变得简洁高效。最后是强大的 Mock 支持——无需额外引入 Mockito 等库，即可完成对象的模拟和 Stub 操作。

环境搭建

在开始编写 Spock 测试之前，需要完成必要的依赖配置。以下分别介绍 Maven 和 Gradle 两种主流构建工具的配置方式。

Maven 配置

在 Maven 项目的 pom.xml 文件中添加以下依赖配置。需要特别注意 Spock 1.x 与 JUnit 4 的兼容配置，以及 Groovy 版本的匹配关系。

<dependencies>
    <!-- Spock 核心依赖 -->
    <dependency>
        <groupId>org.spockframework</groupId>
        <artifactId>spock-core</artifactId>
        <version>2.3-groovy-4.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Groovy 依赖 -->
    <dependency>
        <groupId>org.apache.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>4.0.15</version>
        <type>pom</type>
    </dependency>
</dependencies>

<!-- Maven 编译器配置 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.gmavenplus</groupId>
            <artifactId>gmavenplus-plugin</artifactId>
            <version>3.0.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>addSources</goal>
                        <goal>addTestSources</goal>
                        <goal>compile</goal>
                        <goal>compileTests</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Gradle 配置

对于 Gradle 项目，配置相对简洁。需要确保 Groovy 和 Spock 的版本保持兼容。

dependencies {
    implementation 'org.apache.groovy:groovy-all:4.0.15'
    testImplementation 'org.spockframework:spock-core:2.3-groovy-4.0'
}

test {
    useJUnitPlatform()
}

第一个 Spock 测试

理解 Spock 语法的最佳方式是从一个完整的测试示例开始。以下是一个简单的计算器类及其对应测试：

// Calculator.groovy
class Calculator {
    int add(int a, int b) {
        return a + b
    }

    int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零")
        }
        return a / b
    }
}

// CalculatorSpec.groovy
import spock.lang.Specification

class CalculatorSpec extends Specification {

    def "两数相加应该返回正确结果"() {
        given: "创建一个计算器实例"
        def calculator = new Calculator()

        when: "执行 3 加 5 的运算"
        def result = calculator.add(3, 5)

        then: "结果应该等于 8"
        result == 8
    }

    def "除数为零时应该抛出异常"() {
        given: "创建一个计算器实例"
        def calculator = new Calculator()

        when: "执行 10 除以 0 的运算"
        calculator.divide(10, 0)

        then: "应该抛出 IllegalArgumentException 异常"
        thrown(IllegalArgumentException)
    }
}

这个示例展示了 Spock 测试的基本结构。继承 Specification 类是所有 Spock 测试的入口。given 块用于初始化测试数据和被测对象。when 块包含具体的执行逻辑。then 块存放断言条件，语法接近自然语言。需要特别注意的是，then 块中的表达式必须是布尔表达式或异常断言。

核心语法详解

Spock 提供了多个语义化的代码块，每个块都有明确的职责划分。深入理解这些块的用法，是写出高质量测试的关键。

given 块：测试准备

given 块是所有测试逻辑的起点，用于准备测试所需的初始状态。你可以在其中声明变量、创建对象或设置测试数据。

given: "准备用户和订单数据"
def user = new User(name: "张三", balance: 1000)
def order = new Order(amount: 500)

when 块：触发行为

when 块包裹的是你需要测试的方法调用或业务逻辑执行。它是测试的动作点，从这里开始计时或记录状态变化。

when: "用户提交订单"
def paymentResult = paymentService.processPayment(user, order)

then 块：结果断言

then 块用于编写断言条件。这里的表达式会被自动求值为布尔值，== 运算符不仅适用于数值比较，也可以用于对象属性的逐个验证。

then: "支付成功后用户余额应该减少"
paymentResult.success == true
user.balance == 500

expect 块：简化的断言

当 when 块只有一个简单的表达式时，可以用 expect 块替代 when + then 的组合，使代码更加紧凑。

when: "计算 7 乘以 8"
def product = calculator.multiply(7, 8)

then: "结果应该等于 56"
product == 56

// 可简化为：
expect: "7 乘以 8 应该等于 56"
calculator.multiply(7, 8) == 56

where 块：数据驱动测试

where 块是 Spock 最强大的特性之一，它支持以表格形式定义多组测试数据，实现一次编写、多场景覆盖的效果。

def "两数相乘应该返回正确结果"() {
    expect: "a 乘以 b 应该等于 result"
    calculator.multiply(a, b) == result

    where: "定义多组测试数据"
    a | b | result
    2 | 3 | 6
    0 | 5 | 0
    -2| 4 | -8
    7 | 0 | 0
}

高级特性

@Unroll 注解：独立报告每个场景

默认情况下，where 数据表会生成一个测试方法，报告中只显示一条记录。使用 @Unroll 注解后，每个数据行都会成为独立的测试用例，便于定位失败的具体场景。

@Unroll
def "用户名验证：#username 应该返回 #isValid"() {
    expect: "验证结果应该符合预期"
    validator.isValidUsername(username) == isValid

    where: "定义用户名验证测试数据"
    username       | isValid
    "user123"      | true
    "us"           | false
    "user@name"    | false
    ""             | false
}

运行上述测试会生成四个独立的测试用例，报告中的方法名会包含参数值（如 用户名验证：user123 应该返回 true），极大提升了测试结果的可读性。

Mock 与 Stub

Spock 内置了强大的 Mock 能力，无需引入额外库即可完成依赖模拟。Mock() 用于创建模拟对象，Stub() 用于创建存根对象，两者的核心区别在于 Stub 有预设的行为而 Mock 主要用于验证交互。

def "订单服务应该调用正确的仓库接口"() {
    given: "创建 Mock 仓库"
    def warehouse = Mock(WarehouseService)
    def orderService = new OrderService(warehouse: warehouse)

    when: "创建包含两个商品的订单"
    orderService.createOrder([
        new OrderItem(productId: "P001", quantity: 2),
        new OrderItem(productId: "P002", quantity: 1)
    ])

    then: "应该验证两次库存"
    2 * warehouse.checkStock(_)

    and: "库存不足时应该取消订单"
    1 * warehouse.reserveStock("P001", 2) >> false
}

上述示例展示了 Spock Mock 的几个关键特性。2 * warehouse.checkStock(_) 表示 checkStock 方法应该被调用两次，下划线 _ 是通配符匹配任意参数。>> false 是 Stub 的返回值设定，表示当 reserveStock 被调用时返回 false。

测试生命周期

Spock 测试类继承 Specification 后，可以重写多个生命周期方法来控制测试行为。这些方法按照特定顺序执行，理解它们的用途有助于编写更复杂的测试场景。

class DatabaseSpec extends Specification {

    def setupSpec() {
        // 初始化测试数据库
        testDatabase.connect()
    }

    def setup() {
        // 每个测试前清空数据
        testDatabase.clearTables()
    }

    def "应该正确保存用户数据"() {
        given: "创建新用户"
        def user = new User(name: "测试用户")

        when: "保存用户"
        userRepository.save(user)

        then: "用户应该有自增 ID"
        user.id > 0
    }

    def cleanupSpec() {
        // 断开数据库连接
        testDatabase.disconnect()
    }
}

常见问题与解决方案

在 Spock 的实际使用中，以下几个问题较为常见。

异常断言的正确写法：thrown() 方法必须紧跟在 when 块之后，且 when 块中只能包含可能导致异常的代码。如果想在 then 块中断言不抛出异常，使用 noExceptionThrown()。

when: "执行可能抛异常的代码"
def result = service.process(input)

then: "不应抛出任何异常"
noExceptionThrown()

数据表中的变量作用域：where 块中定义的变量只能在 expect 或 then 块中使用，不能在 given 或 when 块中直接引用。如果需要使用 where 中的数据准备测试数据，可以通过方法参数传递。

def "计算折扣价"() {
    given: "根据原价准备商品"
    def product = new Product(originalPrice: price)

    when: "应用折扣"
    def discountedPrice = discountCalculator.apply(product, discountRate)

    then: "折扣价计算正确"
    discountedPrice == expectedPrice

    where: "定义价格测试数据"
    price | discountRate | expectedPrice
    100   | 0.10         | 90
    200   | 0.20         | 160

最佳实践

编写高质量的 Spock 测试需要遵循一些经验法则。

测试命名规范：方法名使用自然语言描述测试意图，配合 @Unroll 注解可以在报告中生成清晰的测试描述。避免使用下划线命名法（如 test_add_two_numbers），改用描述性的驼峰命名（如 两个正数相加应该返回正确结果）。

保持测试独立：每个测试方法应该能够独立执行，不依赖其他测试的运行顺序或状态。使用 setup() 方法确保每次测试都从已知状态开始。

断言粒度控制：一个测试方法应该只验证一个具体的业务逻辑。过多的断言耦合在一起会导致失败定位困难，同时降低测试的可维护性。

合理使用 Mock：Mock 应该用于隔离被测代码的外部依赖，而不是为了绕过复杂的业务逻辑。如果测试变得需要大量 Mock 才能执行，可能是代码设计需要重构的信号。

Spock 框架凭借其优雅的语法设计和强大的数据驱动能力，已成为 Groovy 和 Java 测试领域的事实标准。掌握本文介绍的核心概念和实践方法，你将能够编写出既易于维护又覆盖面完整的测试用例，为代码质量提供坚实保障。