【保存版】MockitoとJUnitで実現する実践的なJavaテスト入門 〜現場で使える15のテクニック〜

MockitoとJUnitの基礎知識

JUnitとMockitoが必要な理由と主要な機能

単体テストは現代のソフトウェア開発において不可欠な要素となっていますが、その中でもJUnitとMockitoは以下の理由から、Javaプロジェクトでは特に重要なテストフレームワークとして位置づけられています：

主要な機能一覧

テストフレームワークの選定ポイント

プロジェクトに適したテストフレームワークを選定する際は、以下の観点から評価することが重要です：

JUnit5とMockitoを選択する際の具体的なメリット：

✅ 充実した機能セット

• パラメータ化テスト
• 動的テスト
• 柔軟なモック作成
• 直感的なAPI

✅ 広範なエコシステム

• IDE対応
• ビルドツール連携
• CI/CDツール連携

✅ 活発なコミュニティ

• 豊富な情報源
• 迅速なバグ修正
• 継続的な機能改善

これらのフレームワークを使用することで、信頼性の高いテストを効率的に実装することが可能となります。

環境構築とプロジェクト設定

Maven/Gradleでの依存関係の設定方法

Mavenの設定

pom.xmlに以下の依存関係を追加します：

<dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito Core -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.3.1</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito JUnit Jupiter -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <version>5.3.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0</version>
        </plugin>
    </plugins>
</build>

Gradleの設定

build.gradleに以下の設定を追加します：

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testImplementation 'org.mockito:mockito-core:5.3.1'
    testImplementation 'org.mockito:mockito-junit-jupiter:5.3.1'
}

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "skipped", "failed"
    }
}

JUnit5とMockitoの互換性確認

バージョン互換性マトリックス

互換性確認のポイント

1. 必要な設定の確認
   • Java言語レベルの設定
   • コンパイラの設定
   • ランタイム設定

2. 動作確認用の簡単なテストケース

import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

class CompatibilityTest {
    @Test
    void simpleTest() {
        // モックの作成
        List<String> mockedList = mock(List.class);

        // 振る舞いの設定
        when(mockedList.get(0)).thenReturn("first");

        // 検証
        assertEquals("first", mockedList.get(0));
        verify(mockedList).get(0);
    }
}

3. トラブルシューティング
   • クラスパスの確認
   • バージョン競合の解決
   • プラグインの設定確認

このような設定を行うことで、JUnitとMockitoを使用した効果的なテスト環境を構築することができます。

JUnitによるテストケース作成の基本

テストメソッドの命名規則とベストプラクティス

推奨される命名規則

テストメソッド名は以下の3つの要素を含めることを推奨します：

1. テスト対象のメソッド名
2. テストするシナリオ
3. 期待される結果

// 良い例
@Test
void calculateTotal_WithValidItems_ReturnsSumOfPrices() {
    // テストコード
}

// 悪い例
@Test
void test1() { // 具体的な内容が分からない
    // テストコード
}

テストメソッドの構造化：AAA（Arrange-Act-Assert）パターン

@Test
void calculateDiscount_WhenPurchaseOver10000_Returns20PercentDiscount() {
    // Arrange（準備）
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(new Item("商品A", 6000));
    cart.addItem(new Item("商品B", 5000));

    // Act（実行）
    double discount = cart.calculateDiscount();

    // Assert（検証）
    assertEquals(2200, discount, "購入額11000円に対して20%の割引が適用されること");
}

アサーションの種類と使い分け

基本的なアサーション

実践的なアサーションの例

class UserServiceTest {
    @Test
    void findById_WithExistingUser_ReturnsUser() {
        // 準備
        UserService service = new UserService();
        User expectedUser = new User("1", "田中太郎");

        // 実行
        Optional<User> result = service.findById("1");

        // 検証
        assertTrue(result.isPresent(), "ユーザーが存在すること");
        assertAll("ユーザー情報の検証",
            () -> assertEquals("1", result.get().getId()),
            () -> assertEquals("田中太郎", result.get().getName())
        );
    }
}

テストライフサイクルの活用方法

ライフサイクルアノテーション

