In software development, code quality management plays a crucial role. Key aspects include code standards, readability, unit testing, and test coverage. For developers, unit testing and test coverage are vital tools for ensuring code quality. Well-crafted test cases help ensure code quality and stability, reduce maintenance costs, increase development efficiency, and enhance team collaboration. An article on OceanBase's quality principles highlights the importance of testing as an integral part of engineering practices, equal to development itself.

OceanBase Engineering Philosophy: Over years of refinement, the OceanBase team has developed a unique engineering culture. Testing is integrated into the development process, making functional testing no longer a separate phase but part of development. This approach minimizes bug introduction at the source. Senior testers focus on complex bugs, building robust testing systems, and automating tests. A streamlined code admission process prevents basic issues and boosts overall development efficiency.

This underscores the significance of test cases in projects. In practice, many developers find writing effective test cases challenging. Often, in project-centric workflows, test cases occupy only a small portion of the development cycle, with testing teams primarily handling functional black-box testing. While this approach works for standard business processes, it struggles with edge cases. Additionally, black-box testing provides limited value beyond compliance reports, leaving developers without safeguards when refactoring or upgrading components.

Common Testing Approaches

In past work experiences, including my own before studying testing theory, understanding various testing methods can be confusing due to their variety and overlap. Below is a categorized summary of common testing approaches:

Each testing method serves distinct goals and applies across different stages of the software lifecycle. From a developer perspective, this article focuses on unit testing (UT), component testing (CT), and integration testing (IT). UT ensures code correctness, CT validates component functionality, and IT confirms module interoperability.

Practical examples will illustrate these testing methods using Spring Boot 2.4.12, JUnit4, and Mockito.

Unit, Component, and Integration Testing

Before diving into examples, let’s explore the tools involved.

Testing Tools

The following examples use spring-boot-starter-test, junit4, and Mockito.

spring-boot-starter-test

spring-boot-starter-test simplifies testing in Spring Boot applications, providing utilities for efficient unit and integration testing. It integrates seamlessly with the Spring ecosystem.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

JUnit4

JUnit4 is a Java-based framework for unit testing. Features include:

• Annotation-driven tests (@Test, @Before, @After, etc.)
• Test suites combining multiple test classes.
• Assertions (assertEquals, assertTrue, etc.) for verifying conditions.
• Runners enabling custom test execution strategies.

Mockito

Mockito simulates external dependencies, isolating tested code and ensuring proper interaction with those dependencies.

Unit Testing Example

Consider a utility class DateUtil with a method:

public static String formatDate(Date date, String pattern) {
    if (date == null) {
        return null;
    }
    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
    return sdf.format(date);
}

A corresponding test case might look like:

public class DateUtilTest {
    @Test
    public void testFormatDateWithNullInput() {
        String result = DateUtil.formatDate(null, "YYYY");
        Assert.assertNull(result);
    }

    @Test
    public void testFormatDateWithValidInput() {
        String formattedDate = DateUtil.formatDate(new Date(), "YYYY");
        Assert.assertNotNull(formattedDate);
    }
}

Component and Integration Testing

For component testing, consider a service UserCaseService that fetches user event lists from another service:

public Response<CaseResponse> getUserCaseList(UserCaseRequest request) {
    Map<String, Object> params = new HashMap<>();
    params.put("phone", request.getPhone());
    params.put("pageNo", request.getPageNo());
    params.put("pageSize", request.getPageSize());
    JSONObject response = HttpUtils.request("/miniapp/user/case", params);
    return response.toJavaObject(Response.class);
}

To isolate this logic, mock the HTTP request:

@Before
public void setUp() {
    restTemplate = Mockito.mock(RestTemplate.class);
    HttpUtils.setRestTemplate(restTemplate);
}

@Test
public void testGetUserCaseList() {
    Mockito.when(restTemplate.postForObject(Mockito.anyString(), Mockito.any(HttpEntity.class), Mockito.any(Class.class)))
           .thenReturn(MockData.createSuccessResponse());

    UserCaseRequest request = new UserCaseRequest();
    request.setPhone("15215608668");
    request.setPageNo(1);
    request.setPageSize(10);

    Response<CaseResponse> response = userCaseService.getUserCaseList(request);
    Assert.assertEquals("200", response.getCode());
}

For integration testing, use @SpringBootTest:

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = Application.class)
@RunWith(SpringRunner.class)
public class UserCaseIntegrationTest {
    @Autowired
    private UserCaseService userCaseService;

    @Test
    public void testGetUserCaseListIntegration() {
        // Integration test logic here
    }
}

To replace a real database with H2 for testing:

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

Specify a test configuration file:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driverClassName: org.h2.Driver
    username: sa
    password: ''

And apply it in tests:

@SpringBootTest
@PropertySource("classpath:application-test.yaml")
public class DatabaseTest { /* ... */ }

Finally, clean up resources after tests:

@After
public void tearDown() {
    userRepository.deleteAll();
}

Conclusion

This article covered how to write effective test cases, focusing on classification, tools, and practical examples of unit, component, and integration testing. It also provided guidance on resource cleanup in testing scenarios.