1use super::Coven;
5use crate::*;
6use coven_crypto::custody::{Keychain, KeyringCustody, StoreKeychain};
7use coven_foundation::files::{FileBudget, StoreDirectories};
8use coven_foundation::network_watch::{NetworkSource, TestNetwork};
9use std::path::{Path, PathBuf};
10use std::sync::Arc;
11
12#[cfg(test)]
13#[path = "test_utils_tests.rs"]
14mod tests;
15
16impl Coven {
17 pub fn in_memory(app_dir: PathBuf) -> Self {
23 Self::in_memory_reporting_to(app_dir, crate::task::HeardBugs::shared())
24 }
25
26 pub fn in_memory_reporting_to(app_dir: PathBuf, bugs: crate::task::BugSinkRef) -> Self {
29 Self::testing(app_dir, Keychain::in_memory("coven-test").expect("valid service name"), bugs)
30 }
31
32 pub fn in_memory_sharing(
36 app_dir: PathBuf,
37 bugs: crate::task::BugSinkRef,
38 files: FileBudget,
39 ) -> Self {
40 Self {
41 files,
42 ..Self::testing(
43 app_dir,
44 Keychain::in_memory("coven-test").expect("valid service name"),
45 bugs,
46 )
47 }
48 }
49
50 pub fn in_memory_with_saved_keychain(app_dir: PathBuf, path: &Path) -> Result<Self, KeyError> {
55 Ok(Self::testing(
56 app_dir,
57 Keychain::in_memory_with_saved_device_entries("coven-test", path)?,
58 crate::task::HeardBugs::shared(),
59 ))
60 }
61
62 pub fn with_block_store(app_dir: PathBuf) -> Self {
66 Self::testing(
67 app_dir,
68 Keychain::in_memory_block_store("coven-test").expect("valid service name"),
69 crate::task::HeardBugs::shared(),
70 )
71 }
72
73 #[cfg(test)]
76 pub(crate) fn with_keychain(app_dir: PathBuf, keychain: Arc<Keychain>) -> Self {
77 Self::testing(app_dir, keychain, crate::task::HeardBugs::shared())
78 }
79
80 #[cfg(test)]
83 pub(crate) fn with_keychain_reporting_to(
84 app_dir: PathBuf,
85 keychain: Arc<Keychain>,
86 bugs: crate::task::BugSinkRef,
87 ) -> Self {
88 Self::testing(app_dir, keychain, bugs)
89 }
90
91 #[cfg(test)]
94 pub(crate) fn directories(&self) -> &StoreDirectories {
95 &self.directories
96 }
97
98 fn testing(app_dir: PathBuf, keychain: Arc<Keychain>, bugs: crate::task::BugSinkRef) -> Self {
99 Self {
100 directories: StoreDirectories::new(app_dir, bugs),
101 keychain,
102 network: NetworkSource::Test(TestNetwork::new(true, false)),
103 files: FileBudget::for_test(),
106 }
107 }
108
109 pub fn another_device(&self, app_dir: PathBuf) -> Self {
115 Self::testing(app_dir, self.keychain.another_device(), self.directories.bugs().clone())
116 }
117
118 pub fn set_up_new_device(&self, app_dir: PathBuf) -> Self {
122 Self::testing(app_dir, self.keychain.set_up_new_device(), self.directories.bugs().clone())
123 }
124
125 pub fn restore_new_device_from_cloud(&self, app_dir: PathBuf) -> Self {
129 Self::testing(
130 app_dir,
131 self.keychain.restore_new_device_from_cloud(),
132 self.directories.bugs().clone(),
133 )
134 }
135
136 pub fn back_up_to_cloud(&self) {
140 self.keychain.back_up_to_cloud();
141 }
142
143 pub fn set_end_to_end_encryption(&self, available: bool) {
146 self.keychain.set_end_to_end_encryption(available);
147 }
148
149 pub async fn create_closed_store(
151 &self,
152 name: &str,
153 ids: IdSourceRef,
154 ) -> Result<StoreDir, StoreCreationError> {
155 let handle = self
156 .builder()
157 .id_source(ids)
158 .synced_tables(Vec::new())
159 .migrations(Vec::new())
160 .create_store(name, "Test device", "Ana", |_| "Private".into(), &[], |_, _| Ok(()))
161 .await?;
162 let directory = self.store_dir(&handle.store_id());
163 handle.close().await?;
164 Ok(directory)
165 }
166
167 pub fn create_store_dir(
169 &self,
170 id: StoreId,
171 ids: &dyn IdSource,
172 ) -> Result<StoreDir, crate::DirectoryCreationError> {
173 self.directories.create_store_dir(id, ids)
174 }
175
176 fn drive_network(&self, change: impl FnOnce(&TestNetwork)) {
178 match &self.network {
179 NetworkSource::Test(network) => change(network),
180 NetworkSource::Platform | NetworkSource::Refused(_) => {
181 panic!("an installation made for a test drives its network")
182 }
183 }
184 }
185
186 pub fn join_network(&self, metered: bool) {
189 self.drive_network(|network| network.join(metered));
190 }
191
192 pub fn lose_network(&self) {
194 self.drive_network(TestNetwork::lose);
195 }
196
197 pub fn network_cannot_tell(&self) {
200 self.drive_network(TestNetwork::cannot_tell);
201 }
202
203 pub fn set_network_metered(&self, metered: bool) {
205 self.drive_network(|network| network.set_metered(metered));
206 }
207
208 pub fn keep_store_keys(
210 &self,
211 directory: &StoreDir,
212 keys: &StoreKeyring,
213 ) -> Result<(), KeyError> {
214 let keychain = Arc::new(StoreKeychain::new(self.keychain.clone(), directory.id()));
215 Custody::<StoreKeyring>::persist(&KeyringCustody::new(keychain), keys)
216 }
217
218 pub fn save_device_keychain(&self, path: &Path) -> Result<(), KeyError> {
223 self.keychain.save_device_entries(path)
224 }
225
226 pub fn lose_storage_credentials(&self, store: StoreId) -> Result<(), KeyError> {
231 StoreKeychain::new(self.keychain.clone(), store).delete_storage_credentials()
232 }
233
234 #[cfg(test)]
236 pub(crate) fn store_keychain(&self, store: StoreId) -> StoreKeychain {
237 StoreKeychain::new(self.keychain.clone(), store)
238 }
239
240 #[cfg(test)]
242 pub(crate) fn person_entries(&self, store: StoreId) -> coven_crypto::custody::PersonEntries {
243 coven_crypto::custody::PersonEntries::new(self.keychain.clone(), store)
244 }
245
246 #[cfg(test)]
248 pub(crate) fn refuse_person_entry_operations(&self, refuse: bool) {
249 self.keychain.refuse_person_entry_operations(refuse);
250 }
251
252 #[cfg(test)]
254 pub(crate) async fn readable_stores(&self) -> Vec<StoreInfo> {
255 self.stores()
256 .await
257 .unwrap()
258 .into_iter()
259 .map(|listed| match listed {
260 ListedStore::Readable(info) => info,
261 ListedStore::Unreadable { id, reason } => {
262 panic!("store {id} is listed as unreadable: {reason}")
263 }
264 })
265 .collect()
266 }
267
268 pub fn fail_next_keychain_operation(&self) {
270 self.keychain.fail_next_operation();
271 }
272
273 #[cfg(test)]
274 pub(crate) fn fail_keychain_operations_after(&self, successes: &[usize]) {
275 self.keychain.fail_operations_after(successes);
276 }
277}