test: add test for the generational counter invalidation

Author: bnjbvr

crates/matrix-sdk-crypto/src/machine.rs

@@ -1843,6 +1843,14 @@ impl OlmMachine {
 
         Ok(true)
     }
+
+    #[cfg(any(feature = "testing", test))]
+    /// Returns whether this `OlmMachine` is the same another one.
+    ///
+    /// Useful for testing purposes only.
+    pub fn same_as(&self, other: &OlmMachine) -> bool {
+        Arc::ptr_eq(&self.inner, &other.inner)
+    }
 }
 
 #[cfg(any(feature = "testing", test))]

crates/matrix-sdk-sqlite/Cargo.toml

@@ -9,6 +9,7 @@ rust-version = { workspace = true }
 
 [features]
 default = ["state-store"]
+testing = ["matrix-sdk-crypto?/testing"]
 
 bundled = ["rusqlite/bundled"]
 crypto-store = [

crates/matrix-sdk/Cargo.toml

@@ -17,7 +17,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = ["e2e-encryption", "automatic-room-key-forwarding", "sqlite", "native-tls"]
-testing = []
+testing = ["matrix-sdk-sqlite?/testing"]
 
 e2e-encryption = [
     "matrix-sdk-base/e2e-encryption",

crates/matrix-sdk/src/encryption/mod.rs

@@ -941,12 +941,15 @@ impl Encryption {
 
 #[cfg(all(test, not(target_arch = "wasm32")))]
 mod tests {
+    use std::time::Duration;
+
+    use matrix_sdk_base::SessionMeta;
     use matrix_sdk_test::{
         async_test, test_json, EventBuilder, GlobalAccountDataTestEvent, JoinedRoomBuilder,
         StateTestEvent,
     };
     use ruma::{
-        event_id,
+        device_id, event_id,
         events::{reaction::ReactionEventContent, relation::Annotation},
         user_id,
     };
@@ -956,7 +959,12 @@ mod tests {
         Mock, MockServer, ResponseTemplate,
     };
 
-    use crate::test_utils::logged_in_client;
+    use crate::{
+        config::RequestConfig,
+        matrix_auth::{Session, SessionTokens},
+        test_utils::logged_in_client,
+        Client,
+    };
 
     #[async_test]
     async fn test_reaction_sending() {
@@ -1076,4 +1084,86 @@ mod tests {
         let found_room = client.get_dm_room(user_id).expect("DM not found!");
         assert!(found_room.get_member_no_sync(user_id).await.unwrap().is_some());
     }
+
+    #[async_test]
+    async fn test_generation_counter_invalidates_olm_machine() {
+        // Create two clients using the same sqlite database.
+        let sqlite_path = std::env::temp_dir().join("generation_counter_sqlite.db");
+        let session = Session {
+            meta: SessionMeta {
+                user_id: user_id!("@example:localhost").to_owned(),
+                device_id: device_id!("DEVICEID").to_owned(),
+            },
+            tokens: SessionTokens { access_token: "1234".to_owned(), refresh_token: None },
+        };
+
+        let client1 = Client::builder()
+            .homeserver_url("http://localhost:1234")
+            .request_config(RequestConfig::new().disable_retry())
+            .sqlite_store(&sqlite_path, None)
+            .build()
+            .await
+            .unwrap();
+        client1.matrix_auth().restore_session(session.clone()).await.unwrap();
+
+        let client2 = Client::builder()
+            .homeserver_url("http://localhost:1234")
+            .request_config(RequestConfig::new().disable_retry())
+            .sqlite_store(sqlite_path, None)
+            .build()
+            .await
+            .unwrap();
+        client2.matrix_auth().restore_session(session).await.unwrap();
+
+        // When the lock isn't enabled, any attempt at locking won't return a guard.
+        let guard = client1.encryption().try_lock_store_once().await.unwrap();
+        assert!(guard.is_none());
+
+        client1.encryption().enable_cross_process_store_lock("client1".to_owned()).await.unwrap();
+        client2.encryption().enable_cross_process_store_lock("client2".to_owned()).await.unwrap();
+
+        // One client can take the lock.
+        let acquired1 = client1.encryption().try_lock_store_once().await.unwrap();
+        assert!(acquired1.is_some());
+
+        // Keep the olm machine, so we can see if it's changed later, by comparing Arcs.
+        let initial_olm_machine =
+            client1.olm_machine().await.clone().expect("must have an olm machine");
+
+        // The other client can't take the lock too.
+        let acquired2 = client2.encryption().try_lock_store_once().await.unwrap();
+        assert!(acquired2.is_none());
+
+        // Now have the first client release the lock,
+        drop(acquired1);
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        // And re-take it.
+        let acquired1 = client1.encryption().try_lock_store_once().await.unwrap();
+        assert!(acquired1.is_some());
+
+        // In that case, the Olm Machine shouldn't change.
+        let olm_machine = client1.olm_machine().await.clone().expect("must have an olm machine");
+        assert!(initial_olm_machine.same_as(&olm_machine));
+
+        // Ok, release again.
+        drop(acquired1);
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        // Client2 can acquire the lock.
+        let acquired2 = client2.encryption().try_lock_store_once().await.unwrap();
+        assert!(acquired2.is_some());
+
+        // And then release it.
+        drop(acquired2);
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        // Client1 can acquire it again,
+        let acquired1 = client1.encryption().try_lock_store_once().await.unwrap();
+        assert!(acquired1.is_some());
+
+        // But now its olm machine has been invalidated and thus regenerated!
+        let olm_machine = client1.olm_machine().await.clone().expect("must have an olm machine");
+        assert!(!initial_olm_machine.same_as(&olm_machine));
+    }
 }