SpringBoot Test: @SpringBootTest and MockMvc practical application summary

introduction

In modern enterprise-level application development, testing has become a key link in ensuring software quality. As the most popular Java development framework at present, SpringBoot provides a complete testing support mechanism. This article will deeply explore the practical application of two core tools in SpringBoot testing: @SpringBootTest annotation and the MockMvc test framework, helping developers build a more robust testing system and improve code quality and maintainability.

1. SpringBoot Test Basics

1.1 Test environment configuration

SpringBoot provides rich testing support, allowing developers to easily perform unit testing and integration testing. Testing in SpringBoot projects requires the introduction of spring-boot-starter-test dependency, which includes test-related libraries such as JUnit, Spring Test, AssertJ, etc. The correct configuration of the test environment is the basis for efficient testing, ensuring that the test cases can run under similar conditions to the production environment, thereby improving the reliability of test results.

// Configurationdependencies {
    // SpringBoot basic dependencies    implementation ':spring-boot-starter-web'
    // Test related dependencies    testImplementation ':spring-boot-starter-test'
    // JUnit 5 support    testImplementation ':junit-jupiter-api:5.8.2'
    testRuntimeOnly ':junit-jupiter-engine:5.8.2'
}
// Or configuration in Maven/*
 <dependencies>
     <!-- SpringBoot Basic Dependencies -->
     <dependency>
         <groupId></groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <!-- Test related dependencies -->
     <dependency>
         <groupId></groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
     </dependency>
 </dependencies>
 */

1.2 Test the directory structure

A standardized test directory structure helps the organization and management of test cases. In SpringBoot projects, the test code is usually located in the src/test/java directory, and the test resource file is located in the src/test/resources directory. The package structure of the test class should be consistent with the main code for easy association and maintenance. The test configuration file can override the main configuration and provide dedicated environment parameters for the test.

src
 ├── main
 │    ├── java
 │    │    └── 
 │    │         ├── controller
 │    │         ├── service
 │    │         └── repository
 │    └── resources
 │         └── 
 └── test
      ├── java
      │    └── 
      │         ├── controller  // Controller test class      │         ├── service     // Service test class      │         └── repository  // Data access test class      └── resources
           └──   // Test-specific configuration

2. Detailed explanation of @SpringBootTest annotation

2.1 Basic usage and configuration options

@SpringBootTest annotation is the core of SpringBoot testing, which provides the ability to load full application context. With this annotation, you can create a test environment close to the real environment, making integration testing more reliable. @SpringBootTest supports a variety of configuration options and can be flexibly adjusted according to testing needs, including specifying startup classes, test configuration files, web environment types, etc.

