// 문제 상황: 테스트가 코루틴 완료를 기다리지 않고 끝나버림
@Test
fun badTest() {
    var result = 0
    CoroutineScope(Dispatchers.Default).launch {
        delay(1000)
        result = 42
    }
    assertEquals(42, result)  // ❌ 실패! 코루틴이 끝나기 전에 assert 실행됨
}

testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.delay
import org.junit.Test
import kotlin.test.assertEquals

class UserRepositoryTest {

    @Test
    fun `사용자 정보를 정상적으로 불러온다`() = runTest {
        // runTest 블록 안은 suspend 컨텍스트 → suspend 함수 직접 호출 가능
        val repository = UserRepository(fakeApi = FakeUserApi())

        val user = repository.fetchUser("user-1")  // suspend 함수

        assertEquals("홍길동", user.name)
    }
}

@Test
fun `delay가 있어도 테스트는 즉시 끝난다`() = runTest {
    val startTime = System.currentTimeMillis()

    delay(10_000)  // 10초 지연 — 하지만 실제로는 기다리지 않음!

    val elapsed = System.currentTimeMillis() - startTime
    println("실제 경과 시간: ${elapsed}ms")  // 수십 ms 이내 (10초가 아님)

    // currentTime: TestScope의 가상 시간 — 실제로는 10초가 "흐른 것으로 간주"됨
    assertEquals(10_000, currentTime)
}

import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.advanceUntilIdle

@Test
fun `StandardTestDispatcher는 launch를 즉시 실행하지 않는다`() = runTest {
    var executed = false

    launch {
        executed = true
    }

    // launch 직후에는 아직 실행되지 않음 (큐에 대기 중)
    assertEquals(false, executed)

    // advanceUntilIdle(): 대기 중인 모든 코루틴 작업을 완료할 때까지 진행
    advanceUntilIdle()

    assertEquals(true, executed)  // 이제 실행 완료
}

@Test
fun `advanceTimeBy로 특정 시간만큼만 진행`() = runTest {
    var tickCount = 0

    launch {
        repeat(5) {
            delay(1000)
            tickCount++
        }
    }

    advanceTimeBy(3000)  // 가상 시간을 3초만 진행
    runCurrent()          // 그 시점까지 예약된 작업 실행

    assertEquals(3, tickCount)  // 3번의 delay(1000)만 통과됨
}

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.After
import org.junit.Before

class MainDispatcherRule : TestWatcher() {
    private val testDispatcher = UnconfinedTestDispatcher()

    override fun starting(description: Description) {
        // Dispatchers.Main을 테스트용 디스패처로 교체 (Android 프레임워크 의존성 제거)
        Dispatchers.setMain(testDispatcher)
    }

    override fun finished(description: Description) {
        Dispatchers.resetMain()  // 원래 상태로 복구 (다른 테스트에 영향 방지)
    }
}

class ProductViewModelTest {
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()  // 모든 테스트에 자동 적용

    @Test
    fun `상품 목록 로드 성공 시 uiState가 갱신된다`() = runTest {
        val viewModel = ProductViewModel(fakeRepository)

        viewModel.loadProducts()

        val state = viewModel.uiState.value
        assertEquals(false, state.isLoading)
        assertEquals(3, state.products.size)
    }
}

@Test
fun `네트워크 오류 시 예외가 발생한다`() = runTest {
    val repository = UserRepository(fakeApi = FailingUserApi())

    // assertFailsWith: suspend 함수가 특정 예외를 던지는지 검증
    val exception = assertFailsWith<NetworkException> {
        repository.fetchUser("user-1")
    }

    assertEquals("네트워크 연결 실패", exception.message)
}

@Test
fun `실패 시 에러 상태로 전환된다`() = runTest {
    val viewModel = ProductViewModel(fakeRepository = FailingRepository())

    viewModel.loadProducts()

    val state = viewModel.uiState.value
    assertNotNull(state.errorMessage)  // 예외가 UiState로 잘 변환되었는지 확인
    assertEquals(false, state.isLoading)
}