Writing a test that uses coroutines interop?

[plusmobileapps]

Has anybody ever written a test which uses the coroutines interop? I was trying to write one with the following being mocked and the class under test

interface FirebaseAuth {
    val authState: StateFlow<FirebaseAuthState>
}

internal class AuthenticationRepositoryImpl(private val auth: FirebaseAuth) :
    AuthenticationRepository {

    override val authState: Observable<AuthState> =
        auth.authState.asObservable()
            .subscribeOn(ioScheduler)
            .map { state ->
                when (state) {
                    is FirebaseAuthState.Authenticated -> AuthState.Authenticated(
                        state.firebaseUser.toWolfPackUser()
                    )
                    FirebaseAuthState.Unauthenticated -> AuthState.Unauthenticated
                }
            }
}

The following test seems to work on android, but hangs on iOS and struggling to figure out what's causing the test to hang? It looks like the asObservable() is technically launching a coroutine so I thought the runTest { } was maybe needed from the kotlinx-coroutines-test, but then why would this test still pass on Android without it?

internal class AuthenticationRepositoryTest : TestsWithMocks() {

    override fun setUpMocks() = injectMocks(mocker)

    @Mock
    lateinit var firebaseAuth: FirebaseAuth

    private val repository by withMocks { AuthenticationRepositoryImpl(firebaseAuth) }

    @BeforeTest
    fun before() {
        overrideSchedulers(main = { TestScheduler() }, io = { TestScheduler() })
    }

    @Test
    fun authState_IsAuthenticated() {
        val firebaseUser: FirebaseUser =
            fakeFirebaseUser().copy(uid = "some id", email = "some email", displayName = "my name")
        every { firebaseAuth.authState } returns MutableStateFlow(
            FirebaseAuthState.Authenticated(firebaseUser)
        )
        repository.authState
            .test()
            .assertValue(
                AuthState.Authenticated(
                    WolfPackUser(
                        userId = firebaseUser.uid,
                        email = firebaseUser.email,
                        displayName = firebaseUser.displayName
                    )
                )
            )
    }

The test is using MocKmp for generating the mocks in the test by the way which works great when the class under test is all reaktive using a similar approach.

[arkivanov]

Do you use a stable version of coroutines or -native-mt? What is the purpose of subscribeOn(ioScheduler) in this particular case?

[arkivanov]

Thanks for the update! I will try to write such a test, and provide updates here.

[arkivanov]

Btw, if you are using the stable version of the Reaktive's coroutines-interop module, then that's might be the issue. It collects the Flow from runBlocking, and so it hangs. You can try the -nmtc version. Please see the readme section.

[arkivanov]

@plusmobileapps This discussion uncovered an issue in Reaktive under the new Kotlin/Native memory model. It freezes things when changing schedulers, and frozen objects still can't be mutated under the new memory model. In the providedMutableStateFlow gets frozen and then crashes when collected. Filed #658.

[plusmobileapps]

I think it might have been because I was using the stable version and I also had the grade property on for disabling freezing. But that was intended only for libraries that haven't migrated yet and are still freezing.

https://github.com/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md

Thank you for investigating and filing an issue.

[arkivanov]

Wow! Thanks for mentioning the way to disable freezing! In this case we don't need to do any changes in the library, since users may just disable freezing entirely. I will add the information to the readme instead.

Now I can confirm, collecting a Flow via Flow.asObservable() operator hangs, if subscribed on the main thread. This is because the stable version of the coroutines-interop module uses runBlocking internally. Switching to the -nmtc version solves the issue and the test passes.

Here is the test:

class AuthenticationRepositoryTest {

    @BeforeTest
    fun before() {
        overrideSchedulers(main = { TestScheduler() }, io = { TestScheduler() })
    }

    @Test
    fun foo() {
        val stateFlow = MutableStateFlow(FirebaseAuthState(x = 1))
        val auth = TestFirebaseAuth(stateFlow)
        val impl = AuthenticationRepositoryImpl(auth)

        impl.authState.test().assertValue(AuthState(x = 1))
    }
}

class TestFirebaseAuth(
    override val authState: StateFlow<FirebaseAuthState>
) : FirebaseAuth

class FirebaseAuthState(val x: Int)

interface FirebaseAuth {
    val authState: StateFlow<FirebaseAuthState>
}

data class AuthState(val x: Int)

internal class AuthenticationRepositoryImpl(auth: FirebaseAuth) {

    val authState: Observable<AuthState> =
        auth.authState.asObservable()
            .subscribeOn(ioScheduler)
            .map { state -> AuthState(x = state.x) }
}