bitwarden_vault/folder/
folder_sync_handler.rs1use std::sync::Arc;
2
3use bitwarden_core::{FromClient, require};
4use bitwarden_state::repository::{Repository, RepositoryOption};
5use bitwarden_sync::{SyncHandler, SyncHandlerError};
6
7use crate::{Folder, FolderId};
8
9#[derive(FromClient)]
13pub struct FolderSyncHandler {
14 repository: Option<Arc<dyn Repository<Folder>>>,
15}
16
17#[async_trait::async_trait]
18impl SyncHandler for FolderSyncHandler {
19 async fn on_sync(
20 &self,
21 response: &bitwarden_api_api::models::SyncResponseModel,
22 ) -> Result<(), SyncHandlerError> {
23 let repository = self.repository.require()?;
24 let api_folders = require!(response.folders.as_ref());
25
26 let folders: Vec<(FolderId, Folder)> = api_folders
27 .iter()
28 .filter_map(|f| {
29 Folder::try_from(f.clone())
30 .inspect_err(
31 |e| tracing::error!(id = ?f.id, error = ?e, "Failed to deserialize folder"),
32 )
33 .ok()
34 .and_then(|folder| {
35 let id = folder.id.or_else(|| {
36 tracing::error!("Skipping folder with missing id");
37 None
38 })?;
39 Some((id, folder))
40 })
41 })
42 .collect();
43
44 repository.replace_all(folders).await?;
45
46 Ok(())
47 }
48}
49
50#[cfg(test)]
51mod tests {
52 use std::sync::Arc;
53
54 use bitwarden_api_api::models::{FolderResponseModel, SyncResponseModel};
55 use bitwarden_test::MemoryRepository;
56
57 use super::*;
58
59 const ENCRYPTED_NAME: &str = "2.AAAAAAAAAAAAAAAAAAAAAA==|AAAAAAAAAAAAAAAAAAAAAA==|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
61
62 fn make_folder_response(id: uuid::Uuid) -> FolderResponseModel {
63 FolderResponseModel {
64 object: Some("folder".to_string()),
65 id: Some(id),
66 name: Some(ENCRYPTED_NAME.to_string()),
67 revision_date: Some("2025-01-01T00:00:00Z".to_string()),
68 }
69 }
70
71 #[tokio::test]
72 async fn test_on_sync_replaces_existing_folders() {
73 let repository = Arc::new(MemoryRepository::<Folder>::default());
74 let handler = FolderSyncHandler {
75 repository: Some(repository.clone()),
76 };
77
78 let id1 = uuid::Uuid::new_v4();
80 let id2 = uuid::Uuid::new_v4();
81 let response = SyncResponseModel {
82 folders: Some(vec![make_folder_response(id1), make_folder_response(id2)]),
83 ..Default::default()
84 };
85 handler.on_sync(&response).await.unwrap();
86 assert_eq!(repository.list().await.unwrap().len(), 2);
87
88 let id3 = uuid::Uuid::new_v4();
90 let response = SyncResponseModel {
91 folders: Some(vec![make_folder_response(id3)]),
92 ..Default::default()
93 };
94 handler.on_sync(&response).await.unwrap();
95
96 let stored = repository.list().await.unwrap();
97 assert_eq!(stored.len(), 1);
98 assert!(repository.get(FolderId::new(id1)).await.unwrap().is_none());
99 assert!(repository.get(FolderId::new(id2)).await.unwrap().is_none());
100 assert!(repository.get(FolderId::new(id3)).await.unwrap().is_some());
101 }
102
103 #[tokio::test]
104 async fn test_on_sync_no_folders_returns_error() {
105 let repository = Arc::new(MemoryRepository::<Folder>::default());
106 let handler = FolderSyncHandler {
107 repository: Some(repository.clone()),
108 };
109
110 let response = SyncResponseModel::default();
111 let result = handler.on_sync(&response).await;
112 assert!(result.is_err());
113 }
114}