Hi All, Im writing some test code and I seem to b...

# coroutines

[Sean Keane]

Hi All,

Im writing some test code and I seem to be having issues with Coroutines. I want to make a request to Login but it calls the function and kicks it off on a new Coroutine. This causes the test to continue and hit the verify BEFORE the request is made. Im working in Multiplatform and using Coroutine testing tools in Android as a target for the tests. This is my test:

class KAuthenticationServiceTest {

    var loginRequest = service.auth.login.build("<mailto:[e-mail]|[e-mail]>", "fakePassword")

    var mockStorage = MockStorage()
    var mockCredentialsManager = MockCredentialsManager()
    var mockNetworkManager = MockNetworkManager()
    lateinit var authService: AuthService

    @BeforeTest
    fun setup() {
        authService = KAuthenticationService(
            storage = mockStorage,
            credentialsManager = mockCredentialsManager,
            networkManager = mockNetworkManager
        )
    }

    /**
     * Given:   A user requests to login
     * When:    The call is made to the login interactor
     * Then:    The request is executed successfully
     */
    @Test
    fun callIsMadeToLoginInteractorToExecuteRequest() = runTest {
        authService.login(loginRequest, {}, {})
        assertTrue {
            mockNetworkManager.requestValue == loginRequest
        }
    }
}

The run test function in Android is the following:

val mainThreadSurrogate = newSingleThreadContext("UI thread")

actual fun <T> runTest(block: suspend () -> T) {
    Dispatchers.setMain(mainThreadSurrogate)
    runBlockingTest {  block() }
}

Im a bit lost as to how I can get the runBlocking to run the authService.login on the same thread so it blocks until executed and then continues to the assert? Has anyone got any suggestions?

[Luis Munoz]

how does authService.login look

[Luis Munoz]

should probably be suspend fun login()

[Luis Munoz]

sounds like you are doing a launch inside of it and it passes right through it

[Sean Keane]

This is my interactor:

internal class LoginInteractor(
    private val loginRequest: LoginRequest,
    private val onSuccess: (Unit) -> Unit,
    private val onError: (KarhooError) -> Unit,
    context: CoroutineContext = Dispatchers.Main,
    private val credentialsManager: CredentialsManager,
    private val networkManager: NetworkManager
) :
    BaseCallInteractor<Credentials>(
        requestRequiresToken = false,
        context = context,
        credentialsManager = credentialsManager,
        onError = onError
    ) {

    override suspend fun makeRequest() {
        networkManager.request(loginRequest).fold(onError, ::onSuccess)
    }

    private fun onSuccess(credentials: Credentials) {
        credentialsManager.saveCredentials(credentials)
        onSuccess.invoke(Unit)
    }

}

[Sean Keane]

It has a base class of this so far.

internal abstract class BaseCallInteractor<RESPONSE> protected constructor(private val requestRequiresToken: Boolean,
                                                                           private val credentialsManager: CredentialsManager,
                                                                           private val onError: (KError) -> Unit,
                                                                           private val context: CoroutineContext,
) {

    internal abstract suspend fun makeRequest()

    fun execute() {
        GlobalScope.launch(context) {
            // TODO CHECK IF TOKEN IS EXPIRED
            if (shouldRefreshToken()) {

            } else {
                makeRequest()
            }
        }
    }

    private fun shouldRefreshToken(): Boolean {
        //requestRequiresToken && !credentialsManager.isValidToken
        return false
    }

    private suspend fun successfulCredentials(credentials: Credentials) {
        credentialsManager.saveCredentials(credentials)
        makeRequest()
    }

}

[Luis Munoz]

Sorry I don't understand your code. Looks like you using callbacks but when you use coroutines it should look sequential, so you wouldn't have callbacks. It should be something like this:

[Luis Munoz]

override suspend fun makeRequest(loginRequest: LoginRequest) {
val result = networkManager.request(loginRequest)

if(result == sucess) {
onSuccess
} else {
onError
}

}

[Luis Munoz]

a callback passes right through the call and calls a function when it completes

[Luis Munoz]

a coroutine suspends until the callback is called

[Luis Munoz]

so the flow looks sequential

[Sean Keane]

Yep, Its part of a lib im building that the user passes in the Request and the onSuccess lambda and onError lambda. I think your right. Ill give it a go tomorrow. I know it works currently so I just need to make it more testable. This is a POC before we roll it out so I need to lock down a pattern before we shift our SDKs to KMP