{"id":127359,"date":"2024-10-24T17:04:00","date_gmt":"2024-10-24T14:04:00","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=127359"},"modified":"2024-10-21T11:59:26","modified_gmt":"2024-10-21T08:59:26","slug":"spring-mvc-testing-springboottest-vs-webmvctest","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/spring-mvc-testing-springboottest-vs-webmvctest.html","title":{"rendered":"Spring MVC Testing: SpringBootTest vs WebMvcTest"},"content":{"rendered":"

When testing RESTful applications in Spring Boot, choosing between @SpringBootTest<\/code> and @WebMvcTest<\/code> is essential for efficient testing. These annotations serve different purposes: @SpringBootTest<\/code> loads the full application context, while @WebMvcTest<\/code> focuses solely on the web layer. This article will compare both approaches and help you understand when to use each one.<\/p>\n

1. Using @SpringBootTest<\/code> with MockMvc<\/h2>\n

@SpringBootTest<\/code> is used for integration testing<\/em> and loads the entire application context. When combined with @AutoConfigureMockMvc<\/code>, it enables the use of MockMvc<\/code> while loading all the beans in the context, including services, repositories, and other components.<\/p>\n

Consider an application where users can perform CRUD operations through a REST API. If we want to test the behaviour of the entire application, from the web layer down to the database layer, @SpringBootTest<\/code> would be appropriate.<\/p>\n

\n@AutoConfigureMockMvc\n@SpringBootTest\npublic class UserApplicationTests {\n\n    @Autowired\n    private UserService userService;\n\n    @Autowired\n    private UserRepository userRepository;\n\n    @Autowired\n    private WebApplicationContext webApplicationContext;\n\n    @Autowired\n    private MockMvc mockMvc;\n\n    @BeforeEach\n    public void setUp() {\n        mockMvc = MockMvcBuilders\n                .webAppContextSetup(webApplicationContext)\n                .build();\n    }\n\n    @Test\n    public void testCreateUser() throws Exception {\n        Users user = new Users();\n        user.setName(\"Mr Fish\");\n        user.setAge(25);\n\n        mockMvc.perform(post(\"\/api\/users\")\n                .contentType(MediaType.APPLICATION_JSON)\n                .content(asJsonString(user)))\n                .andExpect(status().isOk());\n\n        Users savedUser = userRepository.findById(1L).orElse(null);\n        assertNotNull(savedUser);\n        assertEquals(\"Mr Fish\", savedUser.getName());\n        assertEquals(25, savedUser.getAge());\n    }\n    \n    private static String asJsonString(final Object obj) {\n        try {\n            return new ObjectMapper().writeValueAsString(obj);\n        } catch (JsonProcessingException e) {\n            throw new RuntimeException(e);\n        }\n    }\n}\n<\/pre>\n
In this example, @SpringBootTest<\/code> loads the complete application context, including components like UserService<\/code>, UserRepository<\/code>, and other infrastructure components. The MockMvc<\/code> object is employed to simulate HTTP requests to the REST API, allowing for the testing of the entire application stack. This test also ensures that the user is successfully saved in the database, demonstrating an integration test by verifying the interactions between the web, service, and database layers.
 
<\/div> <\/div><\/p>\n
2. Using @WebMvcTest<\/code> with MockMvc <\/h2>\n
@WebMvcTest<\/code> is a Spring Boot annotation designed for slice testing, meaning it focuses solely on testing the MVC layer of an application. It limits the Spring context to web-related components, such as controllers, JSON conversion with Jackson or filters, ensuring that only the necessary components for handling web requests are loaded.<\/p>\n
Now, let\u2019s say we want to test only the controller layer and avoid dealing with the service or repository layers. In this scenario, @WebMvcTest<\/code> is a better choice. It focuses on testing the web layer in isolation.<\/p>\n
\n@WebMvcTest(UserController.class)\npublic class UserControllerTests {\n\n    @Autowired\n    private MockMvc mockMvc;\n\n    @MockBean\n    private UserService userService;\n\n    @Test\n    public void testGetUser() throws Exception {\n        Users user = new Users();\n        user.setId(1L);\n        user.setName(\"Fish\");\n        user.setAge(25);\n\n        when(userService.getUser(1L)).thenReturn(java.util.Optional.of(user));\n\n        mockMvc.perform(get(\"\/api\/users\/1\")\n                .contentType(MediaType.APPLICATION_JSON))\n                .andExpect(status().isOk())\n                .andExpect(jsonPath(\"$.name\").value(\"Fish\"))\n                .andExpect(jsonPath(\"$.age\").value(25));\n    }\n}\n<\/pre>\n
In this example, @WebMvcTest<\/code> is used to load only the web layer, specifically the UserController<\/code>, making it well-suited for unit testing controllers in isolation. The service layer is mocked using @MockBean<\/code>, allowing the test to focus solely on the controller\u2019s logic without relying on the actual service implementation or database. MockMvc<\/code> is used to simulate HTTP requests, and assertions with jsonPath()<\/code> are employed to validate the response. This creates a more lightweight test, concentrating on the controller\u2019s behaviour without involving other layers like the service or database.<\/p>\n
3. Key Differences Between @WebMvcTest<\/code> and @SpringBootTest<\/code><\/h2>\n
3.1 The Degree of Integration<\/h3>\n
One of the main distinctions between @SpringBootTest<\/code> and @WebMvcTest<\/code> is the degree of integration testing they provide.<\/p>\n