testImplementation("org.junit.jupiter:junit-jupiter:5.11.0")
testRuntimeOnly("org.junit.platform:junit-platform-launcher")

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

class CalculatorTest {

    // 백틱으로 자연어에 가까운 테스트 이름 작성 — 실패 리포트에서 바로 의도 파악 가능
    @Test
    fun `두 양수를 더하면 두 수의 합이 반환된다`() {
        val result = Calculator.add(3, 5)
        assertEquals(8, result)
    }

    @Test
    fun `0으로 나누면 예외가 발생한다`() {
        val exception = assertThrows<ArithmeticException> {
            Calculator.divide(10, 0)
        }
        assertEquals("0으로 나눌 수 없습니다", exception.message)
    }
}

import org.junit.jupiter.api.DisplayName

@DisplayName("장바구니 계산 로직")  // 클래스 전체의 표시 이름
class ShoppingCartTest {

    @Test
    @DisplayName("상품을 담으면 총액이 증가한다")  // 이 테스트만의 표시 이름
    fun addItem_increasesTotal() {
        val cart = ShoppingCart()
        cart.addItem(Product("키보드", 50000))

        assertEquals(50000, cart.totalPrice)
    }
}

import org.junit.jupiter.api.Nested

class UserAccountTest {

    private lateinit var account: UserAccount

    @BeforeEach
    fun setUp() {
        account = UserAccount(balance = 10000)
    }

    // @Nested: 안쪽 클래스로 테스트를 논리적 그룹으로 묶음
    @Nested
    @DisplayName("입금 시나리오")
    inner class DepositScenarios {

        @Test
        fun `양수 금액을 입금하면 잔액이 증가한다`() {
            account.deposit(5000)
            assertEquals(15000, account.balance)
        }

        @Test
        fun `음수 금액을 입금하려 하면 예외가 발생한다`() {
            assertThrows<IllegalArgumentException> {
                account.deposit(-1000)
            }
        }
    }

    @Nested
    @DisplayName("출금 시나리오")
    inner class WithdrawScenarios {

        @Test
        fun `잔액 이내 금액은 정상 출금된다`() {
            account.withdraw(3000)
            assertEquals(7000, account.balance)
        }

        @Test
        fun `잔액을 초과해 출금하면 예외가 발생한다`() {
            assertThrows<InsufficientBalanceException> {
                account.withdraw(20000)
            }
        }
    }
}

import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.junit.jupiter.params.provider.CsvSource

class EmailValidatorTest {

    // ValueSource: 단일 값 목록을 순서대로 파라미터에 주입
    @ParameterizedTest
    @ValueSource(strings = ["a@b.com", "user.name@example.co.kr", "test123@gmail.com"])
    fun `유효한 이메일 형식은 통과한다`(email: String) {
        assertTrue(EmailValidator.isValid(email))
    }

    @ParameterizedTest
    @ValueSource(strings = ["invalid", "@nodomain.com", "no-at-sign.com", ""])
    fun `잘못된 이메일 형식은 거부된다`(email: String) {
        assertFalse(EmailValidator.isValid(email))
    }

    // CsvSource: 여러 파라미터를 쌍으로 주입 (입력값, 기대값)
    @ParameterizedTest
    @CsvSource(
        "10, 20, 30",
        "0, 0, 0",
        "-5, 5, 0",
        "100, -50, 50"
    )
    fun `두 수를 더하면 세 번째 값과 같다`(a: Int, b: Int, expected: Int) {
        assertEquals(expected, Calculator.add(a, b))
    }
}

import org.junit.jupiter.api.Assertions.assertAll

@Test
fun `사용자 생성 시 모든 필드가 올바르게 설정된다`() {
    val user = User.create(name = "홍길동", email = "hong@example.com", age = 30)

    // assertAll: 하나가 실패해도 나머지 검증을 계속 진행 후 모든 실패를 함께 리포트
    assertAll(
        "생성된 사용자 검증",
        { assertEquals("홍길동", user.name) },
        { assertEquals("hong@example.com", user.email) },
        { assertEquals(30, user.age) },
        { assertNotNull(user.id) },
        { assertTrue(user.createdAt <= System.currentTimeMillis()) }
    )
}

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.AfterEach

class DatabaseTest {

    private lateinit var database: TestDatabase

    // @BeforeEach: 각 테스트 실행 직전에 매번 실행 (테스트 간 상태 격리)
    @BeforeEach
    fun setUp() {
        database = TestDatabase.createInMemory()
        database.seed(sampleUsers)
    }

    // @AfterEach: 각 테스트 실행 직후에 매번 실행 (자원 정리)
    @AfterEach
    fun tearDown() {
        database.close()
    }

    @Test
    fun `사용자 조회가 정상 동작한다`() {
        val user = database.findUser("user-1")
        assertNotNull(user)
    }
}