feat(indexeddb): add IndexedDB-backed impl for EventCacheStore::load_previous_chunk

Signed-off-by: Michael Goldenberg <m@mgoldenberg.net>

Author: mgoldenberg

crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs

@@ -502,6 +502,59 @@ pub async fn test_load_last_chunk(store: IndexeddbEventCacheStore) {
     assert_eq!(chunk_identifier_generator.current(), 42);
 }
 
+pub async fn test_load_previous_chunk(store: IndexeddbEventCacheStore) {
+    let room_id = &DEFAULT_TEST_ROOM_ID;
+    let linked_chunk_id = LinkedChunkId::Room(room_id);
+    let event = |msg: &str| make_test_event(room_id, msg);
+
+    // Case #1: no chunk at all, equivalent to having an nonexistent
+    // `before_chunk_identifier`.
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(153)).await.unwrap();
+    assert!(previous_chunk.is_none());
+
+    // Case #2: there is one chunk only: we request the previous on this
+    // one, it doesn't exist.
+    let updates =
+        vec![Update::NewItemsChunk { previous: None, new: ChunkIdentifier::new(42), next: None }];
+    store.handle_linked_chunk_updates(linked_chunk_id, updates).await.unwrap();
+
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(42)).await.unwrap();
+    assert!(previous_chunk.is_none());
+
+    // Case #3: there are two chunks.
+    let updates = vec![
+        // new chunk before the one that exists.
+        Update::NewItemsChunk {
+            previous: None,
+            new: ChunkIdentifier::new(7),
+            next: Some(ChunkIdentifier::new(42)),
+        },
+        Update::PushItems {
+            at: Position::new(ChunkIdentifier::new(7), 0),
+            items: vec![event("brigand du jorat"), event("morbier")],
+        },
+    ];
+    store.handle_linked_chunk_updates(linked_chunk_id, updates).await.unwrap();
+
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(42)).await.unwrap();
+
+    assert_matches!(previous_chunk, Some(previous_chunk) => {
+        assert_eq!(previous_chunk.identifier, 7);
+        assert!(previous_chunk.previous.is_none());
+        assert_matches!(previous_chunk.next, Some(next) => {
+            assert_eq!(next, 42);
+        });
+        assert_matches!(previous_chunk.content, ChunkContent::Items(items) => {
+            assert_eq!(items.len(), 2);
+            check_test_event(&items[0], "brigand du jorat");
+            check_test_event(&items[1], "morbier");
+        });
+    });
+}
+
 /// Macro for generating tests for IndexedDB implementation of
 /// [`EventCacheStore`]
 ///
@@ -621,6 +674,13 @@ macro_rules! indexeddb_event_cache_store_integration_tests {
                 $crate::event_cache_store::integration_tests::test_load_last_chunk(store)
                     .await
             }
+
+            #[async_test]
+            async fn test_load_previous_chunk() {
+                let store = get_event_cache_store().await.expect("Failed to get event cache store");
+                $crate::event_cache_store::integration_tests::test_load_previous_chunk(store)
+                    .await
+            }
         }
     };
 }
@@ -654,6 +714,13 @@ macro_rules! event_cache_store_integration_tests {
                 event_cache_store.test_handle_updates_and_rebuild_linked_chunk().await;
             }
 
+            #[async_test]
+            async fn test_linked_chunk_incremental_loading() {
+                let event_cache_store =
+                    get_event_cache_store().await.unwrap().into_event_cache_store();
+                event_cache_store.test_linked_chunk_incremental_loading().await;
+            }
+
             #[async_test]
             async fn test_rebuild_empty_linked_chunk() {
                 let event_cache_store =

crates/matrix-sdk-indexeddb/src/event_cache_store/mod.rs

@@ -353,10 +353,19 @@ impl_event_cache_store! {
         linked_chunk_id: LinkedChunkId<'_>,
         before_chunk_identifier: ChunkIdentifier,
     ) -> Result<Option<RawChunk<Event, Gap>>, IndexeddbEventCacheStoreError> {
-        self.memory_store
-            .load_previous_chunk(linked_chunk_id, before_chunk_identifier)
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+        let linked_chunk_id = linked_chunk_id.to_owned();
+        let room_id = linked_chunk_id.room_id();
+        let transaction = self.transaction(
+            &[keys::LINKED_CHUNKS, keys::EVENTS, keys::GAPS],
+            IdbTransactionMode::Readonly,
+        )?;
+        if let Some(chunk) = transaction.get_chunk_by_id(room_id, &before_chunk_identifier).await? {
+            if let Some(previous_identifier) = chunk.previous {
+                let previous_identifier = ChunkIdentifier::new(previous_identifier);
+                return Ok(transaction.load_chunk_by_id(room_id, &previous_identifier).await?);
+            }
+        }
+        Ok(None)
     }
 
     async fn clear_all_linked_chunks(&self) -> Result<(), IndexeddbEventCacheStoreError> {