delay()

intent

TestCoroutineDispatcher

orbitDispatcher

advanceTimeBy

runBlockingTest

TestCoroutineDispatcher

blocking

override fun orbit(orbitFlow: suspend ContainerContext<STATE, SIDE_EFFECT>.() -> Unit) {
        if (!isolateFlow || dispatched.compareAndSet(0, 1)) {
            if (blocking) {
                runBlocking {
                    orbitFlow(pluginContext)
                }
            } else {
                super.orbit(orbitFlow)
            }
        }
    }

runBlockingTest(myTestCoroutineDispatcherInstance)

runBlockingTest(myTestDispatcher) {
  val action = Random.nextInt()
  val middleware = MyMiddleware().test(initialState)

  middleware.doSomething(action)

  container.assert(initialState) {
    ...
  }

}

class TestCoroutineDispatcherTest {

    private val dispatcher = TestCoroutineDispatcher()

    @Test
    fun `on executor no delay`() = runBlockingTest(dispatcher) {
        Executor(dispatcher).invoke()
    }
}

class Executor(private val dispatcher: CoroutineDispatcher = Dispatchers.Default) {

    suspend operator fun invoke() {
        withContext(dispatcher) {
            delay(10_000)
            println("Yeah")
        }
    }
}

assert

TestCoroutineDispatcher

delay

TestCoroutineDispatcher

TestCoroutineDispatcher

Dispatchers.Unconfined

advanceTimeBy

withContext(Dispatchers.Default

withContext(Dispatchers.Default)

test-dispatcher-overrides

runBlocking

TestContainer

await

StateTestMiddleware().test(initialState = initialState) {
    somethingInBackground(action)
}.assert(initialState) {
    states(
        { copy(count = action) }
    )
}

too fragile and implicit not to make a mistake in the future

runBlockingTest

assert

runBlockingTest under the hood (which I believe a good idea in terms of automagic solution)

Container.orbit

test-overhaul

intent

runBlockingTest

withTimeout

withTimeout

testIntent