package ;
import ;
import ;
import ;
import ;
import static ;
// Basic usage: Load the complete Spring application context@SpringBootTest
public class BasicApplicationTests {
    @Autowired
    private Environment environment;  // Inject environment variables    @Test
    void contextLoads() {
        // Verify that the context is loading correctly        assertNotNull(environment);
        ("Active profiles: " + (", ", ()));
    }
}
// Advanced configuration: Custom test properties@SpringBootTest(
    // Specify the startup class    classes = ,
    // Specify the web environment type    webEnvironment = .RANDOM_PORT,
    // Set test properties    properties = {
        "=test",
        "-path=/api"
    }
)
class CustomizedApplicationTest {
    // Test code...}

2.2 Application scenarios of different WebEnvironment modes

The webEnvironment property annotated by @SpringBootTest defines the test web environment type and has four optional values: MOCK, RANDOM_PORT, DEFINED_PORT and NONE. Each mode is suitable for different test scenarios. Correctly selecting the Web environment mode can improve testing efficiency and reduce resource consumption.

package ;
import ;
import ;
import ;
import ;
import ;
import static ;
// MOCK mode: The server is not started, suitable for testing controllers through MockMvc@SpringBootTest(webEnvironment = )
class MockWebEnvironmentTest {
    // Test with MockMvc...}
// RANDOM_PORT mode: start real server, random port, suitable for end-to-end testing@SpringBootTest(webEnvironment = .RANDOM_PORT)
class RandomPortWebEnvironmentTest {
    @LocalServerPort
    private int port;  // Get randomly allocated ports    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void testHomeEndpoint() {
        // Send real HTTP request        String response = (
            "http://localhost:" + port + "/api/home", 
            
        );
        assertThat(response).contains("Welcome");
    }
}
// DEFINED_PORT mode: port defined in use@SpringBootTest(webEnvironment = .DEFINED_PORT)
class DefinedPortWebEnvironmentTest {
    // Use fixed port to test...}
// NONE mode: does not start the web environment, suitable for pure business logic testing@SpringBootTest(webEnvironment = )
class NoWebEnvironmentTest {
    // Only test the service layer and storage layer...}

3. MockMvc practical application

3.1 Basic usage method of MockMvc

MockMvc is a core component of the Spring MVC testing framework. It simulates HTTP requests and responses and tests the controller without starting a real server. MockMvc provides a smooth API that can build requests, execute calls, and verify responses. This method of test execution is fast and consumes less resources, which is especially suitable for controller unit testing. Using MockMvc can ensure the correctness and stability of the web layer code.

package ;
import ;
import ;
import ;
import ;
import static ;
import static ;
import static ;
// @WebMvcTest focuses on the test controller layer and only loads MVC-related components@WebMvcTest()
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;  // MockMvc is automatically injected by Spring    @Test
    void testGetUserById() throws Exception {
        // Execute GET request and verify the response        (get("/users/1"))  // Build GET request               .andExpect(status().isOk())  // Verify that the HTTP status code is 200               .andExpect(content().contentType("application/json"))  // Verify content type               .andExpect(content().json("{\"id\":1,\"name\":\"John\"}"));  // Verify the JSON response content    }
}

3.2 Advanced request construction and response verification

MockMvc provides a wealth of request building options and response verification methods that comprehensively test the various behaviors of the controller. Through the advanced API, complex request scenarios can be simulated, including adding request headers, setting parameters, submitting form data, uploading files, etc. At the same time, MockMvc also provides a detailed response verification mechanism, which can check HTTP status code, response header, response body content, etc.

package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import static .*;
import static .*;
import static .*;
@WebMvcTest()
public class ProductControllerAdvancedTest {
    @Autowired
    private MockMvc mockMvc;
    @Autowired
    private ObjectMapper objectMapper;  // for JSON conversion    @Test
    void testCreateProduct() throws Exception {
        // Create test data        Product product = new Product(null, "Laptop", 6999.99, 10);
        // Execute POST request        (
                post("/products")  // POST request                    .contentType(MediaType.APPLICATION_JSON)  // Set Content-Type                    .header("Authorization", "Bearer token123")  // Add custom request header                    .content((product))  // Request body JSON               )
               .andDo(())  // Print request and response details               .andExpect(status().isCreated())  // I hope to return the 201 status code               .andExpect(header().exists("Location"))  // Verify that the response header contains Location               .andExpect(jsonPath("$.id", not(nullValue())))  // Verify that the ID has been generated               .andExpect(jsonPath("$.name", is("Laptop")))  // Verify attribute value               .andExpect(jsonPath("$.price", closeTo(6999.99, 0.01)));  // Verify floating point numbers    }
    @Test
    void testSearchProducts() throws Exception {
        // Test GET request with query parameters        (
                get("/products/search")
                    .param("keyword", "computer")  // Add query parameters                    .param("minPrice", "5000")
                    .param("maxPrice", "10000")
               )
               .andExpect(status().isOk())
               .andExpect(jsonPath("$", hasSize(greaterThan(0))))  // Verify that the array is not empty               .andExpect(jsonPath("$[0].name", containsString("computer")));  // The verification results contain keywords    }
}
// Simple product categoryclass Product {
    private Long id;
    private String name;
    private double price;
    private int stock;
    //Constructor, getter and setter are slightly    public Product(Long id, String name, double price, int stock) {
         = id;
         = name;
         = price;
         = stock;
    }
    // Getter and setter slightly...}

4. Simulate service layer and dependencies

4.1 Use @MockBean to simulate the service

When testing a controller, it is often necessary to simulate the behavior of the service layer. Spring Boot provides @MockBean annotation, which can be used to replace beans in Spring containers as Mockito mock objects. This approach allows controller testing to focus on control layer logic without caring about the actual implementation of the service layer. By configuring the return value of the simulated object, you can test the controller's behavior in different scenarios.

package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import static ;
import static ;
import static ;
import static ;
import static ;
@WebMvcTest()
public class UserControllerWithMockServiceTest {
    @Autowired
    private MockMvc mockMvc;
    @MockBean  // Create and inject a simulated implementation of UserService    private UserService userService;
    @Test
    void testGetUserById() throws Exception {
        // Configure the behavior of simulated services        User mockUser = new User(1L, "Zhang San", "zhangsan@");
        when((1L)).thenReturn((mockUser));
        when((99L)).thenReturn(());  // Simulate the situation where the user does not exist        // Test successful scenario        (get("/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.id").value(1))
               .andExpect(jsonPath("$.name").value("Zhang San"));
        // Test the scenario where the user does not exist        (get("/users/99"))
               .andExpect(status().isNotFound());  // Expect to return 404    }
    @Test
    void testGetAllUsers() throws Exception {
        // Configure the simulation service to return to the user list        when(()).thenReturn((
            new User(1L, "Zhang San", "zhangsan@"),
            new User(2L, "Li Si", "lisi@")
        ));
        // Test to get all user APIs        (get("/users"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$").isArray())
               .andExpect(jsonPath("$.length()").value(2))
               .andExpect(jsonPath("$[0].name").value("Zhang San"))
               .andExpect(jsonPath("$[1].name").value("Li Si"));
    }
}
// User model classclass User {
    private Long id;
    private String name;
    private String email;
    //Constructor, getter and setter are slightly    public User(Long id, String name, String email) {
         = id;
         = name;
         = email;
    }
    // Getter and setter slightly...}

