Sulkta-OSS/element-x-ada
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename Async to AsyncData

Browse source
This commit is contained in:
Benoit Marty 2024-01-04 16:30:56 +01:00
parent 3b2882ce2f
commit 7b2341aec7
139 changed files with 745 additions and 745 deletions
Download patch file Download diff file Expand all files Collapse all files

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisablePresenter.kt
View file

@ -25,7 +25,7 @@ import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import io.element.android.features.securebackup.impl.loggerTagDisable
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.Presenter
import io.element.android.libraries.architecture.runCatchingUpdatingState
import io.element.android.libraries.core.meta.BuildMeta
@ -44,7 +44,7 @@ class SecureBackupDisablePresenter @Inject constructor(
override fun present(): SecureBackupDisableState {
val backupState by encryptionService.backupStateStateFlow.collectAsState()
Timber.tag(loggerTagDisable.value).d("backupState: $backupState")
val disableAction = remember { mutableStateOf<Async<Unit>>(Async.Uninitialized) }
val disableAction = remember { mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized) }
val coroutineScope = rememberCoroutineScope()
var showDialog by remember { mutableStateOf(false) }
fun handleEvents(event: SecureBackupDisableEvents) {
@ -57,7 +57,7 @@ class SecureBackupDisablePresenter @Inject constructor(
}
SecureBackupDisableEvents.DismissDialogs -> {
showDialog = false
disableAction.value = Async.Uninitialized
disableAction.value = AsyncData.Uninitialized
}
}
}
@ -71,7 +71,7 @@ class SecureBackupDisablePresenter @Inject constructor(
)
}
private fun CoroutineScope.disableBackup(disableAction: MutableState<Async<Unit>>) = launch {
private fun CoroutineScope.disableBackup(disableAction: MutableState<AsyncData<Unit>>) = launch {
suspend {
Timber.tag(loggerTagDisable.value).d("Calling encryptionService.disableRecovery()")
encryptionService.disableRecovery().getOrThrow()

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableState.kt
View file

@ -16,12 +16,12 @@
package io.element.android.features.securebackup.impl.disable
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.matrix.api.encryption.BackupState
data class SecureBackupDisableState(
val backupState: BackupState,
val disableAction: Async<Unit>,
val disableAction: AsyncData<Unit>,
val showConfirmationDialog: Boolean,
val appName: String,
val eventSink: (SecureBackupDisableEvents) -> Unit

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableStateProvider.kt
View file

@ -17,7 +17,7 @@
package io.element.android.features.securebackup.impl.disable
import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.matrix.api.encryption.BackupState
open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBackupDisableState> {
@ -25,15 +25,15 @@ open class SecureBackupDisableStateProvider : PreviewParameterProvider<SecureBac
get() = sequenceOf(
aSecureBackupDisableState(),
aSecureBackupDisableState(showConfirmationDialog = true),
aSecureBackupDisableState(disableAction = Async.Loading()),
aSecureBackupDisableState(disableAction = Async.Failure(Exception("Failed to disable"))),
aSecureBackupDisableState(disableAction = AsyncData.Loading()),
aSecureBackupDisableState(disableAction = AsyncData.Failure(Exception("Failed to disable"))),
// Add other states here
)
}
fun aSecureBackupDisableState(
backupState: BackupState = BackupState.UNKNOWN,
disableAction: Async<Unit> = Async.Uninitialized,
disableAction: AsyncData<Unit> = AsyncData.Uninitialized,
showConfirmationDialog: Boolean = false,
) = SecureBackupDisableState(
backupState = backupState,

6
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisableView.kt
View file

@ -34,7 +34,7 @@ import androidx.compose.ui.unit.dp
import io.element.android.compound.theme.ElementTheme
import io.element.android.compound.tokens.generated.CompoundIcons
import io.element.android.features.securebackup.impl.R
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
@ -53,7 +53,7 @@ fun SecureBackupDisableView(
modifier: Modifier = Modifier,
) {
LaunchedEffect(state.disableAction) {
if (state.disableAction is Async.Success) {
if (state.disableAction is AsyncData.Success) {
onDone()
}
}
@ -72,7 +72,7 @@ fun SecureBackupDisableView(
onConfirm = { state.eventSink.invoke(SecureBackupDisableEvents.DisableBackup(force = true)) },
onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },
)
} else if (state.disableAction is Async.Failure) {
} else if (state.disableAction is AsyncData.Failure) {
ErrorDialog(
content = state.disableAction.error.let { it.message ?: it.toString() },
onDismiss = { state.eventSink.invoke(SecureBackupDisableEvents.DismissDialogs) },

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnablePresenter.kt
View file

@ -22,7 +22,7 @@ import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import io.element.android.features.securebackup.impl.loggerTagDisable
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.Presenter
import io.element.android.libraries.architecture.runCatchingUpdatingState
import io.element.android.libraries.matrix.api.encryption.EncryptionService
@ -37,14 +37,14 @@ class SecureBackupEnablePresenter @Inject constructor(
@Composable
override fun present(): SecureBackupEnableState {
val enableAction = remember { mutableStateOf<Async<Unit>>(Async.Uninitialized) }
val enableAction = remember { mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized) }
val coroutineScope = rememberCoroutineScope()
fun handleEvents(event: SecureBackupEnableEvents) {
when (event) {
is SecureBackupEnableEvents.EnableBackup ->
coroutineScope.enableBackup(enableAction)
SecureBackupEnableEvents.DismissDialog -> {
enableAction.value = Async.Uninitialized
enableAction.value = AsyncData.Uninitialized
}
}
}
@ -55,7 +55,7 @@ class SecureBackupEnablePresenter @Inject constructor(
)
}
private fun CoroutineScope.enableBackup(action: MutableState<Async<Unit>>) = launch {
private fun CoroutineScope.enableBackup(action: MutableState<AsyncData<Unit>>) = launch {
suspend {
Timber.tag(loggerTagDisable.value).d("Calling encryptionService.enableBackups()")
encryptionService.enableBackups().getOrThrow()

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableState.kt
View file

@ -16,9 +16,9 @@
package io.element.android.features.securebackup.impl.enable
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
data class SecureBackupEnableState(
val enableAction: Async<Unit>,
val enableAction: AsyncData<Unit>,
val eventSink: (SecureBackupEnableEvents) -> Unit
)

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableStateProvider.kt
View file

@ -17,20 +17,20 @@
package io.element.android.features.securebackup.impl.enable
import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
open class SecureBackupEnableStateProvider : PreviewParameterProvider<SecureBackupEnableState> {
override val values: Sequence<SecureBackupEnableState>
get() = sequenceOf(
aSecureBackupEnableState(),
aSecureBackupEnableState(enableAction = Async.Loading()),
aSecureBackupEnableState(enableAction = Async.Failure(Exception("Failed to enable"))),
aSecureBackupEnableState(enableAction = AsyncData.Loading()),
aSecureBackupEnableState(enableAction = AsyncData.Failure(Exception("Failed to enable"))),
// Add other states here
)
}
fun aSecureBackupEnableState(
enableAction: Async<Unit> = Async.Uninitialized,
enableAction: AsyncData<Unit> = AsyncData.Uninitialized,
) = SecureBackupEnableState(
enableAction = enableAction,
eventSink = {}

6
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnableView.kt
View file

@ -26,7 +26,7 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import androidx.compose.ui.tooling.preview.PreviewParameter
import io.element.android.features.securebackup.impl.R
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.atomic.pages.FlowStepPage
import io.element.android.libraries.designsystem.components.dialogs.ErrorDialog
import io.element.android.libraries.designsystem.preview.ElementPreview
@ -42,7 +42,7 @@ fun SecureBackupEnableView(
modifier: Modifier = Modifier,
) {
LaunchedEffect(state.enableAction) {
if (state.enableAction is Async.Success) {
if (state.enableAction is AsyncData.Success) {
onDone()
}
}
@ -53,7 +53,7 @@ fun SecureBackupEnableView(
iconVector = ImageVector.vectorResource(CommonDrawables.ic_key),
buttons = { Buttons(state = state) }
)
if (state.enableAction is Async.Failure) {
if (state.enableAction is AsyncData.Failure) {
ErrorDialog(
content = state.enableAction.error.let { it.message ?: it.toString() },
onDismiss = { state.eventSink.invoke(SecureBackupEnableEvents.DismissDialog) },

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyPresenter.kt
View file

@ -27,7 +27,7 @@ import androidx.compose.runtime.setValue
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.tools.RecoveryKeyTools
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.Presenter
import io.element.android.libraries.architecture.runCatchingUpdatingState
import io.element.android.libraries.matrix.api.encryption.EncryptionService
@ -47,13 +47,13 @@ class SecureBackupEnterRecoveryKeyPresenter @Inject constructor(
mutableStateOf("")
}
val submitAction = remember {
mutableStateOf<Async<Unit>>(Async.Uninitialized)
mutableStateOf<AsyncData<Unit>>(AsyncData.Uninitialized)
}
fun handleEvents(event: SecureBackupEnterRecoveryKeyEvents) {
when (event) {
SecureBackupEnterRecoveryKeyEvents.ClearDialog -> {
submitAction.value = Async.Uninitialized
submitAction.value = AsyncData.Uninitialized
}
is SecureBackupEnterRecoveryKeyEvents.OnRecoveryKeyChange -> {
val previousRecoveryKey = recoveryKey
@ -86,7 +86,7 @@ class SecureBackupEnterRecoveryKeyPresenter @Inject constructor(
private fun CoroutineScope.submitRecoveryKey(
recoveryKey: String,
action: MutableState<Async<Unit>>
action: MutableState<AsyncData<Unit>>
) = launch {
suspend {
encryptionService.recover(recoveryKey).getOrThrow()

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyState.kt
View file

@ -17,12 +17,12 @@
package io.element.android.features.securebackup.impl.enter
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
// Do not use default value, so no member get forgotten in the presenters.
data class SecureBackupEnterRecoveryKeyState(
val recoveryKeyViewState: RecoveryKeyViewState,
val isSubmitEnabled: Boolean,
val submitAction: Async<Unit>,
val submitAction: AsyncData<Unit>,
val eventSink: (SecureBackupEnterRecoveryKeyEvents) -> Unit
)

8
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyStateProvider.kt
View file

@ -20,22 +20,22 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.setup.views.aFormattedRecoveryKey
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
open class SecureBackupEnterRecoveryKeyStateProvider : PreviewParameterProvider<SecureBackupEnterRecoveryKeyState> {
override val values: Sequence<SecureBackupEnterRecoveryKeyState>
get() = sequenceOf(
aSecureBackupEnterRecoveryKeyState(recoveryKey = ""),
aSecureBackupEnterRecoveryKeyState(),
aSecureBackupEnterRecoveryKeyState(submitAction = Async.Loading()),
aSecureBackupEnterRecoveryKeyState(submitAction = Async.Failure(Exception("A Failure"))),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncData.Loading()),
aSecureBackupEnterRecoveryKeyState(submitAction = AsyncData.Failure(Exception("A Failure"))),
)
}
fun aSecureBackupEnterRecoveryKeyState(
recoveryKey: String = aFormattedRecoveryKey(),
isSubmitEnabled: Boolean = recoveryKey.isNotEmpty(),
submitAction: Async<Unit> = Async.Uninitialized,
submitAction: AsyncData<Unit> = AsyncData.Uninitialized,
) = SecureBackupEnterRecoveryKeyState(
recoveryKeyViewState = RecoveryKeyViewState(
recoveryKeyUserStory = RecoveryKeyUserStory.Enter,

6
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/root/SecureBackupRootPresenter.kt
View file

@ -25,7 +25,7 @@ import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import io.element.android.features.securebackup.impl.loggerTagRoot
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.architecture.Presenter
import io.element.android.libraries.architecture.runCatchingUpdatingState
import io.element.android.libraries.core.meta.BuildMeta
@ -55,7 +55,7 @@ class SecureBackupRootPresenter @Inject constructor(
Timber.tag(loggerTagRoot.value).d("backupState: $backupState")
Timber.tag(loggerTagRoot.value).d("recoveryState: $recoveryState")
val doesBackupExistOnServerAction: MutableState<Async<Boolean>> = remember { mutableStateOf(Async.Uninitialized) }
val doesBackupExistOnServerAction: MutableState<AsyncData<Boolean>> = remember { mutableStateOf(AsyncData.Uninitialized) }
LaunchedEffect(backupState) {
if (backupState == BackupState.UNKNOWN) {
@ -79,7 +79,7 @@ class SecureBackupRootPresenter @Inject constructor(
)
}
private fun CoroutineScope.getKeyBackupStatus(action: MutableState<Async<Boolean>>) = launch {
private fun CoroutineScope.getKeyBackupStatus(action: MutableState<AsyncData<Boolean>>) = launch {
suspend {
encryptionService.doesBackupExistOnServer().getOrThrow()
}.runCatchingUpdatingState(action)

4
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/root/SecureBackupRootState.kt
View file

@ -16,14 +16,14 @@
package io.element.android.features.securebackup.impl.root
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
import io.element.android.libraries.matrix.api.encryption.BackupState
import io.element.android.libraries.matrix.api.encryption.RecoveryState
data class SecureBackupRootState(
val backupState: BackupState,
val doesBackupExistOnServer: Async<Boolean>,
val doesBackupExistOnServer: AsyncData<Boolean>,
val recoveryState: RecoveryState,
val appName: String,
val snackbarMessage: SnackbarMessage?,

12
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/root/SecureBackupRootStateProvider.kt
View file

@ -17,7 +17,7 @@
package io.element.android.features.securebackup.impl.root
import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.utils.snackbar.SnackbarMessage
import io.element.android.libraries.matrix.api.encryption.BackupState
import io.element.android.libraries.matrix.api.encryption.RecoveryState
@ -25,10 +25,10 @@ import io.element.android.libraries.matrix.api.encryption.RecoveryState
open class SecureBackupRootStateProvider : PreviewParameterProvider<SecureBackupRootState> {
override val values: Sequence<SecureBackupRootState>
get() = sequenceOf(
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = Async.Uninitialized),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = Async.Success(true)),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = Async.Success(false)),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = Async.Failure(Exception("An error"))),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = AsyncData.Uninitialized),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = AsyncData.Success(true)),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = AsyncData.Success(false)),
aSecureBackupRootState(backupState = BackupState.UNKNOWN, doesBackupExistOnServer = AsyncData.Failure(Exception("An error"))),
aSecureBackupRootState(backupState = BackupState.ENABLED),
aSecureBackupRootState(recoveryState = RecoveryState.UNKNOWN),
aSecureBackupRootState(recoveryState = RecoveryState.ENABLED),
@ -40,7 +40,7 @@ open class SecureBackupRootStateProvider : PreviewParameterProvider<SecureBackup
fun aSecureBackupRootState(
backupState: BackupState = BackupState.UNKNOWN,
doesBackupExistOnServer: Async<Boolean> = Async.Uninitialized,
doesBackupExistOnServer: AsyncData<Boolean> = AsyncData.Uninitialized,
recoveryState: RecoveryState = RecoveryState.UNKNOWN,
snackbarMessage: SnackbarMessage? = null,
) = SecureBackupRootState(

10
features/securebackup/impl/src/main/kotlin/io/element/android/features/securebackup/impl/root/SecureBackupRootView.kt
View file

@ -24,7 +24,7 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.tooling.preview.PreviewParameter
import io.element.android.features.securebackup.impl.R
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.components.async.AsyncLoading
import io.element.android.libraries.designsystem.components.list.ListItemContent
import io.element.android.libraries.designsystem.components.preferences.PreferenceDivider
@ -82,7 +82,7 @@ fun SecureBackupRootView(
BackupState.WAITING_FOR_SYNC -> Unit
BackupState.UNKNOWN -> {
when (state.doesBackupExistOnServer) {
is Async.Success -> when (state.doesBackupExistOnServer.data) {
is AsyncData.Success -> when (state.doesBackupExistOnServer.data) {
true -> {
PreferenceText(
title = stringResource(id = R.string.screen_chat_backup_key_backup_action_disable),
@ -97,8 +97,8 @@ fun SecureBackupRootView(
)
}
}
is Async.Loading,
Async.Uninitialized -> {
is AsyncData.Loading,
AsyncData.Uninitialized -> {
ListItem(headlineContent = {
Row(
modifier = Modifier.fillMaxWidth(),
@ -108,7 +108,7 @@ fun SecureBackupRootView(
}
})
}
is Async.Failure -> {
is AsyncData.Failure -> {
ListItem(
headlineContent = {
Text(

14
features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/disable/SecureBackupDisablePresenterTest.kt
View file

@ -20,7 +20,7 @@ import app.cash.molecule.RecompositionMode
import app.cash.molecule.moleculeFlow
import app.cash.turbine.test
import com.google.common.truth.Truth.assertThat
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.matrix.api.encryption.BackupState
import io.element.android.libraries.matrix.api.encryption.EncryptionService
import io.element.android.libraries.matrix.test.core.aBuildMeta
@ -42,7 +42,7 @@ class SecureBackupDisablePresenterTest {
}.test {
val initialState = awaitItem()
assertThat(initialState.backupState).isEqualTo(BackupState.UNKNOWN)
assertThat(initialState.disableAction).isEqualTo(Async.Uninitialized)
assertThat(initialState.disableAction).isEqualTo(AsyncData.Uninitialized)
assertThat(initialState.showConfirmationDialog).isFalse()
assertThat(initialState.appName).isEqualTo("Element")
}
@ -80,9 +80,9 @@ class SecureBackupDisablePresenterTest {
skipItems(1)
val loadingState = awaitItem()
assertThat(loadingState.showConfirmationDialog).isFalse()
assertThat(loadingState.disableAction).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState.disableAction).isInstanceOf(AsyncData.Loading::class.java)
val finalState = awaitItem()
assertThat(finalState.disableAction).isEqualTo(Async.Success(Unit))
assertThat(finalState.disableAction).isEqualTo(AsyncData.Success(Unit))
}
}
@ -106,12 +106,12 @@ class SecureBackupDisablePresenterTest {
skipItems(1)
val loadingState = awaitItem()
assertThat(loadingState.showConfirmationDialog).isFalse()
assertThat(loadingState.disableAction).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState.disableAction).isInstanceOf(AsyncData.Loading::class.java)
val errorState = awaitItem()
assertThat(errorState.disableAction).isInstanceOf(Async.Failure::class.java)
assertThat(errorState.disableAction).isInstanceOf(AsyncData.Failure::class.java)
errorState.eventSink(SecureBackupDisableEvents.DismissDialogs)
val finalState = awaitItem()
assertThat(finalState.disableAction).isEqualTo(Async.Uninitialized)
assertThat(finalState.disableAction).isEqualTo(AsyncData.Uninitialized)
}
}

14
features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/enable/SecureBackupEnablePresenterTest.kt
View file

@ -20,7 +20,7 @@ import app.cash.molecule.RecompositionMode
import app.cash.molecule.moleculeFlow
import app.cash.turbine.test
import com.google.common.truth.Truth.assertThat
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.matrix.api.encryption.EncryptionService
import io.element.android.libraries.matrix.test.AN_EXCEPTION
import io.element.android.libraries.matrix.test.encryption.FakeEncryptionService
@ -40,7 +40,7 @@ class SecureBackupEnablePresenterTest {
presenter.present()
}.test {
val initialState = awaitItem()
assertThat(initialState.enableAction).isEqualTo(Async.Uninitialized)
assertThat(initialState.enableAction).isEqualTo(AsyncData.Uninitialized)
}
}
@ -53,9 +53,9 @@ class SecureBackupEnablePresenterTest {
val initialState = awaitItem()
initialState.eventSink(SecureBackupEnableEvents.EnableBackup)
val loadingState = awaitItem()
assertThat(loadingState.enableAction).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState.enableAction).isInstanceOf(AsyncData.Loading::class.java)
val finalState = awaitItem()
assertThat(finalState.enableAction).isEqualTo(Async.Success(Unit))
assertThat(finalState.enableAction).isEqualTo(AsyncData.Success(Unit))
}
}
@ -70,12 +70,12 @@ class SecureBackupEnablePresenterTest {
val initialState = awaitItem()
initialState.eventSink(SecureBackupEnableEvents.EnableBackup)
val loadingState = awaitItem()
assertThat(loadingState.enableAction).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState.enableAction).isInstanceOf(AsyncData.Loading::class.java)
val errorState = awaitItem()
assertThat(errorState.enableAction).isEqualTo(Async.Failure<Unit>(AN_EXCEPTION))
assertThat(errorState.enableAction).isEqualTo(AsyncData.Failure<Unit>(AN_EXCEPTION))
errorState.eventSink(SecureBackupEnableEvents.DismissDialog)
val finalState = awaitItem()
assertThat(finalState.enableAction).isEqualTo(Async.Uninitialized)
assertThat(finalState.enableAction).isEqualTo(AsyncData.Uninitialized)
}
}

14
features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/enter/SecureBackupEnterRecoveryKeyPresenterTest.kt
View file

@ -23,7 +23,7 @@ import com.google.common.truth.Truth.assertThat
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyUserStory
import io.element.android.features.securebackup.impl.setup.views.RecoveryKeyViewState
import io.element.android.features.securebackup.impl.tools.RecoveryKeyTools
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.matrix.api.encryption.EncryptionService
import io.element.android.libraries.matrix.test.AN_EXCEPTION
import io.element.android.libraries.matrix.test.encryption.FakeEncryptionService
@ -44,7 +44,7 @@ class SecureBackupEnterRecoveryKeyPresenterTest {
}.test {
val initialState = awaitItem()
assertThat(initialState.isSubmitEnabled).isFalse()
assertThat(initialState.submitAction).isEqualTo(Async.Uninitialized)
assertThat(initialState.submitAction).isEqualTo(AsyncData.Uninitialized)
assertThat(initialState.recoveryKeyViewState).isEqualTo(
RecoveryKeyViewState(
recoveryKeyUserStory = RecoveryKeyUserStory.Enter,
@ -76,22 +76,22 @@ class SecureBackupEnterRecoveryKeyPresenterTest {
encryptionService.givenRecoverFailure(AN_EXCEPTION)
withRecoveryKeyState.eventSink(SecureBackupEnterRecoveryKeyEvents.Submit)
val loadingState = awaitItem()
assertThat(loadingState.submitAction).isEqualTo(Async.Loading<Unit>())
assertThat(loadingState.submitAction).isEqualTo(AsyncData.Loading<Unit>())
assertThat(loadingState.isSubmitEnabled).isFalse()
val errorState = awaitItem()
assertThat(errorState.submitAction).isEqualTo(Async.Failure<Unit>(AN_EXCEPTION))
assertThat(errorState.submitAction).isEqualTo(AsyncData.Failure<Unit>(AN_EXCEPTION))
assertThat(errorState.isSubmitEnabled).isFalse()
errorState.eventSink(SecureBackupEnterRecoveryKeyEvents.ClearDialog)
val clearedState = awaitItem()
assertThat(clearedState.submitAction).isEqualTo(Async.Uninitialized)
assertThat(clearedState.submitAction).isEqualTo(AsyncData.Uninitialized)
assertThat(clearedState.isSubmitEnabled).isTrue()
encryptionService.givenRecoverFailure(null)
clearedState.eventSink(SecureBackupEnterRecoveryKeyEvents.Submit)
val loadingState2 = awaitItem()
assertThat(loadingState2.submitAction).isEqualTo(Async.Loading<Unit>())
assertThat(loadingState2.submitAction).isEqualTo(AsyncData.Loading<Unit>())
assertThat(loadingState2.isSubmitEnabled).isFalse()
val finalState = awaitItem()
assertThat(finalState.submitAction).isEqualTo(Async.Success(Unit))
assertThat(finalState.submitAction).isEqualTo(AsyncData.Success(Unit))
assertThat(finalState.isSubmitEnabled).isFalse()
}
}

10
features/securebackup/impl/src/test/kotlin/io/element/android/features/securebackup/impl/root/SecureBackupRootPresenterTest.kt
View file

@ -20,7 +20,7 @@ import app.cash.molecule.RecompositionMode
import app.cash.molecule.moleculeFlow
import app.cash.turbine.test
import com.google.common.truth.Truth.assertThat
import io.element.android.libraries.architecture.Async
import io.element.android.libraries.architecture.AsyncData
import io.element.android.libraries.designsystem.utils.snackbar.SnackbarDispatcher
import io.element.android.libraries.matrix.api.encryption.BackupState
import io.element.android.libraries.matrix.api.encryption.EncryptionService
@ -65,15 +65,15 @@ class SecureBackupRootPresenterTest {
val initialState = awaitItem()
encryptionService.givenDoesBackupExistOnServerResult(Result.failure(AN_EXCEPTION))
assertThat(initialState.backupState).isEqualTo(BackupState.UNKNOWN)
assertThat(initialState.doesBackupExistOnServer).isEqualTo(Async.Uninitialized)
assertThat(initialState.doesBackupExistOnServer).isEqualTo(AsyncData.Uninitialized)
val loadingState1 = awaitItem()
assertThat(loadingState1.doesBackupExistOnServer).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState1.doesBackupExistOnServer).isInstanceOf(AsyncData.Loading::class.java)
val errorState = awaitItem()
assertThat(errorState.doesBackupExistOnServer).isEqualTo(Async.Failure<Boolean>(AN_EXCEPTION))
assertThat(errorState.doesBackupExistOnServer).isEqualTo(AsyncData.Failure<Boolean>(AN_EXCEPTION))
encryptionService.givenDoesBackupExistOnServerResult(Result.success(false))
errorState.eventSink.invoke(SecureBackupRootEvents.RetryKeyBackupState)
val loadingState2 = awaitItem()
assertThat(loadingState2.doesBackupExistOnServer).isInstanceOf(Async.Loading::class.java)
assertThat(loadingState2.doesBackupExistOnServer).isInstanceOf(AsyncData.Loading::class.java)
val finalState = awaitItem()
assertThat(finalState.doesBackupExistOnServer.dataOrNull()).isFalse()
}