Spring Boot MockMvc - CRUD Example Tutorial

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In Spring Boot, the MockMvc framework provides a powerful and convenient way to test your web applications by simulating HTTP requests and validating the responses. 

In this blog post, we will delve into the details of Spring Boot's MockMvc framework and explore how it can be used for effective web application testing. 

What is MockMvc in Spring Boot? 

MockMvc is a part of the Spring Test framework that provides a simulated environment for testing web applications without the need for a running server. It allows you to send HTTP requests, handle the requests in your controllers, and validate the responses in a controlled and isolated manner. 

With MockMvc, you can test the behavior of your web application's endpoints and verify that they are working as expected.

Spring Boot MockMvc Example

Add Maven Dependencies

To use MockMvc in your Spring Boot project, you need to include the spring-boot-starter-test dependency in your project configuration file, such as Maven's pom.xml or Gradle's build file.

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

Also, add below spring-boot-starter-web dependency to build REST APIs in the Spring boot application:

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

Create Spring MVC Controller 

Next, let's create HelloWorldController and annotate it with @RestController annotation:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    @GetMapping("/hello/{name}")
    public String sayHello(@PathVariable String name) {
        return "Hello, " + name + "!";
    }
}

In the above example, the HelloWorldController class is annotated with @RestController, which indicates that it is a controller class responsible for handling HTTP requests and returning JSON responses. 

The @GetMapping annotation is used to map the /hello/{name} URL path to the sayHello method. The @PathVariable annotation is used to extract the {name} path variable and pass it as a method parameter. The method returns a simple greeting message.

Next, run your Spring boot application and send a request to the REST API. For example, you can send a GET request to http://localhost:8080/hello/Ramesh to get a response of "Hello, Ramesh!".

Unit Testing HelloController Class

Create a test class and annotate it with @WebMvcTest:

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.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

@WebMvcTest(HelloWorldController.class)
public class HelloWorldControllerTest {

	@Autowired
	private MockMvc mockMvc;

	@Test
	public void testGetEndpoint() throws Exception {
		mockMvc.perform(get("/hello/Ramesh"))
				.andDo(print())
				.andExpect(status().isOk())
				.andExpect(content().string("Hello, Ramesh!"));
	}
}

Note that we are using @WebMvcTest annotation to load only HelloWorldController class:

@WebMvcTest(HelloWorldController.class)

The MockMvc instance is autowired and used to perform HTTP requests and assertions in the test methods.

	@Autowired
	private MockMvc mockMvc;

The mockMvc.perform() is used to send the HTTP request, and the andExpect() method is used to validate the response. Various methods like status(), content(), and more are available for asserting different aspects of the response, such as status codes, headers, and response body.

Run the Unit Test

JUnit Tests for CRUD REST APIs

Let’s create some JUnit tests which will test different HTTP methods in the controller class.

GET REST API

Consider we have below GET User REST:

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUser(id);
        if (user != null) {
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

Next, here is the JUnit test to call Get User REST API using MockMvc:

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetUser() throws Exception {
        mockMvc.perform(get("/api/users/{id}", 1)
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("John"))
                .andExpect(jsonPath("$.email").value("john@example.com"));
    }

This test method performs a GET request to retrieve a user by its ID. It validates the response status, as well as the name and email values of the retrieved user.

POST REST API

Consider we have below Create User REST:

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.createUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
    }

Next, here is the JUnit test to call Create User REST API using MockMvc:

    @Test
    public void testCreateUser() throws Exception {
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"name\": \"John\", \"email\": \"john@example.com\"}")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("John"))
                .andExpect(jsonPath("$.email").value("john@example.com"));
    }

This test method performs a POST request to create a new user by sending a JSON payload containing the user's name and email. It then validates the response status, as well as the name and email values of the created user.

PUT REST API

Consider we have below Update User REST:

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
        User user = userService.updateUser(id, updatedUser);
        if (user != null) {
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

Next, here is the JUnit test to call Update User REST API using MockMvc:

    @Test
    public void testUpdateUser() throws Exception {
        mockMvc.perform(put("/api/users/{id}", 1)
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"name\": \"John Doe\", \"email\": \"johndoe@example.com\"}")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("John Doe"))
                .andExpect(jsonPath("$.email").value("johndoe@example.com"));
    }

This test method performs a PUT request to update a user's information. It sends a JSON payload containing the updated name and email and then verifies the response status and the updated values of the user.

DELETE REST API

Consider we have below Delete User REST:

    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return ResponseEntity.ok(users);
    }

Next, here is the JUnit test to call Delete User REST API using MockMvc:

    @Test
    public void testDeleteUser() throws Exception {
        mockMvc.perform(delete("/api/users/{id}", 1))
                .andExpect(status().isOk());
    }

This test method performs a DELETE request to delete a user by its ID. It checks the response status to ensure the deletion was successful.

Conclusion

The MockMvc framework in Spring Boot provides a powerful and convenient way to test your web applications. By simulating HTTP requests and validating the responses, you can ensure that your endpoints are working correctly and delivering the expected results. 

MockMvc simplifies the process of testing the web layer and helps you build reliable and robust web applications with confidence.

Check all the Spring Boot testing tutorials and guides: Spring Boot Unit Testing and Integration Testing Tutorials