MockMVC: Kiểm Thử Controller Của Bạn Mà Không Cần Khởi Động Server | Java Spring Roadmap

Chào mừng các bạn quay trở lại với series “Java Spring Roadmap”! Trên hành trình khám phá Spring Framework đầy mạnh mẽ, chúng ta đã đi qua nhiều chặng đường quan trọng: từ việc hiểu lý do tại sao chọn Spring, nắm vững các thuật ngữ cốt lõi, khám phá cách Spring hoạt động, làm chủ Dependency Injection (DI) và IoC Container, cho đến việc xây dựng ứng dụng web đầu tiên với Spring MVC và hiểu về kiến trúc DispatcherServlet. Chúng ta cũng đã tìm hiểu về việc kiểm thử lớp Repository và Transaction. Hôm nay, chúng ta sẽ tập trung vào một khía cạnh cực kỳ quan trọng trong phát triển ứng dụng web: kiểm thử lớp Controller.

Lớp Controller là giao diện tiếp nhận các request từ người dùng hoặc các hệ thống khác. Việc đảm bảo rằng Controller xử lý request đúng đắn, gọi đúng logic nghiệp vụ, và trả về response chính xác là điều thiết yếu. Tuy nhiên, kiểm thử Controller thường yêu cầu môi trường web, mà việc khởi động một web server (như Tomcat nhúng) cho mỗi bài test có thể tốn thời gian và tài nguyên. Đây chính là lúc MockMVC tỏa sáng.

MockMVC Là Gì? Tại Sao Nó Quan Trọng?

MockMVC là một phần của Spring Test framework, được thiết kế đặc biệt để kiểm thử các Controller của Spring MVC mà không cần phải khởi động một Servlet container đầy đủ. Thay vào đó, nó mô phỏng (mock) môi trường Servlet API và DispatcherServlet. Điều này cho phép bạn gửi các “request ảo” đến Controller của mình và kiểm tra kết quả (status code, header, body, view, model,…) một cách nhanh chóng và hiệu quả.

Hãy hình dung quy trình xử lý một HTTP request trong Spring MVC: Request đi vào qua Servlet Container (như Tomcat), đến DispatcherServlet, được mapping tới một Controller method, xử lý logic (thường gọi đến Service layer), và trả về Response. Khi kiểm thử tích hợp (integration test) thông thường cho lớp web với @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT), bạn cần khởi động toàn bộ ngữ cảnh Spring và nhúng một web server trên một cổng ngẫu nhiên. Sau đó, bạn dùng một HTTP client (như RestTemplate hoặc WebTestClient) để gửi request thật qua mạng. Quá trình này khá chậm và tốn kém về tài nguyên.

MockMVC loại bỏ bước khởi động web server và gửi request qua mạng. Nó trực tiếp “triệu tập” DispatcherServlet trong cùng một JVM, đưa request ảo vào đó. DispatcherServlet xử lý request đó gần như y hệt như trong môi trường thật, nhưng không cần kết nối mạng hay server vật lý. Điều này giúp các bài test Controller chạy nhanh hơn đáng kể, cải thiện tốc độ phản hồi của quy trình phát triển và tích hợp liên tục (CI).

Việc sử dụng MockMVC đặc biệt quan trọng vì nó cho phép bạn kiểm thử:

• Mapping Request: Đảm bảo đúng URL, method HTTP (GET, POST, PUT, DELETE,…) được ánh xạ tới đúng Controller method.
• Tham số Request: Kiểm tra việc Controller xử lý các tham số trên URL (path variables, request parameters) và body request (JSON, form data) như thế nào.
• Xử lý Logic: Mặc dù MockMVC tập trung vào lớp Controller, bạn có thể mock các Service/Repository mà Controller phụ thuộc để kiểm thử logic xử lý request trong Controller một cách độc lập.
• Response: Xác minh status code HTTP (200 OK, 201 Created, 400 Bad Request, 404 Not Found,…), nội dung response body (JSON, XML, HTML), headers, và các thuộc tính của Model (nếu dùng Server-Side Rendering).
• Xử lý Lỗi: Kiểm thử cách Controller bắt và xử lý các ngoại lệ.

Thiết Lập Môi Trường Kiểm Thử Với MockMVC

Để sử dụng MockMVC, bạn cần đảm bảo dự án của mình có dependency cần thiết. Với Spring Boot, điều này thường được cung cấp sẵn trong spring-boot-starter-test. Nếu bạn không dùng Spring Boot hoặc cần thêm, dependency chính là spring-test.

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

