adding direct login error path tests

vector/src/test/java/im/vector/app/features/onboarding/DirectLoginUseCaseTest.kt

@@ -16,12 +16,15 @@
 
 package im.vector.app.features.onboarding
 
+import im.vector.app.R
 import im.vector.app.test.fakes.FakeAuthenticationService
 import im.vector.app.test.fakes.FakeSession
 import im.vector.app.test.fakes.FakeStringProvider
 import im.vector.app.test.fakes.FakeUri
 import im.vector.app.test.fakes.FakeUriFactory
+import im.vector.app.test.fakes.toTestString
 import kotlinx.coroutines.test.runTest
+import org.amshove.kluent.should
 import org.amshove.kluent.shouldBeEqualTo
 import org.junit.Test
 import org.matrix.android.sdk.api.MatrixPatterns.getDomain
@@ -32,12 +35,14 @@ import org.matrix.android.sdk.api.auth.wellknown.WellknownResult
 private val A_LOGIN_OR_REGISTER_ACTION = OnboardingAction.LoginOrRegister("@a-user:id.org", "a-password", "a-device-name")
 private val A_WELLKNOWN_SUCCESS_RESULT = WellknownResult.Prompt("https://homeserverurl.com", identityServerUrl = null, WellKnown())
 private val A_WELLKNOWN_FAILED_WITH_CONTENT_RESULT = WellknownResult.FailPrompt("https://homeserverurl.com", WellKnown())
+private val A_WELLKNOWN_FAILED_WITHOUT_CONTENT_RESULT = WellknownResult.FailPrompt(null, null)
 private val NO_HOMESERVER_CONFIG: HomeServerConnectionConfig? = null
 private val A_FALLBACK_CONFIG: HomeServerConnectionConfig = HomeServerConnectionConfig(
         homeServerUri = FakeUri("https://${A_LOGIN_OR_REGISTER_ACTION.username.getDomain()}").instance,
         homeServerUriBase = FakeUri(A_WELLKNOWN_SUCCESS_RESULT.homeServerUrl).instance,
         identityServerUri = null
 )