class OrderProcessingTest {
    private OrderService orderService;
    private DatabaseConnection dbConnection;

    @BeforeAll
    static void initClass() {
        // クラス全体で1回だけ実行される初期化
        // 例：データベーススキーマの作成
    }

    @BeforeEach
    void setUp() {
        // 各テストメソッド前の準備
        dbConnection = new DatabaseConnection();
        orderService = new OrderService(dbConnection);
    }

    @Test
    void processOrder_WithValidOrder_CompletesSuccessfully() {
        // テストコード
    }

    @AfterEach
    void tearDown() {
        // 各テストメソッド後の後処理
        dbConnection.close();
    }

    @AfterAll
    static void cleanupClass() {
        // クラス全体の終了時に1回実行
        // 例：一時ファイルの削除
    }
}

テストライフサイクル活用のベストプラクティス

1. リソース管理

   class ResourceManagementTest {
       private AutoCloseable resource;

       @BeforeEach
       void setUp() {
           resource = new ExpensiveResource();
       }

       @AfterEach
       void cleanup() throws Exception {
           if (resource != null) {
               resource.close();
           }
       }
   }

2. テストデータの準備

   class DatabaseTest {
       private static DatabaseConnection connection;

       @BeforeAll
       static void initDatabase() {
           connection = DatabaseConnection.create();
           connection.executeScript("schema.sql");
       }

       @BeforeEach
       void setupTestData() {
           connection.executeScript("test-data.sql");
       }

       @AfterEach
       void cleanupTestData() {
           connection.executeScript("cleanup.sql");
       }
   }

これらの基本的な要素を適切に組み合わせることで、保守性が高く信頼性のあるテストコードを作成することができます。

Mockitoで実現するモックオブジェクトの活用

モックとスタブの違いと使い分け

モックとスタブの定義

実装例での違い

class UserServiceTest {
    @Test
    void demonstrateMockVsStub() {
        // スタブの例：戻り値の設定が主目的
        UserRepository stubRepo = mock(UserRepository.class);
        when(stubRepo.findById("1")).thenReturn(new User("1", "田中太郎"));

        // モックの例：メソッド呼び出しの検証が主目的
        UserNotifier mockNotifier = mock(UserNotifier.class);

        UserService service = new UserService(stubRepo, mockNotifier);
        service.updateUser("1", "新しい名前");

        // モックの検証
        verify(mockNotifier).notifyUserUpdated("1");
    }
}

verify()を使用した呼び出し検証の方法

基本的な検証方法

@Test
void verifyMethodCalls() {
    // モックの作成
    OrderProcessor mockProcessor = mock(OrderProcessor.class);
    OrderService service = new OrderService(mockProcessor);

    // メソッド実行
    Order order = new Order("1", "商品A");
    service.processOrder(order);

    // 検証パターン
    verify(mockProcessor).process(order);                    // 1回呼び出されたことを確認
    verify(mockProcessor, times(1)).process(order);         // 明示的に1回の呼び出しを確認
    verify(mockProcessor, atLeastOnce()).process(order);    // 最低1回呼び出されたことを確認
    verify(mockProcessor, never()).cancel(order);           // 呼び出されていないことを確認
}

高度な検証パターン

@Test
void advancedVerification() {
    PaymentGateway mockGateway = mock(PaymentGateway.class);
    PaymentService service = new PaymentService(mockGateway);

    service.processPayments(Arrays.asList(
        new Payment("1", 1000),
        new Payment("2", 2000)
    ));

    // 呼び出し順序の検証
    InOrder inOrder = inOrder(mockGateway);
    inOrder.verify(mockGateway).processPayment(argThat(p -> p.getId().equals("1")));
    inOrder.verify(mockGateway).processPayment(argThat(p -> p.getId().equals("2")));

    // 引数のキャプチャと検証
    ArgumentCaptor<Payment> paymentCaptor = ArgumentCaptor.forClass(Payment.class);
    verify(mockGateway, times(2)).processPayment(paymentCaptor.capture());
    List<Payment> capturedPayments = paymentCaptor.getAllValues();
    assertEquals(2, capturedPayments.size());
}

