테스트 코드 — JUnit 5와 Mockito로 자바 테스트 작성하기

// build.gradle
dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
}

test {
    useJUnitPlatform() // JUnit 5 플랫폼 사용
}

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

class CalculatorTest {

    @Test
    void 더하기_테스트() {
        // given - 준비
        Calculator calc = new Calculator();

        // when - 실행
        int result = calc.add(2, 3);

        // then - 검증
        assertEquals(5, result);
    }
}

// 값 비교
assertEquals(5, result);                    // 같은지
assertNotEquals(0, result);                 // 다른지

// 참/거짓
assertTrue(list.isEmpty());                 // 참인지
assertFalse(user.isBlocked());              // 거짓인지

// null 검사
assertNull(deletedUser);                    // null인지
assertNotNull(savedUser);                   // null이 아닌지

// 예외 검증
assertThrows(IllegalArgumentException.class, () -> {
    calc.divide(10, 0); // 0으로 나누면 예외 발생
});

// 예외 메시지까지 검증
Exception ex = assertThrows(IllegalArgumentException.class, () -> {
    calc.divide(10, 0);
});
assertEquals("0으로 나눌 수 없습니다", ex.getMessage());

// 여러 검증을 한 번에 — 하나가 실패해도 나머지를 계속 실행
assertAll(
    () -> assertEquals("홍길동", user.getName()),
    () -> assertEquals(25, user.getAge()),
    () -> assertNotNull(user.getEmail())
);

class UserServiceTest {

    private UserService service;
    private UserRepository repo;

    @BeforeAll
    static void 전체_초기화() {
        // 모든 테스트 전에 한 번만 실행
        // static 메서드여야 한다
        System.out.println("테스트 시작");
    }

    @BeforeEach
    void 각_테스트_전() {
        // 각 테스트 메서드 실행 전마다 호출
        repo = new FakeUserRepository();
        service = new UserService(repo);
    }

    @AfterEach
    void 각_테스트_후() {
        // 각 테스트 메서드 실행 후마다 호출
        // 리소스 정리 등
    }

    @AfterAll
    static void 전체_정리() {
        // 모든 테스트 후에 한 번만 실행
        System.out.println("테스트 종료");
    }

    @Test
    void 사용자_생성() {
        // service와 repo는 @BeforeEach에서 이미 준비됨
        User user = service.create("홍길동");
        assertNotNull(user.getId());
    }
}

@BeforeAll (한 번)
  ├─ @BeforeEach → @Test 메서드 1 → @AfterEach
  ├─ @BeforeEach → @Test 메서드 2 → @AfterEach
  └─ @BeforeEach → @Test 메서드 3 → @AfterEach
@AfterAll (한 번)

@DisplayName("Calculator 테스트")
class CalculatorTest {

    @Test
    @DisplayName("양수 두 개를 더하면 합을 반환한다")
    void addPositiveNumbers() {
        assertEquals(5, new Calculator().add(2, 3));
    }

    @Test
    @DisplayName("0으로 나누면 IllegalArgumentException이 발생한다")
    void divideByZero() {
        assertThrows(IllegalArgumentException.class,
            () -> new Calculator().divide(10, 0));
    }
}

@DisplayName("OrderService")
class OrderServiceTest {

    @Nested
    @DisplayName("주문 생성 시")
    class CreateOrder {

        @Test
        @DisplayName("재고가 충분하면 주문이 성공한다")
        void 재고_충분() {
            // ...
        }

        @Test
        @DisplayName("재고가 부족하면 예외가 발생한다")
        void 재고_부족() {
            // ...
        }
    }

    @Nested
    @DisplayName("주문 취소 시")
    class CancelOrder {

        @Test
        @DisplayName("배송 전이면 취소가 가능하다")
        void 배송_전_취소() {
            // ...
        }

        @Test
        @DisplayName("배송 후에는 취소가 불가능하다")
        void 배송_후_취소() {
            // ...
        }
    }
}

OrderService
├── 주문 생성 시
│   ├── ✅ 재고가 충분하면 주문이 성공한다
│   └── ✅ 재고가 부족하면 예외가 발생한다
└── 주문 취소 시
    ├── ✅ 배송 전이면 취소가 가능하다
    └── ✅ 배송 후에는 취소가 불가능하다

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5})
void 양수_판별(int number) {
    assertTrue(number > 0);
}

@ParameterizedTest
@CsvSource({
    "1, 2, 3",    // 1 + 2 = 3
    "10, 20, 30", // 10 + 20 = 30
    "-1, 1, 0"    // -1 + 1 = 0
})
void 덧셈_테스트(int a, int b, int expected) {
    assertEquals(expected, new Calculator().add(a, b));
}

@ParameterizedTest
@MethodSource("userProvider")
void 사용자_이름_검증(String name, boolean expected) {
    assertEquals(expected, UserValidator.isValidName(name));
}

