【Java初心者向け】JUnit & Mockito入門 ― 単体テストの基礎からモックの使い方まで徹底解説

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

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

<!-- Mockito JUnit Jupiter 連携 -->
<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-junit-jupiter</artifactId>
  <version>5.8.0</version>
  <scope>test</scope>
</dependency>

// Calculator.java（テスト対象クラス）
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("0 で割ることはできません");
        }
        return a / b;
    }
}

// CalculatorTest.java（テストクラス）
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

@DisplayName("電卓クラスのテスト")
class CalculatorTest {

    private Calculator calculator;

    @BeforeEach  // 各テストの前に実行される
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    @DisplayName("足し算：2 + 3 = 5 になること")
    void testAdd() {
        // Arrange（準備）
        int a = 2, b = 3;

        // Act（実行）
        int result = calculator.add(a, b);

        // Assert（検証）
        assertEquals(5, result, "2 + 3 は 5 であるべき");
    }

    @Test
    @DisplayName("ゼロ除算で例外が発生すること")
    void testDivideByZero() {
        assertThrows(
            IllegalArgumentException.class,
            () -> calculator.divide(10, 0)
        );
    }
}

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

@ExtendWith(MockitoExtension.class)  // Mockito を JUnit 5 で有効化
class OrderServiceTest {

    @Mock                          // モック化する依存クラス
    private OrderRepository orderRepository;

    @InjectMocks                   // テスト対象（モックが自動注入される）
    private OrderService orderService;

    @Test
    @DisplayName("注文IDから注文を取得できること")
    void testGetOrder() {
        // Arrange：モックの振る舞いを定義
        Order mockOrder = new Order(1L, "コーヒー", 500);
        when(orderRepository.findById(1L)).thenReturn(mockOrder);

        // Act：テスト対象メソッドを実行
        Order result = orderService.getOrder(1L);

        // Assert：結果を検証
        assertEquals("コーヒー", result.getName());
        assertEquals(500, result.getPrice());

        // Verify：モックのメソッドが呼ばれたか確認
        verify(orderRepository, times(1)).findById(1L);
    }
}

public class ShopService {
    private final ItemRepository  itemRepository;
    private final StockRepository stockRepository;

    public ShopService(ItemRepository itemRepository,
                       StockRepository stockRepository) {
        this.itemRepository  = itemRepository;
        this.stockRepository = stockRepository;
    }

    public boolean purchase(long itemId, int quantity) {
        Item item = itemRepository.findById(itemId);
        if (item == null) {
            throw new IllegalArgumentException("商品が見つかりません");
        }
        int stock = stockRepository.getStock(itemId);
        if (stock < quantity) {
            return false;  // 在庫不足
        }
        stockRepository.decreaseStock(itemId, quantity);
        return true;
    }
}

@ExtendWith(MockitoExtension.class)
class ShopServiceTest {

    @Mock private ItemRepository  itemRepository;
    @Mock private StockRepository stockRepository;
    @InjectMocks private ShopService shopService;

    @Test
    @DisplayName("在庫が十分にある場合、購入が成功すること")
    void testPurchaseSuccess() {
        // Arrange
        Item mockItem = new Item(1L, "りんご");
        when(itemRepository.findById(1L)).thenReturn(mockItem);
        when(stockRepository.getStock(1L)).thenReturn(10);  // 在庫10個

        // Act
        boolean result = shopService.purchase(1L, 3);  // 3個購入

        // Assert
        assertTrue(result);
        verify(stockRepository).decreaseStock(1L, 3);  // 在庫が減らされたか確認
    }

    @Test
    @DisplayName("在庫不足の場合、購入が失敗すること")
    void testPurchaseFailDueToStockShortage() {
        // Arrange
        Item mockItem = new Item(1L, "りんご");
        when(itemRepository.findById(1L)).thenReturn(mockItem);
        when(stockRepository.getStock(1L)).thenReturn(2);   // 在庫2個のみ

        // Act
        boolean result = shopService.purchase(1L, 5);  // 5個購入しようとする

        // Assert
        assertFalse(result);
        verify(stockRepository, never()).decreaseStock(anyLong(), anyInt());  // 在庫減少は呼ばれない
    }

    @Test
    @DisplayName("存在しない商品IDを指定すると例外が発生すること")
    void testPurchaseItemNotFound() {
        when(itemRepository.findById(99L)).thenReturn(null);

        assertThrows(
            IllegalArgumentException.class,
            () -> shopService.purchase(99L, 1)
        );
    }
}