when()とthenReturn()による戻り値の設定

基本的な戻り値設定

@Test
void demonstrateReturnValues() {
    UserRepository mockRepo = mock(UserRepository.class);

    // 単純な戻り値
    when(mockRepo.findById("1")).thenReturn(new User("1", "田中太郎"));

    // 複数回の呼び出しで異なる値
    when(mockRepo.getStatus())
        .thenReturn("ACTIVE")
        .thenReturn("INACTIVE");

    // 条件付きの戻り値
    when(mockRepo.findById(argThat(id -> id.startsWith("VIP"))))
        .thenReturn(new User("VIP1", "VIP会員"));
}

高度な戻り値設定パターン

@Test
void advancedReturnValues() {
    DataService mockService = mock(DataService.class);

    // 例外をスロー
    when(mockService.getData("invalid"))
        .thenThrow(new IllegalArgumentException());

    // 動的な戻り値
    when(mockService.processData(any()))
        .thenAnswer(invocation -> {
            String input = invocation.getArgument(0);
            return "処理済み: " + input;
        });

    // void メソッドで例外をスロー
    doThrow(new SecurityException())
        .when(mockService)
        .deleteData("protected");
}

実践的な使用例

@Test
void practicalExample() {
    // モックの作成
    PaymentGateway mockGateway = mock(PaymentGateway.class);
    PaymentValidator mockValidator = mock(PaymentValidator.class);
    PaymentService service = new PaymentService(mockGateway, mockValidator);

    Payment payment = new Payment("1", 5000);

    // バリデーションの設定
    when(mockValidator.validate(payment)).thenReturn(true);

    // 支払い処理の設定
    when(mockGateway.processPayment(payment))
        .thenAnswer(invocation -> {
            Payment p = invocation.getArgument(0);
            return new PaymentResult(p.getId(), "SUCCESS", LocalDateTime.now());
        });

    // テスト実行
    PaymentResult result = service.pay(payment);

    // 検証
    verify(mockValidator).validate(payment);
    verify(mockGateway).processPayment(payment);
    assertEquals("SUCCESS", result.getStatus());
}

これらの機能を適切に組み合わせることで、テスト対象のコードを外部依存から分離し、確実なテストを実現することができます。

実践的なテストシナリオの実装

データベース接続のモック化手法

JDBCを使用する場合のモック化

@ExtendWith(MockitoExtension.class)
class UserRepositoryTest {
    @Mock
    private Connection mockConnection;

    @Mock
    private PreparedStatement mockPreparedStatement;

    @Mock
    private ResultSet mockResultSet;

    @InjectMocks
    private UserRepository userRepository;

    @Test
    void findById_WhenUserExists_ReturnsUser() throws SQLException {
        // モックの設定
        when(mockConnection.prepareStatement(anyString()))
            .thenReturn(mockPreparedStatement);
        when(mockPreparedStatement.executeQuery())
            .thenReturn(mockResultSet);
        when(mockResultSet.next())
            .thenReturn(true)
            .thenReturn(false);

        // ResultSetの値設定
        when(mockResultSet.getString("id")).thenReturn("1");
        when(mockResultSet.getString("name")).thenReturn("田中太郎");
        when(mockResultSet.getString("email")).thenReturn("tanaka@example.com");

        // テスト実行
        Optional<User> result = userRepository.findById("1");

        // 検証
        assertTrue(result.isPresent());
        assertEquals("田中太郎", result.get().getName());

        // SQL実行の検証
        verify(mockPreparedStatement).setString(1, "1");
        verify(mockPreparedStatement).executeQuery();
    }
}

JPAを使用する場合のモック化

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock
    private EntityManager mockEntityManager;

    @Mock
    private TypedQuery<User> mockQuery;

    @InjectMocks
    private UserService userService;

    @Test
    void findActiveUsers_ReturnsActiveUsersList() {
        // モックの設定
        when(mockEntityManager.createQuery(anyString(), eq(User.class)))
            .thenReturn(mockQuery);

        List<User> expectedUsers = Arrays.asList(
            new User("1", "田中太郎", true),
            new User("2", "山田花子", true)
        );
        when(mockQuery.getResultList()).thenReturn(expectedUsers);

        // テスト実行
        List<User> activeUsers = userService.findActiveUsers();

        // 検証
        assertEquals(2, activeUsers.size());
        verify(mockQuery).getResultList();
    }
}

