tests: add missing required state types

chore(base): clippy lint - use let-else

fix: minor fixes

feat: fixup

fix: remove proxy

chore: satisfy the linter

Author: kaylendog

crates/matrix-sdk-base/src/response_processors/state_events.rs

@@ -25,7 +25,9 @@ use ruma::{
 use serde::Deserialize;
 use tracing::warn;
 
-use super::{Context, e2ee};
+use super::Context;
+#[cfg(feature = "e2e-encryption")]
+use super::e2ee;
 use crate::store::BaseStateStore;
 
 /// Collect [`AnySyncStateEvent`].
@@ -41,7 +43,7 @@ pub mod sync {
             room::member::{MembershipState, RoomMemberEventContent},
         },
     };
-    use tracing::{error, instrument, warn};
+    use tracing::{error, instrument};
 
     use super::{super::profiles, AnySyncStateEvent, Context, Raw};
     use crate::{
@@ -156,19 +158,17 @@ pub mod sync {
                             .unwrap();
                         if let RoomEventDecryptionResult::Decrypted(room_event) = decrypted_event {
                             // Unpack event type and state key from outer.
-                            let (outer_event_type, outer_state_key) =
-                                match outer.state_key().split_once(":") {
-                                    None => {
-                                        warn!(
-                                            event_id = outer.event_id().as_str(),
-                                            state_key = event.state_key(),
-                                            "Malformed state key"
-                                        );
-                                        // Discard the event entirely.
-                                        continue;
-                                    }
-                                    Some(result) => result,
-                                };
+                            let Some((outer_event_type, outer_state_key)) =
+                                outer.state_key().split_once(":")
+                            else {
+                                error!(
+                                    event_id = outer.event_id().as_str(),
+                                    state_key = event.state_key(),
+                                    "Malformed state key"
+                                );
+                                // Discard the event entirely.
+                                continue;
+                            };
 
                             let inner = match room_event
                                 .event
@@ -178,15 +178,15 @@ pub mod sync {
                             {
                                 Ok(inner) => inner,
                                 Err(e) => {
-                                    warn!("Malformed event body: {e}");
+                                    error!("Malformed event body: {e}");
                                     continue;
                                 }
                             };
 
                             // Check event types match, discard if not.
                             let inner_event_type = inner.event_type().to_string();
                             if outer_event_type != inner_event_type {
-                                warn!(
+                                error!(
                                     event_id = outer.event_id().as_str(),
                                     expected = outer_event_type,
                                     found = inner_event_type,
@@ -197,7 +197,7 @@ pub mod sync {
 
                             // Check state keys match, discard if not.
                             if outer_state_key != inner.state_key() {
-                                warn!(
+                                error!(
                                     event_id = outer.event_id().as_str(),
                                     expected = outer_state_key,
                                     found = inner.state_key(),

crates/matrix-sdk-ui/tests/integration/room_list_service.rs

@@ -369,6 +369,7 @@ async fn test_sync_all_states() -> Result<(), Error> {
                         ["m.room.create", ""],
                         ["m.room.history_visibility", ""],
                         ["io.element.functional_members", ""],
+                        ["m.room.encrypted", "*"]
                     ],
                     "filters": {},
                     "timeline_limit": 1,
@@ -2273,6 +2274,7 @@ async fn test_room_subscription() -> Result<(), Error> {
                         ["m.room.create", ""],
                         ["m.room.history_visibility", ""],
                         ["io.element.functional_members", ""],
+                        ["m.room.encrypted", "*"],
                         ["m.room.pinned_events", ""],
                     ],
                     "timeline_limit": 20,
@@ -2316,6 +2318,7 @@ async fn test_room_subscription() -> Result<(), Error> {
                         ["m.room.create", ""],
                         ["m.room.history_visibility", ""],
                         ["io.element.functional_members", ""],
+                        ["m.room.encrypted", "*"],
                         ["m.room.pinned_events", ""],
                     ],
                     "timeline_limit": 20,

crates/matrix-sdk/src/room/futures.rs

@@ -407,9 +407,12 @@ impl<'a> SendStateEventRaw<'a> {
     }
 
     /// Returns `true` if the inner event should be encrypted.
+    #[cfg(feature = "e2e-encryption")]
     fn should_encrypt(room: &Room, event_type: &str) -> bool {
+        use tracing::debug;
+
         if !room.encryption_state().is_state_encrypted() {
-            trace!("Sending plaintext event as the room does NOT support encrypted state events.");
+            debug!("Sending plaintext event as the room does NOT support encrypted state events.");
             return false;
         }
 
@@ -427,6 +430,7 @@ impl<'a> SendStateEventRaw<'a> {
                 | "m.space.child"
                 | "m.space.parent"
         ) {
+            debug!("Sending plaintext event as its type is excluded from encryption.");
             return false;
         }
 
@@ -439,17 +443,28 @@ impl<'a> IntoFuture for SendStateEventRaw<'a> {
     boxed_into_future!(extra_bounds: 'a);
 
     fn into_future(self) -> Self::IntoFuture {
+        #[cfg(feature = "e2e-encryption")]
         let Self { room, mut event_type, state_key, mut content, tracing_span, request_config } =
             self;
 
+        // This is here purely to satisfy the linter on non-encrypting targets.
+        #[cfg(not(feature = "e2e-encryption"))]
+        let Self { room, event_type, state_key, content, tracing_span, request_config } = self;
+
         let fut = async move {
             room.ensure_room_joined()?;
+
+            #[cfg(feature = "e2e-encryption")]
             let mut state_key = state_key.to_owned();
+            #[cfg(not(feature = "e2e-encryption"))]
+            let state_key = state_key.to_owned();
 
             #[cfg(feature = "e2e-encryption")]
             if Self::should_encrypt(room, event_type) {
+                use tracing::debug;
+
                 Span::current().record("is_room_encrypted", true);
-                trace!(
+                debug!(
                     room_id = ?room.room_id(),
                     "Sending encrypted event because the room is encrypted.",
                 );

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

@@ -121,7 +121,7 @@ pub async fn logged_in_client_with_server() -> (Client, wiremock::MockServer) {
 #[macro_export]
 macro_rules! assert_next_with_timeout {
     ($stream:expr) => {
-        $crate::assert_next_with_timeout!($stream, 5000)
+        $crate::assert_next_with_timeout!($stream, 500)
     };
     ($stream:expr, $timeout_ms:expr) => {{
         // Needed for subscribers, as they won't use the StreamExt features

testing/matrix-sdk-integration-testing/src/tests/e2ee/state_events.rs

@@ -1,4 +1,4 @@
-use std::ops::Deref;
+use std::{ops::Deref, time::Duration};
 
 use anyhow::Result;
 use assert_matches2::assert_let;
@@ -52,14 +52,24 @@ async fn test_e2ee_state_events() -> Result<()> {
             .await?,
     );
 
-    // Alice creates a room ...
+    // Alice creates an encrypted room ...
     let alice_room = alice
         .create_room(assign!(CreateRoomRequest::new(), {
             name: Some("Cat Photos".to_owned()),
             preset: Some(RoomPreset::PublicChat),
         }))
         .await?;
-    alice_room.enable_encryption().await?;
+    alice_room.enable_encryption_with_state().await?;
+
+    // HACK: wait for sync
+    let _ = tokio::time::sleep(Duration::from_secs(3)).await;
+
+    // (sanity checks)
+    assert!(alice_room.encryption_state().is_encrypted(), "Encryption was not enabled.");
+    assert!(
+        alice_room.encryption_state().is_state_encrypted(),
+        "State encryption was not enabled."
+    );
 
     info!(room_id = ?alice_room.room_id(), "Alice has created and enabled encryption in the room");