Testing side effects of the Presenter

[jpetitto]

I'm having trouble determining how I might test side effects of the presenter. Using the project sample as an example:

@Composable
fun CounterPresenter(
  events: Flow<CounterEvent>,
  randomService: RandomService,
): CounterModel {
  var count by remember { mutableStateOf(0) }
  var loading by remember { mutableStateOf(false) }

  LaunchedEffect(Unit) {
    events.collect { event ->
      when (event) {
        is Change -> {
          count += event.delta
        }
        Randomize -> {
          loading = true
          launch {
            count = randomService.get(-20, 20)
            loading = false
          }
        }
        SideEffect -> {
          // does not cause recomposition since there are no changes to the model
          randomService.sideEffect()
        }
      }
    }
  }

  return CounterModel(count, loading)
}

Since there is no recomposition when emitting a SideEffect event, I can't assert that the service was actually invoked (FYI, I'm using mockk in my tests for this):

  @Test fun sideEffect() {
    val events = MutableSharedFlow<CounterEvent>()
    testMolecule({
      CounterPresenter(events, randomService)
    }) {
      assertEquals(CounterModel(0, false), awaitItem())
      events.emit(SideEffect)
      verify { randomService.sideEffect() } // assertion fails
    }
  }

If the presenter were to also update the CounterModel in some way when receiving a SideEffect event, then the above test would pass.

Is there a way to test such scenarios? Or am I approaching the test and/or the presenter wrong?

[mattprecious]

This seems like more of a coroutine testing issue and not something specific to molecule. By calling events.emit(SideEffect) and the immediately calling verify { randomService.sideEffect() }, you haven't given the events collection coroutine the opportunity to run before the assertion. I suspect if you add a yield() or two before the verify it will pass.

The way we handle this is to use channels which allows the test to suspend and wait for the event handler to execute. Not sure how to hook this up using mockk, but this is roughly what our code would look like:

class TestRandomService : RandomService {
  val sideEffects = Channel<Unit>(capacity = UNLIMITED)

  override fun sideEffect() {
    sideEffect.trySend(Unit)
  }
}

And then your test would be updated to something like:

  @Test fun sideEffect() {
    val events = MutableSharedFlow<CounterEvent>()
    val service = TestRandomService()

    testMolecule({
      CounterPresenter(events, service)
    }) {
      assertEquals(CounterModel(0, false), awaitItem())
      events.emit(SideEffect)

      withTimeout(1.seconds) {
        service.sideEffects.receive()
      }
    }
  }