github-starred/android
2
0
Fork 0
mirror of https://github.com/bitwarden/android.git synced 2026-04-29 12:32:26 -05:00
Code Issues 936 Packages Projects Releases 122 Wiki Activity

PM-25478: Update sends and folders while vault is locked (#5837)

Browse Source
This commit is contained in:
David Perez
2025-09-05 09:32:49 -05:00
committed by GitHub
parent 393931a5c6
commit 2bd4834b14
2 changed files with 107 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
app/src/main/kotlin/com/x8bit/bitwarden/data/vault/repository/VaultRepositoryImpl.kt
View File

@@ -114,7 +114,6 @@ import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.mapNotNull
import kotlinx.coroutines.flow.merge import kotlinx.coroutines.flow.merge
import kotlinx.coroutines.flow.onEach import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.onStart import kotlinx.coroutines.flow.onStart
@@ -1397,15 +1396,14 @@ class VaultRepositoryImpl(
val isUpdate = syncSendUpsertData.isUpdate val isUpdate = syncSendUpsertData.isUpdate
val revisionDate = syncSendUpsertData.revisionDate val revisionDate = syncSendUpsertData.revisionDate
val localSend = sendDataStateFlow val localSend = vaultDiskSource
.mapNotNull { it.data } .getSends(userId = userId)
.first() .first()
.sendViewList
.find { it.id == sendId } .find { it.id == sendId }
val isValidCreate = !isUpdate && localSend == null val isValidCreate = !isUpdate && localSend == null
val isValidUpdate = isUpdate && val isValidUpdate = isUpdate &&
localSend != null && localSend != null &&
localSend.revisionDate.epochSecond < revisionDate.toEpochSecond() localSend.revisionDate.toEpochSecond() < revisionDate.toEpochSecond()
if (!isValidCreate && !isValidUpdate) return if (!isValidCreate && !isValidUpdate) return
@@ -1447,21 +1445,20 @@ class VaultRepositoryImpl(
val folderId = syncFolderUpsertData.folderId val folderId = syncFolderUpsertData.folderId
val isUpdate = syncFolderUpsertData.isUpdate val isUpdate = syncFolderUpsertData.isUpdate
val revisionDate = syncFolderUpsertData.revisionDate val revisionDate = syncFolderUpsertData.revisionDate
val localFolder = vaultDiskSource
val localFolder = foldersStateFlow .getFolders(userId = userId)
.mapNotNull { it.data }
.first() .first()
.find { it.id == folderId } .find { it.id == folderId }
val isValidCreate = !isUpdate && localFolder == null val isValidCreate = !isUpdate && localFolder == null
val isValidUpdate = isUpdate && val isValidUpdate = isUpdate &&
localFolder != null && localFolder != null &&
localFolder.revisionDate.epochSecond < revisionDate.toEpochSecond() localFolder.revisionDate.toEpochSecond() < revisionDate.toEpochSecond()
if (!isValidCreate && !isValidUpdate) return if (!isValidCreate && !isValidUpdate) return
folderService folderService
.getFolder(folderId) .getFolder(folderId = folderId)
.onSuccess { vaultDiskSource.saveFolder(userId, it) } .onSuccess { vaultDiskSource.saveFolder(userId = userId, folder = it) }
} }
//endregion Push Notification helpers //endregion Push Notification helpers

315
app/src/test/kotlin/com/x8bit/bitwarden/data/vault/repository/VaultRepositoryTest.kt
View File

@@ -3788,53 +3788,37 @@ class VaultRepositoryTest {
fun `syncSendUpsertFlow update failure with 404 code should make a request for a send and then delete it`() = fun `syncSendUpsertFlow update failure with 404 code should make a request for a send and then delete it`() =
runTest { runTest {
val number = 1 val number = 1
val userId = MOCK_USER_STATE.activeUserId
val sendId = "mockId-$number" val sendId = "mockId-$number"
fakeAuthDiskSource.userState = MOCK_USER_STATE
val response: HttpException = mockk { val response: HttpException = mockk {
every { code() } returns 404 every { code() } returns 404
} }
coEvery { sendsService.getSend(sendId = sendId) } returns response.asFailure()
coEvery { coEvery {
sendsService.getSend(sendId) vaultDiskSource.deleteSend(userId = userId, sendId = sendId)
} returns response.asFailure()
coEvery {
vaultDiskSource.deleteSend(any(), any())
} just runs } just runs
fakeAuthDiskSource.userState = MOCK_USER_STATE val sendView = createMockSend(
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId) number = number,
val sendView = createMockSendView(number = number) revisionDate = ZonedDateTime.now(clock).minus(5, ChronoUnit.MINUTES),
)
coEvery { coEvery {
vaultSdkSource.decryptSendList( vaultDiskSource.getSends(userId = userId)
userId = MOCK_USER_STATE.activeUserId, } returns MutableStateFlow(listOf(sendView))
sendList = listOf(createMockSdkSend(number = number)),
)
} returns listOf(sendView).asSuccess()
val sendsFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Send>>() mutableSyncSendUpsertFlow.tryEmit(
setupVaultDiskSourceFlows(sendsFlow = sendsFlow) SyncSendUpsertData(
sendId = sendId,
vaultRepository.sendDataStateFlow.test { revisionDate = ZonedDateTime.now(clock),
// Populate and consume items related to the sends flow isUpdate = true,
awaitItem() ),
sendsFlow.tryEmit(listOf(createMockSend(number = number))) )
awaitItem()
mutableSyncSendUpsertFlow.tryEmit(
SyncSendUpsertData(
sendId = sendId,
revisionDate = ZonedDateTime.now(),
isUpdate = true,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
sendsService.getSend(sendId) sendsService.getSend(sendId = sendId)
vaultDiskSource.deleteSend( vaultDiskSource.deleteSend(userId = userId, sendId = sendId)
userId = MOCK_USER_STATE.activeUserId,
sendId = sendId,
)
} }
} }
@@ -3842,51 +3826,31 @@ class VaultRepositoryTest {
@Test @Test
fun `syncSendUpsertFlow create failure with 404 code should make a request for a send and do nothing`() = fun `syncSendUpsertFlow create failure with 404 code should make a request for a send and do nothing`() =
runTest { runTest {
val userId = MOCK_USER_STATE.activeUserId
val sendId = "mockId-1" val sendId = "mockId-1"
fakeAuthDiskSource.userState = MOCK_USER_STATE fakeAuthDiskSource.userState = MOCK_USER_STATE
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId)
val response: HttpException = mockk { val response: HttpException = mockk {
every { code() } returns 404 every { code() } returns 404
} }
coEvery { sendsService.getSend(sendId = sendId) } returns response.asFailure()
coEvery { coEvery {
sendsService.getSend(sendId) vaultDiskSource.getSends(userId = userId)
} returns response.asFailure() } returns MutableStateFlow(emptyList())
coEvery { mutableSyncSendUpsertFlow.tryEmit(
vaultSdkSource.decryptSendList( SyncSendUpsertData(
userId = MOCK_USER_STATE.activeUserId, sendId = sendId,
sendList = listOf(), revisionDate = ZonedDateTime.now(clock),
) isUpdate = false,
} returns emptyList<SendView>().asSuccess() ),
)
val sendsFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Send>>()
setupVaultDiskSourceFlows(sendsFlow = sendsFlow)
vaultRepository.sendDataStateFlow.test {
// Populate and consume items related to the sends flow
awaitItem()
sendsFlow.tryEmit(emptyList())
awaitItem()
mutableSyncSendUpsertFlow.tryEmit(
SyncSendUpsertData(
sendId = sendId,
revisionDate = ZonedDateTime.now(),
isUpdate = false,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
sendsService.getSend(sendId) sendsService.getSend(sendId = sendId)
} }
coVerify(exactly = 0) { coVerify(exactly = 0) {
vaultDiskSource.deleteSend( vaultDiskSource.deleteSend(userId = userId, sendId = sendId)
userId = MOCK_USER_STATE.activeUserId,
sendId = sendId,
)
} }
} }
@@ -3895,50 +3859,28 @@ class VaultRepositoryTest {
fun `syncSendUpsertFlow valid create success should make a request for a send and then store it`() = fun `syncSendUpsertFlow valid create success should make a request for a send and then store it`() =
runTest { runTest {
val number = 1 val number = 1
val userId = MOCK_USER_STATE.activeUserId
val sendId = "mockId-$number" val sendId = "mockId-$number"
fakeAuthDiskSource.userState = MOCK_USER_STATE fakeAuthDiskSource.userState = MOCK_USER_STATE
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId)
coEvery { coEvery {
vaultSdkSource.decryptSendList( vaultDiskSource.getSends(userId = userId)
userId = MOCK_USER_STATE.activeUserId, } returns MutableStateFlow(emptyList())
sendList = listOf(), val send = mockk<SyncResponseJson.Send>()
) coEvery { sendsService.getSend(sendId = sendId) } returns send.asSuccess()
} returns listOf<SendView>().asSuccess() coEvery { vaultDiskSource.saveSend(userId = userId, send = send) } just runs
val sendsFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Send>>() mutableSyncSendUpsertFlow.tryEmit(
setupVaultDiskSourceFlows(sendsFlow = sendsFlow) SyncSendUpsertData(
sendId = sendId,
val send: SyncResponseJson.Send = mockk() revisionDate = ZonedDateTime.now(clock),
coEvery { isUpdate = false,
sendsService.getSend(sendId) ),
} returns send.asSuccess() )
coEvery {
vaultDiskSource.saveSend(any(), any())
} just runs
vaultRepository.sendDataStateFlow.test {
// Populate and consume items related to the sends flow
awaitItem()
sendsFlow.tryEmit(listOf())
awaitItem()
mutableSyncSendUpsertFlow.tryEmit(
SyncSendUpsertData(
sendId = sendId,
revisionDate = ZonedDateTime.now(),
isUpdate = false,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
sendsService.getSend(sendId) sendsService.getSend(sendId = sendId)
vaultDiskSource.saveSend( vaultDiskSource.saveSend(userId = userId, send = send)
userId = MOCK_USER_STATE.activeUserId,
send = send,
)
} }
} }
@@ -3947,51 +3889,33 @@ class VaultRepositoryTest {
fun `syncSendUpsertFlow valid update success should make a request for a send and then store it`() = fun `syncSendUpsertFlow valid update success should make a request for a send and then store it`() =
runTest { runTest {
val number = 1 val number = 1
val userId = MOCK_USER_STATE.activeUserId
val sendId = "mockId-$number" val sendId = "mockId-$number"
fakeAuthDiskSource.userState = MOCK_USER_STATE fakeAuthDiskSource.userState = MOCK_USER_STATE
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId) val sendView = createMockSend(
val sendView = createMockSendView(number = number) number = number,
revisionDate = ZonedDateTime.now(clock).minus(5, ChronoUnit.MINUTES),
)
coEvery { coEvery {
vaultSdkSource.decryptSendList( vaultDiskSource.getSends(userId = userId)
userId = MOCK_USER_STATE.activeUserId, } returns MutableStateFlow(listOf(sendView))
sendList = listOf(createMockSdkSend(number = number)),
)
} returns listOf(sendView).asSuccess()
val sendsFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Send>>() val send = mockk<SyncResponseJson.Send>()
setupVaultDiskSourceFlows(sendsFlow = sendsFlow) coEvery { sendsService.getSend(sendId = sendId) } returns send.asSuccess()
coEvery { vaultDiskSource.saveSend(userId = userId, send = send) } just runs
val send: SyncResponseJson.Send = mockk() mutableSyncSendUpsertFlow.tryEmit(
coEvery { SyncSendUpsertData(
sendsService.getSend(sendId) sendId = sendId,
} returns send.asSuccess() revisionDate = ZonedDateTime.now(clock),
isUpdate = true,
coEvery { ),
vaultDiskSource.saveSend(any(), any()) )
} just runs
vaultRepository.sendDataStateFlow.test {
// Populate and consume items related to the sends flow
awaitItem()
sendsFlow.tryEmit(listOf(createMockSend(number = number)))
awaitItem()
mutableSyncSendUpsertFlow.tryEmit(
SyncSendUpsertData(
sendId = sendId,
revisionDate = ZonedDateTime.now(),
isUpdate = true,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
sendsService.getSend(sendId) sendsService.getSend(sendId = sendId)
vaultDiskSource.saveSend( vaultDiskSource.saveSend(userId = userId, send = send)
userId = MOCK_USER_STATE.activeUserId,
send = send,
)
} }
} }
@@ -4140,50 +4064,28 @@ class VaultRepositoryTest {
fun `syncFolderUpsertFlow valid create success should make a request for a folder and then store it`() = fun `syncFolderUpsertFlow valid create success should make a request for a folder and then store it`() =
runTest { runTest {
val number = 1 val number = 1
val userId = MOCK_USER_STATE.activeUserId
val folderId = "mockId-$number" val folderId = "mockId-$number"
fakeAuthDiskSource.userState = MOCK_USER_STATE fakeAuthDiskSource.userState = MOCK_USER_STATE
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId)
coEvery { coEvery {
vaultSdkSource.decryptFolderList( vaultDiskSource.getFolders(userId = userId)
userId = MOCK_USER_STATE.activeUserId, } returns MutableStateFlow(emptyList())
folderList = listOf(), val folder = mockk<SyncResponseJson.Folder>()
) coEvery { folderService.getFolder(folderId = folderId) } returns folder.asSuccess()
} returns listOf<FolderView>().asSuccess() coEvery { vaultDiskSource.saveFolder(userId = userId, folder = folder) } just runs
val foldersFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Folder>>() mutableSyncFolderUpsertFlow.tryEmit(
setupVaultDiskSourceFlows(foldersFlow = foldersFlow) SyncFolderUpsertData(
folderId = folderId,
val folder: SyncResponseJson.Folder = mockk() revisionDate = ZonedDateTime.now(clock),
coEvery { isUpdate = false,
folderService.getFolder(folderId) ),
} returns folder.asSuccess() )
coEvery {
vaultDiskSource.saveFolder(any(), any())
} just runs
vaultRepository.foldersStateFlow.test {
// Populate and consume items related to the folders flow
awaitItem()
foldersFlow.tryEmit(listOf())
awaitItem()
mutableSyncFolderUpsertFlow.tryEmit(
SyncFolderUpsertData(
folderId = folderId,
revisionDate = ZonedDateTime.now(),
isUpdate = false,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
folderService.getFolder(folderId) folderService.getFolder(folderId = folderId)
vaultDiskSource.saveFolder( vaultDiskSource.saveFolder(userId = userId, folder = folder)
userId = MOCK_USER_STATE.activeUserId,
folder = folder,
)
} }
} }
@@ -4192,51 +4094,32 @@ class VaultRepositoryTest {
fun `syncFolderUpsertFlow valid update success should make a request for a folder and then store it`() = fun `syncFolderUpsertFlow valid update success should make a request for a folder and then store it`() =
runTest { runTest {
val number = 1 val number = 1
val userId = MOCK_USER_STATE.activeUserId
val folderId = "mockId-$number" val folderId = "mockId-$number"
fakeAuthDiskSource.userState = MOCK_USER_STATE fakeAuthDiskSource.userState = MOCK_USER_STATE
setVaultToUnlocked(userId = MOCK_USER_STATE.activeUserId) val folderView = createMockFolder(
val folderView = createMockFolderView(number = number) number = number,
revisionDate = ZonedDateTime.now(clock).minus(5, ChronoUnit.MINUTES),
)
coEvery { coEvery {
vaultSdkSource.decryptFolderList( vaultDiskSource.getFolders(userId = userId)
userId = MOCK_USER_STATE.activeUserId, } returns MutableStateFlow(listOf(folderView))
folderList = listOf(createMockSdkFolder(number = number)), val folder = mockk<SyncResponseJson.Folder>()
) coEvery { folderService.getFolder(folderId = folderId) } returns folder.asSuccess()
} returns listOf(folderView).asSuccess() coEvery { vaultDiskSource.saveFolder(userId = userId, folder = folder) } just runs
val foldersFlow = bufferedMutableSharedFlow<List<SyncResponseJson.Folder>>() mutableSyncFolderUpsertFlow.tryEmit(
setupVaultDiskSourceFlows(foldersFlow = foldersFlow) SyncFolderUpsertData(
folderId = folderId,
val folder: SyncResponseJson.Folder = mockk() revisionDate = ZonedDateTime.now(clock),
coEvery { isUpdate = true,
folderService.getFolder(folderId) ),
} returns folder.asSuccess() )
coEvery {
vaultDiskSource.saveFolder(any(), any())
} just runs
vaultRepository.foldersStateFlow.test {
// Populate and consume items related to the folders flow
awaitItem()
foldersFlow.tryEmit(listOf(createMockFolder(number = number)))
awaitItem()
mutableSyncFolderUpsertFlow.tryEmit(
SyncFolderUpsertData(
folderId = folderId,
revisionDate = ZonedDateTime.now(),
isUpdate = true,
),
)
}
coVerify(exactly = 1) { coVerify(exactly = 1) {
folderService.getFolder(folderId) folderService.getFolder(folderId)
vaultDiskSource.saveFolder( vaultDiskSource.saveFolder(userId = userId, folder = folder)
userId = MOCK_USER_STATE.activeUserId,
folder = folder,
)
} }
} }