Trong bài test của bạn, có hai cách phổ biến để cấu hình MockMVC:

Cách 1: Sử Dụng @WebMvcTest

@WebMvcTest là annotation chuyên biệt cho việc kiểm thử lớp MVC (Controller). Nó tự động cấu hình Spring context chỉ với các bean liên quan đến MVC, bao gồm DispatcherServlet và các Controller được chỉ định. Nó **không** load toàn bộ ứng dụng Spring Boot, giúp test chạy nhanh hơn.

Khi sử dụng @WebMvcTest, bạn cần chỉ định (các) Controller mà bạn muốn kiểm thử. Các bean khác (Service, Repository) sẽ không được load vào context. Nếu Controller của bạn phụ thuộc vào các bean này, bạn sẽ cần mock chúng bằng @MockBean.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;

// Giả sử đây là Controller bạn muốn test
// @RestController
// class MyController {
//     @Autowired MyService myService;
//     @GetMapping("/hello/{name}")
//     public String sayHello(@PathVariable String name) {
//         return "Hello, " + myService.processName(name);
//     }
// }
//
// Giả sử đây là Service mà Controller phụ thuộc
// @Service
// class MyService {
//     public String processName(String name) { return name.toUpperCase(); }
// }

@WebMvcTest(MyController.class) // Chỉ định Controller cần test
class MyControllerWebMvcTest {

    @Autowired
    private MockMvc mockMvc; // Inject MockMvc instance

    @MockBean // Mock MyService vì @WebMvcTest không load nó
    private MyService myService;

    @Test
    void testSayHello() throws Exception {
        // Khi myService.processName("World") được gọi, trả về "WORLD"
        when(myService.processName("World")).thenReturn("WORLD");

        mockMvc.perform(get("/hello/World")) // Thực hiện GET request đến "/hello/World"
               .andExpect(status().isOk()) // Mong đợi status code là 200 OK
               .andExpect(content().string("Hello, WORLD")); // Mong đợi body response là "Hello, WORLD"
    }
}

Cách 2: Sử Dụng @SpringBootTest và @AutoConfigureMockMvc

@SpringBootTest load toàn bộ ngữ cảnh ứng dụng Spring Boot. Khi kết hợp với @AutoConfigureMockMvc, nó cũng tự động cấu hình và cung cấp một instance MockMvc.

Cách này phù hợp khi bạn muốn kiểm thử Controller trong ngữ cảnh đầy đủ của ứng dụng, bao gồm cả các Service và Repository thật (không mock). Tuy nhiên, nó sẽ chạy chậm hơn @WebMvcTest do phải load nhiều bean hơn.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;

// Giả sử đây là Controller và Service thật
// @RestController
// class MyController {
//     @Autowired MyService myService;
//     @GetMapping("/hello/{name}")
//     public String sayHello(@PathVariable String name) {
//         return "Hello, " + myService.processName(name);
//     }
// }
//
// @Service
// class MyService {
//     public String processName(String name) { return name.toUpperCase(); }
// }

@SpringBootTest // Load toàn bộ Spring context
@AutoConfigureMockMvc // Cấu hình và cung cấp MockMvc
class MyControllerSpringBootTest {

    @Autowired
    private MockMvc mockMvc; // Inject MockMvc instance

    // Không cần @MockBean MyService nếu muốn dùng bean thật

    @Test
    void testSayHello() throws Exception {
        // Logic test tương tự như trên, nhưng sử dụng Service thật
        mockMvc.perform(get("/hello/World"))
               .andExpect(status().isOk())
               .andExpect(content().string("Hello, WORLD"));
    }
}

Lựa chọn giữa hai cách phụ thuộc vào phạm vi kiểm thử bạn muốn: kiểm thử Controller một cách độc lập (như unit test cho lớp web) dùng @WebMvcTest, hay kiểm thử Controller trong ngữ cảnh ứng dụng đầy đủ (như integration test cho lớp web) dùng @SpringBootTest + @AutoConfigureMockMvc.

Thực Hiện Các Request Và Kiểm Tra Response Với MockMVC

Trung tâm của MockMVC là đối tượng MockMvc. Bạn sử dụng phương thức perform() của nó để mô phỏng việc thực hiện một request. Phương thức này nhận vào một đối tượng RequestBuilder, được tạo ra bởi các phương thức tĩnh từ lớp MockMvcRequestBuilders (ví dụ: get(), post(), put(), delete()). Sau khi perform(), bạn nhận được một đối tượng ResultActions, cho phép bạn thêm các xác minh (assertions) bằng phương thức andExpect(), sử dụng các phương thức tĩnh từ MockMvcResultMatchers (ví dụ: status(), content(), header(), view(), model()).