4.2 Test exception handling and boundary situations

Comprehensive testing should include handling of exceptions and boundary conditions. In SpringBoot applications, the controller usually handles exceptions through @ExceptionHandler or @ControllerAdvice. MockMvc can effectively test these exception handling mechanisms to ensure that the system can respond correctly in exceptional situations. Testing boundary conditions can improve the robustness of the code.

package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import static ;
import static ;
import static ;
import static ;
import static ;
import static ;
import static ;
@WebMvcTest()
public class OrderControllerExceptionTest {
    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private OrderService orderService;
    @Test
    void testResourceNotFoundExceptionHandling() throws Exception {
        // Configure the simulation service to throw an exception        when((anyLong()))
            .thenThrow(new ResourceNotFoundException("Order not found with id: 999"));
        // Verify that the exception is handled correctly        (get("/orders/999"))
               .andExpect(status().isNotFound())  // Expect to return 404               .andExpect(jsonPath("$.message").value("Order not found with id: 999"))
               .andExpect(jsonPath("$.timestamp").exists());
    }
    @Test
    void testInvalidInputHandling() throws Exception {
        // Test the processing of invalid input        (
                post("/orders")
                    .contentType(MediaType.APPLICATION_JSON)
                    .content("{\"customerName\":\"\",\"amount\":-10}")  // Invalid data               )
               .andExpect(status().isBadRequest())  // Expect to return 400               .andExpect(jsonPath("$.fieldErrors").isArray())
               .andExpect(jsonPath("$.fieldErrors[?(@.field=='customerName')]").exists())
               .andExpect(jsonPath("$.fieldErrors[?(@.field=='amount')]").exists());
    }
    @Test
    void testUnauthorizedAccess() throws Exception {
        // Test unauthorized access processing        doThrow(new SecurityException("Unauthorized access")).when(orderService)
            .deleteOrder(anyLong());
        (get("/orders/123/delete"))
               .andExpect(status().isUnauthorized())  // Expect to return 401               .andExpect(jsonPath("$.error").value("Unauthorized access"));
    }
}

5. Testing best practices

5.1 Test data preparation and cleaning

Good tests should be isolated and repeatable. In SpringBoot testing, attention should be paid to the preparation and cleaning of test data. Use the @BeforeEach and @AfterEach annotations to perform preparation and cleaning operations before and after each test method. For database testing, you can use the @Sql annotation to execute SQL scripts, or automatically roll back transactions with the @Transactional annotation.

