编写可读性高、可维护性强的测试。 避免常见的测试反模式。 如何让测试更高效和稳定。具体是什么，代码案例

为了编写高效、稳定、可读性高且易于维护的测试，需要遵循一系列良好的实践，同时避免一些常见的测试反模式。以下是具体内容、相关原则以及代码示例：

1. 编写可读性高、可维护性强的测试

原则

1. 清晰的测试命名

测试方法名称应直观描述测试的行为和预期结果。

2. Arrange-Act-Assert (AAA)

测试结构分为准备（Arrange）、执行（Act）、验证（Assert）三个部分，保持代码清晰。

3. 避免魔法值

使用常量或变量代替硬编码值，使测试更易理解。

4. 单一职责原则

每个测试方法只测试一个功能或行为，确保问题定位清晰。

示例代码

import org.junit.jupiter.api.*;

import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

    // 被测类
    static class Calculator {
        int add(int a, int b) {
            return a + b;
        }
    }

    private Calculator calculator;

    @BeforeEach
    void setup() {
        calculator = new Calculator(); // Arrange: 初始化被测对象
    }

    @Test
    void shouldReturnSumWhenAddTwoNumbers() { // 清晰的命名
        // Act: 执行方法
        int result = calculator.add(2, 3);

        // Assert: 验证结果
        assertEquals(5, result, "加法结果应为5");
    }
}

2. 避免常见的测试反模式

1) 不稳定的测试（Flaky Test）

• 问题：测试结果不确定，偶尔失败。
• 原因：
  • 依赖外部环境（如数据库、网络）。
  • 使用随机数据，未固定种子值。
• 解决：隔离外部依赖，使用 Mock 或 Stub。

反例

@Test
void testWithUnstableNetwork() {
    String response = fetchFromExternalAPI(); // 外部依赖，网络不稳定可能导致测试失败
    assertNotNull(response);
}

改进

@Test
void testWithMockedNetwork() {
    ExternalService service = mock(ExternalService.class);
    when(service.fetch()).thenReturn("Mock Response");
    
    String response = service.fetch();
    assertEquals("Mock Response", response);
}

2) 过于复杂的测试（Over-Specified Test）

• 问题：过多验证导致测试难以维护。
• 原因：测试了不必要的细节或实现细节。
• 解决：只测试需要验证的功能，避免测试实现细节。

反例

@Test
void testWithTooManyAssertions() {
    List<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");

    assertEquals(2, list.size());
    assertEquals("A", list.get(0));
    assertEquals("B", list.get(1));
    assertTrue(list.contains("A"));
    assertTrue(list.contains("B"));
}

改进

@Test
void testListContent() {
    List<String> list = List.of("A", "B");
    assertIterableEquals(List.of("A", "B"), list, "列表内容应匹配");
}

3. 如何让测试更高效和稳定

原则

使用 Mock 减少外部依赖
模拟外部依赖（如数据库、文件系统、网络请求）提高效率和稳定性。

并行测试

使用并行执行测试减少运行时间（如 JUnit 5 的 @Execution 注解）。

独立性

确保测试之间没有依赖，每个测试可以单独运行。

清理资源

使用 @AfterEach 或 @AfterAll 清理资源，避免资源泄漏。

固定随机种子

如果测试中使用随机数，固定种子值确保结果一致。

示例代码

高效测试 - 使用 Mock 和 Stub

import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;

class OrderServiceTest {

    static class OrderService {
        private final ExternalPaymentGateway gateway;

        OrderService(ExternalPaymentGateway gateway) {
            this.gateway = gateway;
        }

        boolean processOrder(int orderId) {
            return gateway.processPayment(orderId);
        }
    }

    interface ExternalPaymentGateway {
        boolean processPayment(int orderId);
    }

    @Test
    void testProcessOrder() {
        ExternalPaymentGateway mockGateway = mock(ExternalPaymentGateway.class);
        when(mockGateway.processPayment(123)).thenReturn(true);

        OrderService orderService = new OrderService(mockGateway);
        assertTrue(orderService.processOrder(123), "订单处理应成功");
    }
}

清理资源

import org.junit.jupiter.api.*;

import java.util.ArrayList;
import java.util.List;

class ResourceCleanupTest {

    private List<String> resources;

    @BeforeEach
    void setup() {
        resources = new ArrayList<>();
    }

    @AfterEach
    void cleanup() {
        resources.clear();
    }

    @Test
    void testResourceUsage() {
        resources.add("Resource1");
        resources.add("Resource2");
        Assertions.assertFalse(resources.isEmpty());
    }
}

总结表

实践目标 方法
提高可读性 清晰命名、AAA结构、避免魔法值。
减少复杂性 测试单一职责，避免过多验证。
提高效率 Mock 外部依赖、并行测试、避免重复计算。
保证稳定性 独立测试、清理资源、固定随机种子。
通过遵循上述实践和改进测试代码结构，可以编写出高效、稳定、可维护的测试代码，从而提升整个项目的质量和可靠性。