外部APIのテスト実装パターン

RestTemplateを使用する外部API呼び出しのテスト

@ExtendWith(MockitoExtension.class)
class WeatherServiceTest {
    @Mock
    private RestTemplate mockRestTemplate;

    @InjectMocks
    private WeatherService weatherService;

    @Test
    void getWeather_ReturnsWeatherInfo() {
        // モックの設定
        WeatherResponse mockResponse = new WeatherResponse("晴れ", 25.0);
        ResponseEntity<WeatherResponse> responseEntity = 
            new ResponseEntity<>(mockResponse, HttpStatus.OK);

        when(mockRestTemplate.exchange(
            anyString(),
            eq(HttpMethod.GET),
            any(HttpEntity.class),
            eq(WeatherResponse.class)
        )).thenReturn(responseEntity);

        // テスト実行
        WeatherInfo result = weatherService.getWeather("Tokyo");

        // 検証
        assertEquals("晴れ", result.getCondition());
        assertEquals(25.0, result.getTemperature(), 0.01);

        // API呼び出しの検証
        verify(mockRestTemplate).exchange(
            contains("/weather/Tokyo"),
            eq(HttpMethod.GET),
            any(HttpEntity.class),
            eq(WeatherResponse.class)
        );
    }

    @Test
    void getWeather_WhenApiError_ThrowsException() {
        // エラーレスポンスのモック
        when(mockRestTemplate.exchange(
            anyString(),
            eq(HttpMethod.GET),
            any(HttpEntity.class),
            eq(WeatherResponse.class)
        )).thenThrow(new RestClientException("API Error"));

        // 例外の検証
        assertThrows(WeatherServiceException.class, 
            () -> weatherService.getWeather("Invalid"));
    }
}

非同期処理のテスト方法

CompletableFutureを使用する非同期処理のテスト

@ExtendWith(MockitoExtension.class)
class AsyncServiceTest {
    @Mock
    private UserRepository mockUserRepo;

    @Mock
    private EmailService mockEmailService;

    @InjectMocks
    private AsyncService asyncService;

    @Test
    void sendNotification_CompletesSuccessfully() {
        // モックの設定
        User user = new User("1", "田中太郎", "tanaka@example.com");
        when(mockUserRepo.findByIdAsync("1"))
            .thenReturn(CompletableFuture.completedFuture(user));

        when(mockEmailService.sendEmailAsync(anyString(), anyString()))
            .thenReturn(CompletableFuture.completedFuture(true));

        // テスト実行
        CompletableFuture<Boolean> result = asyncService.sendNotification("1", "テスト通知");

        // 非同期処理の完了を待機して検証
        assertTrue(result.join());

        // 処理順序の検証
        verify(mockUserRepo).findByIdAsync("1");
        verify(mockEmailService).sendEmailAsync(
            eq("tanaka@example.com"),
            eq("テスト通知")
        );
    }
}

スケジュールされたタスクのテスト

@ExtendWith(MockitoExtension.class)
class ScheduledTaskTest {
    @Mock
    private TaskExecutor mockExecutor;

    @Mock
    private DataCleanupTask mockCleanupTask;

    @InjectMocks
    private TaskScheduler scheduler;

    @Test
    void scheduleCleanup_ExecutesTask() {
        // モックの設定
        doAnswer(invocation -> {
            Runnable task = invocation.getArgument(0);
            task.run();
            return null;
        }).when(mockExecutor).execute(any(Runnable.class));

        // テスト実行
        scheduler.scheduleCleanup();

        // 検証
        verify(mockExecutor).execute(any(Runnable.class));
        verify(mockCleanupTask).cleanup();
    }
}

これらの実装パターンを理解し、適切に使用することで、複雑な実務上のシナリオでも信頼性の高いテストを実装することができます。

テストコードの品質向上テクニック

