Kotlin Flow unit testing exceptions and job with FlowOn with different Dispatchers

Using the code below to test exceptions with Flow and MockK

@Test fun given network error returned from repos, should throw exception() = testCoroutineScope.runBlockingTest {

    // GIVEN
    every { postRemoteRepository.getPostFlow() } returns flow<List<PostDTO>> {
        emit(throw Exception("Network Exception"))
    }

    // WHEN
    var expected: Exception? = null
    useCase.getPostFlow()
        .catch { throwable: Throwable ->
            expected = throwable as Exception
            println("⏰ Expected: $expected")
        }
        .launchIn(testCoroutineScope)

    // THEN
    println("⏰ TEST THEN")

    Truth.assertThat(expected).isNotNull()
    Truth.assertThat(expected).isInstanceOf(Exception::class.java)
    Truth.assertThat(expected?.message).isEqualTo("Network Exception")
}

And prints

⏰ TEST THEN
⏰ Expected: java.lang.Exception: Network Exception

And the test fails with

expected not to be: null

Method i test is

fun getPostFlow(): Flow<List<Post>> {
    return postRemoteRepository.getPostFlow()

            //  This method is just to show flowOn below changes current thread
        .map {
            // Runs in IO Thread DefaultDispatcher-worker-2
            println("⏰ PostsUseCase map() FIRST thread: ${Thread.currentThread().name}")
           it
        }
        .flowOn(Dispatchers.IO)
        .map {
            // Runs in Default Thread DefaultDispatcher-worker-1
            println("⏰ PostsUseCase map() thread: ${Thread.currentThread().name}")
            mapper.map(it)
        }
        // This is a upstream operator, does not leak downstream
        .flowOn(Dispatchers.Default)

}

This is not a completely practical function but just to check how Dispatchers work with Flow and tests.

At the time of writing the question i commented out .flowOn(Dispatchers.IO), the one on top the test passed. Also changing Dispatchers.IO to Dispatchers.Default and caused test to pass. I assume it's due to using different threads.

1- Is there a function or way to set all flowOn methods to same thread without modifying the code?

I tried testing success scenario this time with

    @Test
    fun `given data returned from api, should have data`() = testCoroutineScope.runBlockingTest {

        // GIVEN
        coEvery { postRemoteRepository.getPostFlow() } returns flow { emit(postDTOs) }
        every { dtoToPostMapper.map(postDTOs) } returns postList

        val actual = postList

        // WHEN
        val expected = mutableListOf<Post>()
//        useCase.getPostFlow().collect {postList->
//            println("⏰ Collect: ${postList.size}")
//
//            expected.addAll(postList)
//        }

        val job = useCase.getPostFlow()
            .onEach { postList ->
                println("⏰ Collect: ${postList.size}")

                expected.addAll(postList)
            }
            .launchIn(testCoroutineScope)

        job.cancel()

        // THEN
        println("⏰ TEST THEN")
        Truth.assertThat(expected).containsExactlyElementsIn(actual)
    }

When i tried to snippet that is commented out, test fails with

java.lang.IllegalStateException: This job has not completed yet

It seems that test could pass if job has been canceled, the one with launchIn that returns job passes.

2- Why with collect job is not canceled, and it only happens when the first flowOn uses Dispatchers.IO?