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:fakeEmail@mail.com|fakeEmail@mail.com>", "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?

how does authService.login look

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)
    }

}

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:

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