Тестирование Flow: когда хватает toList, а когда нужен Turbine

Тест на поток написан, запущен — и висит. Через десять секунд падает:

kotlinx.coroutines.test.UncompletedCoroutinesError:
After waiting for 10s, the test coroutine is not completing

Код при этом совершенно безобидный:

@Test
fun `тикер считает`() = runTest {
    var count = 0
    tickerFlow().collect { count++ }     // поток бесконечный
    assertEquals(3, count)
}

Проблема не в тесте, а в том, что collect ждёт завершения потока. Бесконечный поток не завершится никогда, и runTest, подождав положенное, объявляет тест незавершённым.

Когда хватает toList

Если поток конечный и нужен весь результат целиком — ничего специального не требуется. toList() запускает сбор, складывает значения в список, список сравнивается с эталоном:

@Test
fun `поток отдаёт три числа`() = runTest {
    val result = numbersFlow().toList()
    assertEquals(listOf(1, 2, 3), result)
}

Не тащите в проект библиотеку, пока хватает одной функции.

toList() бессилен ровно в двух случаях. Первый — поток бесконечный, и мы его только что видели. Второй — важно не только что пришло, но и когда: toList() сваливает всё в список, никакой информации о времени не сохраняя.

Turbine

testImplementation "app.cash.turbine:turbine:1.2.1"

Библиотека добавляет любому Flow метод-расширение test { }. Внутри блока доступны четыре основные функции:

  • awaitItem() — дождаться следующего значения и вернуть его;
  • expectNoEvents() — проверить, что с прошлой проверки ничего не приходило;
  • awaitComplete() — проверить, что конечный поток завершился штатно;
  • cancelAndIgnoreRemainingEvents() — закончить наблюдение, не разбирая остаток.

Последняя для бесконечных потоков обязательна. StateFlow и SharedFlow сами никогда не завершаются, и без явной отмены Turbine сочтёт это ошибкой теста.

Тот же тикер, но проверяем первые три значения:

@Test
fun `тикер эмиттит числа по порядку`() = runTest {
    tickerFlow().test {
        assertEquals(0, awaitItem())
        assertEquals(1, awaitItem())
        assertEquals(2, awaitItem())
        cancelAndIgnoreRemainingEvents()
    }
}

awaitItem() забирает значения по одному, в порядке поступления — ровно так, как это делал бы настоящий подписчик. В студии напротив каждого вызова появится значок точки приостановки: функция приостанавливается, пока ждёт.

Где Turbine незаменим: проверка времени

Вот задача, которую toList() не решает в принципе. Поток отдаёт то, что печатает пользователь, а оператор debounce(300) должен пропустить дальше только последнее значение — и только когда ввод затих на 300 мс.

@Test
fun `debounce пропускает промежуточные значения`() = runTest {
    val searchQuery = MutableSharedFlow<String>()

    searchQuery.debounce(300).test {
        searchQuery.emit("к")       // t = 0
        advanceTimeBy(50)
        searchQuery.emit("ко")      // t = 50
        advanceTimeBy(50)
        searchQuery.emit("кот")     // t = 100
        advanceTimeBy(200)
        expectNoEvents()            // t = 300, тишина ещё не набралась
        advanceTimeBy(200)
        assertEquals("кот", awaitItem())
        cancelAndIgnoreRemainingEvents()
    }
}

Мы двигаем виртуальное время руками и проверяем два утверждения: до истечения паузы наружу не ушло ничего, а после — ушло именно последнее значение. Каждый новый ввод сбрасывал таймер, поэтому «к» и «ко» не дожили.

Горячие потоки: кто опоздал, тот потерял

У SharedFlow нет памяти по умолчанию. Значение, отправленное до того, как появился подписчик, исчезает бесследно:

val flow = MutableSharedFlow<Int>()
flow.emit(1)          // никто не слушает — значение потеряно
flow.test {
    flow.emit(2)
    assertEquals(2, awaitItem())
}

У StateFlow проще: он всегда хранит текущее значение и отдаёт его новому подписчику немедленно. Одно последнее значение спасти можно всегда.

А если нужно проверить именно его — Turbine часто и не нужен:

val flow = MutableStateFlow(0)
flow.value = 42
assertEquals(42, flow.value)

Документация прямо рекомендует проверять .value: StateFlow ведёт себя так, будто к нему применён conflate(), и промежуточные значения непредсказуемы — закладываться на них не стоит.

Если же от SharedFlow нужно поймать несколько значений, отправленных до подписки, выход один: заранее задать replay и знать, на сколько значений вы планируете опоздать.

Правило выбора

Поток конечный и интересует результат целиком — toList(). Нужна временная шкала, проверка пауз, порядка эмитов или поведение бесконечного потока — Turbine.

Тестирование корутин и потоков — часть руководства по корутинам.