@WebMvcTest for controller testing in Spring Boot - Step-by-Step Execution

Concept Flow - @WebMvcTest for controller testing

Start Test

↓

Load @WebMvcTest Context

↓

Inject MockMvc

↓

Perform HTTP Request

↓

Controller Handles Request

↓

Return Response

↓

Assert Response & Status

↓

Test Ends

The test starts by loading only the web layer with @WebMvcTest, then MockMvc performs a simulated HTTP request to the controller, which handles it and returns a response that the test asserts.

Execution Sample

Spring Boot

@WebMvcTest(MyController.class)
class MyControllerTest {
  @Autowired
  MockMvc mockMvc;

  @Test
  void testHello() throws Exception {
    mockMvc.perform(org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get("/hello")).andExpect(org.springframework.test.web.servlet.result.MockMvcResultMatchers.status().isOk());
  }
}

This test loads only MyController, performs a GET request to /hello, and checks if the response status is 200 OK.

Execution Table

Step	Action	Component	Result	Notes
1	Start test	Test runner	Test context starts	Test framework initializes
2	Load @WebMvcTest context	Spring Boot	Only web layer loaded	No full app context
3	Inject MockMvc	Test class	MockMvc instance ready	Used to simulate HTTP calls
4	Perform GET /hello	MockMvc	Request sent to controller	Simulates browser call
5	Controller handles request	MyController	Processes /hello	Runs controller method
6	Return response	MyController	HTTP 200 OK	Response ready for test
7	Assert response status	Test	Status is 200 OK	Test passes if true
8	Test ends	Test runner	Test completes	No errors

💡 Test ends after asserting the HTTP response status is OK

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	Final
mockMvc	null	MockMvc instance	Used to send GET /hello	Received response	Ready for next test
responseStatus	N/A	N/A	N/A	200 OK	200 OK

Key Moments - 3 Insights

Why does @WebMvcTest load only the web layer and not the full application?

Because @WebMvcTest is designed to test controllers in isolation, it loads only the web-related beans like controllers, filters, and MVC config, skipping services and repositories. This is shown in execution_table step 2.

How does MockMvc simulate an HTTP request without a real server?

MockMvc performs requests inside the test context by calling controller methods directly, without starting a server. This is shown in execution_table steps 4 and 5.

What happens if the controller returns a different status than expected?

The assertion in step 7 will fail, causing the test to fail. This ensures the controller behaves as expected.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the MockMvc instance created?

A Step 5

B Step 3

C Step 2

D Step 1

💡 Hint

Check the 'Action' and 'Result' columns in execution_table row for step 3

At which step does the controller actually process the HTTP request?

A Step 5

B Step 4

C Step 6

D Step 7

💡 Hint

Look for 'Controller handles request' in execution_table

If the controller returned HTTP 404 instead of 200, which step would detect this?

A Step 5

B Step 6

C Step 7

D Step 4

💡 Hint

The assertion of response status happens in step 7

Concept Snapshot

@WebMvcTest loads only the web layer for controller testing.
MockMvc simulates HTTP requests without starting a server.
Use @WebMvcTest(MyController.class) to test one controller.
Perform requests with mockMvc.perform() and assert results.
This isolates controller logic from services and repositories.

Full Transcript

This visual execution trace shows how @WebMvcTest works for controller testing in Spring Boot. The test starts by loading only the web layer, not the full application context. Then, MockMvc is injected to simulate HTTP requests. When mockMvc.perform(get("/hello")) runs, it sends a fake GET request to the controller. The controller processes the request and returns an HTTP 200 OK response. The test asserts this status to verify correct behavior. This approach isolates the controller and speeds up tests by avoiding full context loading.

Practice

1. What is the main purpose of using @WebMvcTest in Spring Boot testing?

easy

A. To test only the web layer (controllers) without starting the full application context

B. To test the entire Spring Boot application including database and services

C. To perform integration testing with real HTTP calls

D. To test only the service layer without controllers

Solution

1. Step 1: Understand the role of @WebMvcTest

   @WebMvcTest is designed to load only the Spring MVC components like controllers, filters, and related configurations, not the full app context.

2. Step 2: Compare with other test annotations

   Unlike @SpringBootTest which loads the full context, @WebMvcTest focuses on controller layer for fast, isolated web tests.

3. Final Answer:

   To test only the web layer (controllers) without starting the full application context -> Option A

4. Quick Check:

   @WebMvcTest = controller-only test [OK]

Hint: Remember @WebMvcTest loads only controllers, not full app [OK]

Common Mistakes:

• Thinking @WebMvcTest loads full Spring context
• Confusing @WebMvcTest with @SpringBootTest
• Assuming it tests service or repository layers

2. Which of the following is the correct way to declare a test class using @WebMvcTest for a controller named UserController?

easy

