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

SecurityAndPrivacyEvents -> SecurityAndPrivacyEvent

Browse source
This commit is contained in:
Benoit Marty 2025-12-03 16:13:12 +01:00 • committed by Benoit Marty
parent a2c92db360
commit f9b0690257
7 changed files with 87 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

24
features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyEvents.kt → features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyEvent.kt
View file

@ -8,16 +8,16 @@
package io.element.android.features.securityandprivacy.impl.root package io.element.android.features.securityandprivacy.impl.root
sealed interface SecurityAndPrivacyEvents { sealed interface SecurityAndPrivacyEvent {
data object EditRoomAddress : SecurityAndPrivacyEvents data object EditRoomAddress : SecurityAndPrivacyEvent
data object Save : SecurityAndPrivacyEvents data object Save : SecurityAndPrivacyEvent
data object Exit : SecurityAndPrivacyEvents data object Exit : SecurityAndPrivacyEvent
data object DismissExitConfirmation : SecurityAndPrivacyEvents data object DismissExitConfirmation : SecurityAndPrivacyEvent
data class ChangeRoomAccess(val roomAccess: SecurityAndPrivacyRoomAccess) : SecurityAndPrivacyEvents data class ChangeRoomAccess(val roomAccess: SecurityAndPrivacyRoomAccess) : SecurityAndPrivacyEvent
data object ToggleEncryptionState : SecurityAndPrivacyEvents data object ToggleEncryptionState : SecurityAndPrivacyEvent
data object CancelEnableEncryption : SecurityAndPrivacyEvents data object CancelEnableEncryption : SecurityAndPrivacyEvent
data object ConfirmEnableEncryption : SecurityAndPrivacyEvents data object ConfirmEnableEncryption : SecurityAndPrivacyEvent
data class ChangeHistoryVisibility(val historyVisibility: SecurityAndPrivacyHistoryVisibility) : SecurityAndPrivacyEvents data class ChangeHistoryVisibility(val historyVisibility: SecurityAndPrivacyHistoryVisibility) : SecurityAndPrivacyEvent
data object ToggleRoomVisibility : SecurityAndPrivacyEvents data object ToggleRoomVisibility : SecurityAndPrivacyEvent
data object DismissSaveError : SecurityAndPrivacyEvents data object DismissSaveError : SecurityAndPrivacyEvent
} }

24
features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyPresenter.kt
View file

