matrix_sdk_crypto/store/
integration_tests.rs

1/// A macro which will run the CryptoStore integration test suite.
2///
3/// You need to provide a `async fn get_store() -> StoreResult<impl StateStore>`
4/// providing a fresh store on the same level you invoke the macro.
5///
6/// ## Usage Example:
7/// ```no_run
8/// # use matrix_sdk_crypto::store::{
9/// #    MemoryStore as MyCryptoStore,
10/// # };
11///
12/// #[cfg(test)]
13/// mod tests {
14///     use super::MyCryptoStore;
15///
16///     async fn get_store(
17///         name: &str,
18///         passphrase: Option<&str>,
19///         clear_data: bool,
20///     ) -> MyCryptoStore {
21///         let store = MyCryptoStore::new();
22///         if clear_data {
23///             store.clear();
24///         }
25///         store
26///     }
27///
28///     cryptostore_integration_tests!();
29/// }
30/// ```
31#[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                // Given we created a session and saved it in the store
249                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                // When we reload the store
284                let store = get_store(store_name, None, false).await;
285
286                // Then the same account and session info was reloaded
287                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                // Given we saved an outbound group session
302                {
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                // When we reload the account
335                let store = get_store(dir, None, false).await;
336                store.load_account().await.unwrap();
337
338                // Then the saved session is restored
339                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            /// Test that we can import an inbound group session via [`CryptoStore::save_changes`]
346            #[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            /// Test that we can import a backed-up group session via
360            /// [`CryptoStore::save_inbound_group_sessions`]
361            #[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                // It should *not* be returned by a request for backup for the same backup version
385                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            /// Test that the behaviour of a key imported from an *old* backup is correct
394            ///
395            /// This currently only works on the MemoryStore, so is ignored. The other stores
396            /// are waiting for more work on https://github.com/element-hq/element-web/issues/26892.
397            #[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                // The session should be returned by a request for backup from a different backup version.
413                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            /// Test that we can import a not-backed-up group session via
422            /// [`CryptoStore::save_inbound_group_sessions`]
423            #[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                // It should be returned by a request for backup
447                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                // Given a store exists with multiple unbacked-up sessions
454                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                // When I mark some as backed up
466                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                // And ask which still need backing up
475                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                // Then the sessions we said were backed up no longer need backing up
479                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                // And the sessions we didn't mention still need backing up
486                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                // Given a store exists where all sessions are backed up to backup_1
497                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                // Sanity: none need backing up to the same backup
513                {
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                // Some stores ignore backup_version and just reset when you tell them to. Tell
519                // them here.
520                store.reset_backup_state().await.expect("reset failed");
521
522                // When we ask what needs backing up to a different backup version
523                let to_back_up = store.inbound_group_sessions_for_backup("backup_02", 10).await.unwrap();
524
525                // Then the answer is everything
526                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                // Given a store exists, containing inbound group sessions from different devices
573                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                // When we fetch the list of sessions for device 1, unknown
615                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                // Then the expected sessions are returned
623                assert_session_lists_eq(sessions_1_u, [dev_1_unknown_a, dev_1_unknown_b], "device 1 sessions");
624
625                // And when we ask for the list of sessions for device 2, with device keys
626                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                // Then the matching session is returned
632                assert_eq!(sessions_2_d, vec![dev_2_keys], "device 2 sessions");
633
634                // And we can fetch device 1, keys in batches.
635                // We call the batch function repeatedly, to ensure it terminates correctly.
636                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                    // If there are no results in the batch, we have reached the end of the results.
647                    let Some(last_session) = sessions_1_k_batch.last() else {
648                        break;
649                    };
650
651                    // Check that there are exactly two results in the batch
652                    assert_eq!(sessions_1_k_batch.len(), 2);
653
654                    previous_last_session_id = Some(last_session.session_id().to_owned());
655
656                    // Modify one of the results, to check that that doesn't break iteration
657                    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            /// Assert that two lists of sessions are the same, modulo ordering.
672            ///
673            /// There is no requirement for `get_inbound_group_sessions_for_device_batch` to
674            /// return the results in a specific order. This helper ensures that the two lists
675            /// of inbound group sessions are equivalent, without worrying about the ordering.
676            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                // If None, should not clear the existing saved key
1244                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                // Add three entries
1319                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                // Check we get the right one
1330                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                // Should extend the lease automatically (same holder).
1396                let acquired2 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1397                assert!(acquired2);
1398
1399                // Should extend the lease automatically (same holder + time is ok).
1400                let acquired3 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1401                assert!(acquired3);
1402
1403                // Another attempt at taking the lock should fail, because it's taken.
1404                let acquired4 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1405                assert!(!acquired4);
1406
1407                // Even if we insist.
1408                let acquired5 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1409                assert!(!acquired5);
1410
1411                // That's a nice test we got here, go take a little nap.
1412                tokio::time::sleep(Duration::from_millis(50)).await;
1413
1414                // Still too early.
1415                let acquired55 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1416                assert!(!acquired55);
1417
1418                // Ok you can take another nap then.
1419                tokio::time::sleep(Duration::from_millis(250)).await;
1420
1421                // At some point, we do get the lock.
1422                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                // The other gets it almost immediately too.
1428                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                // But when we take a longer lease...
1434                let acquired8 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1435                assert!(acquired8);
1436
1437                // It blocks the other user.
1438                let acquired9 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
1439                assert!(!acquired9);
1440
1441                // We can hold onto our lease.
1442                let acquired10 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
1443                assert!(acquired10);
1444            }
1445        }
1446    };
1447}