A. @WebMvcTest(UserController.class)
public class UserControllerTest {}

B. @WebMvcTest
public class UserControllerTest {}

C. @WebMvcTest(services = UserController.class)
public class UserControllerTest {}

D. @WebMvcTest(controllers = UserController.class)
public class UserControllerTest {}

Solution

1. Step 1: Check @WebMvcTest syntax for specifying controllers

   The correct syntax to specify which controllers to test is using the 'controllers' attribute, e.g., @WebMvcTest(controllers = UserController.class).

2. Step 2: Eliminate incorrect options

   @WebMvcTest(UserController.class) public class UserControllerTest {} misses 'controllers =' keyword, @WebMvcTest public class UserControllerTest {} does not specify controller, @WebMvcTest(services = UserController.class) public class UserControllerTest {} wrongly uses 'services' attribute.

3. Final Answer:

   @WebMvcTest(controllers = UserController.class) public class UserControllerTest {} -> Option D

4. Quick Check:

   @WebMvcTest(controllers = ...) is correct syntax [OK]

Hint: Use 'controllers =' to specify controller class in @WebMvcTest [OK]

Common Mistakes:

• Omitting 'controllers =' keyword
• Using 'services =' instead of 'controllers ='
• Not specifying any controller class

3. Given the following test code snippet using @WebMvcTest and MockMvc, what will be the HTTP status returned by the test?

@WebMvcTest(controllers = HelloController.class)
public class HelloControllerTest {

  @Autowired
  private MockMvc mockMvc;

  @Test
  public void testHello() throws Exception {
    mockMvc.perform(get("/hello"))
           .andExpect(status().isOk());
  }
}

@RestController
class HelloController {
  @GetMapping("/hello")
  public String sayHello() {
    return "Hello World";
  }
}

medium

A. 404 Not Found

B. 200 OK

C. 500 Internal Server Error

D. 302 Found (Redirect)

Solution

1. Step 1: Analyze the controller mapping

   The HelloController has a GET mapping for '/hello' that returns a string "Hello World".

2. Step 2: Understand MockMvc test behavior

   The test performs a GET request to '/hello' and expects status 200 OK, which matches the controller's response.

3. Final Answer:

   200 OK -> Option B

4. Quick Check:

   GET /hello returns 200 OK [OK]

Hint: Check controller mappings match test request URL [OK]

Common Mistakes:

• Expecting 404 when mapping exists
• Confusing status codes for successful GET
• Missing controller in @WebMvcTest causing 404

4. Identify the error in the following @WebMvcTest test class that causes the test to fail with a NullPointerException.

@WebMvcTest(controllers = UserController.class)
public class UserControllerTest {

  private MockMvc mockMvc;

  @Test
  public void testGetUser() throws Exception {
    mockMvc.perform(get("/user/1"))
           .andExpect(status().isOk());
  }
}

medium

A. Missing @Autowired annotation on MockMvc field

B. Wrong controller class specified in @WebMvcTest

C. Missing @Test annotation on test method

D. MockMvc cannot perform GET requests

Solution

1. Step 1: Check MockMvc initialization

   The MockMvc field is declared but not initialized or injected, so it remains null causing NullPointerException.

2. Step 2: Fix by adding @Autowired

   Adding @Autowired on the MockMvc field lets Spring inject the mockMvc instance for testing.

3. Final Answer:

   Missing @Autowired annotation on MockMvc field -> Option A

4. Quick Check:

   MockMvc must be @Autowired to avoid null [OK]

Hint: Always @Autowired MockMvc in @WebMvcTest classes [OK]

Common Mistakes:

• Forgetting @Autowired on MockMvc
• Assuming MockMvc is auto-initialized without annotation
• Misnaming test methods without @Test

5. You want to test a controller OrderController that depends on a service OrderService. Using @WebMvcTest, how can you provide a mock OrderService to the controller during testing?

hard

A. Create a new OrderService instance manually in the test method

B. Use @Autowired on OrderService field to inject real service

C. Use @MockBean on OrderService field in the test class to inject a mock

D. Use @SpringBootTest instead of @WebMvcTest to load full context

Solution

1. Step 1: Understand @WebMvcTest scope

   @WebMvcTest loads only web layer, so service beans are not loaded automatically.

2. Step 2: Use @MockBean to provide mock dependencies

   Annotating OrderService with @MockBean in the test class creates and injects a mock into the controller.

3. Final Answer:

   Use @MockBean on OrderService field in the test class to inject a mock -> Option C

4. Quick Check:

   @MockBean mocks service dependencies in @WebMvcTest [OK]

Hint: Use @MockBean to mock services in @WebMvcTest [OK]

Common Mistakes:

• Trying to @Autowired real service in @WebMvcTest
• Not mocking service causing NoSuchBeanDefinitionException
• Switching to @SpringBootTest unnecessarily