Coroutine ‐ Coroutine Testing
- 테스트 더블은 객체에 대한 대체물로 객체의 행동을 모방하는 객체이다.
- 다른 객체와 의존성을 가진 객체를 테스트하기 위해 테스트 더블이 필요하다.
- 테스트 더블의 종류로는 대표적으로 스텁(Stub), 페이크(Fake), 목(Mock) 이 3가지가 있다.
-
Stub
- 스텁이란, 미리 정의된 데이터를 반환하는 모방 객체이다. 반환 값이 없는 함수는 구현하지 않고 반환 값이 있는 동작만 미리 정의된 데이터를 반환하도록 구현한다.
- 이 때, 스텁을 만들 때 미리 정의된 데이터를 내부 프로퍼티로 고정하면 유연하지 못해진다.
- 유연하게 만들기 위해서는 미리 정의된 데이터를 주입 받는 형태로 만들어야 한다.
-
Fake
- 페이크란, 실제 객체와 비슷하게 동작하도록 구현된 모방 객체이다.
- 간단한 일시 중단 함수를 테스트 할 때는
runBlocking()함수를 사용해 코루틴을 만들면 된다. -
runBlocking()함수를 사용해 실행에 오랜 시간이 걸리는 일시 중단 함수를 테스트하면 문제가 생긴다.
class RepeatAddUseCaseTest {
@Test
fun `100번 더하면 100이 반환된다`(): Unit = runBlocking {
// Given
val repeatAddUseCase = RepeatAddUseCase()
// When
val result: Int = repeatAddUseCase.add(100)
// Then
assertEquals(100, result)
}
}- 코루틴 테스트 라이브러리는
TestCoroutineScheduler객체를 통해 가상 시간에서 테스트를 진행할 수 있도록 하는 기능을 제공한다. -
TestCoroutineScheduler객체를 사용하면 시간을 자유자재로 다룰 수 있다. -
TestCoroutineScheduler.advanceTimeBy(): 가상 시간을 흐르게 만들 수 있다. -
TestCoroutineScheduler.currentTime: 현재 시간(가상 시간)을 알 수 있다.
-
TestCoroutineScheduler객체는TestDispatcher객체를 만드는StandardTestDispatcher함수와 함께 사용할 수 있다.
@OptIn(ExperimentalCoroutinesApi::class)
class CoroutineTest {
@Test
fun `가상 시간 위에서 테스트 진행`() {
// Given: 테스트 환경 설정
val testCoroutineScheduler = TestCoroutineScheduler()
val testDispatcher = StandardTestDispatcher(scheduler = testCoroutineScheduler)
val testCoroutineScope = CoroutineScope(context = testDispatcher)
var result = 0
// When: 코루틴 실행 (즉시 시작되지 않고 스케줄러에 등록됨)
testCoroutineScope.launch {
delay(10000L) // 10초 대기
result = 1
delay(10000L) // 추가 10초 대기
result = 2
}
// Then: 가상 시간을 흐르게 하며 결과 검증
// 1. 5초 흐르게 함 (총 5초 지남) -> delay(10000) 중이므로 result는 아직 0
testCoroutineScheduler.advanceTimeBy(5000L)
assertEquals(0, result)
// 2. 추가 6초 흐르게 함 (총 11초 지남) -> 첫 번째 delay(10000) 종료, result는 1이 됨
testCoroutineScheduler.advanceTimeBy(6000L)
assertEquals(1, result)
// 3. 추가 10초 흐르게 함 (총 21초 지남) -> 두 번째 delay(10000) 종료, result는 2가 됨
testCoroutineScheduler.advanceTimeBy(10000L)
assertEquals(2, result)
}
}-
TestCoroutineScheduler의advanceUntilIdle()함수가 호출되면 가상 시간 스케줄러를 사용하는 모든 코루틴이 완료될 때까지 시간이 흐른다.
@OptIn(ExperimentalCoroutinesApi::class)
class CoroutineAdvanceTest {
@Test
fun `advanceUntilIdle의 동작 살펴보기`() {
// Given: 테스트 환경 설정
val testCoroutineScheduler = TestCoroutineScheduler()
val testDispatcher = StandardTestDispatcher(scheduler = testCoroutineScheduler)
val testCoroutineScope = CoroutineScope(context = testDispatcher)
var result = 0
// When: 코루틴 실행 (총 20초의 대기 시간이 포함됨)
testCoroutineScope.launch {
delay(10_000L) // 10초 대기
result = 1
delay(10_000L) // 추가 10초 대기
result = 2
}
// advanceUntilIdle() 호출:
// 스케줄러에 남아있는 모든 작업(위의 두 번의 delay 포함)이 끝날 때까지
// 시간을 자동으로 점프합니다.
testCoroutineScheduler.advanceUntilIdle()
// Then: 모든 작업이 완료되었으므로 result는 최종값인 2가 됨
assertEquals(2, result)
}
}-
StandardTestDispatcher함수는TestCoroutineScheduler을 생성하는 부분을 포함한다.
@Suppress("FunctionName")
public fun StandardTestDispatcher(
scheduler: TestCoroutineScheduler? = null,
name: String? = null
): TestDispatcher = StandardTestDispatcherImpl(
scheduler ?: TestMainDispatcher.currentTestScheduler ?: TestCoroutineScheduler(), name)-
TestScope를 사용하면 내부에TestDispatcher을 가진TestScope객체가 반환된다. -
TestScope은 확장 함수를 통해advancedUntilIdle,advanceTimeBy를 직접 호출할 수 있도록 한다.
/**
* A coroutine scope that for launching test coroutines.
*
* The scope provides the following functionality:
* - The [coroutineContext] includes a [coroutine dispatcher][TestDispatcher] that supports delay-skipping, using
* a [TestCoroutineScheduler] for orchestrating the virtual time.
* This scheduler is also available via the [testScheduler] property, and some helper extension
* methods are defined to more conveniently interact with it: see [TestScope.currentTime], [TestScope.runCurrent],
* [TestScope.advanceTimeBy], and [TestScope.advanceUntilIdle].
* - When inside [runTest], uncaught exceptions from the child coroutines of this scope will be reported at the end of
* the test.
* It is invalid for child coroutines to throw uncaught exceptions when outside the call to [TestScope.runTest]:
* the only guarantee in this case is the best effort to deliver the exception.
*
* The usual way to access a [TestScope] is to call [runTest], but it can also be constructed manually, in order to
* use it to initialize the components that participate in the test.
*
* #### Differences from the deprecated [TestCoroutineScope]
*
* - This doesn't provide an equivalent of [TestCoroutineScope.cleanupTestCoroutines], and so can't be used as a
* standalone mechanism for writing tests: it does require that [runTest] is eventually called.
* The reason for this is that a proper cleanup procedure that supports using non-test dispatchers and arbitrary
* coroutine suspensions would be equivalent to [runTest], but would also be more error-prone, due to the potential
* for forgetting to perform the cleanup.
* - [TestCoroutineScope.advanceTimeBy] also calls [TestCoroutineScheduler.runCurrent] after advancing the virtual time.
* - No support for dispatcher pausing, like [DelayController] allows. [TestCoroutineDispatcher], which supported
* pausing, is deprecated; now, instead of pausing a dispatcher, one can use [withContext] to run a dispatcher that's
* paused by default, like [StandardTestDispatcher].
* - No access to the list of unhandled exceptions.
*/
public sealed interface TestScope : CoroutineScope {
// ...
}-
runTest()함수는TestScope객체를 사용해 코루틴을 실행시키고 그 코루틴 내부에서 일시 중단 함수가 실행되더라도 가상 시간을 자동으로 흐르게 해 곧바로 실행 완료될 수 있도록 하는 코루틴 빌더 함수이다. - 즉,
advanceUntilIdle을 호출하지 않더라도 가상 시간이 흐른다. -
runTest()함수는 테스트 전체를 감싸는 방식으로 자주 사용된다. -
runTest()함수는runTest()함수로 생성된 코루틴의 시간만 흐르게 만든다.runTest()함수를 호출해 생성된TestScope을 사용해 새로운 코루틴이 실행된다면 이 코루틴은 자동으로 시간이 흐르지 않게 된다. 이런 경우advanceUntilIdle()함수를 명시적으로 호출해줘야 한다.
@OptIn(ExperimentalCoroutinesApi::class)
class CoroutineRunTest {
@Test
fun `runTest 사용하기`() = runTest {
// Given
var result = 0
// When: runTest 내부에서는 delay를 자동으로 건너뜁니다.
// 별도의 스케줄러 설정이나 advanceTimeBy 호출 없이도
// 20초가 지난 후의 상태를 즉시 확인할 수 있습니다.
delay(10_000L) // 10초 대기
result = 1
delay(10_000L) // 10초 대기
result = 2
// Then
assertEquals(2, result)
}
}@OptIn(ExperimentalCoroutinesApi::class)
class CoroutineAdvanceTest {
@Test
fun `runTest 내부에서 advanceUntilIdle 사용하기`() = runTest {
var result = 0
// 별도의 코루틴을 시작 (runTest는 이 안의 코드가 끝날 때까지 기다리지 않음)
launch {
delay(1000L) // 1초 대기
result = 1
}
// 1. 아직 자식 코루틴이 수행되지 않음
println("가상 시간: ${this.currentTime}ms, result = $result")
// 2. 자식 코루틴이 완료될 때까지 가상 시간을 이동
advanceUntilIdle()
// 3. 자식 코루틴이 모두 완료됨
println("가상 시간: ${this.currentTime}ms, result = $result")
}
}- 일시 중단 함수 내부에서 새로운 코루틴을 생성하는 경우는 테스트가 쉽지만, 일시 중단 함수가 아닌 일반 함수 내부에서 새로운 코루틴을 실행하는 경우도 있다.
- 이런 경우
StringStateHolder내부의CoroutineScope객체는 별도의 루트Job객체를 가져runTest로 실행되는 코루틴과 구조화가 되지 않고,Dispatchers.IO를 사용해 코루틴을 실행하기 때문에 실제 시간 위에서 실행된다. -
StringStateHolder가CoroutineDispatcher을 주입받도록 구현을 변경해 해결할 수 있다.
class StringStateHolder(
// 테스트 가능하도록 디스패처를 주입받음 (기본값은 Dispatchers.IO)
private val dispatcher: CoroutineDispatcher = Dispatchers.IO
) {
private val coroutineScope = CoroutineScope(dispatcher)
var stringState = ""
private set
fun updateStringWithDelay(string: String) {
coroutineScope.launch {
delay(1000L)
stringState = string
}
}
}
@OptIn(ExperimentalCoroutinesApi::class)
class StringStateHolderTestSuccess {
@Test
fun `updateStringWithDelay(ABC)가 호출되면 문자열이 ABC로 변경된다`() {
// Given: 테스트용 디스패처 생성 및 주입
val testDispatcher = StandardTestDispatcher()
val stringStateHolder = StringStateHolder(dispatcher = testDispatcher)
// When: 비동기 메서드 호출
stringStateHolder.updateStringWithDelay("ABC")
// Then: 가상 시간을 끝까지 전진시킨 후 결과 검증
testDispatcher.scheduler.advanceUntilIdle()
assertEquals("ABC", stringStateHolder.stringState)
}
}-
runTest를 호출해 실행되는 코루틴은 호출 쓰레드를 블로킹하며, 내부의 모든 코루틴이 실행 완료될 때까지 종료되지 않도록 한다. -
runTest코루틴 내부에서 새롭게launch()함수가 호출된 다음, 이launch()코루틴 내부에서 while문과 같이 무한히 실행되는 작업이 실행되면runTest코루틴은 끝나지 않고 계속해서 실행되기 때문에 테스트가 실패한다. -
runTest람다식의 수신 객체인TestScope은 BackGroundScope를 제공한다. - BackGroundScope은
runTest모든 코드가 실행되면 자동으로 취소되고 이를 통해 테스트가 무한히 실행되는 것을 방지할 수 있다.
@OptIn(ExperimentalCoroutinesApi::class)
class CoroutineTimeoutTest {
@Test
fun `backgroundScope를 사용하여 타임아웃 해결하기`() = runTest {
var result = 0
// runTest가 제공하는 backgroundScope에서 launch를 실행합니다.
// 이 코루틴은 테스트가 끝날 때 자동으로 cancel되므로 무한 루프여도 안전합니다.
backgroundScope.launch {
while (true) {
delay(1000L)
result += 1
}
}
// 1. 가상 시간을 1.5초(1500ms) 전진 -> result가 1이 됨 (성공)
advanceTimeBy(1500L)
assertEquals(1, result)
// 2. 가상 시간을 추가로 1초(1000ms) 전진 -> result가 2가 됨 (성공)
advanceTimeBy(1000L)
assertEquals(2, result)
// 테스트 본문이 여기서 끝나면, runTest가 backgroundScope에 있던
// 무한 루프 코루틴을 알아서 취소시키며 테스트가 정상적으로 '성공' 종료됩니다.
}
}