@ -108,9 +108,9 @@ class SecurityAndPrivacyPresenter(
var showEnableEncryptionConfirmation by remember(savedSettings.isEncrypted) { mutableStateOf(false) } var showEnableEncryptionConfirmation by remember(savedSettings.isEncrypted) { mutableStateOf(false) }
val permissions by room.securityAndPrivacyPermissionsAsState(syncUpdateFlow.value) val permissions by room.securityAndPrivacyPermissionsAsState(syncUpdateFlow.value)
fun handleEvent(event: SecurityAndPrivacyEvents) { fun handleEvent(event: SecurityAndPrivacyEvent) {
when (event) { when (event) {
SecurityAndPrivacyEvents.Save -> { SecurityAndPrivacyEvent.Save -> {
coroutineScope.save( coroutineScope.save(
saveAction = saveAction, saveAction = saveAction,
isVisibleInRoomDirectory = savedIsVisibleInRoomDirectory, isVisibleInRoomDirectory = savedIsVisibleInRoomDirectory,
@ -118,44 +118,44 @@ class SecurityAndPrivacyPresenter(
editedSettings = editedSettings editedSettings = editedSettings
) )
} }
is SecurityAndPrivacyEvents.ChangeRoomAccess -> { is SecurityAndPrivacyEvent.ChangeRoomAccess -> {
editedRoomAccess = event.roomAccess editedRoomAccess = event.roomAccess
} }
is SecurityAndPrivacyEvents.ToggleEncryptionState -> { is SecurityAndPrivacyEvent.ToggleEncryptionState -> {
if (editedIsEncrypted) { if (editedIsEncrypted) {
editedIsEncrypted = false editedIsEncrypted = false
} else { } else {
showEnableEncryptionConfirmation = true showEnableEncryptionConfirmation = true
} }
} }
is SecurityAndPrivacyEvents.ChangeHistoryVisibility -> { is SecurityAndPrivacyEvent.ChangeHistoryVisibility -> {
editedHistoryVisibility = event.historyVisibility editedHistoryVisibility = event.historyVisibility
} }
SecurityAndPrivacyEvents.ToggleRoomVisibility -> { SecurityAndPrivacyEvent.ToggleRoomVisibility -> {
editedVisibleInRoomDirectory = when (val edited = editedVisibleInRoomDirectory) { editedVisibleInRoomDirectory = when (val edited = editedVisibleInRoomDirectory) {
is AsyncData.Success -> AsyncData.Success(!edited.data) is AsyncData.Success -> AsyncData.Success(!edited.data)
else -> edited else -> edited
} }
} }
SecurityAndPrivacyEvents.EditRoomAddress -> navigator.openEditRoomAddress() SecurityAndPrivacyEvent.EditRoomAddress -> navigator.openEditRoomAddress()
SecurityAndPrivacyEvents.CancelEnableEncryption -> { SecurityAndPrivacyEvent.CancelEnableEncryption -> {
showEnableEncryptionConfirmation = false showEnableEncryptionConfirmation = false
} }
SecurityAndPrivacyEvents.ConfirmEnableEncryption -> { SecurityAndPrivacyEvent.ConfirmEnableEncryption -> {
showEnableEncryptionConfirmation = false showEnableEncryptionConfirmation = false
editedIsEncrypted = true editedIsEncrypted = true
} }
SecurityAndPrivacyEvents.DismissSaveError -> { SecurityAndPrivacyEvent.DismissSaveError -> {
saveAction.value = AsyncAction.Uninitialized saveAction.value = AsyncAction.Uninitialized
} }
SecurityAndPrivacyEvents.Exit -> { SecurityAndPrivacyEvent.Exit -> {
saveAction.value = if (savedSettings == editedSettings || saveAction.value == AsyncAction.ConfirmingCancellation) { saveAction.value = if (savedSettings == editedSettings || saveAction.value == AsyncAction.ConfirmingCancellation) {
AsyncAction.Success(Unit) AsyncAction.Success(Unit)
} else { } else {
AsyncAction.ConfirmingCancellation AsyncAction.ConfirmingCancellation
} }
} }
SecurityAndPrivacyEvents.DismissExitConfirmation -> { SecurityAndPrivacyEvent.DismissExitConfirmation -> {
saveAction.value = AsyncAction.Uninitialized saveAction.value = AsyncAction.Uninitialized
} }
} }

2
features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyState.kt
View file

@ -24,7 +24,7 @@ data class SecurityAndPrivacyState(
val saveAction: AsyncAction<Unit>, val saveAction: AsyncAction<Unit>,
val isSpace: Boolean, val isSpace: Boolean,
private val permissions: SecurityAndPrivacyPermissions, private val permissions: SecurityAndPrivacyPermissions,
val eventSink: (SecurityAndPrivacyEvents) -> Unit val eventSink: (SecurityAndPrivacyEvent) -> Unit
) { ) {
val canBeSaved = savedSettings != editedSettings val canBeSaved = savedSettings != editedSettings

2
features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyStateProvider.kt
View file

@ -117,7 +117,7 @@ fun aSecurityAndPrivacyState(
), ),
isKnockEnabled: Boolean = true, isKnockEnabled: Boolean = true,
isSpace: Boolean = false, isSpace: Boolean = false,
eventSink: (SecurityAndPrivacyEvents) -> Unit = {} eventSink: (SecurityAndPrivacyEvent) -> Unit = {}
) = SecurityAndPrivacyState( ) = SecurityAndPrivacyState(
editedSettings = editedSettings, editedSettings = editedSettings,
savedSettings = savedSettings, savedSettings = savedSettings,

30
features/securityandprivacy/impl/src/main/kotlin/io/element/android/features/securityandprivacy/impl/root/SecurityAndPrivacyView.kt
View file

@ -60,7 +60,7 @@ fun SecurityAndPrivacyView(
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
) { ) {
BackHandler { BackHandler {
state.eventSink(SecurityAndPrivacyEvents.Exit) state.eventSink(SecurityAndPrivacyEvent.Exit)
} }
Scaffold( Scaffold(
modifier = modifier, modifier = modifier,
@ -68,10 +68,10 @@ fun SecurityAndPrivacyView(
SecurityAndPrivacyToolbar( SecurityAndPrivacyToolbar(
isSaveActionEnabled = state.canBeSaved, isSaveActionEnabled = state.canBeSaved,
onBackClick = { onBackClick = {
state.eventSink(SecurityAndPrivacyEvents.Exit) state.eventSink(SecurityAndPrivacyEvent.Exit)
}, },
onSaveClick = { onSaveClick = {
state.eventSink(SecurityAndPrivacyEvents.Save) state.eventSink(SecurityAndPrivacyEvent.Save)
}, },
) )
} }
@ -90,7 +90,7 @@ fun SecurityAndPrivacyView(
edited = state.editedSettings.roomAccess, edited = state.editedSettings.roomAccess,
saved = state.savedSettings.roomAccess, saved = state.savedSettings.roomAccess,
isKnockEnabled = state.isKnockEnabled, isKnockEnabled = state.isKnockEnabled,
onSelectOption = { state.eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(it)) }, onSelectOption = { state.eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(it)) },
) )
} }
if (state.showRoomVisibilitySections) { if (state.showRoomVisibilitySections) {
@ -98,10 +98,10 @@ fun SecurityAndPrivacyView(
RoomAddressSection( RoomAddressSection(
roomAddress = state.editedSettings.address, roomAddress = state.editedSettings.address,
homeserverName = state.homeserverName, homeserverName = state.homeserverName,
onRoomAddressClick = { state.eventSink(SecurityAndPrivacyEvents.EditRoomAddress) }, onRoomAddressClick = { state.eventSink(SecurityAndPrivacyEvent.EditRoomAddress) },
isVisibleInRoomDirectory = state.editedSettings.isVisibleInRoomDirectory, isVisibleInRoomDirectory = state.editedSettings.isVisibleInRoomDirectory,
onVisibilityChange = { onVisibilityChange = {
state.eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility) state.eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
}, },
) )
} }
@ -110,10 +110,10 @@ fun SecurityAndPrivacyView(
isRoomEncrypted = state.editedSettings.isEncrypted, isRoomEncrypted = state.editedSettings.isEncrypted,
// encryption can't be disabled once enabled // encryption can't be disabled once enabled
canToggleEncryption = !state.savedSettings.isEncrypted, canToggleEncryption = !state.savedSettings.isEncrypted,
onToggleEncryption = { state.eventSink(SecurityAndPrivacyEvents.ToggleEncryptionState) }, onToggleEncryption = { state.eventSink(SecurityAndPrivacyEvent.ToggleEncryptionState) },
showConfirmation = state.showEnableEncryptionConfirmation, showConfirmation = state.showEnableEncryptionConfirmation,
onDismissConfirmation = { state.eventSink(SecurityAndPrivacyEvents.CancelEnableEncryption) }, onDismissConfirmation = { state.eventSink(SecurityAndPrivacyEvent.CancelEnableEncryption) },
onConfirmEncryption = { state.eventSink(SecurityAndPrivacyEvents.ConfirmEnableEncryption) }, onConfirmEncryption = { state.eventSink(SecurityAndPrivacyEvent.ConfirmEnableEncryption) },
) )
} }
if (state.showHistoryVisibilitySection) { if (state.showHistoryVisibilitySection) {
@ -121,7 +121,7 @@ fun SecurityAndPrivacyView(
editedOption = state.editedSettings.historyVisibility, editedOption = state.editedSettings.historyVisibility,
savedOptions = state.savedSettings.historyVisibility, savedOptions = state.savedSettings.historyVisibility,
availableOptions = state.availableHistoryVisibilities, availableOptions = state.availableHistoryVisibilities,
onSelectOption = { state.eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(it)) }, onSelectOption = { state.eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(it)) },
) )
} }
} }
@ -129,14 +129,14 @@ fun SecurityAndPrivacyView(
AsyncActionView( AsyncActionView(
async = state.saveAction, async = state.saveAction,
onSuccess = { }, onSuccess = { },
onErrorDismiss = { state.eventSink(SecurityAndPrivacyEvents.DismissSaveError) }, onErrorDismiss = { state.eventSink(SecurityAndPrivacyEvent.DismissSaveError) },
confirmationDialog = { confirming -> confirmationDialog = { confirming ->
when (confirming) { when (confirming) {
is AsyncAction.ConfirmingCancellation -> is AsyncAction.ConfirmingCancellation ->
SaveChangesDialog( SaveChangesDialog(
onSaveClick = { state.eventSink(SecurityAndPrivacyEvents.Save) }, onSaveClick = { state.eventSink(SecurityAndPrivacyEvent.Save) },
onDiscardClick = { state.eventSink(SecurityAndPrivacyEvents.Exit) }, onDiscardClick = { state.eventSink(SecurityAndPrivacyEvent.Exit) },
onDismiss = { state.eventSink(SecurityAndPrivacyEvents.DismissExitConfirmation) } onDismiss = { state.eventSink(SecurityAndPrivacyEvent.DismissExitConfirmation) }
) )
} }
}, },
@ -146,7 +146,7 @@ fun SecurityAndPrivacyView(
progressText = stringResource(CommonStrings.common_saving), progressText = stringResource(CommonStrings.common_saving),
) )
}, },
onRetry = { state.eventSink(SecurityAndPrivacyEvents.Save) }, onRetry = { state.eventSink(SecurityAndPrivacyEvent.Save) },
) )
} }

