Springでのテスト最適化：MockMvcを活用した効率的な実装方法

<!-- Mavenの場合 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

// Gradleの場合
testImplementation 'org.springframework.boot:spring-boot-starter-test'

@SpringBootTest
public class MyServiceTest {
    // テストコード
}

@WebMvcTest(controllers = MyController.class)
public class MyControllerTest {
    // コントローラーテストコード
}

@WebMvcTest(MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetEndpoint() throws Exception {
        mockMvc.perform(get("/my-endpoint"))
               .andExpect(status().isOk())
               .andExpect(content().string("Expected Response"));
    }
}

@RestController
public class MyController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

@WebMvcTest(MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

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

@RestController
public class MyController {

    @PostMapping("/submit")
    public ResponseEntity<String> submit(@RequestBody String input) {
        if ("valid".equals(input)) {
            return ResponseEntity.ok("Success");
        } else {
            return ResponseEntity.badRequest().body("Error");
        }
    }
}

@WebMvcTest(MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testSubmitEndpointValidInput() throws Exception {
        mockMvc.perform(post("/submit")
               .content("valid")
               .contentType(MediaType.TEXT_PLAIN))
               .andExpect(status().isOk())
               .andExpect(content().string("Success"));
    }

    @Test
    public void testSubmitEndpointInvalidInput() throws Exception {
        mockMvc.perform(post("/submit")
               .content("invalid")
               .contentType(MediaType.TEXT_PLAIN))
               .andExpect(status().isBadRequest())
               .andExpect(content().string("Error"));
    }
}

@RestController
public class MyController {

    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        return "Hello, " + name + "!";
    }
}

@WebMvcTest(MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGreetEndpoint() throws Exception {
        mockMvc.perform(get("/greet").param("name", "John"))
               .andExpect(status().isOk())
               .andExpect(content().string("Hello, John!"));
    }
}

<!-- Maven依存関係 -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

@SpringBootTest
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testSaveAndFindUser() {
        User user = new User("John Doe", "john@example.com");
        userRepository.save(user);

        User foundUser = userRepository.findByEmail("john@example.com");
        assertEquals("John Doe", foundUser.getName());
    }
}

@DataJpaTest
public class UserRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private UserRepository userRepository;

    @Test
    public void whenFindByEmail_thenReturnUser() {
        User user = new User("Jane Doe", "jane@example.com");
        entityManager.persistAndFlush(user);

        User found = userRepository.findByEmail(user.getEmail());
        assertEquals(user.getName(), found.getName());
    }
}

@SpringBootTest
@Sql(scripts = "/test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindUserById() {
        User user = userRepository.findById(1L).orElse(null);
        assertEquals("John Doe", user.getName());
    }
}

@Test
@Transactional
public void testUserTransaction() {
    User user = new User("Test User", "test@example.com");
    userRepository.save(user);

    // データベースに保存されていることを確認
    User foundUser = userRepository.findByEmail("test@example.com");
    assertNotNull(foundUser);
    assertEquals("Test User", foundUser.getName());

    // テスト終了後にロールバックされる
}

@WebMvcTest(MyController.class)
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private MyService myService;

    @Test
    public void testControllerWithMockedService() throws Exception {
        // モックされたMyServiceの動作を定義
        when(myService.getData()).thenReturn("Mocked Data");

        mockMvc.perform(get("/data"))
               .andExpect(status().isOk())
               .andExpect(content().string("Mocked Data"));
    }
}

// メソッド呼び出し時に特定の値を返す
when(myService.getData()).thenReturn("Mocked Data");

// メソッド呼び出し時に例外を投げる
when(myService.getData()).thenThrow(new RuntimeException("Error"));

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

@SpringBootTest
public class UserServiceTest {

    @MockBean
    private UserRepository userRepository;

    @Autowired
    private UserService userService;

    @Test
    public void testGetUserById() {
        // モックされたUserRepositoryの動作を定義
        User mockUser = new User("John Doe", "john@example.com");
        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));

        User user = userService.getUserById(1L);
        assertEquals("John Doe", user.getName());
    }
}