Dưới đây là các ví dụ minh họa:

Kiểm tra Status Code

mockMvc.perform(get("/users/1")) // GET request đến /users/1
       .andExpect(status().isOk()); // Mong đợi status 200 OK

mockMvc.perform(post("/users")) // POST request đến /users
       .andExpect(status().isCreated()); // Mong đợi status 201 Created

mockMvc.perform(get("/nonexistent-page"))
       .andExpect(status().isNotFound()); // Mong đợi status 404 Not Found

mockMvc.perform(get("/protected-resource"))
       .andExpect(status().isUnauthorized()); // Mong đợi status 401 Unauthorized (nếu chưa đăng nhập)

Kiểm tra Nội dung Response Body

Bạn có thể kiểm tra nội dung body response dưới dạng chuỗi, JSON, hoặc bằng cách sử dụng JsonPath/XPath.

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

// Giả sử Controller trả về JSON như {"id": 1, "name": "Test User"}
mockMvc.perform(get("/api/users/1"))
       .andExpect(status().isOk())
       .andExpect(content().contentType("application/json")) // Kiểm tra Content-Type header
       .andExpect(jsonPath("$.id").value(1)) // Kiểm tra giá trị trường "id"
       .andExpect(jsonPath("$.name").value("Test User")); // Kiểm tra giá trị trường "name"

// Kiểm tra body là một chuỗi cụ thể
mockMvc.perform(get("/plain-text"))
       .andExpect(status().isOk())
       .andExpect(content().string("This is plain text."));

Kiểm tra Headers Response

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;

mockMvc.perform(get("/download/file"))
       .andExpect(status().isOk())
       .andExpect(header().string("Content-Disposition", "attachment; filename=\"report.pdf\""));

Gửi Request với Tham số và Body

Bạn có thể thêm tham số query, path variables, headers, và body vào request.

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.http.MediaType.APPLICATION_JSON;

// POST request với body JSON
String newUserJson = "{\"name\":\"New User\",\"email\":\"newuser@example.com\"}";
mockMvc.perform(post("/api/users")
               .contentType(APPLICATION_JSON) // Set Content-Type header
               .content(newUserJson)) // Set request body
       .andExpect(status().isCreated()) // Mong đợi status 201
       .andExpect(jsonPath("$.name").value("New User")); // Kiểm tra giá trị trong response

// GET request với tham số query
mockMvc.perform(get("/api/products")
               .param("category", "electronics") // Thêm tham số query ?category=electronics
               .param("sort", "price")) // Thêm tham số query &sort=price
       .andExpect(status().isOk());

// GET request với path variable (đã được xử lý trong get("/hello/{name}") ví dụ trên)
mockMvc.perform(get("/users/{id}", 123)); // {id} sẽ được thay thế bằng 123

Kiểm tra View và Model (cho Server-Side Rendering)

Nếu bạn đang xây dựng ứng dụng web truyền thống sử dụng ViewResolver (như JSP, Thymeleaf, FreeMarker), bạn có thể kiểm tra tên view được trả về và các attribute trong Model.

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;

// Giả sử Controller trả về ModelAndView("userView", model)
mockMvc.perform(get("/showUser/1"))
       .andExpect(status().isOk())
       .andExpect(view().name("userView")) // Kiểm tra tên view
       .andExpect(model().attributeExists("user")) // Kiểm tra Model có attribute "user"
       .andExpect(model().attribute("user", someUserObject)); // Kiểm tra giá trị của attribute "user"

MockMvc So Với Các Loại Kiểm Thử Khác

Để hiểu rõ vị trí của MockMVC trong chiến lược kiểm thử, hãy xem xét bảng so sánh sau:

MockMVC nằm ở đâu đó giữa Unit Test và Full Integration Test. Nó là một loại kiểm thử tích hợp “nhẹ” cho lớp web. Nó nhanh hơn kiểm thử tích hợp đầy đủ vì không cần khởi động server, nhưng vẫn kiểm thử được sự tương tác của Controller với Spring MVC infrastructure (DispatcherServlet, Argument Resolvers, Exception Handlers,…) và có thể mock các tầng bên dưới để kiểm thử Controller một cách cô lập.

Các Kịch Bản Nâng Cao Với MockMVC