テストの可読性を高めるためのパターン

1. カスタムアサーションの作成

public class OrderAssert {
    private final Order actual;

    private OrderAssert(Order actual) {
        this.actual = actual;
    }

    public static OrderAssert assertThat(Order actual) {
        return new OrderAssert(actual);
    }

    public OrderAssert hasStatus(OrderStatus status) {
        assertEquals(status, actual.getStatus(), 
            "注文のステータスが期待値と異なります");
        return this;
    }

    public OrderAssert hasItemCount(int count) {
        assertEquals(count, actual.getItems().size(), 
            "注文商品数が期待値と異なります");
        return this;
    }
}

// 使用例
@Test
void processOrder_WithValidItems_CompletesSuccessfully() {
    Order order = orderService.processOrder(validItems);

    assertThat(order)
        .hasStatus(OrderStatus.COMPLETED)
        .hasItemCount(2);
}

2. テストケースのグループ化

@Nested
class WhenProcessingValidOrder {
    private Order validOrder;

    @BeforeEach
    void setUp() {
        validOrder = createValidOrder();
    }

    @Test
    void completesSuccessfully() {
        // テスト内容
    }

    @Test
    void sendsConfirmationEmail() {
        // テスト内容
    }
}

@Nested
class WhenProcessingInvalidOrder {
    private Order invalidOrder;

    @BeforeEach
    void setUp() {
        invalidOrder = createInvalidOrder();
    }

    @Test
    void throwsValidationException() {
        // テスト内容
    }
}

テストデータの効率的な準備方法

1. テストデータビルダーの活用

public class UserBuilder {
    private String id = "1";
    private String name = "テストユーザー";
    private String email = "test@example.com";
    private boolean active = true;

    public static UserBuilder aUser() {
        return new UserBuilder();
    }

    public UserBuilder withId(String id) {
        this.id = id;
        return this;
    }

    public UserBuilder withName(String name) {
        this.name = name;
        return this;
    }

    public UserBuilder inactive() {
        this.active = false;
        return this;
    }

    public User build() {
        return new User(id, name, email, active);
    }
}

// 使用例
@Test
void findActiveUsers_ReturnsOnlyActiveUsers() {
    User activeUser = UserBuilder.aUser()
        .withName("活性ユーザー")
        .build();

    User inactiveUser = UserBuilder.aUser()
        .withName("非活性ユーザー")
        .inactive()
        .build();

    // テストの実行と検証
}

テストカバレッジの測定と改善

JaCoCoの設定（Maven）

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.8</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
        <execution>
            <id>check</id>
            <goals>
                <goal>check</goal>
            </goals>
            <configuration>
                <rules>
                    <rule>
                        <element>CLASS</element>
                        <limits>
                            <limit>
                                <counter>LINE</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.80</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

カバレッジ改善のためのチェックリスト

• [ ] 主要なビジネスロジックのパスをカバー
• [ ] エラーケースのテストを含める
• [ ] 境界値のテストを追加
• [ ] 条件分岐の全パターンをテスト
• [ ] 例外処理のテストを実装

@Test
void validateOrder_WithVariousConditions() {
    // 境界値テスト
    assertThrows(ValidationException.class, 
        () -> orderService.validate(createOrderWithAmount(0)));

    assertDoesNotThrow(
        () -> orderService.validate(createOrderWithAmount(1)));

    // エラーケース
    Order invalidOrder = createOrderWithoutItems();
    ValidationException ex = assertThrows(ValidationException.class,
        () -> orderService.validate(invalidOrder));
    assertEquals("注文項目は必須です", ex.getMessage());

    // 条件分岐
    assertTrue(orderService.validate(createRegularOrder()));
    assertTrue(orderService.validate(createPremiumOrder()));
}

これらのテクニックを適切に組み合わせることで、保守性が高く、信頼性のあるテストコードを作成することができます。また、継続的なリファクタリングとレビューを通じて、テストコードの品質を維持・向上させることが重要です。

よくあるエラーとトラブルシューティング

NullPointerExceptionの回避方法

1. よくある原因と対策

