JUnitとMockitoによる単体テスト

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class SimpleCalculator {
  int add(int a, int b) {
    return a + b;
  }
}

// This is a JUnit 5 test class
class SimpleCalculatorTest {

  @Test
  void testAddition() {
    SimpleCalculator calc = new SimpleCalculator();
    int result = calc.add(2, 3);
    // An 'assertion' checks if the result is correct
    assertEquals(5, result, "2 + 3 should be 5");
    System.out.println("Addition test passed!");
  }

  public static void main(String[] args) {
    // In a real project, JUnit runs tests automatically.
    // Here, we simulate a call for demonstration.
    System.out.println("--- Simulating JUnit Test ---");
    new SimpleCalculatorTest().testAddition();
    System.out.println("--- Simulation Complete ---");
  }
}

import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;

// Simple dependent class (e.g., a repository)
class DataRepository {
  String findDataById(String id) {
    throw new UnsupportedOperationException("Not implemented for real use!");
  }
}

// Our service class under test
class MyService {
  private final DataRepository repository;

  MyService(DataRepository repository) {
    this.repository = repository;
  }

  String processData(String id) {
    return "Processed: " + repository.findDataById(id);
  }
}

class MyServiceTestSetup {

  @Mock
  DataRepository mockRepository; // Mock of DataRepository

  @InjectMocks
  MyService myService; // Service where mocks are injected

  MyServiceTestSetup() {
    // This initializes the mocks
    MockitoAnnotations.openMocks(this);
    System.out.println("Mocks initialized for MyServiceTest!");
    System.out.println("mockRepository is a Mockito mock: " + (mockRepository != null));
    System.out.println("myService has mock injected: " + (myService != null));
  }

  public static void main(String[] args) {
    System.out.println("--- Setting Up Mocks Demo ---");
    new MyServiceTestSetup();
    System.out.println("--- Demo Complete ---");
  }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.when;

// Re-using classes from previous example
class DataRepository {
  String findDataById(String id) {
    return "Real Data for " + id;
  }
}

class MyService {
  private final DataRepository repository;
  MyService(DataRepository repository) {
    this.repository = repository;
  }
  String processData(String id) {
    return "Processed: " + repository.findDataById(id);
  }
}

class MyServiceTestBehavior {

  @Mock
  DataRepository mockRepository;

  @InjectMocks
  MyService myService;

  MyServiceTestBehavior() {
    MockitoAnnotations.openMocks(this);
  }

  @Test
  void testProcessDataWithMock() {
    // 1. Define mock behavior: when findDataById("123") is called,
    //    return "Mocked Data".
    when(mockRepository.findDataById("123")).thenReturn("Mocked Data");

    // 2. Call the service method
    String result = myService.processData("123");

    // 3. Assert the result
    assertEquals("Processed: Mocked Data", result);
    System.out.println("Test passed! Result: " + result);
  }

  public static void main(String[] args) {
    System.out.println("--- Mock Behavior Demo ---");
    MyServiceTestBehavior test = new MyServiceTestBehavior();
    test.testProcessDataWithMock();
    System.out.println("--- Demo Complete ---");
  }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;

// Re-using classes from previous example
class DataRepository {
  String findDataById(String id) {
    return "Real Data for " + id;
  }
}

class MyService {
  private final DataRepository repository;
  MyService(DataRepository repository) {
    this.repository = repository;
  }
  String processData(String id) {
    return "Processed: " + repository.findDataById(id);
  }
  void saveData(String id, String data) {
    // Imagine this saves to DB via repository
    repository.findDataById(id); // Example interaction
    System.out.println("Saving data via mock...");
  }
}

class MyServiceTestVerification {

  @Mock
  DataRepository mockRepository;

  @InjectMocks
  MyService myService;

  MyServiceTestVerification() {
    MockitoAnnotations.openMocks(this);
  }

  @Test
  void testProcessDataAndVerify() {
    // Define mock behavior
    when(mockRepository.findDataById("456")).thenReturn("Verify Data");

    // Call the service method
    String result = myService.processData("456");

    // Assert the result
    assertEquals("Processed: Verify Data", result);

    // Verify that findDataById was called exactly once with "456"
    verify(mockRepository, times(1)).findDataById("456");
    System.out.println("Test passed! Method interaction verified.");
  }

  public static void main(String[] args) {
    System.out.println("--- Mock Verification Demo ---");
    MyServiceTestVerification test = new MyServiceTestVerification();
    test.testProcessDataAndVerify();
    System.out.println("--- Demo Complete ---");
  }
}