blocking corountine scope

Hi in order to simplify unit testing I am trying to get changable context of the Corountene context like below (I am able to change context from test method) object MyGlobalContext : CoroutineScope { var context : CoroutineContext = Dispatchers.Default override val coroutineContext: CoroutineContext get() = context } Hovewer I am wondering weather it is possible to make averything created on the MyGlobalContext (like MyGlobalContext.launch; MyGlobalContext.actor etc) to run as runBlocking in order to make the methods synchronous for test purposes?

[wyaeld]

Here are 2 examples below that show you what you can do, hopefully that helps.

The issue you are seeing is that your assertEquals is not going to wait for the coroutine to have completed. Also you can problems for yourself modifying state outside a coroutine unless you are using the correct patterns to do so.

    @Test
    fun `corountine scope dispatcher unconfined 1`() {

        var context: CoroutineContext = Dispatchers.Unconfined
        val scope = CoroutineScope(context)
        var x = 0


        var job = scope.launch {
            delay(100);
            x++
        }

        runBlocking {
            withTimeout(200) {
                job.join()
                assertThat(x).isEqualTo(1)
            }
        }
    }

    @Test
    fun `corountine scope dispatcher unconfined 2`(){
        var context : CoroutineContext = Dispatchers.Unconfined
        val scope = CoroutineScope(context)
        val x = 0

        runBlocking {

            var result = scope.async {
                delay(100)
                x+1 }

            withTimeout(200) {
                val returned = result.await()
                assertThat(returned).isEqualTo(1)
            }
        }

    }

[zach-klippenstein]

This is exactly why the concept of a “global scope” is discouraged. If you change your TestClass to inject the dispatcher or context to use via the constructor, like so:

class TestClass(private val context: CoroutineContext) {
  private val scope = CoroutineScope(context)
  var number = 1

  fun addOne() {
    scope.launch { number++ }
  }
}

Then your test can simply inject Dispatchers.Unconfined and you’ll have the behavior you’re looking for:

@Test
fun test1() {
  val cl = TestClass(Dispatchers.Unconfined)
  cl.addOne()
  assertEquals(cl.number, 2)
}