// 悪い例
@Test
void badExample() {
    UserService userService = mock(UserService.class);
    when(userService.getUser().getName()).thenReturn("田中"); // NullPointerException発生
}

// 良い例
@Test
void goodExample() {
    UserService userService = mock(UserService.class);
    User mockUser = mock(User.class);
    when(userService.getUser()).thenReturn(mockUser);
    when(mockUser.getName()).thenReturn("田中");
}

2. 予防的な対策

@Test
void preventiveExample() {
    // Optional使用による安全なテスト
    UserService userService = mock(UserService.class);
    when(userService.findUserById("1"))
        .thenReturn(Optional.of(new User("1", "田中")));

    // アサーションでnullチェック
    User result = userService.findUserById("1").orElse(null);
    assertNotNull(result, "ユーザーが取得できていることを確認");
    assertEquals("田中", result.getName());
}

モックの戻り値設定ミスの対処法

1. 引数マッチャーの誤った使用

// 誤った使用例
@Test
void incorrectMatcherUsage() {
    UserService service = mock(UserService.class);

    // エラー: any()とリテラル値を混在させている
    when(service.findUser(any(), "admin")).thenReturn(new User());
}

// 正しい使用例
@Test
void correctMatcherUsage() {
    UserService service = mock(UserService.class);

    // 正しい: すべての引数にマッチャーを使用
    when(service.findUser(any(), eq("admin"))).thenReturn(new User());
}

2. よくあるトラブルと解決策

@Test
void commonTroubleshooting() {
    OrderService orderService = mock(OrderService.class);

    // 問題1: 具体的な引数と抽象的なマッチャーの混在
    // ❌ 誤った方法
    when(orderService.processOrder("123", any())).thenThrow(new RuntimeException());

    // ✅ 正しい方法
    when(orderService.processOrder(eq("123"), any())).thenThrow(new RuntimeException());

    // 問題2: void メソッドの設定
    // ❌ 誤った方法
    // when(orderService.sendNotification(any())).thenThrow(new RuntimeException());

    // ✅ 正しい方法
    doThrow(new RuntimeException()).when(orderService).sendNotification(any());
}

3. デバッグのためのベストプラクティス

@Test
void debuggingBestPractices() {
    OrderService orderService = mock(OrderService.class);

    // モックの呼び出し確認を詳細に行う
    when(orderService.processOrder(any())).thenReturn(new Order());

    orderService.processOrder(new Order());

    // 詳細な検証
    verify(orderService, times(1)).processOrder(argThat(order -> {
        // 引数の詳細をログ出力
        System.out.println("Actual argument: " + order);
        return true;
    }));
}

これらの一般的なエラーとその解決策を理解することで、テストコードの信頼性を向上させ、デバッグ時間を短縮することができます。また、予防的な対策を講じることで、エラーの発生自体を減らすことが可能です。

現場での実践的な活用方法

CIパイプラインでのテスト自動化

GitHub Actionsを使用したテスト自動化の例

name: Java CI with Maven

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2

    - name: Set up JDK 17
      uses: actions/setup-java@v2
      with:
        java-version: '17'
        distribution: 'adopt'

    - name: Cache Maven packages
      uses: actions/cache@v2
      with:
        path: ~/.m2
        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
        restore-keys: ${{ runner.os }}-m2

    - name: Run Tests
      run: mvn -B test

    - name: Generate Test Report
      if: always()
      run: mvn surefire-report:report-only

    - name: Upload Test Results
      if: always()
      uses: actions/upload-artifact@v2
      with:
        name: test-results
        path: target/site/surefire-report.html

Jenkins Pipeline設定例

pipeline {
    agent any

    tools {
        maven 'Maven 3.8.4'
        jdk 'JDK 17'
    }

    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/your/repository.git'
            }
        }

        stage('Build and Test') {
            steps {
                sh 'mvn clean test'
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                    jacoco(
                        execPattern: '**/target/jacoco.exec',
                        classPattern: '**/target/classes',
                        sourcePattern: '**/src/main/java'
                    )
                }
            }
        }
    }
}

チーム開発におけるテストの統一基準

1. テスト命名規則