Kiểm Thử Bảo Mật (Authentication/Authorization)

Nếu ứng dụng của bạn sử dụng Spring Security (chủ đề chúng ta đã tìm hiểu trong các bài trước như Spring Security 101, Cấu hình xác thực, RBAC, JWT), bạn cần kiểm thử xem các endpoint có được bảo vệ đúng cách hay không. MockMVC cung cấp các phương thức hỗ trợ tích hợp với Spring Security Test:

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;

// Giả sử endpoint /admin chỉ cho phép user có role ADMIN
mockMvc.perform(get("/admin").with(user("admin").roles("ADMIN"))) // Thực hiện request với user "admin" có role ADMIN
       .andExpect(status().isOk());

mockMvc.perform(get("/admin").with(user("user").roles("USER"))) // Thực hiện request với user "user" có role USER
       .andExpect(status().isForbidden()); // Mong đợi status 403 Forbidden

// Đối với các request POST, PUT, DELETE, bạn cần thêm CSRF token nếu bảo mật được bật
mockMvc.perform(post("/api/users").with(csrf()))
       .andExpect(status().isCreated());

Để sử dụng with(user()) và with(csrf()), bạn cần thêm dependency spring-security-test và cấu hình tích hợp Spring Security Test trong bài test của mình (thường tự động với @WebMvcTest hoặc @SpringBootTest).

Kiểm Thử File Upload

MockMVC cũng hỗ trợ mô phỏng việc upload file:

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;

byte[] fileContent = "file content".getBytes();
MockMultipartFile file = new MockMultipartFile("file", "test.txt", "text/plain", fileContent);

mockMvc.perform(multipart("/upload").file(file))
       .andExpect(status().isOk());

Best Practices Khi Sử Dụng MockMVC

• Giữ Test Focused: Sử dụng @WebMvcTest và @MockBean để kiểm thử Controller một cách độc lập nhất có thể. Điều này giúp test chạy nhanh và dễ dàng xác định lỗi nằm ở Controller hay tầng nghiệp vụ/dữ liệu.
• Mock Dependencies Cẩn Thận: Chỉ mock những dependency mà Controller thực sự phụ thuộc. Cấu hình mock logic (when(...).thenReturn(...)) sao cho phù hợp với kịch bản test của bạn.
• Sử Dụng Tên Test Rõ Ràng: Đặt tên phương thức test mô tả rõ ràng hành vi đang được kiểm thử (ví dụ: shouldReturnOkStatusForValidRequest, shouldReturnBadRequestWhenBodyIsMissing).
• Assert Chính Xác: Thay vì chỉ kiểm tra status code, hãy kiểm tra nội dung body, headers, hoặc thuộc tính Model để đảm bảo Controller trả về đúng dữ liệu và format. Sử dụng JsonPath/XPath để kiểm tra cấu trúc và giá trị JSON/XML.
• Tránh Kiểm Thử Logic Nghiệp Vụ trong Controller Test: Logic nghiệp vụ phức tạp nên được kiểm thử bằng unit test cho lớp Service. MockMVC test chỉ nên xác minh rằng Controller gọi đúng Service với đúng tham số và xử lý kết quả trả về đúng cách.

Kết Luận

MockMVC là một công cụ vô giá trong bộ Spring Test framework, cho phép các nhà phát triển kiểm thử lớp web (Controller) một cách hiệu quả mà không cần chi phí overhead của việc khởi động server đầy đủ. Bằng cách mô phỏng môi trường Servlet và DispatcherServlet, MockMVC giúp các bài test chạy nhanh, tập trung và đáng tin cậy.

Nắm vững cách sử dụng MockMVC là một kỹ năng quan trọng trên con đường trở thành một lập trình viên Java Spring giỏi. Nó không chỉ giúp bạn viết code chất lượng hơn mà còn tăng tốc độ phát triển và đảm bảo tính ổn định của ứng dụng. Hãy tích hợp MockMVC vào quy trình kiểm thử của bạn ngay hôm nay!

Hy vọng bài viết này đã cung cấp cho bạn cái nhìn sâu sắc về MockMVC. Chúng ta sẽ tiếp tục khám phá các khía cạnh khác của Java Spring Roadmap trong các bài viết tiếp theo. Đừng quên theo dõi nhé!

Bạn có thể tìm hiểu thêm về MockMVC và Spring Test framework trong tài liệu chính thức của Spring.

Hẹn gặp lại trong chặng tiếp theo của Java Spring Roadmap!