48
features/securityandprivacy/impl/src/test/kotlin/io/element/android/features/securityandprivacy/impl/SecurityAndPrivacyPresenterTest.kt
View file

@ -9,7 +9,7 @@
package io.element.android.features.securityandprivacy.impl package io.element.android.features.securityandprivacy.impl
import com.google.common.truth.Truth.assertThat import com.google.common.truth.Truth.assertThat
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyEvents import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyEvent
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyHistoryVisibility import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyHistoryVisibility
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyPresenter import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyPresenter
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyRoomAccess import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyRoomAccess
@ -96,13 +96,13 @@ class SecurityAndPrivacyPresenterTest {
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly) assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly)
assertThat(showRoomVisibilitySections).isFalse() assertThat(showRoomVisibilitySections).isFalse()
eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone)) eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.Anyone) assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.Anyone)
assertThat(showRoomVisibilitySections).isTrue() assertThat(showRoomVisibilitySections).isTrue()
assertThat(canBeSaved).isTrue() assertThat(canBeSaved).isTrue()
eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.InviteOnly)) eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.InviteOnly))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly) assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly)
@ -119,12 +119,12 @@ class SecurityAndPrivacyPresenterTest {
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceSelection) assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceSelection)
eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceInvite)) eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceInvite))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceInvite) assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceInvite)
assertThat(canBeSaved).isTrue() assertThat(canBeSaved).isTrue()
eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceSelection)) eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceSelection))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceSelection) assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.SinceSelection)
@ -140,26 +140,26 @@ class SecurityAndPrivacyPresenterTest {
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isEncrypted).isFalse() assertThat(editedSettings.isEncrypted).isFalse()
eventSink(SecurityAndPrivacyEvents.ToggleEncryptionState) eventSink(SecurityAndPrivacyEvent.ToggleEncryptionState)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(showEnableEncryptionConfirmation).isTrue() assertThat(showEnableEncryptionConfirmation).isTrue()
eventSink(SecurityAndPrivacyEvents.CancelEnableEncryption) eventSink(SecurityAndPrivacyEvent.CancelEnableEncryption)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(showEnableEncryptionConfirmation).isFalse() assertThat(showEnableEncryptionConfirmation).isFalse()
eventSink(SecurityAndPrivacyEvents.ToggleEncryptionState) eventSink(SecurityAndPrivacyEvent.ToggleEncryptionState)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(showEnableEncryptionConfirmation).isTrue() assertThat(showEnableEncryptionConfirmation).isTrue()
eventSink(SecurityAndPrivacyEvents.ConfirmEnableEncryption) eventSink(SecurityAndPrivacyEvent.ConfirmEnableEncryption)
} }
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isEncrypted).isTrue() assertThat(editedSettings.isEncrypted).isTrue()
assertThat(showEnableEncryptionConfirmation).isFalse() assertThat(showEnableEncryptionConfirmation).isFalse()
assertThat(canBeSaved).isTrue() assertThat(canBeSaved).isTrue()
eventSink(SecurityAndPrivacyEvents.ToggleEncryptionState) eventSink(SecurityAndPrivacyEvent.ToggleEncryptionState)
} }
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
@ -186,12 +186,12 @@ class SecurityAndPrivacyPresenterTest {
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(false)) assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(false))
eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility) eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true)) assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true))
assertThat(canBeSaved).isTrue() assertThat(canBeSaved).isTrue()
eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility) eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(false)) assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(false))
@ -208,7 +208,7 @@ class SecurityAndPrivacyPresenterTest {
presenter.test { presenter.test {
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
eventSink(SecurityAndPrivacyEvents.EditRoomAddress) eventSink(SecurityAndPrivacyEvent.EditRoomAddress)
} }
assert(openEditRoomAddressLambda).isCalledOnce() assert(openEditRoomAddressLambda).isCalledOnce()
} }
@ -243,23 +243,23 @@ class SecurityAndPrivacyPresenterTest {
skipItems(2) skipItems(2)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly) assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly)
eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone)) eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone))
} }
with(awaitItem()) { with(awaitItem()) {
eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.Anyone)) eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.Anyone))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.Anyone) assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.Anyone)
eventSink(SecurityAndPrivacyEvents.ConfirmEnableEncryption) eventSink(SecurityAndPrivacyEvent.ConfirmEnableEncryption)
} }
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isEncrypted).isTrue() assertThat(editedSettings.isEncrypted).isTrue()
eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility) eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true)) assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true))
eventSink(SecurityAndPrivacyEvents.Save) eventSink(SecurityAndPrivacyEvent.Save)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(saveAction).isEqualTo(AsyncAction.Loading) assertThat(saveAction).isEqualTo(AsyncAction.Loading)
@ -311,23 +311,23 @@ class SecurityAndPrivacyPresenterTest {
skipItems(2) skipItems(2)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly) assertThat(editedSettings.roomAccess).isEqualTo(SecurityAndPrivacyRoomAccess.InviteOnly)
eventSink(SecurityAndPrivacyEvents.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone)) eventSink(SecurityAndPrivacyEvent.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.Anyone))
} }
with(awaitItem()) { with(awaitItem()) {
eventSink(SecurityAndPrivacyEvents.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.Anyone)) eventSink(SecurityAndPrivacyEvent.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.Anyone))
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.Anyone) assertThat(editedSettings.historyVisibility).isEqualTo(SecurityAndPrivacyHistoryVisibility.Anyone)
eventSink(SecurityAndPrivacyEvents.ConfirmEnableEncryption) eventSink(SecurityAndPrivacyEvent.ConfirmEnableEncryption)
} }
skipItems(1) skipItems(1)
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isEncrypted).isTrue() assertThat(editedSettings.isEncrypted).isTrue()
eventSink(SecurityAndPrivacyEvents.ToggleRoomVisibility) eventSink(SecurityAndPrivacyEvent.ToggleRoomVisibility)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true)) assertThat(editedSettings.isVisibleInRoomDirectory).isEqualTo(AsyncData.Success(true))
eventSink(SecurityAndPrivacyEvents.Save) eventSink(SecurityAndPrivacyEvent.Save)
} }
with(awaitItem()) { with(awaitItem()) {
assertThat(saveAction).isEqualTo(AsyncAction.Loading) assertThat(saveAction).isEqualTo(AsyncAction.Loading)
@ -352,7 +352,7 @@ class SecurityAndPrivacyPresenterTest {
assert(updateRoomVisibilityLambda).isCalledOnce() assert(updateRoomVisibilityLambda).isCalledOnce()
assert(updateRoomHistoryVisibilityLambda).isCalledOnce() assert(updateRoomHistoryVisibilityLambda).isCalledOnce()
// Clear error // Clear error
state.eventSink(SecurityAndPrivacyEvents.DismissSaveError) state.eventSink(SecurityAndPrivacyEvent.DismissSaveError)
with(awaitItem()) { with(awaitItem()) {
assertThat(saveAction).isEqualTo(AsyncAction.Uninitialized) assertThat(saveAction).isEqualTo(AsyncAction.Uninitialized)
} }

44
features/securityandprivacy/impl/src/test/kotlin/io/element/android/features/securityandprivacy/impl/SecurityAndPrivacyViewTest.kt
View file

@ -14,7 +14,7 @@ import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick import androidx.compose.ui.test.performClick
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyEvents import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyEvent
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyHistoryVisibility import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyHistoryVisibility
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyRoomAccess import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyRoomAccess
import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyState import io.element.android.features.securityandprivacy.impl.root.SecurityAndPrivacyState
@ -39,53 +39,53 @@ class SecurityAndPrivacyViewTest {
@Test @Test
fun `click on back invokes emits the expected event`() { fun `click on back invokes emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.pressBack() rule.pressBack()
recorder.assertSingle(SecurityAndPrivacyEvents.Exit) recorder.assertSingle(SecurityAndPrivacyEvent.Exit)
} }
@Test @Test
fun `discard cancellation emits the expected event`() { fun `discard cancellation emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
saveAction = AsyncAction.ConfirmingCancellation, saveAction = AsyncAction.ConfirmingCancellation,
eventSink = recorder, eventSink = recorder,
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(CommonStrings.action_discard) rule.clickOn(CommonStrings.action_discard)
recorder.assertSingle(SecurityAndPrivacyEvents.Exit) recorder.assertSingle(SecurityAndPrivacyEvent.Exit)
} }
@Test @Test
fun `save cancellation confirmation emits the expected event`() { fun `save cancellation confirmation emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
saveAction = AsyncAction.ConfirmingCancellation, saveAction = AsyncAction.ConfirmingCancellation,
eventSink = recorder, eventSink = recorder,
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(CommonStrings.action_save, inDialog = true) rule.clickOn(CommonStrings.action_save, inDialog = true)
recorder.assertSingle(SecurityAndPrivacyEvents.Save) recorder.assertSingle(SecurityAndPrivacyEvent.Save)
} }
@Test @Test
fun `click on room access item emits the expected event`() { fun `click on room access item emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(R.string.screen_security_and_privacy_room_access_invite_only_option_title) rule.clickOn(R.string.screen_security_and_privacy_room_access_invite_only_option_title)
recorder.assertSingle(SecurityAndPrivacyEvents.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.InviteOnly)) recorder.assertSingle(SecurityAndPrivacyEvent.ChangeRoomAccess(SecurityAndPrivacyRoomAccess.InviteOnly))
} }
@Test @Test
fun `click on disabled save doesn't emit event`() { fun `click on disabled save doesn't emit event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>(expectEvents = false) val recorder = EventsRecorder<SecurityAndPrivacyEvent>(expectEvents = false)
val state = aSecurityAndPrivacyState(eventSink = recorder) val state = aSecurityAndPrivacyState(eventSink = recorder)
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(CommonStrings.action_save) rule.clickOn(CommonStrings.action_save)
@ -94,7 +94,7 @@ class SecurityAndPrivacyViewTest {
@Test @Test
fun `click on enabled save emits the expected event`() { fun `click on enabled save emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
editedSettings = aSecurityAndPrivacySettings( editedSettings = aSecurityAndPrivacySettings(
@ -103,14 +103,14 @@ class SecurityAndPrivacyViewTest {
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(CommonStrings.action_save) rule.clickOn(CommonStrings.action_save)
recorder.assertSingle(SecurityAndPrivacyEvents.Save) recorder.assertSingle(SecurityAndPrivacyEvent.Save)
} }
@Test @Test
@Config(qualifiers = "h640dp") @Config(qualifiers = "h640dp")
fun `click on room address item emits the expected event`() { fun `click on room address item emits the expected event`() {
val address = "@alias:matrix.org" val address = "@alias:matrix.org"
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
editedSettings = aSecurityAndPrivacySettings( editedSettings = aSecurityAndPrivacySettings(
@ -120,13 +120,13 @@ class SecurityAndPrivacyViewTest {
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.onNodeWithText(address).performClick() rule.onNodeWithText(address).performClick()
recorder.assertSingle(SecurityAndPrivacyEvents.EditRoomAddress) recorder.assertSingle(SecurityAndPrivacyEvent.EditRoomAddress)
} }
@Test @Test
@Config(qualifiers = "h1024dp") @Config(qualifiers = "h1024dp")
fun `click on room visibility item emits the expected event`() { fun `click on room visibility item emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
editedSettings = aSecurityAndPrivacySettings( editedSettings = aSecurityAndPrivacySettings(
@ -136,13 +136,13 @@ class SecurityAndPrivacyViewTest {
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(R.string.screen_security_and_privacy_room_directory_visibility_toggle_title) rule.clickOn(R.string.screen_security_and_privacy_room_directory_visibility_toggle_title)
recorder.assertSingle(SecurityAndPrivacyEvents.ToggleRoomVisibility) recorder.assertSingle(SecurityAndPrivacyEvent.ToggleRoomVisibility)
} }
@Test @Test
@Config(qualifiers = "h640dp") @Config(qualifiers = "h640dp")
fun `click on history visibility item emits the expected event`() { fun `click on history visibility item emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
editedSettings = aSecurityAndPrivacySettings( editedSettings = aSecurityAndPrivacySettings(
@ -151,32 +151,32 @@ class SecurityAndPrivacyViewTest {
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(R.string.screen_security_and_privacy_room_history_since_selecting_option_title) rule.clickOn(R.string.screen_security_and_privacy_room_history_since_selecting_option_title)
recorder.assertSingle(SecurityAndPrivacyEvents.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceSelection)) recorder.assertSingle(SecurityAndPrivacyEvent.ChangeHistoryVisibility(SecurityAndPrivacyHistoryVisibility.SinceSelection))
} }
@Test @Test
@Config(qualifiers = "h640dp") @Config(qualifiers = "h640dp")
fun `click on encryption item emits the expected event`() { fun `click on encryption item emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
savedSettings = aSecurityAndPrivacySettings(isEncrypted = false), savedSettings = aSecurityAndPrivacySettings(isEncrypted = false),
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(R.string.screen_security_and_privacy_encryption_toggle_title) rule.clickOn(R.string.screen_security_and_privacy_encryption_toggle_title)
recorder.assertSingle(SecurityAndPrivacyEvents.ToggleEncryptionState) recorder.assertSingle(SecurityAndPrivacyEvent.ToggleEncryptionState)
} }
@Test @Test
fun `click on encryption confirm emits the expected event`() { fun `click on encryption confirm emits the expected event`() {
val recorder = EventsRecorder<SecurityAndPrivacyEvents>() val recorder = EventsRecorder<SecurityAndPrivacyEvent>()
val state = aSecurityAndPrivacyState( val state = aSecurityAndPrivacyState(
eventSink = recorder, eventSink = recorder,
showEncryptionConfirmation = true, showEncryptionConfirmation = true,
) )
rule.setSecurityAndPrivacyView(state) rule.setSecurityAndPrivacyView(state)
rule.clickOn(R.string.screen_security_and_privacy_enable_encryption_alert_confirm_button_title) rule.clickOn(R.string.screen_security_and_privacy_enable_encryption_alert_confirm_button_title)
recorder.assertSingle(SecurityAndPrivacyEvents.ConfirmEnableEncryption) recorder.assertSingle(SecurityAndPrivacyEvent.ConfirmEnableEncryption)
} }
} }