I'm using molecule for tests and finding that I so...

# squarelibraries

[eygraber]

I'm using molecule for tests and finding that I sometimes have to use delay(1) when causing state changes within a LaunchedEffect so that molecule doesn't skip any state changes:

runTest {
      moleculeFlow(RecompositionMode.Immediate) {
        val state = model.currentState()

        LaunchedEffect(Unit) {
          model.validate("")
          delay(1)
          state.text.edit { append("A") }
        }

        state
      }.test {
        awaitItem().validationResult shouldBe NameValidator.Result.Valid
        awaitItem().validationResult shouldBe NameValidator.Result.Required // without delay(1) this is missed
        awaitItem().validationResult shouldBe NameValidator.Result.Valid
        cancel()
      }
    }

My setup doesn't seem to be the most typical to begin with, but is there something I could change to not need the delay(1)?

[saket]

is this related? https://github.com/cashapp/turbine/issues/204

[eygraber]

Not as far as I know. model.currentState() is backed by a Compose MutableState, and I don't think they do anything like that.

[saket]

right, but isn't your test function testing a state flow?

[saket]

whoops i see you're using moleculeFlow which returns a Flow and not a StateFlow

[kevin.cianfarini]

Just because you're using moleculeFlow doesn't mean that the compose state isn't switching values so quickly that it doesn't have time to recompose for an intermediary state, and thus produce a new emission

[kevin.cianfarini]

The delay here allows other coroutines to run, which in this case is a recomposition that then emits your value

[kevin.cianfarini]

This seems like a very contrived example of your actual test you're writing. If it is, know that you should be coordinating your test dependencies and your system under test.

For example, if the delay is standing in for a network call, it would be better to not allow that function to return until your SUT is ready. We do this by queuing elements into our fake network service only after the test is otherwise ready for the network call to complete

[eygraber]

That is the exact test 😅

[eygraber]

Using yield doesn't work though, which I found weird.

[eygraber]

The model basically looks like

class Model(val validator: NameValidator) {
  private var validationResult = mutableStateOf(NameValidator.Result.Valid)

  @Composable
  fun currentState() = MyState(
    text = rememberTextFieldState(),
    validationResult = validationResult,
  )

  fun validate(text: CharSequence): Boolean {
    validationResult = validator.validate(text)
    return validationResult.isValid
  }
}

[kevin.cianfarini]

When you say "that is exactly the test" do you mean the sample above? Or that you're faking a network request

[eygraber]

The code I posted above is the actual test in my codebase

[eygraber]

Maybe it's something internal in TextFieldState?

[kevin.cianfarini]

I doubt it. Without the delay you're synchronously editing the state's value twice. If I were you I'd model the test like this:

runTest {
      val trigger = Channel<Unit>()
      moleculeFlow(RecompositionMode.Immediate) {
        val state = model.currentState()

        LaunchedEffect(Unit) {
          model.validate("")
          trigger.recieve()
          state.text.edit { append("A") }
        }

        state
      }.test {
        awaitItem().validationResult shouldBe NameValidator.Result.Valid
        trigger.send(Unit)
        awaitItem().validationResult shouldBe NameValidator.Result.Required 
        awaitItem().validationResult shouldBe NameValidator.Result.Valid
        cancel()
      }
    }

This channel coordinates your SUT and your testing code.

[eygraber]

Ok I thought with Immediate it would still pick up all the state changes even synchronously.

[kevin.cianfarini]

Nope. Frame clocks in compose are still implemented with suspending function, so they still need to be dispatched. The immediate frame clock will make its best effort to recompose as soon as a state's value is changed, but there's no guarantee it catches every state change.

[eygraber]

OK so for tests like these coordination is the best way to make sure that all the changes are picked up

[kevin.cianfarini]

Yes.

[kevin.cianfarini]

Typically, I have a fake of some sort that suspends until you enqueue an element in it. Eg.

class MyFakeNetworkService : NetworkService {
  
  private val channel = Channel<Foo>(Channel.Buffered)

  suspend fun getFoo(): Foo = channel.recieve()

  fun enqueueFoo(foo: Foo) = channel.trySend(foo).getOrThrow()
}