From 05a595b4ebc869d96cae388deb404f7589dcf8a1 Mon Sep 17 00:00:00 2001 From: Priyonto M Rahman Date: Sat, 14 Nov 2026 20:32:06 +0100 Subject: [PATCH 1/2] task: Send email alongside code for auth #1742 --- .../station/dfu/domain/GitHubRepository.kt | 5 +- .../data/response/RuuviNetworkResponse.kt | 5 +- .../station/network/domain/HttpLogging.kt | 22 +++ .../domain/NetworkResponseLocalizer.kt | 14 +- .../network/domain/NetworkSignInInteractor.kt | 23 ++- .../station/network/domain/RuuviNetworkApi.kt | 5 +- .../network/domain/RuuviNetworkInteractor.kt | 6 +- .../network/domain/RuuviNetworkRepository.kt | 13 +- .../ruuvi/station/network/ui/CodeEditView.kt | 6 +- .../station/network/ui/ShareSensorActivity.kt | 4 +- .../station/network/ui/SignInViewModel.kt | 16 ++- app/src/main/res/values-de/strings.xml | 4 + app/src/main/res/values-fi/strings.xml | 4 + app/src/main/res/values-fr/strings.xml | 4 + app/src/main/res/values-pl/strings.xml | 4 + app/src/main/res/values-sv/strings.xml | 4 + app/src/main/res/values/strings.xml | 4 + .../network/data/RuuviNetworkResponseTest.kt | 70 ++++++++++ .../station/network/domain/HttpLoggingTest.kt | 65 +++++++++ .../domain/NetworkResponseLocalizerTest.kt | 131 ++++++++++++++++++ .../domain/NetworkSignInInteractorTest.kt | 111 +++++++++++++++ .../network/domain/RuuviNetworkApiTest.kt | 60 ++++++++ .../domain/RuuviNetworkInteractorTest.kt | 95 +++++++++++++ .../domain/RuuviNetworkRepositoryTest.kt | 78 +++++++++++ .../station/network/ui/SignInViewModelTest.kt | 112 +++++++++++++++ 25 files changed, 828 insertions(+), 37 deletions(-) create mode 100644 app/src/main/java/com/ruuvi/station/network/domain/HttpLogging.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/data/RuuviNetworkResponseTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/HttpLoggingTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/NetworkSignInInteractorTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkApiTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkInteractorTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkRepositoryTest.kt create mode 100644 app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt diff --git a/app/src/main/java/com/ruuvi/station/dfu/domain/GitHubRepository.kt b/app/src/main/java/com/ruuvi/station/dfu/domain/GitHubRepository.kt index ab26e89b8..9f724be77 100644 --- a/app/src/main/java/com/ruuvi/station/dfu/domain/GitHubRepository.kt +++ b/app/src/main/java/com/ruuvi/station/dfu/domain/GitHubRepository.kt @@ -1,6 +1,7 @@ package com.ruuvi.station.dfu.domain import com.ruuvi.station.dfu.data.LatestReleaseResponse +import com.ruuvi.station.network.domain.createHttpLoggingInterceptor import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.withContext import okhttp3.OkHttpClient @@ -13,9 +14,7 @@ class GitHubRepository( private val dispatcher: CoroutineDispatcher ) { - private val interceptor: HttpLoggingInterceptor = HttpLoggingInterceptor().also { - it.level = HttpLoggingInterceptor.Level.BODY - } + private val interceptor: HttpLoggingInterceptor = createHttpLoggingInterceptor() private val client = OkHttpClient.Builder().addInterceptor(interceptor).build() diff --git a/app/src/main/java/com/ruuvi/station/network/data/response/RuuviNetworkResponse.kt b/app/src/main/java/com/ruuvi/station/network/data/response/RuuviNetworkResponse.kt index cfb5ea940..0a105de63 100644 --- a/app/src/main/java/com/ruuvi/station/network/data/response/RuuviNetworkResponse.kt +++ b/app/src/main/java/com/ruuvi/station/network/data/response/RuuviNetworkResponse.kt @@ -1,10 +1,13 @@ package com.ruuvi.station.network.data.response +import com.google.gson.annotations.SerializedName + data class RuuviNetworkResponse ( val result: String, var error: String, val data: T?, - val code: String? + val code: String?, + @SerializedName("sub_code") val subCode: String? = null ) { fun isSuccess() = result == successResult diff --git a/app/src/main/java/com/ruuvi/station/network/domain/HttpLogging.kt b/app/src/main/java/com/ruuvi/station/network/domain/HttpLogging.kt new file mode 100644 index 000000000..c792934d1 --- /dev/null +++ b/app/src/main/java/com/ruuvi/station/network/domain/HttpLogging.kt @@ -0,0 +1,22 @@ +package com.ruuvi.station.network.domain + +import com.ruuvi.station.BuildConfig +import okhttp3.logging.HttpLoggingInterceptor + +private val accessTokenInBody = Regex("\"accessToken\"\\s*:\\s*\"[^\"]*\"") + +/** + * HTTP logging for debug builds only: release builds log nothing. Debug logs hide the session + * token (Authorization header and accessToken in a body) and the sign-in code and e-mail sent in + * the URL. Other body content is logged as it is. + */ +fun createHttpLoggingInterceptor( + debug: Boolean = BuildConfig.DEBUG, + logger: HttpLoggingInterceptor.Logger = HttpLoggingInterceptor.Logger.DEFAULT +): HttpLoggingInterceptor = HttpLoggingInterceptor { message -> + logger.log(message.replace(accessTokenInBody, "\"accessToken\":\"██\"")) +}.also { + it.level = if (debug) HttpLoggingInterceptor.Level.BODY else HttpLoggingInterceptor.Level.NONE + it.redactHeader("Authorization") + it.redactQueryParams("token", "email") +} diff --git a/app/src/main/java/com/ruuvi/station/network/domain/NetworkResponseLocalizer.kt b/app/src/main/java/com/ruuvi/station/network/domain/NetworkResponseLocalizer.kt index 8849ead8f..016e61b52 100644 --- a/app/src/main/java/com/ruuvi/station/network/domain/NetworkResponseLocalizer.kt +++ b/app/src/main/java/com/ruuvi/station/network/domain/NetworkResponseLocalizer.kt @@ -9,7 +9,7 @@ class NetworkResponseLocalizer ( ) { fun localizeResponse(response: RuuviNetworkResponse<*>?) { if (response?.isError() == true) { - response.error = when (response.code) { + response.error = localizeSubCode(response.subCode) ?: when (response.code) { ER_FORBIDDEN -> context.getString(R.string.cloud_er_forbidden) ER_UNAUTHORIZED -> context.getString(R.string.cloud_er_unauthorized) ER_INTERNAL -> context.getString(R.string.cloud_er_internal) @@ -36,6 +36,14 @@ class NetworkResponseLocalizer ( } } + private fun localizeSubCode(subCode: String?): String? = when (subCode) { + ER_SUB_INVALID_CODE -> context.getString(R.string.cloud_er_sub_invalid_code) + ER_SUB_CODE_USED -> context.getString(R.string.cloud_er_sub_code_used) + ER_SUB_CODE_EXPIRED -> context.getString(R.string.cloud_er_sub_code_expired) + ER_SUB_TOO_MANY_ATTEMPTS -> context.getString(R.string.cloud_er_sub_too_many_attempts) + else -> null + } + companion object { const val ER_FORBIDDEN = "ER_FORBIDDEN" const val ER_UNAUTHORIZED = "ER_UNAUTHORIZED" @@ -58,5 +66,9 @@ class NetworkResponseLocalizer ( const val ER_INVALID_MAC_ADDRESS = "ER_INVALID_MAC_ADDRESS" const val ER_SUB_DATA_STORAGE_ERROR = "ER_SUB_DATA_STORAGE_ERROR" const val ER_SUB_NO_USER = "ER_SUB_NO_USER" + const val ER_SUB_INVALID_CODE = "ER_SUB_INVALID_CODE" + const val ER_SUB_CODE_USED = "ER_SUB_CODE_USED" + const val ER_SUB_CODE_EXPIRED = "ER_SUB_CODE_EXPIRED" + const val ER_SUB_TOO_MANY_ATTEMPTS = "ER_SUB_TOO_MANY_ATTEMPTS" } } \ No newline at end of file diff --git a/app/src/main/java/com/ruuvi/station/network/domain/NetworkSignInInteractor.kt b/app/src/main/java/com/ruuvi/station/network/domain/NetworkSignInInteractor.kt index d4ff84702..57abe250b 100644 --- a/app/src/main/java/com/ruuvi/station/network/domain/NetworkSignInInteractor.kt +++ b/app/src/main/java/com/ruuvi/station/network/domain/NetworkSignInInteractor.kt @@ -1,6 +1,8 @@ package com.ruuvi.station.network.domain +import com.ruuvi.station.R import com.ruuvi.station.app.preferences.PreferencesRepository +import com.ruuvi.station.app.ui.UiText import com.ruuvi.station.database.domain.NetworkRequestRepository import com.ruuvi.station.database.domain.SensorSettingsRepository import com.ruuvi.station.database.domain.TagRepository @@ -20,20 +22,17 @@ class NetworkSignInInteractor ( private val pushRegisterInteractor: PushRegisterInteractor, private val preferencesRepository: PreferencesRepository, ) { - fun signIn(token: String, response: (String) -> Unit) { - networkInteractor.verifyUser(token) {response-> - if (response?.isSuccess() == true) { + fun signIn(token: String, email: String, onResult: (UiText?) -> Unit) { + networkInteractor.verifyUser(token, email) { response -> + val error = response?.error + if (response?.isSuccess() == true && response.data != null) { pushRegisterInteractor.checkAndRegisterDeviceToken() + onResult(null) + } else if (error.isNullOrEmpty()) { + onResult(UiText.StringResource(R.string.unknown_error)) + } else { + onResult(UiText.DynamicString(error)) } - - var errorText = "" - // TODO LOCALIZE - if (response == null) { - errorText = "Unknown error" - } else if (!response.error.isNullOrEmpty()) { - errorText = response.error - } - response(errorText) } } diff --git a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkApi.kt b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkApi.kt index 0c5ed476e..f0556565f 100644 --- a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkApi.kt +++ b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkApi.kt @@ -13,7 +13,10 @@ interface RuuviNetworkApi{ @Headers("Content-Type: application/json") @GET("verify") - suspend fun verifyUser(@Query("token") token: String): Response + suspend fun verifyUser( + @Query("token") token: String, + @Query("email") email: String + ): Response @Headers("Content-Type: application/json") @GET("user") diff --git a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkInteractor.kt b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkInteractor.kt index a142d909d..ccf575c1a 100644 --- a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkInteractor.kt +++ b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkInteractor.kt @@ -42,11 +42,11 @@ class RuuviNetworkInteractor ( } } - fun verifyUser(token: String, onResult: (UserVerifyResponse?) -> Unit) { - networkRepository.verifyUser(token) { response -> + fun verifyUser(token: String, email: String, onResult: (UserVerifyResponse?) -> Unit) { + networkRepository.verifyUser(token, email) { response -> networkResponseLocalizer.localizeResponse(response) response?.let { - if (response.error.isNullOrEmpty() && response.data != null) { + if (response.isSuccess() && response.data != null) { tokenRepository.saveTokenInfo( NetworkTokenInfo(response.data.email, response.data.accessToken)) firebaseInteractor.logSignIn() diff --git a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkRepository.kt b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkRepository.kt index 16e53a2be..e033d49ba 100644 --- a/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkRepository.kt +++ b/app/src/main/java/com/ruuvi/station/network/domain/RuuviNetworkRepository.kt @@ -27,16 +27,15 @@ class RuuviNetworkRepository @VisibleForTesting internal constructor( private val dispatcher: CoroutineDispatcher, private val imageInteractor: ImageInteractor, - private val preferencesRepository: PreferencesRepository + private val preferencesRepository: PreferencesRepository, + httpClient: OkHttpClient? = null ) { val ioScope = CoroutineScope(Dispatchers.IO) - private val interceptor: HttpLoggingInterceptor = HttpLoggingInterceptor().also { - it.level = HttpLoggingInterceptor.Level.BODY - } + private val interceptor: HttpLoggingInterceptor = createHttpLoggingInterceptor() - private val client = OkHttpClient + private val client = httpClient ?: OkHttpClient .Builder() .addNetworkInterceptor { chain -> chain.proceed( @@ -91,11 +90,11 @@ class RuuviNetworkRepository } } - fun verifyUser(token: String, onResult: (UserVerifyResponse?) -> Unit) { + fun verifyUser(token: String, email: String, onResult: (UserVerifyResponse?) -> Unit) { ioScope.launch { var result: UserVerifyResponse? try { - val response = retrofitService.verifyUser(token) + val response = retrofitService.verifyUser(token, email) if (response.isSuccessful) { result = response.body() } else { diff --git a/app/src/main/java/com/ruuvi/station/network/ui/CodeEditView.kt b/app/src/main/java/com/ruuvi/station/network/ui/CodeEditView.kt index d4959068a..e6b539ba9 100644 --- a/app/src/main/java/com/ruuvi/station/network/ui/CodeEditView.kt +++ b/app/src/main/java/com/ruuvi/station/network/ui/CodeEditView.kt @@ -74,7 +74,7 @@ class CodeEditView @JvmOverloads binding.code2EditText.text.toString() + binding.code3EditText.text.toString() + binding.code4EditText.text.toString() - Timber.d("processChanges $code") + Timber.d("processChanges ${code.length}") if (code.length == 4) { onCodeEntered?.invoke(code) } @@ -84,12 +84,12 @@ class CodeEditView @JvmOverloads override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {} override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) { - Timber.d("onTextChanged $s $start $before $count") + Timber.d("onTextChanged $start $before $count") if (count > 0 && nextControl != null) nextControl.requestFocus() } override fun afterTextChanged(s: Editable) { - Timber.d("afterTextChanged $s") + Timber.d("afterTextChanged ${s.length}") val input = s.toString().trim().uppercase(Locale.getDefault()) when { diff --git a/app/src/main/java/com/ruuvi/station/network/ui/ShareSensorActivity.kt b/app/src/main/java/com/ruuvi/station/network/ui/ShareSensorActivity.kt index 9a5e38830..b87ec53e8 100644 --- a/app/src/main/java/com/ruuvi/station/network/ui/ShareSensorActivity.kt +++ b/app/src/main/java/com/ruuvi/station/network/ui/ShareSensorActivity.kt @@ -409,7 +409,7 @@ fun SharingWebView( ) { super.onPageStarted(view, url, favicon) evaluateJavascript(script) { - Timber.d("evaluateJavascript $script RESULT $it") + Timber.d("evaluateJavascript RESULT $it") } } @@ -417,7 +417,7 @@ fun SharingWebView( override fun onPageFinished(view: WebView?, url: String?) { super.onPageFinished(view, url) evaluateJavascript(script) { - Timber.d("evaluateJavascript $script RESULT $it") + Timber.d("evaluateJavascript RESULT $it") } } }) diff --git a/app/src/main/java/com/ruuvi/station/network/ui/SignInViewModel.kt b/app/src/main/java/com/ruuvi/station/network/ui/SignInViewModel.kt index 9f0aba0e4..13cfc0781 100644 --- a/app/src/main/java/com/ruuvi/station/network/ui/SignInViewModel.kt +++ b/app/src/main/java/com/ruuvi/station/network/ui/SignInViewModel.kt @@ -44,7 +44,7 @@ class SignInViewModel( } setProgress(true) - _email.value = email + _email.value = email.trim() networkInteractor.registerUser(UserRegisterRequest(email = email.trim())) { if (it == null) { @@ -62,10 +62,18 @@ class SignInViewModel( } fun verifyCode(token: String) { + val email = _email.value + if (email.isBlank()) { + // the address does not survive process death, go back to the e-mail page to ask for it again + viewModelScope.launch { + _uiEvent.emit(UiEvent.NavigateUp) + } + return + } setProgress(true) - networkSignInInteractor.signIn(token) { response -> - if (response.isNullOrEmpty()) { + networkSignInInteractor.signIn(token, email) { error -> + if (error == null) { viewModelScope.launch { var retry = true networkDataSyncInteractor.syncNetworkData() @@ -97,7 +105,7 @@ class SignInViewModel( } } } else { - showError(UiText.DynamicString(response)) + showError(error) setProgress(false) viewModelScope.launch { _tokenProcessed.emit(true) diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 73739ec4b..dff17138e 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -385,6 +385,10 @@ Insgesamt verwendete Freigaben für Ihr Konto: %3$,d/%4$,d Ungültige MAC-Adresse Datenspeicherfehler Kein Benutzer + Dieser Code ist falsch. Bitte überprüfen Sie den Code in Ihrer E-Mail und versuchen Sie es erneut. + Dieser Code wurde bereits verwendet. Fordern Sie einen neuen Code an, um sich anzumelden. + Dieser Code ist abgelaufen. Fordern Sie einen neuen Code an, um sich anzumelden. + Zu viele falsche Codes. Bitte warten Sie 15 Minuten und versuchen Sie es erneut. Experimentelle Funktionen Entwicklereinstellungen Bei normalem Gebrauch ist es nicht erforderlich, den Offset anzupassen.\n\nWenn Sie ein fortgeschrittener Benutzer sind und die werkseitig kalibrierten Sensoren manuell konfigurieren möchten, ist dies möglich.\n\nTipps zur Kalibrierung sind auf ruuvi.com/support verfügbar diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 37167c8f2..cc1008bc1 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -385,6 +385,10 @@ Tilillesi käytetyt jaot yhteensä: %3$,d/%4$,d Virheellinen MAC-osoite Tallennusvirhe Ei käyttäjää + Koodi on väärä. Tarkista sähköpostiisi saamasi koodi ja yritä uudelleen. + Tämä koodi on jo käytetty. Pyydä uusi koodi kirjautuaksesi sisään. + Tämä koodi on vanhentunut. Pyydä uusi koodi kirjautuaksesi sisään. + Liian monta väärää koodia. Odota 15 minuuttia ja yritä uudelleen. Kokeelliset ominaisuudet Kehittäjäasetukset Anturin kalibrointi ei ole tarpeellista normaalissa käytössä.\n\nTämä ominaisuus on tarkoitettu edistyneille käyttäjille.\n\nKalibroinnin lisäohjeet löytyvät osoitteesta ruuvi.com/fi/tuki diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index f46d143f6..1a8b7d575 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -385,6 +385,10 @@ Total des partages utilisés pour votre compte : %3$,d/%4$,d Adresse MAC invalide Erreur d\'enregistrement Pas d\'utilisateur + Ce code est incorrect. Vérifiez le code reçu par e-mail et réessayez. + Ce code a déjà été utilisé. Demandez un nouveau code pour vous connecter. + Ce code a expiré. Demandez un nouveau code pour vous connecter. + Trop de codes incorrects. Veuillez patienter 15 minutes et réessayer. Options avancées Paramètres du développeur En utilisation normale, il n\'est pas nécessaire de calibrer le capteur.\n\nSi vous souhaitez tout de même calibrer calibrer le capteur \n\n les instructions sont trouvables ici ruuvi.com/support diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index c1e8006bb..db6af7916 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -385,6 +385,10 @@ Nieprawidłowy adres MAC Błąd w zapisie danych Brak użytkownika + Ten kod jest nieprawidłowy. Sprawdź kod w wiadomości e-mail i spróbuj ponownie. + Ten kod został już użyty. Poproś o nowy kod, aby się zalogować. + Ten kod wygasł. Poproś o nowy kod, aby się zalogować. + Zbyt wiele nieprawidłowych kodów. Odczekaj 15 minut i spróbuj ponownie. Funkcje eksperymentalne Ustawienia programisty W codziennym użytkowaniu nie jest konieczna regulacja wyrównania.\n\nJeśli jesteś zaawansowanym użytkownikiem i chciałbyś ręcznie skonfigurować fabrycznie skalibrowane czujniki, jest to możliwe.\n\nWskazówki dotyczące kalibracji są dostępne na stronie ruuvi.com/support. diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 2863ce91a..c95d93c53 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -385,6 +385,10 @@ Totalt antal använda delningar för ditt konto: %3$,d/%4$,d Ogiltig MAC-address Datalagringsfel Ingen användare + Koden är felaktig. Kontrollera koden i ditt e-postmeddelande och försök igen. + Den här koden har redan använts. Begär en ny kod för att logga in. + Den här koden har gått ut. Begär en ny kod för att logga in. + För många felaktiga koder. Vänta 15 minuter och försök igen. Experimentella funktioner Utvecklarinställningar Vid normal användning är det inte nödvändigt att kalibrera sensorerna.\n\nOm du är en avancerad användare och vill kalibrera manuellt är det möjligt att göra det.\n\nKalibreringstips finns på ruuvi.com/support diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index a3b999bab..1756b553c 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -385,6 +385,10 @@ Total used shares for your account: %3$,d/%4$,d Invalid MAC address Data storage error No user + That code is incorrect. Check the code in your email and try again. + This code has already been used. Request a new code to sign in. + This code has expired. Request a new code to sign in. + Too many incorrect codes. Please wait 15 minutes and try again. Experimental features Developer settings In normal use, it\'s not necessary to adjust the offset.\n\nIf you\'re an advanced user and you\'d like to manually configure the factory calibrated sensors, it\'s possible to do so.\n\nCalibration tips are available on ruuvi.com/support diff --git a/app/src/test/java/com/ruuvi/station/network/data/RuuviNetworkResponseTest.kt b/app/src/test/java/com/ruuvi/station/network/data/RuuviNetworkResponseTest.kt new file mode 100644 index 000000000..4777bbcc4 --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/data/RuuviNetworkResponseTest.kt @@ -0,0 +1,70 @@ +package com.ruuvi.station.network.data + +import com.google.gson.Gson +import com.google.gson.reflect.TypeToken +import com.ruuvi.station.network.data.response.UserVerifyResponse +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class RuuviNetworkResponseTest { + @Test + fun `sub_code is parsed from an error body`() { + val response = parse( + """{"result":"error","error":"That code is incorrect.","code":"ER_TOKEN_EXPIRED","sub_code":"ER_SUB_INVALID_CODE"}""" + ) + + assertTrue(response.isError()) + assertEquals("ER_TOKEN_EXPIRED", response.code) + assertEquals("ER_SUB_INVALID_CODE", response.subCode) + assertEquals("That code is incorrect.", response.error) + assertNull(response.data) + } + + @Test + fun `error body from an old server has no sub code`() { + val response = parse("""{"result":"error","error":"Token expired.","code":"ER_TOKEN_EXPIRED"}""") + + assertTrue(response.isError()) + assertEquals("ER_TOKEN_EXPIRED", response.code) + assertNull(response.subCode) + } + + @Test + fun `unknown code and sub_code are kept as they are`() { + val response = parse( + """{"result":"error","error":"New error.","code":"ER_SOMETHING_NEW","sub_code":"ER_SUB_SOMETHING_NEW","extra":1}""" + ) + + assertEquals("ER_SOMETHING_NEW", response.code) + assertEquals("ER_SUB_SOMETHING_NEW", response.subCode) + } + + @Test + fun `success body is parsed without a sub code`() { + val response = parse( + """{"result":"success","data":{"email":"user@example.com","accessToken":"token","newUser":false}}""" + ) + + assertTrue(response.isSuccess()) + assertEquals("user@example.com", response.data?.email) + assertEquals("token", response.data?.accessToken) + assertNull(response.subCode) + } + + @Test + fun `body without result is neither a success nor an error`() { + val response = parse("""{"data":{"email":"user@example.com","accessToken":"token","newUser":false}}""") + + assertNotNull(response.data) + assertFalse(response.isSuccess()) + assertFalse(response.isError()) + } + + // same parsing as RuuviNetworkRepository uses for error bodies + private fun parse(json: String): UserVerifyResponse = + Gson().fromJson(json, object : TypeToken() {}.type) +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/HttpLoggingTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/HttpLoggingTest.kt new file mode 100644 index 000000000..a74f5f8cf --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/HttpLoggingTest.kt @@ -0,0 +1,65 @@ +package com.ruuvi.station.network.domain + +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Protocol +import okhttp3.Request +import okhttp3.Response +import okhttp3.ResponseBody.Companion.toResponseBody +import okhttp3.logging.HttpLoggingInterceptor +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import java.util.concurrent.CopyOnWriteArrayList + +class HttpLoggingTest { + private val lines = CopyOnWriteArrayList() + private val logger = HttpLoggingInterceptor.Logger { lines.add(it) } + + // the logging interceptor runs first; the second one answers, so nothing is sent to the network + private fun call(debug: Boolean) { + val client = OkHttpClient.Builder() + .addInterceptor(createHttpLoggingInterceptor(debug, logger)) + .addInterceptor { chain -> + Response.Builder() + .request(chain.request()) + .protocol(Protocol.HTTP_1_1) + .code(200) + .message("OK") + .body(BODY.toResponseBody("application/json".toMediaType())) + .build() + } + .build() + val request = Request.Builder() + .url("https://example.invalid/verify?token=$CODE&email=user%40example.com") + .header("Authorization", "Bearer $SESSION_TOKEN") + .build() + client.newCall(request).execute().close() + } + + @Test + fun `release builds log nothing`() { + call(debug = false) + + assertTrue(lines.isEmpty()) + } + + @Test + fun `debug builds hide the session token and the code and e-mail in the URL`() { + call(debug = true) + + val log = lines.joinToString("\n") + assertTrue(log.contains("/verify?")) + assertTrue(log.contains("\"result\":\"success\"")) + assertFalse(log.contains(SESSION_TOKEN)) + assertFalse(log.contains(CODE)) + assertFalse(log.contains("user%40example.com")) + assertFalse(log.contains("user@example.com")) + } + + private companion object { + const val CODE = "QZ7K" + const val SESSION_TOKEN = "session-token-value" + const val BODY = """{"result":"success","data":{"accessToken": "$SESSION_TOKEN"}}""" + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt new file mode 100644 index 000000000..2725b9b58 --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt @@ -0,0 +1,131 @@ +package com.ruuvi.station.network.domain + +import android.app.Application +import androidx.test.core.app.ApplicationProvider +import com.ruuvi.station.R +import com.ruuvi.station.network.data.response.RuuviNetworkResponse +import com.ruuvi.station.network.data.response.UserVerifyResponse +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35], application = Application::class) +class NetworkResponseLocalizerTest { + private val context: Application = ApplicationProvider.getApplicationContext() + private val localizer = NetworkResponseLocalizer(context) + + @Test + fun `expired token without a sub code keeps the old message`() { + assertEquals( + context.getString(R.string.cloud_er_token_expired), + localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED) + ) + } + + @Test + fun `invalid code sub code has its own message`() { + assertEquals( + context.getString(R.string.cloud_er_sub_invalid_code), + localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED, NetworkResponseLocalizer.ER_SUB_INVALID_CODE) + ) + } + + @Test + fun `used code sub code has its own message`() { + assertEquals( + context.getString(R.string.cloud_er_sub_code_used), + localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED, NetworkResponseLocalizer.ER_SUB_CODE_USED) + ) + } + + @Test + fun `expired code sub code has its own message`() { + assertEquals( + context.getString(R.string.cloud_er_sub_code_expired), + localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED, NetworkResponseLocalizer.ER_SUB_CODE_EXPIRED) + ) + } + + @Test + fun `too many attempts sub code has its own message`() { + assertEquals( + context.getString(R.string.cloud_er_sub_too_many_attempts), + localize(ER_THROTTLED, NetworkResponseLocalizer.ER_SUB_TOO_MANY_ATTEMPTS) + ) + } + + @Test + fun `sub code messages differ from each other and from the old message`() { + val messages = listOf( + R.string.cloud_er_token_expired, + R.string.cloud_er_sub_invalid_code, + R.string.cloud_er_sub_code_used, + R.string.cloud_er_sub_code_expired, + R.string.cloud_er_sub_too_many_attempts, + ).map { context.getString(it) } + + assertEquals(messages.size, messages.toSet().size) + } + + @Test + fun `unknown sub code falls back to the code`() { + assertEquals( + context.getString(R.string.cloud_er_token_expired), + localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED, "ER_SUB_SOMETHING_NEW") + ) + } + + @Test + fun `no user sub code is still resolved from the code`() { + assertEquals( + context.getString(R.string.cloud_er_internal), + localize(NetworkResponseLocalizer.ER_INTERNAL, NetworkResponseLocalizer.ER_SUB_NO_USER) + ) + } + + @Test + fun `throttled without a sub code keeps the server text`() { + assertEquals(SERVER_TEXT, localize(ER_THROTTLED)) + } + + @Test + fun `unknown code keeps the server text`() { + assertEquals(SERVER_TEXT, localize("ER_SOMETHING_NEW", "ER_SUB_SOMETHING_NEW")) + assertEquals(SERVER_TEXT, localize(null)) + } + + @Test + fun `response that is not an error is left untouched`() { + val response = errorResponse( + NetworkResponseLocalizer.ER_TOKEN_EXPIRED, + NetworkResponseLocalizer.ER_SUB_INVALID_CODE + ).copy(result = RuuviNetworkResponse.successResult) + + localizer.localizeResponse(response) + + assertEquals(SERVER_TEXT, response.error) + } + + private fun localize(code: String?, subCode: String? = null): String { + val response = errorResponse(code, subCode) + localizer.localizeResponse(response) + return response.error + } + + private fun errorResponse(code: String?, subCode: String?): UserVerifyResponse = + RuuviNetworkResponse( + result = RuuviNetworkResponse.errorResult, + error = SERVER_TEXT, + data = null, + code = code, + subCode = subCode, + ) + + private companion object { + const val SERVER_TEXT = "Text from the server" + const val ER_THROTTLED = "ER_THROTTLED" + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/NetworkSignInInteractorTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/NetworkSignInInteractorTest.kt new file mode 100644 index 000000000..a28038a0f --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/NetworkSignInInteractorTest.kt @@ -0,0 +1,111 @@ +package com.ruuvi.station.network.domain + +import com.google.gson.Gson +import com.google.gson.reflect.TypeToken +import com.ruuvi.station.R +import com.ruuvi.station.app.ui.UiText +import com.ruuvi.station.firebase.domain.PushRegisterInteractor +import com.ruuvi.station.network.data.response.RuuviNetworkResponse +import com.ruuvi.station.network.data.response.UserVerifyResponse +import com.ruuvi.station.network.data.response.UserVerifyResponseBody +import io.mockk.every +import io.mockk.mockk +import io.mockk.slot +import io.mockk.verify +import org.junit.Assert.assertEquals +import org.junit.Test + +class NetworkSignInInteractorTest { + private val networkInteractor = mockk(relaxed = true) + private val pushRegisterInteractor = mockk(relaxed = true) + private val interactor = NetworkSignInInteractor( + tagRepository = mockk(relaxed = true), + networkInteractor = networkInteractor, + networkDataSyncInteractor = mockk(relaxed = true), + networkTokenRepository = mockk(relaxed = true), + networkRequestRepository = mockk(relaxed = true), + sensorSettingsRepository = mockk(relaxed = true), + pushRegisterInteractor = pushRegisterInteractor, + preferencesRepository = mockk(relaxed = true), + ) + + @Test + fun `successful response with data signs in`() { + assertEquals(listOf(null), signIn(successResponse())) + + verify(exactly = 1) { networkInteractor.verifyUser(CODE, EMAIL, any()) } + verify(exactly = 1) { pushRegisterInteractor.checkAndRegisterDeviceToken() } + } + + @Test + fun `body without result is not a sign in`() { + val response: UserVerifyResponse = Gson().fromJson( + """{"data":{"email":"$EMAIL","accessToken":"token","newUser":false}}""", + object : TypeToken() {}.type + ) + + assertEquals(listOf(UNKNOWN_ERROR), signIn(response)) + + verify(exactly = 0) { pushRegisterInteractor.checkAndRegisterDeviceToken() } + } + + @Test + fun `successful response without data is not a sign in`() { + assertEquals(listOf(UNKNOWN_ERROR), signIn(successResponse().copy(data = null))) + + verify(exactly = 0) { pushRegisterInteractor.checkAndRegisterDeviceToken() } + } + + @Test + fun `missing response shows the unknown error`() { + assertEquals(listOf(UNKNOWN_ERROR), signIn(null)) + + verify(exactly = 0) { pushRegisterInteractor.checkAndRegisterDeviceToken() } + } + + @Test + fun `error without a message shows the unknown error`() { + val response = successResponse().copy(result = RuuviNetworkResponse.errorResult, data = null) + + assertEquals(listOf(UNKNOWN_ERROR), signIn(response)) + } + + @Test + fun `error message is passed on`() { + val response = successResponse().copy( + result = RuuviNetworkResponse.errorResult, + error = "That code is incorrect.", + data = null, + code = NetworkResponseLocalizer.ER_TOKEN_EXPIRED, + subCode = NetworkResponseLocalizer.ER_SUB_INVALID_CODE, + ) + + assertEquals(listOf(UiText.DynamicString("That code is incorrect.")), signIn(response)) + + verify(exactly = 0) { pushRegisterInteractor.checkAndRegisterDeviceToken() } + } + + private fun signIn(response: UserVerifyResponse?): List { + val onResult = slot<(UserVerifyResponse?) -> Unit>() + every { networkInteractor.verifyUser(any(), any(), capture(onResult)) } answers { + onResult.captured(response) + } + val results = mutableListOf() + interactor.signIn(CODE, EMAIL) { results.add(it) } + return results + } + + private fun successResponse(): UserVerifyResponse = + RuuviNetworkResponse( + result = RuuviNetworkResponse.successResult, + error = "", + data = UserVerifyResponseBody(email = EMAIL, accessToken = "token", newUser = false), + code = null, + ) + + private companion object { + const val CODE = "AB12" + const val EMAIL = "user@example.com" + val UNKNOWN_ERROR = UiText.StringResource(R.string.unknown_error) + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkApiTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkApiTest.kt new file mode 100644 index 000000000..3c6cdf36b --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkApiTest.kt @@ -0,0 +1,60 @@ +package com.ruuvi.station.network.domain + +import kotlinx.coroutines.runBlocking +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Protocol +import okhttp3.Request +import okhttp3.Response +import okhttp3.ResponseBody.Companion.toResponseBody +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import retrofit2.Retrofit +import retrofit2.converter.gson.GsonConverterFactory + +class RuuviNetworkApiTest { + private val requests = mutableListOf() + + // answers every request itself, nothing is sent to the network + private val client = OkHttpClient.Builder() + .addInterceptor { chain -> + requests.add(chain.request()) + Response.Builder() + .request(chain.request()) + .protocol(Protocol.HTTP_1_1) + .code(403) + .message("Forbidden") + .body(ERROR_BODY.toResponseBody("application/json".toMediaType())) + .build() + } + .build() + + private val api = Retrofit.Builder() + .baseUrl("https://localhost/") + .addConverterFactory(GsonConverterFactory.create()) + .client(client) + .build() + .create(RuuviNetworkApi::class.java) + + @Test + fun `verifyUser sends the code and the e-mail as query parameters`() { + val response = runBlocking { api.verifyUser("AB12", "first.last+tag@example.com") } + + assertFalse(response.isSuccessful) + val url = requests.single().url + assertEquals("GET", requests.single().method) + assertEquals("/verify", url.encodedPath) + assertEquals(setOf("token", "email"), url.queryParameterNames) + assertEquals("AB12", url.queryParameter("token")) + assertEquals("first.last+tag@example.com", url.queryParameter("email")) + // a bare + would be read as a space by the server + assertTrue(url.encodedQuery.orEmpty().contains("first.last%2Btag")) + } + + private companion object { + const val ERROR_BODY = + """{"result":"error","error":"That code is incorrect.","code":"ER_TOKEN_EXPIRED","sub_code":"ER_SUB_INVALID_CODE"}""" + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkInteractorTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkInteractorTest.kt new file mode 100644 index 000000000..27d5f92ff --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkInteractorTest.kt @@ -0,0 +1,95 @@ +package com.ruuvi.station.network.domain + +import com.google.gson.Gson +import com.google.gson.reflect.TypeToken +import com.ruuvi.station.firebase.domain.FirebaseInteractor +import com.ruuvi.station.network.data.NetworkTokenInfo +import com.ruuvi.station.network.data.response.RuuviNetworkResponse +import com.ruuvi.station.network.data.response.UserVerifyResponse +import com.ruuvi.station.network.data.response.UserVerifyResponseBody +import io.mockk.every +import io.mockk.mockk +import io.mockk.slot +import io.mockk.verify +import org.junit.Assert.assertEquals +import org.junit.Test + +class RuuviNetworkInteractorTest { + private val tokenRepository = mockk(relaxed = true) + private val networkRepository = mockk(relaxed = true) + private val firebaseInteractor = mockk(relaxed = true) + private val networkResponseLocalizer = mockk(relaxed = true) + private val interactor = RuuviNetworkInteractor( + tokenRepository = tokenRepository, + networkRepository = networkRepository, + networkRequestExecutor = mockk(relaxed = true), + sensorSettingsRepository = mockk(relaxed = true), + firebaseInteractor = firebaseInteractor, + networkResponseLocalizer = networkResponseLocalizer, + ) + + @Test + fun `verifyUser sends the code with the e-mail and saves the token on success`() { + val response = successResponse() + + assertEquals(listOf(response), verifyUser(response)) + + verify(exactly = 1) { networkRepository.verifyUser(CODE, EMAIL, any()) } + verify(exactly = 1) { networkResponseLocalizer.localizeResponse(response) } + verify(exactly = 1) { tokenRepository.saveTokenInfo(NetworkTokenInfo(EMAIL, TOKEN)) } + verify(exactly = 1) { firebaseInteractor.logSignIn() } + } + + @Test + fun `verifyUser does not save a token from a body without result`() { + val response: UserVerifyResponse = Gson().fromJson( + """{"data":{"email":"$EMAIL","accessToken":"$TOKEN","newUser":false}}""", + object : TypeToken() {}.type + ) + + assertEquals(listOf(response), verifyUser(response)) + + assertNotSignedIn() + } + + @Test + fun `verifyUser does not save a token from an error response`() { + verifyUser(successResponse().copy(result = RuuviNetworkResponse.errorResult)) + assertNotSignedIn() + + verifyUser(successResponse().copy(data = null)) + assertNotSignedIn() + + assertEquals(listOf(null), verifyUser(null)) + assertNotSignedIn() + } + + private fun assertNotSignedIn() { + verify(exactly = 0) { tokenRepository.saveTokenInfo(any()) } + verify(exactly = 0) { firebaseInteractor.logSignIn() } + } + + private fun verifyUser(response: UserVerifyResponse?): List { + val onResult = slot<(UserVerifyResponse?) -> Unit>() + every { networkRepository.verifyUser(any(), any(), capture(onResult)) } answers { + onResult.captured(response) + } + val results = mutableListOf() + interactor.verifyUser(CODE, EMAIL) { results.add(it) } + return results + } + + private fun successResponse(): UserVerifyResponse = + RuuviNetworkResponse( + result = RuuviNetworkResponse.successResult, + error = "", + data = UserVerifyResponseBody(email = EMAIL, accessToken = TOKEN, newUser = false), + code = null, + ) + + private companion object { + const val CODE = "AB12" + const val EMAIL = "user@example.com" + const val TOKEN = "token" + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkRepositoryTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkRepositoryTest.kt new file mode 100644 index 000000000..3b29b7ffa --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/domain/RuuviNetworkRepositoryTest.kt @@ -0,0 +1,78 @@ +package com.ruuvi.station.network.domain + +import com.ruuvi.station.network.data.response.UserVerifyResponse +import io.mockk.mockk +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.test.UnconfinedTestDispatcher +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.setMain +import kotlinx.coroutines.withTimeout +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Protocol +import okhttp3.Request +import okhttp3.Response +import okhttp3.ResponseBody.Companion.toResponseBody +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import java.util.concurrent.CopyOnWriteArrayList + +@OptIn(ExperimentalCoroutinesApi::class) +class RuuviNetworkRepositoryTest { + private val requests = CopyOnWriteArrayList() + + // answers every request itself, nothing is sent to the network + private val client = OkHttpClient.Builder() + .addInterceptor { chain -> + requests.add(chain.request()) + Response.Builder() + .request(chain.request()) + .protocol(Protocol.HTTP_1_1) + .code(403) + .message("Forbidden") + .body(ERROR_BODY.toResponseBody("application/json".toMediaType())) + .build() + } + .build() + + private val repository = RuuviNetworkRepository( + dispatcher = Dispatchers.IO, + imageInteractor = mockk(relaxed = true), + preferencesRepository = mockk(relaxed = true), + httpClient = client + ) + + @Before + fun setUp() { + Dispatchers.setMain(UnconfinedTestDispatcher()) + } + + @After + fun tearDown() { + Dispatchers.resetMain() + } + + @Test + fun `verifyUser sends the code as token and the address as email`() { + val result = CompletableDeferred() + + repository.verifyUser("AB12", "user@example.com") { result.complete(it) } + val response = runBlocking { withTimeout(TIMEOUT_MS) { result.await() } } + + val url = requests.single().url + assertEquals("/verify", url.encodedPath) + assertEquals("token=AB12&email=user%40example.com", url.encodedQuery) + assertEquals("ER_SUB_INVALID_CODE", response?.subCode) + } + + private companion object { + const val TIMEOUT_MS = 10_000L + const val ERROR_BODY = + """{"result":"error","error":"That code is incorrect.","code":"ER_TOKEN_EXPIRED","sub_code":"ER_SUB_INVALID_CODE"}""" + } +} diff --git a/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt b/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt new file mode 100644 index 000000000..7ef26d18c --- /dev/null +++ b/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt @@ -0,0 +1,112 @@ +package com.ruuvi.station.network.ui + +import com.ruuvi.station.R +import com.ruuvi.station.app.ui.UiEvent +import com.ruuvi.station.app.ui.UiText +import com.ruuvi.station.network.data.request.UserRegisterRequest +import com.ruuvi.station.network.domain.NetworkDataSyncInteractor +import com.ruuvi.station.network.domain.NetworkSignInInteractor +import com.ruuvi.station.network.domain.RuuviNetworkInteractor +import io.mockk.every +import io.mockk.mockk +import io.mockk.slot +import io.mockk.verify +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.toList +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.UnconfinedTestDispatcher +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.runTest +import kotlinx.coroutines.test.setMain +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class SignInViewModelTest { + private val dispatcher = UnconfinedTestDispatcher() + private val networkInteractor = mockk(relaxed = true) + private val networkSignInInteractor = mockk(relaxed = true) + private val networkDataSyncInteractor = mockk(relaxed = true) + private lateinit var viewModel: SignInViewModel + + @Before + fun setUp() { + Dispatchers.setMain(dispatcher) + viewModel = SignInViewModel(networkInteractor, networkSignInInteractor, networkDataSyncInteractor) + } + + @After + fun tearDown() { + Dispatchers.resetMain() + } + + @Test + fun `code is verified with the trimmed e-mail the code was requested for`() = runTest(dispatcher) { + viewModel.submitEmail(" $EMAIL \n") + + assertEquals(EMAIL, viewModel.email.value) + verify(exactly = 1) { networkInteractor.registerUser(UserRegisterRequest(EMAIL), any()) } + + viewModel.verifyCode(CODE) + + verify(exactly = 1) { networkSignInInteractor.signIn(CODE, EMAIL, any()) } + } + + @Test + fun `code is not verified without an e-mail and the user is sent back to the e-mail page`() = runTest(dispatcher) { + val events = collectEvents() + + viewModel.verifyCode(CODE) + + verify(exactly = 0) { networkSignInInteractor.signIn(any(), any(), any()) } + assertEquals(listOf(UiEvent.NavigateUp), events) + } + + @Test + fun `code is not verified with a blank e-mail`() = runTest(dispatcher) { + viewModel.submitEmail(" ") + val events = collectEvents() + + viewModel.verifyCode(CODE) + + verify(exactly = 0) { networkSignInInteractor.signIn(any(), any(), any()) } + assertEquals(listOf(UiEvent.NavigateUp), events) + } + + @Test + fun `failed verification shows the error and clears the code without navigating`() = runTest(dispatcher) { + val error = UiText.StringResource(R.string.cloud_er_sub_code_expired) + val onResult = slot<(UiText?) -> Unit>() + every { networkSignInInteractor.signIn(any(), any(), capture(onResult)) } answers { + onResult.captured(error) + } + viewModel.submitEmail(EMAIL) + val events = collectEvents() + val tokenProcessed = mutableListOf() + backgroundScope.launch(dispatcher) { viewModel.tokenProcessed.toList(tokenProcessed) } + + viewModel.verifyCode(CODE) + + assertEquals(listOf(UiEvent.ShowSnackbar(error)), events.filterIsInstance()) + assertTrue(events.none { it is UiEvent.Navigate || it is UiEvent.NavigateUp || it is UiEvent.Finish }) + assertEquals(UiEvent.Progress(false, null), events.last { it is UiEvent.Progress }) + assertEquals(listOf(true), tokenProcessed) + verify(exactly = 0) { networkDataSyncInteractor.syncNetworkData() } + } + + private fun TestScope.collectEvents(): List { + val events = mutableListOf() + backgroundScope.launch(dispatcher) { viewModel.uiEvent.toList(events) } + return events + } + + private companion object { + const val CODE = "AB12" + const val EMAIL = "user@example.com" + } +} From e005744867645a68a64f40a74626021a3aad88e6 Mon Sep 17 00:00:00 2001 From: Priyonto M Rahman Date: Sat, 14 Nov 2026 21:16:37 +0100 Subject: [PATCH 2/2] fixup! task: Send email alongside code for auth --- .../domain/NetworkResponseLocalizerTest.kt | 33 ++++++++++++++++--- .../station/network/ui/SignInViewModelTest.kt | 30 +++++++++++++++++ 2 files changed, 59 insertions(+), 4 deletions(-) diff --git a/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt b/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt index 2725b9b58..658f8e091 100644 --- a/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt +++ b/app/src/test/java/com/ruuvi/station/network/domain/NetworkResponseLocalizerTest.kt @@ -71,11 +71,36 @@ class NetworkResponseLocalizerTest { } @Test - fun `unknown sub code falls back to the code`() { - assertEquals( - context.getString(R.string.cloud_er_token_expired), - localize(NetworkResponseLocalizer.ER_TOKEN_EXPIRED, "ER_SUB_SOMETHING_NEW") + fun `missing or unknown sub code preserves existing error messages`() { + val messages = listOf( + NetworkResponseLocalizer.ER_FORBIDDEN to R.string.cloud_er_forbidden, + NetworkResponseLocalizer.ER_UNAUTHORIZED to R.string.cloud_er_unauthorized, + NetworkResponseLocalizer.ER_INTERNAL to R.string.cloud_er_internal, + NetworkResponseLocalizer.ER_INVALID_FORMAT to R.string.cloud_er_invalid_format, + NetworkResponseLocalizer.ER_USER_NOT_FOUND to R.string.cloud_er_user_not_found, + NetworkResponseLocalizer.ER_SENSOR_NOT_FOUND to R.string.cloud_er_sensor_not_found, + NetworkResponseLocalizer.ER_TOKEN_EXPIRED to R.string.cloud_er_token_expired, + NetworkResponseLocalizer.ER_SUBSCRIPTION_NOT_FOUND to R.string.cloud_er_subscription_not_found, + NetworkResponseLocalizer.ER_SHARE_COUNT_REACHED to R.string.cloud_er_share_count_reached, + NetworkResponseLocalizer.ER_SENSOR_SHARE_COUNT_REACHED to R.string.cloud_er_sensor_share_count_reached, + NetworkResponseLocalizer.ER_NO_DATA_TO_SHARE to R.string.cloud_er_no_data_to_share, + NetworkResponseLocalizer.ER_SENSOR_ALREADY_SHARED to R.string.cloud_er_sensor_already_shared, + NetworkResponseLocalizer.ER_UNABLE_TO_SEND_EMAIL to R.string.cloud_er_unable_to_send_email, + NetworkResponseLocalizer.ER_MISSING_ARGUMENT to R.string.cloud_er_missing_argument, + NetworkResponseLocalizer.ER_INVALID_DENSITY_MODE to R.string.cloud_er_invalid_density_mode, + NetworkResponseLocalizer.ER_INVALID_SORT_MODE to R.string.cloud_er_invalid_sort_mode, + NetworkResponseLocalizer.ER_INVALID_TIME_RANGE to R.string.cloud_er_invalid_time_range, + NetworkResponseLocalizer.ER_INVALID_EMAIL_ADDRESS to R.string.cloud_er_invalid_email_address, + NetworkResponseLocalizer.ER_INVALID_MAC_ADDRESS to R.string.cloud_er_invalid_mac_address, + NetworkResponseLocalizer.ER_SUB_DATA_STORAGE_ERROR to R.string.cloud_er_sub_data_storage_error, + NetworkResponseLocalizer.ER_SUB_NO_USER to R.string.cloud_er_sub_no_user, ) + + for ((code, message) in messages) { + for (subCode in listOf(null, "ER_SUB_SOMETHING_NEW")) { + assertEquals("code=$code, subCode=$subCode", context.getString(message), localize(code, subCode)) + } + } } @Test diff --git a/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt b/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt index 7ef26d18c..14b8ffb96 100644 --- a/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt +++ b/app/src/test/java/com/ruuvi/station/network/ui/SignInViewModelTest.kt @@ -3,6 +3,7 @@ package com.ruuvi.station.network.ui import com.ruuvi.station.R import com.ruuvi.station.app.ui.UiEvent import com.ruuvi.station.app.ui.UiText +import com.ruuvi.station.network.data.NetworkSyncEvent import com.ruuvi.station.network.data.request.UserRegisterRequest import com.ruuvi.station.network.domain.NetworkDataSyncInteractor import com.ruuvi.station.network.domain.NetworkSignInInteractor @@ -13,6 +14,7 @@ import io.mockk.slot import io.mockk.verify import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.toList import kotlinx.coroutines.launch import kotlinx.coroutines.test.TestScope @@ -78,6 +80,34 @@ class SignInViewModelTest { assertEquals(listOf(UiEvent.NavigateUp), events) } + @Test + fun `successful verification finishes after sensors sync and clears the code`() = runTest(dispatcher) { + val syncEvents = MutableSharedFlow() + every { networkDataSyncInteractor.syncEvents } returns syncEvents + every { networkSignInInteractor.signIn(CODE, EMAIL, any()) } answers { + thirdArg<(UiText?) -> Unit>()(null) + } + viewModel.submitEmail(EMAIL) + val events = collectEvents() + val tokenProcessed = mutableListOf() + backgroundScope.launch(dispatcher) { viewModel.tokenProcessed.toList(tokenProcessed) } + + viewModel.verifyCode(CODE) + + verify(exactly = 1) { networkDataSyncInteractor.syncNetworkData() } + assertEquals(listOf(UiEvent.Progress(true, null)), events) + assertTrue(tokenProcessed.isEmpty()) + + syncEvents.emit(NetworkSyncEvent.SensorsSynced) + + assertEquals( + listOf(UiEvent.Progress(true, null), UiEvent.Progress(false, null), UiEvent.Finish), + events, + ) + assertEquals(listOf(true), tokenProcessed) + assertEquals(0, syncEvents.subscriptionCount.value) + } + @Test fun `failed verification shows the error and clears the code without navigating`() = runTest(dispatcher) { val error = UiText.StringResource(R.string.cloud_er_sub_code_expired)