+private val AN_ERROR = RuntimeException()
 
 class DirectLoginUseCaseTest {
 
@@ -59,7 +64,7 @@ class DirectLoginUseCaseTest {
     }
 
     @Test
-    fun `given wellknown fails but has content, when logging in directly, then returns success with direct session result`() = runTest {
+    fun `given wellknown fails with content, when logging in directly, then returns success with direct session result`() = runTest {
         fakeAuthenticationService.givenWellKnown(A_LOGIN_OR_REGISTER_ACTION.username, config = NO_HOMESERVER_CONFIG, result = A_WELLKNOWN_FAILED_WITH_CONTENT_RESULT)
         val (username, password, initialDeviceName) = A_LOGIN_OR_REGISTER_ACTION
         fakeAuthenticationService.givenDirectAuthentication(A_FALLBACK_CONFIG, username, password, initialDeviceName, result = fakeSession)
@@ -68,4 +73,37 @@ class DirectLoginUseCaseTest {
 
         result shouldBeEqualTo Result.success(fakeSession)
     }
+
+    @Test
+    fun `given wellknown fails without content, when logging in directly, then returns well known error`() = runTest {
+        fakeAuthenticationService.givenWellKnown(A_LOGIN_OR_REGISTER_ACTION.username, config = NO_HOMESERVER_CONFIG, result = A_WELLKNOWN_FAILED_WITHOUT_CONTENT_RESULT)
+        val (username, password, initialDeviceName) = A_LOGIN_OR_REGISTER_ACTION
+        fakeAuthenticationService.givenDirectAuthentication(A_FALLBACK_CONFIG, username, password, initialDeviceName, result = fakeSession)
+
+        val result = useCase.execute(A_LOGIN_OR_REGISTER_ACTION, homeServerConnectionConfig = NO_HOMESERVER_CONFIG)
+
+        result should { this.isFailure }
+        result should { this.exceptionOrNull() is Exception }
+        result should { this.exceptionOrNull()?.message == R.string.autodiscover_well_known_error.toTestString() }
+    }
+
+    @Test
+    fun `given wellknown throws, when logging in directly, then returns failure result with original cause`() = runTest {
+        fakeAuthenticationService.givenWellKnownThrows(A_LOGIN_OR_REGISTER_ACTION.username, config = NO_HOMESERVER_CONFIG, cause = AN_ERROR)
+
+        val result = useCase.execute(A_LOGIN_OR_REGISTER_ACTION, homeServerConnectionConfig = NO_HOMESERVER_CONFIG)
+
+        result shouldBeEqualTo Result.failure(AN_ERROR)
+    }
+
+    @Test
+    fun `given direct authentication throws, when logging in directly, then returns failure result with original cause`() = runTest {
+        fakeAuthenticationService.givenWellKnown(A_LOGIN_OR_REGISTER_ACTION.username, config = NO_HOMESERVER_CONFIG, result = A_WELLKNOWN_SUCCESS_RESULT)
+        val (username, password, initialDeviceName) = A_LOGIN_OR_REGISTER_ACTION
+        fakeAuthenticationService.givenDirectAuthenticationThrows(A_FALLBACK_CONFIG, username, password, initialDeviceName, cause = AN_ERROR)
+
+        val result = useCase.execute(A_LOGIN_OR_REGISTER_ACTION, homeServerConnectionConfig = NO_HOMESERVER_CONFIG)
+
+        result shouldBeEqualTo Result.failure(AN_ERROR)
+    }
 }

vector/src/test/java/im/vector/app/features/onboarding/OnboardingViewModelTest.kt

@@ -138,6 +138,26 @@ class OnboardingViewModelTest {
                 .finish()
     }
 
+    @Test
+    fun `given has sign in with matrix id sign mode, when handling login or register action fails, then emits error`() = runTest {
+        val initialState = initialState.copy(signMode = SignMode.SignInWithMatrixId)
+        viewModel = createViewModel(initialState)
+        fakeDirectLoginUseCase.givenFailureResult(A_LOGIN_OR_REGISTER_ACTION, config = null, cause = AN_ERROR)
+        givenInitialisesSession(fakeSession)
+        val test = viewModel.test()
+
+        viewModel.handle(A_LOGIN_OR_REGISTER_ACTION)
+
+        test
+                .assertStatesChanges(
+                        initialState,
+                        { copy(isLoading = true) },
+                        { copy(isLoading = false) }
+                )
+                .assertEvents(OnboardingViewEvents.Failure(AN_ERROR))
+                .finish()
+    }
+
     @Test
     fun `when handling SignUp then sets sign mode to sign up and starts registration`() = runTest {
         givenRegistrationResultFor(RegisterAction.StartRegistration, ANY_CONTINUING_REGISTRATION_RESULT)

vector/src/test/java/im/vector/app/test/fakes/FakeAuthenticationService.kt

@@ -43,7 +43,15 @@ class FakeAuthenticationService : AuthenticationService by mockk() {
         coEvery { getWellKnownData(matrixId, config) } returns result
     }
 
+    fun givenWellKnownThrows(matrixId: String, config: HomeServerConnectionConfig?, cause: Throwable) {
+        coEvery { getWellKnownData(matrixId, config) } throws cause
+    }
+
     fun givenDirectAuthentication(config: HomeServerConnectionConfig, matrixId: String, password: String, deviceName: String, result: FakeSession) {
         coEvery { directAuthentication(config, matrixId, password, deviceName) } returns result
     }
+
+    fun givenDirectAuthenticationThrows(config: HomeServerConnectionConfig, matrixId: String, password: String, deviceName: String, cause: Throwable) {
+        coEvery { directAuthentication(config, matrixId, password, deviceName) } throws  cause
+    }
 }

vector/src/test/java/im/vector/app/test/fakes/FakeDirectLoginUseCase.kt

@@ -28,4 +28,8 @@ class FakeDirectLoginUseCase {
     fun givenSuccessResult(action: OnboardingAction.LoginOrRegister, config: HomeServerConnectionConfig?, result: FakeSession) {
         coEvery { instance.execute(action, config) } returns Result.success(result)
     }
+
+    fun givenFailureResult(action: OnboardingAction.LoginOrRegister, config: HomeServerConnectionConfig?, cause: Throwable) {
+        coEvery { instance.execute(action, config) } returns Result.failure(cause)
+    }
 }

vector/src/test/java/im/vector/app/test/fakes/FakeStringProvider.kt

@@ -30,3 +30,5 @@ class FakeStringProvider {
         }
     }
 }
+
+fun Int.toTestString() = "test-$this"