test(sdk): Test the RoomEvents' methods.

This patch adds unit tests for the `RoomEvents`' methods.

Author: Hywan

crates/matrix-sdk/src/event_cache/linked_chunk/mod.rs

@@ -852,6 +852,12 @@ impl ChunkIdentifierGenerator {
 #[repr(transparent)]
 pub struct ChunkIdentifier(u64);
 
+impl PartialEq<u64> for ChunkIdentifier {
+    fn eq(&self, other: &u64) -> bool {
+        self.0 == *other
+    }
+}
+
 /// The position of something inside a [`Chunk`].
 ///
 /// It's a pair of a chunk position and an item index.

crates/matrix-sdk/src/event_cache/store.rs

@@ -137,3 +137,386 @@ impl fmt::Debug for RoomEvents {
         formatter.debug_struct("RoomEvents").field("chunk", &self.chunks).finish()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use assert_matches2::assert_let;
+    use matrix_sdk_test::{EventBuilder, ALICE};
+    use ruma::{events::room::message::RoomMessageEventContent, EventId, OwnedEventId};
+
+    use super::*;
+
+    fn new_event(event_builder: &EventBuilder, event_id: &str) -> (OwnedEventId, Event) {
+        let event_id = EventId::parse(event_id).unwrap();
+
+        let event = SyncTimelineEvent::new(event_builder.make_sync_message_event_with_id(
+            *ALICE,
+            &event_id,
+            RoomMessageEventContent::text_plain("foo"),
+        ));
+
+        (event_id, event)
+    }
+
+    #[test]
+    fn test_new_room_events_has_zero_events() {
+        let room_events = RoomEvents::new();
+
+        assert_eq!(room_events.chunks.len(), 0);
+    }
+
+    #[test]
+    fn test_push_events() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+        let (event_id_2, event_2) = new_event(&event_builder, "$ev2");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0, event_1]);
+        room_events.push_events([event_2]);
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 2);
+            assert_eq!(event.event_id().unwrap(), event_id_2);
+
+            assert!(events.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_push_events_with_duplicates() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0.clone()]);
+        room_events.push_events([event_0]);
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert!(events.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_push_gap() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0]);
+        room_events.push_gap(Gap { prev_token: "hello".to_owned() });
+        room_events.push_events([event_1]);
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert!(events.next().is_none());
+        }
+
+        {
+            let mut chunks = room_events.chunks();
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_gap());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert!(chunks.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_insert_events_at() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+        let (event_id_2, event_2) = new_event(&event_builder, "$ev2");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0, event_1]);
+
+        let position_of_event_1 = room_events
+            .events()
+            .find_map(|(position, event)| {
+                (event.event_id().unwrap() == event_id_1).then_some(position)
+            })
+            .unwrap();
+
+        room_events.insert_events_at([event_2], position_of_event_1).unwrap();
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_2);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 2);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert!(events.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_insert_events_at_with_dupicates() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0, event_1.clone()]);
+
+        let position_of_event_1 = room_events
+            .events()
+            .find_map(|(position, event)| {
+                (event.event_id().unwrap() == event_id_1).then_some(position)
+            })
+            .unwrap();
+
+        room_events.insert_events_at([event_1], position_of_event_1).unwrap();
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 2);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert!(events.next().is_none());
+        }
+    }
+    #[test]
+    fn test_insert_gap_at() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0, event_1]);
+
+        let position_of_event_1 = room_events
+            .events()
+            .find_map(|(position, event)| {
+                (event.event_id().unwrap() == event_id_1).then_some(position)
+            })
+            .unwrap();
+
+        room_events
+            .insert_gap_at(Gap { prev_token: "hello".to_owned() }, position_of_event_1)
+            .unwrap();
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert!(events.next().is_none());
+        }
+
+        {
+            let mut chunks = room_events.chunks();
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_gap());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert!(chunks.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_replace_gap_at() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+        let (event_id_2, event_2) = new_event(&event_builder, "$ev2");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0]);
+        room_events.push_gap(Gap { prev_token: "hello".to_owned() });
+
+        let chunk_identifier_of_gap = room_events
+            .chunks()
+            .find_map(|chunk| chunk.is_gap().then_some(chunk.first_position()))
+            .unwrap()
+            .chunk_identifier();
+
+        room_events.replace_gap_at([event_1, event_2], chunk_identifier_of_gap).unwrap();
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_2);
+
+            assert!(events.next().is_none());
+        }
+
+        {
+            let mut chunks = room_events.chunks();
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert!(chunks.next().is_none());
+        }
+    }
+
+    #[test]
+    fn test_replace_gap_at_with_duplicates() {
+        let event_builder = EventBuilder::new();
+
+        let (event_id_0, event_0) = new_event(&event_builder, "$ev0");
+        let (event_id_1, event_1) = new_event(&event_builder, "$ev1");
+
+        let mut room_events = RoomEvents::new();
+
+        room_events.push_events([event_0.clone()]);
+        room_events.push_gap(Gap { prev_token: "hello".to_owned() });
+
+        let chunk_identifier_of_gap = room_events
+            .chunks()
+            .find_map(|chunk| chunk.is_gap().then_some(chunk.first_position()))
+            .unwrap()
+            .chunk_identifier();
+
+        room_events.replace_gap_at([event_0, event_1], chunk_identifier_of_gap).unwrap();
+
+        {
+            let mut events = room_events.events();
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 0);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 0);
+            assert_eq!(event.event_id().unwrap(), event_id_0);
+
+            assert_let!(Some((position, event)) = events.next());
+            assert_eq!(position.chunk_identifier(), 2);
+            assert_eq!(position.index(), 1);
+            assert_eq!(event.event_id().unwrap(), event_id_1);
+
+            assert!(events.next().is_none());
+        }
+
+        {
+            let mut chunks = room_events.chunks();
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert_let!(Some(chunk) = chunks.next());
+            assert!(chunk.is_items());
+
+            assert!(chunks.next().is_none());
+        }
+    }
+}