package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import static ;
@DataJpaTest  // Annotation dedicated to JPA warehouse layer testingpublic class EmployeeRepositoryTest {
    @Autowired
    private EmployeeRepository employeeRepository;
    @BeforeEach
    void setUp() {
        // Prepare data before testing        ((
            new Employee(null, "Zhang San", "Development", 12000.0, (2020, 5, 1)),
            new Employee(null, "Li Si", "test", 10000.0, (2021, 3, 15)),
            new Employee(null, "Wang Wu", "Development", 15000.0, (2019, 8, 12))
        ));
    }
    @AfterEach
    void tearDown() {
        // Clean up data after testing        ();
    }
    @Test
    void testFindByDepartment() {
        // Test by department        List&lt;Employee&gt; developers = ("Development");
        assertThat(developers).hasSize(2);
        assertThat(developers).extracting(Employee::getName)
                             .containsExactlyInAnyOrder("Zhang San", "Wang Wu");
    }
    @Test
    @Sql("/test-data/")  // Execute SQL script to add more test data    void testFindBySalaryRange() {
        // Test based on salary range        List&lt;Employee&gt; employees = (11000.0, 14000.0);
        assertThat(employees).hasSize(2);
        assertThat(employees).extracting(Employee::getName)
                             .contains("Zhang San");
    }
}
// Employee entity classclass Employee {
    private Long id;
    private String name;
    private String department;
    private Double salary;
    private LocalDate hireDate;
    //Constructor, getter and setter are slightly    public Employee(Long id, String name, String department, Double salary, LocalDate hireDate) {
         = id;
         = name;
         = department;
         = salary;
         = hireDate;
    }
    // getter...}

5.2 Test coverage and continuous integration

Test coverage is an important measure of test quality, and high coverage usually means less untested code and fewer potential bugs. In SpringBoot projects, you can use tools such as JaCoCo to count the test coverage. Integrate tests into the CI/CD process to ensure that every code submission triggers automatic testing, which can detect problems as early as possible and improve development efficiency.

// Configure the JaCoCo test coverage plug-in in/*
 plugins {
     id 'jacoco'
 }
 jacoco {
     toolVersion = "0.8.7"
 }
 test {
     finalizedBy jacocoTestReport // Generate coverage report after the test is completed
 }
 jacocoTestReport {
     dependsOn test // Make sure the test is executed
     reports {
          true
          true
     }
 }
 // Set the coverage threshold
 jacocoTestCoverageVerification {
     violationRules {
         rule {
             limit {
                 minimum = 0.80 // Minimum 80% coverage
             }
         }
     }
 }
 */
// Sample Test Class - Ensure high coveragepackage ;
import ;
import ;
import ;
import ;
import ;
import static ;
import static ;
@SpringBootTest
public class TaxCalculatorServiceTest {
    @Autowired
    private TaxCalculatorService taxCalculatorService;
    @ParameterizedTest
    @CsvSource({
        "5000.0, 0.0",       // No more than the starting point        "8000.0, 90.0",      // The first tax rate is 3%        "20000.0, 1590.0",   // The second tax rate is 10%        "50000.0, 7590.0"    // The third tax rate is 20%    })
    void testCalculateIncomeTax(double income, double expectedTax) {
        double tax = (income);
        assertThat(tax).isEqualTo(expectedTax);
    }
    @Test
    void testCalculateIncomeTaxWithNegativeIncome() {
        // Test boundary situation: negative income        assertThatThrownBy(() -&gt; (-1000.0))
            .isInstanceOf()
            .hasMessageContaining("Income cannot be negative");
    }
    // More test cases to ensure high coverage...}

Summarize

This article introduces the practical application of @SpringBootTest annotation and MockMvc test framework in SpringBoot testing environment in detail. @SpringBootTest provides the ability to load full application context, supports different web environment modes, and is suitable for various integration testing scenarios. MockMvc focuses on controller layer testing, verifies controller behavior without starting a real server by simulating HTTP requests and responses. In actual development, rational configuration of the test environment, preparation of test data, simulating service dependencies, and handling exceptions and boundary situations is crucial to building a robust test system. Following best practices, such as maintaining test isolation, pursuing high test coverage, integrating automated test processes, etc., can significantly improve code quality and development efficiency. Through the technologies and methods introduced in this article, developers can build a more reliable and efficient SpringBoot application testing system, providing strong guarantees for the long-term and stable operation of the project.

This is the article about SpringBoot Testing @SpringBootTest and MockMvc practical application summary. For more related SpringBoot Testing @SpringBootTest and MockMvc content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!