@RestController
public class UserController {

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found"));
    }

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFound(UserNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testUserNotFound() throws Exception {
        // ユーザーが存在しない場合の動作をモック
        when(userService.findById(1L)).thenReturn(Optional.empty());

        // エラーが適切に処理されているかをテスト
        mockMvc.perform(get("/users/1"))
               .andExpect(status().isNotFound())
               .andExpect(content().string("User not found"));
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFound(UserNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGeneralException(Exception ex) {
        return new ResponseEntity<>("An error occurred", HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

@WebMvcTest(UserController.class)
public class GlobalExceptionHandlerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testGlobalExceptionHandler() throws Exception {
        // 一般的な例外が発生した場合のモック
        when(userService.findById(1L)).thenThrow(new RuntimeException("Unexpected error"));

        // 一般例外が500エラーとして処理されるか確認
        mockMvc.perform(get("/users/1"))
               .andExpect(status().isInternalServerError())
               .andExpect(content().string("An error occurred"));
    }
}

@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<Map<String, Object>> handleUserNotFound(UserNotFoundException ex) {
    Map<String, Object> errorResponse = new HashMap<>();
    errorResponse.put("error", "User not found");
    errorResponse.put("code", 404);
    errorResponse.put("timestamp", System.currentTimeMillis());
    return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}

@Test
public void testCustomErrorResponse() throws Exception {
    when(userService.findById(1L)).thenReturn(Optional.empty());

    mockMvc.perform(get("/users/1"))
           .andExpect(status().isNotFound())
           .andExpect(jsonPath("$.error").value("User not found"))
           .andExpect(jsonPath("$.code").value(404));
}

@RestController
public class SecureController {

    @GetMapping("/secure")
    public String secureEndpoint() {
        return "This is a secure endpoint";
    }
}

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/secure").authenticated()
            .and()
            .httpBasic(); // Basic認証を使用
    }
}

@WebMvcTest(SecureController.class)
@Import(SecurityConfig.class)
public class SecureControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testAccessWithoutAuthentication() throws Exception {
        mockMvc.perform(get("/secure"))
               .andExpect(status().isUnauthorized());
    }
}

@Test
public void testAccessWithAuthentication() throws Exception {
    mockMvc.perform(get("/secure")
            .with(httpBasic("user", "password")))
            .andExpect(status().isOk())
            .andExpect(content().string("This is a secure endpoint"));
}

@Test
public void testAccessWithInvalidCredentials() throws Exception {
    mockMvc.perform(get("/secure")
            .with(httpBasic("invalidUser", "wrongPassword")))
            .andExpect(status().isUnauthorized());
}

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/admin").hasRole("ADMIN")
            .and()
            .httpBasic();
    }
}

@Test
public void testAdminAccessWithCorrectRole() throws Exception {
    mockMvc.perform(get("/admin")
            .with(user("adminUser").roles("ADMIN")))
            .andExpect(status().isOk());
}

@Test
public void testAdminAccessWithIncorrectRole() throws Exception {
    mockMvc.perform(get("/admin")
            .with(user("normalUser").roles("USER")))
            .andExpect(status().isForbidden());
}

@WebMvcTest(MyController.class)
public class MyControllerTest {
    // Web層のみをテスト
}

@DataJpaTest
public class MyRepositoryTest {
    // JPAリポジトリ層のみをテスト
}

junit.jupiter.execution.parallel.enabled = true
junit.jupiter.execution.parallel.mode.default = concurrent

@Test
@Transactional
public void testDatabaseInteraction() {
    // テスト実行後に自動的にロールバック
}

<configuration>
    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> performAsyncTask() {
        try {
            Thread.sleep(2000); // 非同期タスクのシミュレーション
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return CompletableFuture.completedFuture("Task Completed");
    }
}

@SpringBootTest
public class AsyncServiceTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    public void testPerformAsyncTask() throws Exception {
        CompletableFuture<String> future = asyncService.performAsyncTask();

        // 非同期処理が完了するまで待機
        assertEquals("Task Completed", future.get(3, TimeUnit.SECONDS));
    }
}

@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("/async-task")
    public CompletableFuture<String> executeAsyncTask() {
        return asyncService.performAsyncTask();
    }
}

@WebMvcTest(AsyncController.class)
public class AsyncControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private AsyncService asyncService;

    @Test
    public void testExecuteAsyncTask() throws Exception {
        // 非同期サービスのモック設定
        when(asyncService.performAsyncTask()).thenReturn(CompletableFuture.completedFuture("Task Completed"));

        // 非同期リクエストの実行
        MvcResult mvcResult = mockMvc.perform(get("/async-task"))
                                     .andExpect(request().asyncStarted())
                                     .andReturn();

        // 非同期処理が完了するまで待機して結果を確認
        mockMvc.perform(asyncDispatch(mvcResult))
               .andExpect(status().isOk())
               .andExpect(content().string("Task Completed"));
    }
}

@Test
public void testAsyncTaskThrowsException() throws Exception {
    // 非同期サービスのモック設定（例外を投げる）
    when(asyncService.performAsyncTask()).thenThrow(new RuntimeException("Async error"));

    // 非同期リクエストの実行とエラーハンドリングの確認
    MvcResult mvcResult = mockMvc.perform(get("/async-task"))
                                 .andExpect(request().asyncStarted())
                                 .andReturn();

    mockMvc.perform(asyncDispatch(mvcResult))
           .andExpect(status().isInternalServerError())
           .andExpect(content().string("Async error"));
}