// 테스트 데이터를 제공하는 정적 메서드
static Stream<Arguments> userProvider() {
    return Stream.of(
        Arguments.of("홍길동", true),       // 정상 이름
        Arguments.of("", false),            // 빈 문자열
        Arguments.of(null, false),          // null
        Arguments.of("a".repeat(51), false) // 50자 초과
    );
}

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

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

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

@ExtendWith(MockitoExtension.class) // Mockito 활성화
class UserServiceTest {

    @Mock
    UserRepository userRepository; // 가짜 객체 생성

    @InjectMocks
    UserService userService; // Mock을 주입한 실제 객체

    @Test
    void 사용자_조회_성공() {
        // given - Mock 행동 정의 (스텁)
        User fakeUser = new User(1L, "홍길동");
        when(userRepository.findById(1L)).thenReturn(Optional.of(fakeUser));

        // when - 테스트 대상 실행
        User result = userService.findById(1L);

        // then - 검증
        assertEquals("홍길동", result.getName());
        verify(userRepository).findById(1L); // findById가 1번 호출되었는지 검증
    }

    @Test
    void 존재하지_않는_사용자_조회() {
        // given
        when(userRepository.findById(999L)).thenReturn(Optional.empty());

        // when & then
        assertThrows(UserNotFoundException.class,
            () -> userService.findById(999L));
    }
}

// "findById(1L)이 호출되면 fakeUser를 반환해라" → 이게 스텁
when(userRepository.findById(1L)).thenReturn(Optional.of(fakeUser));

// 스텁 설정 (Stub 역할)
when(userRepository.save(any())).thenReturn(savedUser);

// 호출 검증 (Mock 역할)
verify(userRepository).save(any());

@Spy
List<String> spyList = new ArrayList<>();

@Test
void spy_테스트() {
    spyList.add("one");     // 실제 add() 호출
    spyList.add("two");     // 실제 add() 호출

    assertEquals(2, spyList.size()); // 실제 크기: 2

    // 특정 메서드만 스텁
    doReturn(100).when(spyList).size();
    assertEquals(100, spyList.size()); // 스텁된 값: 100
}

@Test
@DisplayName("잔액이 충분하면 출금에 성공한다")
void 출금_성공() {
    // given — 사전 조건, 테스트에 필요한 데이터 준비
    Account account = new Account(10000);

    // when — 테스트 대상 동작 실행
    account.withdraw(3000);

    // then — 결과 검증
    assertEquals(7000, account.getBalance());
}

import static org.mockito.BDDMockito.*;

@Test
@DisplayName("주문 생성 시 재고가 차감된다")
void 주문_재고_차감() {
    // given
    Product product = new Product(1L, "노트북", 10);
    given(productRepository.findById(1L))      // when 대신 given 사용
        .willReturn(Optional.of(product));      // thenReturn 대신 willReturn

    // when
    orderService.createOrder(1L, 2);

    // then
    then(productRepository).should().save(any(Product.class)); // verify 대신 then/should
    assertEquals(8, product.getStock());
}

// build.gradle
plugins {
    id 'jacoco'
}

jacoco {
    toolVersion = "0.8.12"
}

jacocoTestReport {
    reports {
        html.required = true // HTML 리포트 생성
    }
}

// 최소 커버리지 설정 (선택)
jacocoTestCoverageVerification {
    violationRules {
        rule {
            limit {
                minimum = 0.80 // 80% 이상 커버리지 필수
            }
        }
    }
}

// 이 테스트는 커버리지를 올리지만, 의미 있는 검증을 하지 않는다
@Test
void 의미없는_테스트() {
    UserService service = new UserService(mockRepo);
    service.findById(1L); // 호출만 하고 결과는 안 본다
}

     ┌─────────────────────┐
     │                     │
     ▼                     │
  🔴 Red                   │
  실패하는 테스트 작성       │
     │                     │
     ▼                     │
  🟢 Green                 │
  테스트를 통과하는          │
  최소한의 코드 작성         │
     │                     │
     ▼                     │
  🔵 Refactor              │
  코드를 깔끔하게 정리       │
     │                     │
     └─────────────────────┘

@Test
void 문자열_뒤집기() {
    StringUtils utils = new StringUtils();
    assertEquals("cba", utils.reverse("abc"));
    // StringUtils 클래스도 없고, reverse 메서드도 없다 → 컴파일 에러 (Red)
}

class StringUtils {
    String reverse(String input) {
        return new StringBuilder(input).reverse().toString();
    }
}
// 테스트 통과! (Green)

class StringUtils {
    String reverse(String input) {
        if (input == null || input.isEmpty()) {
            return input; // null이나 빈 문자열은 그대로 반환
        }
        return new StringBuilder(input).reverse().toString();
    }
}