// 推奨される命名パターン
class OrderServiceTest {
    @Test
    void processOrder_WithValidItems_ReturnsCompletedOrder() {}

    @Test
    void processOrder_WithInvalidItems_ThrowsValidationException() {}

    @Test
    void calculateTotal_WithDiscounts_AppliesDiscountsCorrectly() {}
}

2. テストの構造化ガイドライン

@ExtendWith(MockitoExtension.class)
class ProductServiceTest {
    // 1. 定数とフィールド
    private static final String PRODUCT_ID = "TEST-001";
    private static final BigDecimal PRICE = new BigDecimal("1000");

    // 2. モックの宣言
    @Mock
    private ProductRepository productRepository;
    @Mock
    private PriceCalculator priceCalculator;

    // 3. テスト対象クラスの初期化
    @InjectMocks
    private ProductService productService;

    // 4. 共通のセットアップ
    @BeforeEach
    void setUp() {
        // 共通の準備処理
    }

    // 5. テストメソッドのグループ化
    @Nested
    class WhenCreatingNewProduct {
        @Test
        void successfulCreation() {
            // テスト実装
        }

        @Test
        void failureCase() {
            // テスト実装
        }
    }
}

3. チームのテスト品質基準

4. レビューチェックリスト

### テストコードレビューチェックリスト

基本項目:
- [ ] テスト名が適切で理解しやすい
- [ ] AAA（Arrange-Act-Assert）パターンに従っている
- [ ] 適切なアサーションを使用している
- [ ] モックの使用が適切

品質確認:
- [ ] 境界値テストが含まれている
- [ ] エラーケースのテストが含まれている
- [ ] テストが独立している（他のテストに依存していない）
- [ ] 不要なテストコードがない

保守性:
- [ ] テストコードが理解しやすい
- [ ] 重複コードが最小限に抑えられている
- [ ] テストデータが適切に管理されている

これらのガイドラインとツールを活用することで、チーム全体で一貫性のある高品質なテストを実装・維持することができます。また、CI/CDパイプラインを通じて自動化されたテスト実行を確立することで、継続的な品質保証が可能となります。

まとめ：効果的なJavaテスト実装への道筋

本記事で学んだ重要ポイント

1. テストフレームワークの基礎
   • JUnitとMockitoの役割と重要性
   • 各フレームワークの主要機能と特徴
   • 適切なテストフレームワークの選定基準
2. 実装の基本から応用まで
   • 環境構築と初期設定のベストプラクティス
   • テストケース作成の基本原則
   • モックオブジェクトの効果的な活用方法
   • 実践的なテストシナリオの実装テクニック
3. 品質向上とトラブルシューティング
   • テストコードの可読性向上手法
   • 効率的なテストデータ管理
   • 一般的なエラーとその解決方法
   • テストカバレッジの測定と改善
4. チーム開発での活用
   • CI/CDパイプラインでの自動化
   • テストの統一基準の確立
   • コードレビューのベストプラクティス

次のステップ

1. スキルの深化
   • パラメータ化テストの活用
   • カスタムアサーションの作成
   • テストデータファクトリーの実装
2. 応用分野の探求
   • マイクロサービステスト
   • 性能テスト
   • セキュリティテスト
3. ツールの拡張
   • TestContainersの活用
   • Seleniumとの連携
   • アーキテクチャテストの導入

リソースとリファレンス

1. 公式ドキュメント
   • JUnit 5ユーザーガイド
   • Mockitoリファレンス
2. 推奨書籍
   • 『Effective Unit Testing』
   • 『Test-Driven Development: By Example』
3. オンラインリソース
   • Maven Central Repository
   • Stack Overflow
   • GitHub サンプルプロジェクト

最後に

テストコードの品質は、プロジェクト全体の品質に直結します。本記事で紹介した技術とベストプラクティスを実践することで、より信頼性の高いJavaアプリケーションを開発することができます。

テストは単なる品質確認ツールではなく、設計品質を向上させ、リファクタリングを容易にし、ドキュメントとしても機能する重要な要素です。継続的な学習と実践を通じて、テストの技術を磨いていくことをお勧めします。