SpringBoot API Testing: Practical Postman and JUnit 5 Techniques

Backend developers need reliable API testing to keep services stable during front‑end integration and production releases; this article shows a two‑step approach—using Postman for daily debugging and JUnit 5 for automated regression.

1. Postman Practical

Postman is the most common tool in daily development; the focus is on using it correctly rather than just knowing how to open it.

1. Environment Isolation

Create separate environments (development, testing, production) and define a baseUrl variable, e.g., http://localhost:8080 for dev and http://test.demo.com for test.

Reference the variable in request URLs as {{baseUrl}}/user so switching environments requires no manual URL changes.

2. Token Requests

Call the login API first and retrieve the token from the response.

Add a header named token with the retrieved value.

All subsequent authorized endpoints automatically carry the token, eliminating repetitive manual entry.

3. Useful Tips

When sending JSON, set Content-Type to application/json, otherwise the backend cannot parse the parameters.

Save frequently used requests to the “Favorites” collection for one‑click reuse.

Use response codes for quick diagnosis: 404 = wrong path, 401 = invalid token, 500 = backend error.

4. Batch Testing

For multiple endpoints, select them in a collection and run them together with “Run Collection”. The runner can export a report, making it easy to share progress with front‑end teams.

2. JUnit 5 Automated Testing

Manual Postman checks become inefficient after each iteration; JUnit 5 enables a single test suite to be executed repeatedly.

1. Dependency Setup

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

2. Example

A complete test class for a user‑management API demonstrates both normal and error scenarios.

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@SpringBootTest
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

    // Normal scenario: query user details
    @Test
    @DisplayName("Test user detail endpoint (normal case)")
    public void testUserDetail() throws Exception {
        mockMvc.perform(get("/user/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.code").value(200))
               .andExpect(jsonPath("$.data.username").isNotEmpty());
    }

    // Error scenario: invalid token
    @Test
    @DisplayName("Test invalid token scenario")
    public void testInvalidToken() throws Exception {
        mockMvc.perform(get("/user/info")
               .header("token", "无效Token"))
               .andExpect(status().is(401))
               .andExpect(jsonPath("$.msg").value("Token无效，请重新登录"));
    }
}

3. Key Points

The test class must be annotated with @SpringBootTest to inject services and controllers.

Use jsonPath to locate response fields, e.g., $.data.id extracts the id from the data object.

Annotate a method with @BeforeEach to set up test data and avoid duplication across test cases.

3. Recommendations

Daily integration: use Postman to quickly locate problems and coordinate parameter adjustments with front‑end developers.

Iterative maintenance: write JUnit 5 tests so that every code change runs the suite, preventing regressions.

Focus on status codes and parameter formats, as they are the most frequent sources of front‑back mismatches.

4. Common Issues and Solutions

Postman request succeeds but backend receives no parameters – verify Content-Type is application/json and that field names match the backend entity.

JUnit test fails with “Bean not found” – ensure the test class is annotated with @SpringBootTest so Spring can inject beans.

Token reported as invalid – check token expiration and confirm the request header name matches the backend expectation (e.g., backend expects token while front‑end may send Authorization).

In summary, effective API testing combines Postman's rapid debugging capabilities with JUnit 5's automated regression power, providing both speed during development and stability in production.