1#[allow(unused_macros)]
32#[macro_export]
33macro_rules! cryptostore_integration_tests {
34 () => {
35 mod cryptostore_integration_tests {
36 use std::collections::{BTreeMap, HashMap};
37 use std::time::Duration;
38
39 use assert_matches::assert_matches;
40 use matrix_sdk_test::async_test;
41 use ruma::{
42 device_id, events::secret::request::SecretName, room_id, serde::Raw,
43 to_device::DeviceIdOrAllDevices, user_id, DeviceId, RoomId, TransactionId, UserId,
44 };
45 use serde_json::value::to_raw_value;
46 use serde_json::json;
47 use matrix_sdk_common::deserialized_responses::WithheldCode;
48 use $crate::{
49 olm::{
50 Account, Curve25519PublicKey, InboundGroupSession, OlmMessageHash,
51 PrivateCrossSigningIdentity, SenderData, SenderDataType, Session
52 },
53 store::{
54 types::{
55 BackupDecryptionKey, Changes, DehydratedDeviceKey, DeviceChanges,
56 IdentityChanges, PendingChanges, StoredRoomKeyBundleData, RoomSettings,
57 },
58 CryptoStore, GossipRequest,
59 },
60 testing::{get_device, get_other_identity, get_own_identity},
61 types::{
62 events::{
63 dummy::DummyEventContent,
64 olm_v1::{DecryptedSecretSendEvent, OlmV1Keys},
65 room_key_request::MegolmV1AesSha2Content,
66 room_key_withheld::{
67 CommonWithheldCodeContent, MegolmV1AesSha2WithheldContent,
68 RoomKeyWithheldContent,
69 },
70 room_key_bundle::RoomKeyBundleContent,
71 secret_send::SecretSendContent,
72 ToDeviceEvent,
73 },
74 requests::ToDeviceRequest,
75 DeviceKeys,
76 EventEncryptionAlgorithm,
77 },
78 vodozemac::megolm::{GroupSession, SessionConfig}, DeviceData, GossippedSecret, LocalTrust, SecretInfo,
79 TrackedUser,
80 };
81
82 use super::get_store;
83
84 fn alice_id() -> &'static UserId {
85 user_id!("@alice:example.org")
86 }
87
88 fn alice_device_id() -> &'static DeviceId {
89 device_id!("ALICEDEVICE")
90 }
91
92 fn bob_id() -> &'static UserId {
93 user_id!("@bob:example.org")
94 }
95
96 fn bob_device_id() -> &'static DeviceId {
97 device_id!("BOBDEVICE")
98 }
99
100 pub async fn get_loaded_store(name: &str) -> (Account, impl CryptoStore) {
101 let store = get_store(name, None, true).await;
102 let account = get_account();
103
104 store.save_pending_changes(PendingChanges { account: Some(account.deep_clone()), }).await.expect("Can't save account");
105
106 (account, store)
107 }
108
109 fn get_account() -> Account {
110 Account::with_device_id(alice_id(), alice_device_id())
111 }
112
113 pub(crate) async fn get_account_and_session() -> (Account, Session) {
114 let alice = Account::with_device_id(alice_id(), alice_device_id());
115 let mut bob = Account::with_device_id(bob_id(), bob_device_id());
116
117 bob.generate_one_time_keys(1);
118 let one_time_key = *bob.one_time_keys().values().next().unwrap();
119 let sender_key = bob.identity_keys().curve25519;
120 let session = alice.create_outbound_session_helper(
121 Default::default(),
122 sender_key,
123 one_time_key,
124 false,
125 alice.device_keys(),
126 );
127
128 (alice, session)
129 }
130
131 #[async_test]
132 async fn test_save_account_via_generic_save() {
133 let store = get_store("save_account_via_generic", None, true).await;
134 assert!(store.get_static_account().is_none());
135 assert!(store.load_account().await.unwrap().is_none());
136 let account = get_account();
137
138 store
139 .save_pending_changes(PendingChanges { account: Some(account) })
140 .await
141 .expect("Can't save account");
142 assert!(store.get_static_account().is_some());
143 }
144
145 #[async_test]
146 async fn test_save_account() {
147 let store = get_store("save_account", None, true).await;
148 assert!(store.get_static_account().is_none());
149 assert!(store.load_account().await.unwrap().is_none());
150 let account = get_account();
151
152 store
153 .save_pending_changes(PendingChanges { account: Some(account) })
154 .await
155 .expect("Can't save account");
156 assert!(store.get_static_account().is_some());
157 }
158
159 #[async_test]
160 async fn test_load_account() {
161 let store = get_store("load_account", None, true).await;
162 let account = get_account();
163
164 store
165 .save_pending_changes(PendingChanges { account: Some(account.deep_clone()) })
166 .await
167 .expect("Can't save account");
168
169 let loaded_account = store.load_account().await.expect("Can't load account");
170 let loaded_account = loaded_account.unwrap();
171
172 assert_eq!(account, loaded_account);
173 }
174
175 #[async_test]
176 async fn test_load_account_with_passphrase() {
177 let passphrase = Some("secret_passphrase");
178 let store = get_store("load_account_with_passphrase", passphrase, true).await;
179 let account = get_account();
180
181 store
182 .save_pending_changes(PendingChanges { account: Some(account.deep_clone()) })
183 .await
184 .expect("Can't save account");
185
186 let loaded_account = store.load_account().await.expect("Can't load account");
187 let loaded_account = loaded_account.unwrap();
188
189 assert_eq!(account, loaded_account);
190 }
191
192 #[async_test]
193 async fn test_save_and_share_account() {
194 let store = get_store("save_and_share_account", None, true).await;
195 let mut account = get_account();
196
197 store
198 .save_pending_changes(PendingChanges { account: Some(account.deep_clone()) })
199 .await
200 .expect("Can't save account");
201
202 account.mark_as_shared();
203 account.update_uploaded_key_count(50);
204
205 store
206 .save_pending_changes(PendingChanges { account: Some(account.deep_clone()) })
207 .await
208 .expect("Can't save account");
209
210 let loaded_account = store.load_account().await.expect("Can't load account");
211 let loaded_account = loaded_account.unwrap();
212
213 assert_eq!(account, loaded_account);
214 assert_eq!(account.uploaded_key_count(), loaded_account.uploaded_key_count());
215 }
216
217 #[async_test]
218 async fn test_load_sessions() {
219 let store = get_store("load_sessions", None, true).await;
220 let (account, session) = get_account_and_session().await;
221 store
222 .save_pending_changes(PendingChanges { account: Some(account.deep_clone()) })
223 .await
224 .expect("Can't save account");
225
226 let changes = Changes {
227 sessions: vec![session.clone()],
228 devices: DeviceChanges { new: vec![DeviceData::from_account(&account)], ..Default::default() },
229 ..Default::default()
230 };
231
232 store.save_changes(changes).await.unwrap();
233
234 let sessions = store
235 .get_sessions(&session.sender_key.to_base64())
236 .await
237 .expect("Can't load sessions")
238 .unwrap();
239 let loaded_session = sessions.get(0).cloned().expect("We should find the session in the store.");
240
241 assert_eq!(&session, &loaded_session, "The loaded session should be the same one we put into the store.");
242 }
243
244 #[async_test]
245 async fn test_add_and_save_session() {
246 let store_name = "add_and_save_session";
247
248 let (session_id, account, sender_key) = {
250 let store = get_store(store_name, None, true).await;
251 let (account, session) = get_account_and_session().await;
252 let sender_key = session.sender_key.to_base64();
253 let session_id = session.session_id().to_owned();
254
255 store
256 .save_pending_changes(PendingChanges {
257 account: Some(account.deep_clone()),
258 })
259 .await
260 .expect("Can't save account");
261 store
262 .save_changes(Changes {
263 devices: DeviceChanges {
264 new: vec![DeviceData::from_account(&account)],
265 ..Default::default()
266 },
267 ..Default::default()
268 })
269 .await
270 .unwrap();
271
272 let changes = Changes { sessions: vec![session.clone()], ..Default::default() };
273 store.save_changes(changes).await.unwrap();
274
275 let sessions = store.get_sessions(&sender_key).await.unwrap().unwrap();
276 let session = &sessions[0];
277
278 assert_eq!(session_id, session.session_id());
279
280 (session_id, account, sender_key)
281 };
282
283 let store = get_store(store_name, None, false).await;
285
286 let loaded_account = store.load_account().await.unwrap().unwrap();
288 assert_eq!(account, loaded_account);
289
290 let sessions = store.get_sessions(&sender_key).await.unwrap().unwrap();
291 let session = &sessions[0];
292
293 assert_eq!(session_id, session.session_id());
294 }
295
296 #[async_test]
297 async fn test_load_outbound_group_session() {
298 let dir = "load_outbound_group_session";
299 let room_id = room_id!("!test:localhost");
300
301 {
303 let (account, store) = get_loaded_store(dir.clone()).await;
304 assert!(
305 store.get_outbound_group_session(&room_id).await.unwrap().is_none(),
306 "Initially there should be no outbound group session"
307 );
308
309 let (session, _) =
310 account.create_group_session_pair_with_defaults(&room_id).await;
311
312 let user_id = user_id!("@example:localhost");
313 let request = ToDeviceRequest::new(
314 user_id,
315 DeviceIdOrAllDevices::AllDevices,
316 "m.dummy",
317 Raw::from_json(to_raw_value(&DummyEventContent::new()).unwrap()),
318 );
319
320 session.add_request(TransactionId::new(), request.into(), Default::default());
321
322 let changes = Changes {
323 outbound_group_sessions: vec![session.clone()],
324 ..Default::default()
325 };
326
327 store.save_changes(changes).await.expect("Can't save group session");
328 assert!(
329 store.get_outbound_group_session(&room_id).await.unwrap().is_some(),
330 "Sanity: after we've saved one, there should be an outbound_group_session"
331 );
332 }
333
334 let store = get_store(dir, None, false).await;
336 store.load_account().await.unwrap();
337
338 assert!(
340 store.get_outbound_group_session(&room_id).await.unwrap().is_some(),
341 "The outbound_group_session should have been loaded"
342 );
343 }
344
345 #[async_test]
347 async fn test_save_changes_save_inbound_group_session() {
348 let (account, store) = get_loaded_store("save_inbound_group_session").await;
349
350 let room_id = &room_id!("!test:localhost");
351 let (_, session) = account.create_group_session_pair_with_defaults(room_id).await;
352
353 let changes =
354 Changes { inbound_group_sessions: vec![session], ..Default::default() };
355
356 store.save_changes(changes).await.expect("Can't save group session");
357 }
358
359 #[async_test]
362 async fn test_save_inbound_group_session_from_backup() {
363 let (account, store) =
364 get_loaded_store("save_inbound_group_session_from_backup").await;
365
366 let room_id = &room_id!("!test:localhost");
367 let (_, session) = account.create_group_session_pair_with_defaults(room_id).await;
368
369 session.mark_as_backed_up();
370 store
371 .save_inbound_group_sessions(vec![session.clone()], Some(&"bkpver1"))
372 .await
373 .expect("could not save sessions");
374
375 let loaded_session = store
376 .get_inbound_group_session(&session.room_id, session.session_id())
377 .await
378 .expect("error when loading session")
379 .expect("session not found in store");
380 assert_eq!(session, loaded_session);
381 assert_eq!(store.get_inbound_group_sessions().await.unwrap().len(), 1);
382 assert_eq!(store.inbound_group_session_counts(None).await.unwrap().total, 1);
383
384 let to_back_up = store.inbound_group_sessions_for_backup("bkpver1", 1).await.unwrap();
386 assert_eq!(to_back_up.len(), 0, "backup was returned by backup query");
387 assert_eq!(
388 store.inbound_group_session_counts(Some(&"bkpver1")).await.unwrap().backed_up, 1,
389 "backed_up count",
390 );
391 }
392
393 #[ignore]
398 #[async_test]
399 async fn test_save_inbound_group_session_from_old_backup() {
400 let (account, store) =
401 get_loaded_store("save_inbound_group_session_from_old_backup").await;
402
403 let room_id = &room_id!("!test:localhost");
404 let (_, session) = account.create_group_session_pair_with_defaults(room_id).await;
405
406 session.mark_as_backed_up();
407 store
408 .save_inbound_group_sessions(vec![session.clone()], Some(&"bkpver1"))
409 .await
410 .expect("could not save sessions");
411
412 let to_back_up = store.inbound_group_sessions_for_backup("bkpver2", 1).await.unwrap();
414 assert_eq!(to_back_up, vec![session]);
415 assert_eq!(
416 store.inbound_group_session_counts(Some(&"bkpver2")).await.unwrap().backed_up, 0,
417 "backed_up count for backup version 2",
418 );
419 }
420
421 #[async_test]
424 async fn test_save_inbound_group_session_from_import() {
425 let (account, store) =
426 get_loaded_store("save_inbound_group_session_from_import").await;
427
428 let room_id = &room_id!("!test:localhost");
429 let (_, session) = account.create_group_session_pair_with_defaults(room_id).await;
430
431 store
432 .save_inbound_group_sessions(vec![session.clone()], None)
433 .await
434 .expect("could not save sessions");
435
436 let loaded_session = store
437 .get_inbound_group_session(&session.room_id, session.session_id())
438 .await
439 .expect("error when loading session")
440 .expect("session not found in store");
441 assert_eq!(session, loaded_session);
442 assert_eq!(store.get_inbound_group_sessions().await.unwrap().len(), 1);
443 assert_eq!(store.inbound_group_session_counts(None).await.unwrap().total, 1);
444 assert_eq!(store.inbound_group_session_counts(None).await.unwrap().backed_up, 0);
445
446 let to_back_up = store.inbound_group_sessions_for_backup("bkpver1", 1).await.unwrap();
448 assert_eq!(to_back_up, vec![session]);
449 }
450
451 #[async_test]
452 async fn test_mark_inbound_group_sessions_as_backed_up() {
453 let (account, store) =
455 get_loaded_store("mark_inbound_group_sessions_as_backed_up").await;
456 let room_id = &room_id!("!test:localhost");
457 let mut sessions: Vec<InboundGroupSession> = Vec::with_capacity(10);
458 for _i in 0..10 {
459 sessions.push(account.create_group_session_pair_with_defaults(room_id).await.1);
460 }
461 let changes = Changes { inbound_group_sessions: sessions.clone(), ..Default::default() };
462 store.save_changes(changes).await.expect("Can't save group session");
463 assert_eq!(store.inbound_group_sessions_for_backup("bkpver", 100).await.unwrap().len(), 10);
464
465 store.mark_inbound_group_sessions_as_backed_up("bkpver", &[
467 session_info(&sessions[1]),
468 session_info(&sessions[3]),
469 session_info(&sessions[5]),
470 session_info(&sessions[7]),
471 session_info(&sessions[9]),
472 ]).await.expect("Failed to mark sessions as backed up");
473
474 let to_back_up = store.inbound_group_sessions_for_backup("bkpver", 10).await.unwrap();
476 let needs_backing_up = |i: usize| to_back_up.iter().any(|s| s.session_id() == sessions[i].session_id());
477
478 assert!(!needs_backing_up(1));
480 assert!(!needs_backing_up(3));
481 assert!(!needs_backing_up(5));
482 assert!(!needs_backing_up(7));
483 assert!(!needs_backing_up(9));
484
485 assert!(needs_backing_up(0));
487 assert!(needs_backing_up(2));
488 assert!(needs_backing_up(4));
489 assert!(needs_backing_up(6));
490 assert!(needs_backing_up(8));
491 assert_eq!(to_back_up.len(), 5);
492 }
493
494 #[async_test]
495 async fn test_reset_inbound_group_session_for_backup() {
496 let (account, store) =
498 get_loaded_store("reset_inbound_group_session_for_backup").await;
499 let room_id = &room_id!("!test:localhost");
500 let mut sessions: Vec<InboundGroupSession> = Vec::with_capacity(10);
501 for _ in 0..10 {
502 sessions.push(account.create_group_session_pair_with_defaults(room_id).await.1);
503 }
504 let changes = Changes { inbound_group_sessions: sessions.clone(), ..Default::default() };
505 store.save_changes(changes).await.expect("Can't save group session");
506 assert_eq!(store.inbound_group_sessions_for_backup("backup_1", 100).await.unwrap().len(), 10);
507 store.mark_inbound_group_sessions_as_backed_up(
508 "backup_1",
509 &(0..10).map(|i| session_info(&sessions[i])).collect::<Vec<_>>(),
510 ).await.expect("Failed to mark sessions as backed up");
511
512 {
514 let to_back_up_old = store.inbound_group_sessions_for_backup("backup_1", 10).await.unwrap();
515 assert_eq!(to_back_up_old.len(), 0);
516 }
517
518 store.reset_backup_state().await.expect("reset failed");
521
522 let to_back_up = store.inbound_group_sessions_for_backup("backup_02", 10).await.unwrap();
524
525 let needs_backing_up = |i: usize| to_back_up.iter().any(|s| s.session_id() == sessions[i].session_id());
527 assert!(needs_backing_up(0));
528 assert!(needs_backing_up(1));
529 assert!(needs_backing_up(8));
530 assert!(needs_backing_up(9));
531 assert_eq!(to_back_up.len(), 10);
532 }
533
534 #[async_test]
535 async fn test_load_inbound_group_session() {
536 let dir = "load_inbound_group_session";
537 let (account, store) = get_loaded_store(dir).await;
538 assert_eq!(store.get_inbound_group_sessions().await.unwrap().len(), 0);
539
540 let room_id = &room_id!("!test:localhost");
541 let (_, session) = account.create_group_session_pair_with_defaults(room_id).await;
542
543 let export = session.export().await;
544
545 let session = InboundGroupSession::from_export(&export).unwrap();
546
547 let changes =
548 Changes { inbound_group_sessions: vec![session.clone()], ..Default::default() };
549
550 store.save_changes(changes).await.expect("Can't save group session");
551
552 drop(store);
553
554 let store = get_store(dir, None, false).await;
555
556 store.load_account().await.unwrap();
557
558 let loaded_session = store
559 .get_inbound_group_session(&session.room_id, session.session_id())
560 .await
561 .unwrap()
562 .unwrap();
563 assert_eq!(session, loaded_session);
564 loaded_session.export().await;
565
566 assert_eq!(store.get_inbound_group_sessions().await.unwrap().len(), 1);
567 assert_eq!(store.inbound_group_session_counts(None).await.unwrap().total, 1);
568 }
569
570 #[async_test]
571 async fn test_fetch_inbound_group_sessions_for_device() {
572 let (account, store) =
574 get_loaded_store("fetch_inbound_group_sessions_for_device").await;
575
576 let dev1 = Curve25519PublicKey::from_base64(
577 "wjLpTLRqbqBzLs63aYaEv2Boi6cFEbbM/sSRQ2oAKk4"
578 ).unwrap();
579 let dev2 = Curve25519PublicKey::from_base64(
580 "LTpv2DGMhggPAXO02+7f68CNEp6A40F0Yl8B094Y8gc"
581 ).unwrap();
582
583 let dev_1_unknown_a = create_session(&account, &dev1, SenderDataType::UnknownDevice).await;
584 let dev_1_unknown_b = create_session(&account, &dev1, SenderDataType::UnknownDevice).await;
585
586 let dev_1_keys_a = create_session(&account, &dev1, SenderDataType::DeviceInfo).await;
587 let dev_1_keys_b = create_session(&account, &dev1, SenderDataType::DeviceInfo).await;
588 let dev_1_keys_c = create_session(&account, &dev1, SenderDataType::DeviceInfo).await;
589 let dev_1_keys_d = create_session(&account, &dev1, SenderDataType::DeviceInfo).await;
590
591 let dev_2_unknown = create_session(
592 &account, &dev2, SenderDataType::UnknownDevice).await;
593
594 let dev_2_keys = create_session(
595 &account, &dev2, SenderDataType::DeviceInfo).await;
596
597 let sessions = vec![
598 dev_1_unknown_a.clone(),
599 dev_1_unknown_b.clone(),
600 dev_1_keys_a.clone(),
601 dev_1_keys_b.clone(),
602 dev_1_keys_c.clone(),
603 dev_1_keys_d.clone(),
604 dev_2_unknown.clone(),
605 dev_2_keys.clone(),
606 ];
607
608 let changes = Changes {
609 inbound_group_sessions: sessions,
610 ..Default::default()
611 };
612 store.save_changes(changes).await.expect("Can't save group session");
613
614 let sessions_1_u = store.get_inbound_group_sessions_for_device_batch(
616 dev1,
617 SenderDataType::UnknownDevice,
618 None,
619 10
620 ).await.expect("Failed to get sessions for dev1");
621
622 assert_session_lists_eq(sessions_1_u, [dev_1_unknown_a, dev_1_unknown_b], "device 1 sessions");
624
625 let sessions_2_d = store
627 .get_inbound_group_sessions_for_device_batch(dev2, SenderDataType::DeviceInfo, None, 10)
628 .await
629 .expect("Failed to get sessions for dev2");
630
631 assert_eq!(sessions_2_d, vec![dev_2_keys], "device 2 sessions");
633
634 let mut sessions_1_k = Vec::new();
637 let mut previous_last_session_id: Option<String> = None;
638 loop {
639 let mut sessions_1_k_batch = store.get_inbound_group_sessions_for_device_batch(
640 dev1,
641 SenderDataType::DeviceInfo,
642 previous_last_session_id,
643 2
644 ).await.expect("Failed to get batch 1");
645
646 let Some(last_session) = sessions_1_k_batch.last() else {
648 break;
649 };
650
651 assert_eq!(sessions_1_k_batch.len(), 2);
653
654 previous_last_session_id = Some(last_session.session_id().to_owned());
655
656 let mut last_session = last_session.clone();
658 last_session.sender_data = SenderData::unknown();
659 store.save_inbound_group_sessions(vec![last_session], None).await.unwrap();
660
661 sessions_1_k.append(&mut sessions_1_k_batch);
662 }
663
664 assert_session_lists_eq(
665 sessions_1_k,
666 [dev_1_keys_a, dev_1_keys_b, dev_1_keys_c, dev_1_keys_d],
667 "device 1 batched results"
668 );
669 }
670
671 fn assert_session_lists_eq<I, J>(actual: I, expected: J, message: &str)
677 where I: IntoIterator<Item = InboundGroupSession>, J: IntoIterator<Item = InboundGroupSession>
678 {
679 let sorter = |a: &InboundGroupSession, b: &InboundGroupSession| Ord::cmp(a.session_id(), b.session_id());
680
681 let mut actual = Vec::from_iter(actual);
682 actual.sort_unstable_by(sorter);
683 let mut expected = Vec::from_iter(expected);
684 expected.sort_unstable_by(sorter);
685 assert_eq!(actual, expected, "{}", message);
686 }
687
688 #[async_test]
689 async fn test_tracked_users() {
690 let dir = "test_tracked_users";
691 let (_account, store) = get_loaded_store(dir.clone()).await;
692
693 let alice = user_id!("@alice:example.org");
694 let bob = user_id!("@bob:example.org");
695 let candy = user_id!("@candy:example.org");
696
697 let loaded = store.load_tracked_users().await.unwrap();
698 assert!(loaded.is_empty(), "Initially there are no tracked users");
699
700 let users = vec![(alice, true), (bob, false)];
701 store.save_tracked_users(&users).await.unwrap();
702
703 let check_loaded_users = |loaded: Vec<TrackedUser>| {
704 let loaded: HashMap<_, _> =
705 loaded.into_iter().map(|u| (u.user_id.to_owned(), u)).collect();
706
707 let loaded_alice =
708 loaded.get(alice).expect("Alice should be in the store as a tracked user");
709 let loaded_bob =
710 loaded.get(bob).expect("Bob should be in the store as as tracked user");
711
712 assert!(!loaded.contains_key(candy), "Candy shouldn't be part of the store");
713 assert_eq!(loaded.len(), 2, "Candy shouldn't be part of the store");
714
715 assert!(loaded_alice.dirty, "Alice should be considered to be dirty");
716 assert!(!loaded_bob.dirty, "Bob should not be considered to be dirty");
717 };
718
719 let loaded = store.load_tracked_users().await.unwrap();
720 check_loaded_users(loaded);
721
722 drop(store);
723
724 let name = dir.clone();let store = get_store(name, None, false).await;
725 let loaded = store.load_tracked_users().await.unwrap();
726 check_loaded_users(loaded);
727 }
728
729 #[async_test]
730 async fn test_device_saving() {
731 let dir = "device_saving";
732 let (_account, store) = get_loaded_store(dir.clone()).await;
733
734 let alice_device_1 = DeviceData::from_account(&Account::with_device_id(
735 "@alice:localhost".try_into().unwrap(),
736 "FIRSTDEVICE".into(),
737 ));
738
739 let alice_device_2 = DeviceData::from_account(&Account::with_device_id(
740 "@alice:localhost".try_into().unwrap(),
741 "SECONDDEVICE".into(),
742 ));
743
744 let json = json!({
745 "algorithms": ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
746 "user_id": "@bob:localhost",
747 "device_id": "BOBDEVICE",
748 "extra_property": "somevalue",
749 "keys": {
750 "curve25519:BOBDEVICE": "n0zs7qnaPLLf/OTL+dDLcI5kaPexbUeQ8jLQ2q6sO0E",
751 "ed25519:BOBDEVICE": "RrKiu4+5EHRBWY6Qj6OtQGC0txpmEeanOz2irEZ/IN4",
752 },
753 "signatures": {
754 "@bob:localhost": {
755 "ed25519:BOBDEVICE": "9NjPewVHfB7Ah32mJ+CBx64mVoiQ8gbh+/2pc9WfAgut/H0Kqd/bbpgJq9Pn518szaXcGqEq0DxDP6CABBX8CQ",
756 },
757 },
758 });
759
760 let bob_device_1_keys: DeviceKeys = serde_json::from_value(json).unwrap();
761 let bob_device_1 = DeviceData::new(bob_device_1_keys, LocalTrust::Unset);
762
763 let changes = Changes {
764 devices: DeviceChanges {
765 new: vec![alice_device_1.clone(), alice_device_2.clone(), bob_device_1.clone()],
766 ..Default::default()
767 },
768 ..Default::default()
769 };
770
771 store.save_changes(changes).await.unwrap();
772
773 drop(store);
774
775 let store = get_store(dir, None, false).await;
776
777 store.load_account().await.unwrap();
778
779 let loaded_device = store
780 .get_device(alice_device_1.user_id(), alice_device_1.device_id())
781 .await
782 .unwrap()
783 .unwrap();
784
785 assert_eq!(alice_device_1, loaded_device);
786
787 for algorithm in loaded_device.algorithms() {
788 assert!(alice_device_1.algorithms().contains(algorithm));
789 }
790 assert_eq!(alice_device_1.algorithms().len(), loaded_device.algorithms().len());
791 assert_eq!(alice_device_1.keys(), loaded_device.keys());
792
793 let user_devices = store.get_user_devices(alice_device_1.user_id()).await.unwrap();
794 assert_eq!(user_devices.len(), 2);
795
796 let bob_device = store
797 .get_device(bob_device_1.user_id(), bob_device_1.device_id())
798 .await
799 .unwrap();
800
801 let bob_device_json = serde_json::to_value(bob_device).unwrap();
802 assert_eq!(bob_device_json["device_keys"]["extra_property"], json!("somevalue"));
803 }
804
805 #[async_test]
806 async fn test_device_deleting() {
807 let dir = "device_deleting";
808 let (_account, store) = get_loaded_store(dir.clone()).await;
809 let device = get_device();
810
811 let changes = Changes {
812 devices: DeviceChanges { changed: vec![device.clone()], ..Default::default() },
813 ..Default::default()
814 };
815
816 store.save_changes(changes).await.unwrap();
817
818 let changes = Changes {
819 devices: DeviceChanges { deleted: vec![device.clone()], ..Default::default() },
820 ..Default::default()
821 };
822
823 store.save_changes(changes).await.unwrap();
824 drop(store);
825
826 let store = get_store(dir, None, false).await;
827
828 store.load_account().await.unwrap();
829
830 let loaded_device =
831 store.get_device(device.user_id(), device.device_id()).await.unwrap();
832
833 assert!(loaded_device.is_none());
834 }
835
836 #[async_test]
837 async fn test_user_saving() {
838 let dir = "user_saving";
839
840 let user_id = user_id!("@example:localhost");
841 let device_id: &DeviceId = "WSKKLTJZCL".into();
842
843 let store = get_store(dir, None, true).await;
844
845 let account = Account::with_device_id(&user_id, device_id);
846
847 store.save_pending_changes(PendingChanges { account: Some(account), })
848 .await
849 .expect("Can't save account");
850
851 let own_identity = get_own_identity();
852
853 let changes = Changes {
854 identities: IdentityChanges {
855 changed: vec![own_identity.clone().into()],
856 ..Default::default()
857 },
858 ..Default::default()
859 };
860
861 store.save_changes(changes).await.expect("Can't save identity");
862
863 drop(store);
864
865 let store = get_store(dir, None, false).await;
866
867 store.load_account().await.unwrap();
868
869 let loaded_user =
870 store.get_user_identity(own_identity.user_id()).await.unwrap().unwrap();
871
872 assert_eq!(loaded_user.master_key(), own_identity.master_key());
873 assert_eq!(loaded_user.self_signing_key(), own_identity.self_signing_key());
874 assert_eq!(loaded_user.own().unwrap().clone(), own_identity.clone());
875
876 let other_identity = get_other_identity();
877
878 let changes = Changes {
879 identities: IdentityChanges {
880 changed: vec![other_identity.clone().into()],
881 ..Default::default()
882 },
883 ..Default::default()
884 };
885
886 store.save_changes(changes).await.unwrap();
887
888 let loaded_user =
889 store.get_user_identity(other_identity.user_id()).await.unwrap().unwrap();
890
891 assert_eq!(loaded_user.master_key(), other_identity.master_key());
892 assert_eq!(loaded_user.self_signing_key(), other_identity.self_signing_key());
893 assert_eq!(loaded_user.user_id(), other_identity.user_id());
894 assert_eq!(loaded_user.other().unwrap().clone(), other_identity);
895
896 own_identity.mark_as_verified();
897
898 let changes = Changes {
899 identities: IdentityChanges {
900 changed: vec![own_identity.into()],
901 ..Default::default()
902 },
903 ..Default::default()
904 };
905
906 store.save_changes(changes).await.unwrap();
907 let loaded_user = store.get_user_identity(&user_id).await.unwrap().unwrap();
908 assert!(loaded_user.own().unwrap().is_verified())
909 }
910
911 #[async_test]
912 async fn test_private_identity_saving() {
913 let (_, store) = get_loaded_store("private_identity_saving").await;
914 assert!(store.load_identity().await.unwrap().is_none());
915 let identity = PrivateCrossSigningIdentity::new(alice_id().to_owned());
916
917 let changes =
918 Changes { private_identity: Some(identity.clone()), ..Default::default() };
919
920 store.save_changes(changes).await.unwrap();
921 let loaded_identity = store.load_identity().await.unwrap().unwrap();
922 assert_eq!(identity.user_id(), loaded_identity.user_id());
923 }
924
925 #[async_test]
926 async fn test_olm_hash_saving() {
927 let (_, store) = get_loaded_store("olm_hash_saving").await;
928
929 let hash = OlmMessageHash {
930 sender_key: "test_sender".to_owned(),
931 hash: "test_hash".to_owned(),
932 };
933
934 let mut changes = Changes::default();
935 changes.message_hashes.push(hash.clone());
936
937 assert!(!store.is_message_known(&hash).await.unwrap());
938 store.save_changes(changes).await.unwrap();
939 assert!(store.is_message_known(&hash).await.unwrap());
940 }
941
942 #[async_test]
943 async fn test_key_request_saving() {
944 let (account, store) = get_loaded_store("key_request_saving").await;
945 let sender_key =
946 Curve25519PublicKey::from_base64("Nn0L2hkcCMFKqynTjyGsJbth7QrVmX3lbrksMkrGOAw")
947 .unwrap();
948
949 let id = TransactionId::new();
950 let info: SecretInfo = MegolmV1AesSha2Content {
951 room_id: room_id!("!test:localhost").to_owned(),
952 sender_key: Some(sender_key),
953 session_id: "test_session_id".to_owned(),
954 }
955 .into();
956
957 let request = GossipRequest {
958 request_recipient: account.user_id().to_owned(),
959 request_id: id.clone(),
960 info: info.clone(),
961 sent_out: false,
962 };
963
964 assert!(store.get_outgoing_secret_requests(&id).await.unwrap().is_none());
965
966 let mut changes = Changes::default();
967 changes.key_requests.push(request.clone());
968 store.save_changes(changes).await.unwrap();
969
970 let request = Some(request);
971
972 let stored_request = store.get_outgoing_secret_requests(&id).await.unwrap();
973 assert_eq!(request, stored_request);
974
975 let stored_request = store.get_secret_request_by_info(&info).await.unwrap();
976 assert_eq!(request, stored_request);
977 assert!(!store.get_unsent_secret_requests().await.unwrap().is_empty());
978
979 let request = GossipRequest {
980 request_recipient: account.user_id().to_owned(),
981 request_id: id.clone(),
982 info: info.clone(),
983 sent_out: true,
984 };
985
986 let mut changes = Changes::default();
987 changes.key_requests.push(request.clone());
988 store.save_changes(changes).await.unwrap();
989
990 assert!(store.get_unsent_secret_requests().await.unwrap().is_empty());
991 let stored_request = store.get_outgoing_secret_requests(&id).await.unwrap();
992 assert_eq!(Some(request), stored_request);
993
994 store.delete_outgoing_secret_requests(&id).await.unwrap();
995
996 let stored_request = store.get_outgoing_secret_requests(&id).await.unwrap();
997 assert_eq!(None, stored_request);
998
999 let stored_request = store.get_secret_request_by_info(&info).await.unwrap();
1000 assert_eq!(None, stored_request);
1001 assert!(store.get_unsent_secret_requests().await.unwrap().is_empty());
1002 }
1003
1004 #[async_test]
1005 async fn test_gossipped_secret_saving() {
1006 let (account, store) = get_loaded_store("gossipped_secret_saving").await;
1007
1008 let secret = "It is a secret to everybody";
1009
1010 let id = TransactionId::new();
1011 let info: SecretInfo = MegolmV1AesSha2Content {
1012 room_id: room_id!("!test:localhost").to_owned(),
1013 sender_key: Some(account.identity_keys().curve25519),
1014 session_id: "test_session_id".to_owned(),
1015 }
1016 .into();
1017
1018 let gossip_request = GossipRequest {
1019 request_recipient: account.user_id().to_owned(),
1020 request_id: id.clone(),
1021 info: info.clone(),
1022 sent_out: true,
1023 };
1024
1025 let mut event = DecryptedSecretSendEvent {
1026 sender: account.user_id().to_owned(),
1027 recipient: account.user_id().to_owned(),
1028 keys: OlmV1Keys {
1029 ed25519: account.identity_keys().ed25519,
1030 },
1031 recipient_keys: OlmV1Keys {
1032 ed25519: account.identity_keys().ed25519,
1033 },
1034 sender_device_keys: None,
1035 content: SecretSendContent::new(id.to_owned(), secret.to_owned()),
1036 };
1037
1038 let value = GossippedSecret {
1039 secret_name: SecretName::RecoveryKey,
1040 gossip_request: gossip_request.to_owned(),
1041 event: event.to_owned(),
1042 };
1043
1044 assert!(
1045 store.get_secrets_from_inbox(&SecretName::RecoveryKey).await.unwrap().is_empty(),
1046 "No secret should initially be found in the store"
1047 );
1048
1049 let mut changes = Changes::default();
1050 changes.secrets.push(value);
1051 store.save_changes(changes).await.unwrap();
1052
1053 let restored = store.get_secrets_from_inbox(&SecretName::RecoveryKey).await.unwrap();
1054 let first_secret = restored.first().expect("We should have restored a secret now");
1055 assert_eq!(first_secret.event.content.secret, secret);
1056 assert_eq!(restored.len(), 1, "We should only have one secret stored for now");
1057
1058 event.content.request_id = TransactionId::new();
1059 let another_secret = GossippedSecret {
1060 secret_name: SecretName::RecoveryKey,
1061 gossip_request,
1062 event,
1063 };
1064
1065 let mut changes = Changes::default();
1066 changes.secrets.push(another_secret);
1067 store.save_changes(changes).await.unwrap();
1068
1069 let restored = store.get_secrets_from_inbox(&SecretName::RecoveryKey).await.unwrap();
1070 assert_eq!(restored.len(), 2, "We should only have two secrets stored");
1071
1072 let restored = store.get_secrets_from_inbox(&SecretName::CrossSigningMasterKey).await.unwrap();
1073 assert!(restored.is_empty(), "We should not have secrets of a different type stored");
1074
1075 store.delete_secrets_from_inbox(&SecretName::RecoveryKey).await.unwrap();
1076
1077 let restored = store.get_secrets_from_inbox(&SecretName::RecoveryKey).await.unwrap();
1078 assert!(restored.is_empty(), "We should not have any secrets after we have deleted them");
1079 }
1080
1081 #[async_test]
1082 async fn test_withheld_info_storage() {
1083 let (account, store) = get_loaded_store("withheld_info_storage").await;
1084
1085 let mut info_list: BTreeMap<_, BTreeMap<_, _>> = BTreeMap::new();
1086
1087 let user_id = account.user_id().to_owned();
1088 let room_id = room_id!("!DwLygpkclUAfQNnfva:example.com");
1089 let session_id_1 = "GBnDxGP9i3IkPsz3/ihNr6P7qjIXxSRVWZ1MYmSn09w";
1090 let session_id_2 = "IDLtnNCH2kIr3xIf1B7JFkGpQmTjyMca2jww+X6zeOE";
1091
1092 let content = RoomKeyWithheldContent::MegolmV1AesSha2(
1093 MegolmV1AesSha2WithheldContent::Unverified(
1094 CommonWithheldCodeContent::new(
1095 room_id.to_owned(),
1096 session_id_1.into(),
1097 Curve25519PublicKey::from_base64(
1098 "9n7mdWKOjr9c4NTlG6zV8dbFtNK79q9vZADoh7nMUwA",
1099 )
1100 .unwrap(),
1101 "DEVICEID".into(),
1102 )
1103 .into(),
1104 ),
1105 );
1106 let event = ToDeviceEvent::new(user_id.to_owned(), content);
1107 info_list
1108 .entry(room_id.to_owned())
1109 .or_default()
1110 .insert(session_id_1.to_owned(), event);
1111
1112 let content = RoomKeyWithheldContent::MegolmV1AesSha2(
1113 MegolmV1AesSha2WithheldContent::BlackListed(
1114 CommonWithheldCodeContent::new(
1115 room_id.to_owned(),
1116 session_id_2.into(),
1117 Curve25519PublicKey::from_base64(
1118 "9n7mdWKOjr9c4NTlG6zV8dbFtNK79q9vZADoh7nMUwA",
1119 )
1120 .unwrap(),
1121 "DEVICEID".into(),
1122 )
1123 .into(),
1124 ),
1125 );
1126 let event = ToDeviceEvent::new(user_id.to_owned(), content);
1127 info_list
1128 .entry(room_id.to_owned())
1129 .or_default()
1130 .insert(session_id_2.to_owned(), event);
1131
1132 let changes = Changes { withheld_session_info: info_list, ..Default::default() };
1133 store.save_changes(changes).await.unwrap();
1134
1135 let is_withheld = store.get_withheld_info(room_id, session_id_1).await.unwrap();
1136
1137 assert_matches!(
1138 is_withheld, Some(event)
1139 if event.content.algorithm() == EventEncryptionAlgorithm::MegolmV1AesSha2 &&
1140 event.content.withheld_code() == WithheldCode::Unverified
1141 );
1142
1143 let is_withheld = store.get_withheld_info(room_id, session_id_2).await.unwrap();
1144
1145 assert_matches!(
1146 is_withheld, Some(event)
1147 if event.content.algorithm() == EventEncryptionAlgorithm::MegolmV1AesSha2 &&
1148 event.content.withheld_code() == WithheldCode::Blacklisted
1149 );
1150
1151 let other_room_id = room_id!("!nQRyiRFuyUhXeaQfiR:example.com");
1152
1153 let is_withheld =
1154 store.get_withheld_info(other_room_id, session_id_2).await.unwrap();
1155
1156 assert!(is_withheld.is_none());
1157 }
1158
1159 #[async_test]
1160 async fn test_room_settings_saving() {
1161 let (_, store) = get_loaded_store("room_settings_saving").await;
1162
1163 let room_1 = room_id!("!test_1:localhost");
1164 let settings_1 = RoomSettings {
1165 algorithm: EventEncryptionAlgorithm::MegolmV1AesSha2,
1166 #[cfg(feature = "experimental-encrypted-state-events")]
1167 encrypt_state_events: false,
1168 only_allow_trusted_devices: true,
1169 session_rotation_period: Some(Duration::from_secs(10)),
1170 session_rotation_period_messages: Some(123),
1171 };
1172
1173 let room_2 = room_id!("!test_2:localhost");
1174 let settings_2 = RoomSettings {
1175 algorithm: EventEncryptionAlgorithm::OlmV1Curve25519AesSha2,
1176 only_allow_trusted_devices: false,
1177 ..Default::default()
1178 };
1179
1180 let room_3 = room_id!("!test_3:localhost");
1181
1182 let changes = Changes {
1183 room_settings: HashMap::from([
1184 (room_1.into(), settings_1.clone()),
1185 (room_2.into(), settings_2.clone()),
1186 ]),
1187 ..Default::default()
1188 };
1189
1190 store.save_changes(changes).await.unwrap();
1191
1192 let loaded_settings_1 = store.get_room_settings(room_1).await.unwrap();
1193 assert_eq!(Some(settings_1), loaded_settings_1);
1194
1195 let loaded_settings_2 = store.get_room_settings(room_2).await.unwrap();
1196 assert_eq!(Some(settings_2), loaded_settings_2);
1197
1198 let loaded_settings_3 = store.get_room_settings(room_3).await.unwrap();
1199 assert_eq!(None, loaded_settings_3);
1200 }
1201
1202 #[async_test]
1203 async fn test_backup_keys_saving() {
1204 let (_account, store) = get_loaded_store("backup_keys_saving").await;
1205
1206 let restored = store.load_backup_keys().await.unwrap();
1207 assert!(restored.decryption_key.is_none(), "Initially no backup decryption key should be present");
1208
1209 let backup_decryption_key = Some(BackupDecryptionKey::new().unwrap());
1210
1211 let changes = Changes { backup_decryption_key, ..Default::default() };
1212 store.save_changes(changes).await.unwrap();
1213
1214 let restored = store.load_backup_keys().await.unwrap();
1215 assert!(restored.decryption_key.is_some(), "We should be able to restore a backup decryption key");
1216 assert!(restored.backup_version.is_none(), "The backup version should still be None");
1217
1218 let changes = Changes { backup_version: Some("some_version".to_owned()), ..Default::default() };
1219 store.save_changes(changes).await.unwrap();
1220
1221 let restored = store.load_backup_keys().await.unwrap();
1222 assert!(restored.decryption_key.is_some(), "The backup decryption key should still be known");
1223 assert!(restored.backup_version.is_some(), "The backup version should now be Some as well");
1224 }
1225
1226 #[async_test]
1227 async fn test_dehydration_pickle_key_saving() {
1228 let (_account, store) = get_loaded_store("dehydration_pickle_key_saving").await;
1229
1230 let restored = store.load_dehydrated_device_pickle_key().await.unwrap();
1231 assert!(restored.is_none(), "Initially no pickle key should be present");
1232
1233 let dehydrated_device_pickle_key = Some(DehydratedDeviceKey::new().unwrap());
1234 let exported_base64 = dehydrated_device_pickle_key.clone().unwrap().to_base64();
1235
1236 let changes = Changes { dehydrated_device_pickle_key, ..Default::default() };
1237 store.save_changes(changes).await.unwrap();
1238
1239 let restored = store.load_dehydrated_device_pickle_key().await.unwrap();
1240 assert!(restored.is_some(), "We should be able to restore a pickle key");
1241 assert_eq!(restored.unwrap().to_base64(), exported_base64);
1242
1243 let changes = Changes { dehydrated_device_pickle_key: None, ..Default::default() };
1245 store.save_changes(changes).await.unwrap();
1246
1247 let restored = store.load_dehydrated_device_pickle_key().await.unwrap();
1248 assert!(restored.is_some(), "We should be able to restore a pickle key");
1249 assert_eq!(restored.unwrap().to_base64(), exported_base64);
1250
1251 }
1252
1253 #[async_test]
1254 async fn test_delete_dehydration_pickle_key() {
1255 let (_account, store) = get_loaded_store("delete_dehydration_pickle_key").await;
1256
1257 let dehydrated_device_pickle_key = DehydratedDeviceKey::new().unwrap();
1258
1259 let changes = Changes { dehydrated_device_pickle_key: Some(dehydrated_device_pickle_key), ..Default::default() };
1260 store.save_changes(changes).await.unwrap();
1261
1262 let restored = store.load_dehydrated_device_pickle_key().await.unwrap();
1263 assert!(restored.is_some(), "We should be able to restore a pickle key");
1264
1265 store.delete_dehydrated_device_pickle_key().await.unwrap();
1266
1267 let restored = store.load_dehydrated_device_pickle_key().await.unwrap();
1268 assert!(restored.is_none(), "The previously saved key should be deleted");
1269
1270 }
1271
1272
1273 #[async_test]
1274 async fn test_custom_value_saving() {
1275 let (_, store) = get_loaded_store("custom_value_saving").await;
1276 store.set_custom_value("A", "Hello".as_bytes().to_vec()).await.unwrap();
1277
1278 let loaded_1 = store.get_custom_value("A").await.unwrap();
1279 assert_eq!(Some("Hello".as_bytes().to_vec()), loaded_1);
1280
1281 let loaded_2 = store.get_custom_value("B").await.unwrap();
1282 assert_eq!(None, loaded_2);
1283 }
1284
1285 #[async_test]
1286 async fn test_received_room_key_bundle() {
1287 let store = get_store("received_room_key_bundle", None, true).await;
1288 let test_room = room_id!("!room:example.org");
1289
1290 fn make_bundle_data(sender_user: &UserId, bundle_uri: &str) -> StoredRoomKeyBundleData {
1291 let jwk = ruma::events::room::JsonWebKeyInit {
1292 kty: "oct".to_owned(),
1293 key_ops: vec!["encrypt".to_owned(), "decrypt".to_owned()],
1294 alg: "A256CTR".to_owned(),
1295 k: ruma::serde::Base64::new(vec![0u8; 0]),
1296 ext: true,
1297 }.into();
1298
1299 let file = ruma::events::room::EncryptedFileInit {
1300 url: ruma::OwnedMxcUri::from(bundle_uri),
1301 key: jwk,
1302 iv: ruma::serde::Base64::new(vec![0u8; 0]),
1303 hashes: Default::default(),
1304 v: "".to_owned(),
1305 }.into();
1306
1307 StoredRoomKeyBundleData {
1308 sender_user: sender_user.to_owned(),
1309 sender_key: Curve25519PublicKey::from_bytes([0u8; 32]),
1310 sender_data: SenderData::unknown(),
1311 bundle_data: RoomKeyBundleContent {
1312 room_id: room_id!("!room:example.org").to_owned(),
1313 file,
1314 },
1315 }
1316 }
1317
1318 let changes = Changes {
1320 received_room_key_bundles: vec![
1321 make_bundle_data(user_id!("@alice:example.com"), "alice1"),
1322 make_bundle_data(user_id!("@bob:example.com"), "bob1"),
1323 make_bundle_data(user_id!("@alice:example.com"), "alice2"),
1324 ],
1325 ..Default::default()
1326 };
1327 store.save_changes(changes).await.unwrap();
1328
1329 let bundle = store.get_received_room_key_bundle_data(
1331 test_room, user_id!("@alice:example.com")
1332 ).await.unwrap().expect("Did not get any bundle data");
1333 assert_eq!(bundle.bundle_data.file.url.to_string(), "alice2");
1334 }
1335
1336 fn session_info(session: &InboundGroupSession) -> (&RoomId, &str) {
1337 (&session.room_id(), &session.session_id())
1338 }
1339
1340 async fn create_session(
1341 account: &Account,
1342 device_curve_key: &Curve25519PublicKey,
1343 sender_data_type: SenderDataType,
1344 ) -> InboundGroupSession {
1345 let sender_data = match sender_data_type {
1346 SenderDataType::UnknownDevice => {
1347 SenderData::UnknownDevice { legacy_session: false, owner_check_failed: false }
1348 }
1349 SenderDataType::DeviceInfo => SenderData::DeviceInfo {
1350 device_keys: account.device_keys().clone(),
1351 legacy_session: false,
1352 },
1353 SenderDataType::VerificationViolation => panic!("VerificationViolation not supported"),
1354 SenderDataType::SenderUnverified=> panic!("SenderUnverified not supported"),
1355 SenderDataType::SenderVerified => panic!("SenderVerified not supported"),
1356 };
1357
1358 let session_key = GroupSession::new(SessionConfig::default()).session_key();
1359
1360 InboundGroupSession::new(
1361 device_curve_key.clone(),
1362 account.device_keys().ed25519_key().unwrap(),
1363 room_id!("!r:s.co"),
1364 &session_key,
1365 sender_data,
1366 EventEncryptionAlgorithm::MegolmV1AesSha2,
1367 None,
1368 false,
1369 )
1370 .unwrap()
1371 }
1372 }
1373 };
1374}
1375
1376#[allow(unused_macros)]
1377#[macro_export]
1378macro_rules! cryptostore_integration_tests_time {
1379 () => {
1380 mod cryptostore_integration_tests_time {
1381 use std::time::Duration;
1382
1383 use matrix_sdk_test::async_test;
1384 use $crate::store::CryptoStore as _;
1385
1386 use super::cryptostore_integration_tests::*;
1387
1388 #[async_test]
1389 async fn test_lease_locks() {
1390 let (_account, store) = get_loaded_store("lease_locks").await;
1391
1392 let acquired0 = store.try_take_leased_lock(0, "key", "alice").await.unwrap();
1393 assert!(acquired0);
1394
1395 let acquired2 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1397 assert!(acquired2);
1398
1399 let acquired3 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1401 assert!(acquired3);
1402
1403 let acquired4 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1405 assert!(!acquired4);
1406
1407 let acquired5 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1409 assert!(!acquired5);
1410
1411 tokio::time::sleep(Duration::from_millis(50)).await;
1413
1414 let acquired55 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1416 assert!(!acquired55);
1417
1418 tokio::time::sleep(Duration::from_millis(250)).await;
1420
1421 let acquired6 = store.try_take_leased_lock(0, "key", "bob").await.unwrap();
1423 assert!(acquired6);
1424
1425 tokio::time::sleep(Duration::from_millis(1)).await;
1426
1427 let acquired7 = store.try_take_leased_lock(0, "key", "alice").await.unwrap();
1429 assert!(acquired7);
1430
1431 tokio::time::sleep(Duration::from_millis(1)).await;
1432
1433 let acquired8 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1435 assert!(acquired8);
1436
1437 let acquired9 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1439 assert!(!acquired9);
1440
1441 let acquired10 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1443 assert!(acquired10);
1444 }
1445 }
1446 };
1447}