bitwarden_vault/folder/
edit.rs1use bitwarden_core::{ApiError, MissingFieldError, key_management::KeyIds};
2use bitwarden_crypto::{CryptoError, KeyStore};
3use bitwarden_error::bitwarden_error;
4use bitwarden_state::repository::{Repository, RepositoryError};
5use thiserror::Error;
6#[cfg(feature = "wasm")]
7use wasm_bindgen::prelude::*;
8
9use crate::{
10 Folder, FolderAddEditRequest, FolderId, FolderView, ItemNotFoundError, VaultParseError,
11};
12
13#[allow(missing_docs)]
14#[bitwarden_error(flat)]
15#[derive(Debug, Error)]
16pub enum EditFolderError {
17 #[error(transparent)]
18 ItemNotFound(#[from] ItemNotFoundError),
19 #[error(transparent)]
20 Crypto(#[from] CryptoError),
21 #[error(transparent)]
22 Api(#[from] ApiError),
23 #[error(transparent)]
24 VaultParse(#[from] VaultParseError),
25 #[error(transparent)]
26 MissingField(#[from] MissingFieldError),
27 #[error(transparent)]
28 Repository(#[from] RepositoryError),
29 #[error(transparent)]
30 Uuid(#[from] uuid::Error),
31}
32
33pub(super) async fn edit_folder<R: Repository<Folder> + ?Sized>(
34 key_store: &KeyStore<KeyIds>,
35 api_client: &bitwarden_api_api::apis::ApiClient,
36 repository: &R,
37 folder_id: FolderId,
38 request: FolderAddEditRequest,
39) -> Result<FolderView, EditFolderError> {
40 let id = folder_id.to_string();
41
42 repository.get(id.clone()).await?.ok_or(ItemNotFoundError)?;
44
45 let folder_request = key_store.encrypt(request)?;
46
47 let resp = api_client
48 .folders_api()
49 .put(&id, Some(folder_request))
50 .await
51 .map_err(ApiError::from)?;
52
53 let folder: Folder = resp.try_into()?;
54
55 debug_assert!(folder.id.unwrap_or_default() == folder_id);
56
57 repository.set(id, folder.clone()).await?;
58
59 Ok(key_store.decrypt(&folder)?)
60}
61
62#[cfg(test)]
63mod tests {
64 use bitwarden_api_api::{apis::ApiClient, models::FolderResponseModel};
65 use bitwarden_core::key_management::SymmetricKeyId;
66 use bitwarden_crypto::{PrimitiveEncryptable, SymmetricCryptoKey};
67 use bitwarden_test::MemoryRepository;
68 use uuid::uuid;
69
70 use super::*;
71 use crate::FolderId;
72
73 async fn repository_add_folder(
74 repository: &MemoryRepository<Folder>,
75 store: &KeyStore<KeyIds>,
76 folder_id: FolderId,
77 name: &str,
78 ) {
79 repository
80 .set(
81 folder_id.to_string(),
82 Folder {
83 id: Some(folder_id),
84 name: name
85 .encrypt(&mut store.context(), SymmetricKeyId::User)
86 .unwrap(),
87 revision_date: "2024-01-01T00:00:00Z".parse().unwrap(),
88 },
89 )
90 .await
91 .unwrap();
92 }
93
94 #[tokio::test]
95 async fn test_edit_folder() {
96 let store: KeyStore<KeyIds> = KeyStore::default();
97 #[allow(deprecated)]
98 let _ = store.context_mut().set_symmetric_key(
99 SymmetricKeyId::User,
100 SymmetricCryptoKey::make_aes256_cbc_hmac_key(),
101 );
102
103 let folder_id: FolderId = "25afb11c-9c95-4db5-8bac-c21cb204a3f1".parse().unwrap();
104
105 let api_client = ApiClient::new_mocked(move |mock| {
106 mock.folders_api
107 .expect_put()
108 .returning(move |id, model| {
109 assert_eq!(id, folder_id.to_string());
110 Ok(FolderResponseModel {
111 object: Some("folder".to_string()),
112 id: Some(folder_id.into()),
113 name: Some(model.unwrap().name),
114 revision_date: Some("2025-01-01T00:00:00Z".to_string()),
115 })
116 })
117 .once();
118 });
119
120 let repository = MemoryRepository::<Folder>::default();
121 repository_add_folder(&repository, &store, folder_id, "old_name").await;
122
123 let result = edit_folder(
124 &store,
125 &api_client,
126 &repository,
127 folder_id,
128 FolderAddEditRequest {
129 name: "test".to_string(),
130 },
131 )
132 .await
133 .unwrap();
134
135 assert_eq!(
136 result,
137 FolderView {
138 id: Some(folder_id),
139 name: "test".to_string(),
140 revision_date: "2025-01-01T00:00:00Z".parse().unwrap(),
141 }
142 );
143 }
144
145 #[tokio::test]
146 async fn test_edit_folder_does_not_exist() {
147 let store: KeyStore<KeyIds> = KeyStore::default();
148
149 let repository = MemoryRepository::<Folder>::default();
150 let folder_id = FolderId::new(uuid!("25afb11c-9c95-4db5-8bac-c21cb204a3f1"));
151
152 let api_client = ApiClient::new_mocked(|_| {});
153
154 let result = edit_folder(
155 &store,
156 &api_client,
157 &repository,
158 folder_id,
159 FolderAddEditRequest {
160 name: "test".to_string(),
161 },
162 )
163 .await;
164
165 assert!(result.is_err());
166 assert!(matches!(
167 result.unwrap_err(),
168 EditFolderError::ItemNotFound(_)
169 ));
170 }
171
172 #[tokio::test]
173 async fn test_edit_folder_http_error() {
174 let store: KeyStore<KeyIds> = KeyStore::default();
175 #[allow(deprecated)]
176 let _ = store.context_mut().set_symmetric_key(
177 SymmetricKeyId::User,
178 SymmetricCryptoKey::make_aes256_cbc_hmac_key(),
179 );
180
181 let folder_id: FolderId = "25afb11c-9c95-4db5-8bac-c21cb204a3f1".parse().unwrap();
182
183 let api_client = ApiClient::new_mocked(move |mock| {
184 mock.folders_api.expect_put().returning(move |_id, _model| {
185 Err(bitwarden_api_api::apis::Error::Io(std::io::Error::other(
186 "Simulated error",
187 )))
188 });
189 });
190
191 let repository = MemoryRepository::<Folder>::default();
192 repository_add_folder(&repository, &store, folder_id, "old_name").await;
193
194 let result = edit_folder(
195 &store,
196 &api_client,
197 &repository,
198 folder_id,
199 FolderAddEditRequest {
200 name: "test".to_string(),
201 },
202 )
203 .await;
204
205 assert!(result.is_err());
206 assert!(matches!(result.unwrap_err(), EditFolderError::Api(_)));
207 }
208}