From 3c42e1b4b99ca0e2bc522ce4eac89e3f01578c64 Mon Sep 17 00:00:00 2001 From: Michael Goldenberg Date: Sun, 25 Jan 2026 15:38:50 -0500 Subject: [PATCH] test(event-cache): move test_load_previous_chunk to integration tests Signed-off-by: Michael Goldenberg --- .../event_cache/store/integration_tests.rs | 78 +++++++++++++++++ .../event_cache_store/integration_tests.rs | 71 +--------------- .../src/event_cache_store.rs | 85 +------------------ 3 files changed, 82 insertions(+), 152 deletions(-) diff --git a/crates/matrix-sdk-base/src/event_cache/store/integration_tests.rs b/crates/matrix-sdk-base/src/event_cache/store/integration_tests.rs index fc20bdef6..530e51701 100644 --- a/crates/matrix-sdk-base/src/event_cache/store/integration_tests.rs +++ b/crates/matrix-sdk-base/src/event_cache/store/integration_tests.rs @@ -144,6 +144,9 @@ pub trait EventCacheStoreIntegrationTests { /// chunk from the store. async fn test_load_last_chunk_with_a_cycle(&self); + /// Test loading the previous chunk in a linked chunk from the store. + async fn test_load_previous_chunk(&self); + /// Test loading a linked chunk incrementally (chunk by chunk) from the /// store. async fn test_linked_chunk_incremental_loading(&self); @@ -480,6 +483,74 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore { self.load_last_chunk(linked_chunk_id).await.unwrap_err(); } + async fn test_load_previous_chunk(&self) { + let room_id = room_id!("!r0:matrix.org"); + 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 = + self.load_previous_chunk(linked_chunk_id, CId::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. + { + self.handle_linked_chunk_updates( + linked_chunk_id, + vec![Update::NewItemsChunk { previous: None, new: CId::new(42), next: None }], + ) + .await + .unwrap(); + + let previous_chunk = + self.load_previous_chunk(linked_chunk_id, CId::new(42)).await.unwrap(); + + assert!(previous_chunk.is_none()); + } + + // Case #3: there are two chunks. + { + self.handle_linked_chunk_updates( + linked_chunk_id, + vec![ + // new chunk before the one that exists. + Update::NewItemsChunk { + previous: None, + new: CId::new(7), + next: Some(CId::new(42)), + }, + Update::PushItems { + at: Position::new(CId::new(7), 0), + items: vec![event("brigand du jorat"), event("morbier")], + }, + ], + ) + .await + .unwrap(); + + let previous_chunk = + self.load_previous_chunk(linked_chunk_id, CId::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"); + }); + }); + } + } + async fn test_linked_chunk_incremental_loading(&self) { let room_id = room_id!("!r0:matrix.org"); let linked_chunk_id = LinkedChunkId::Room(room_id); @@ -1976,6 +2047,13 @@ macro_rules! event_cache_store_integration_tests { event_cache_store.test_load_last_chunk_with_a_cycle().await; } + #[async_test] + async fn test_load_previous_chunk() { + let event_cache_store = + get_event_cache_store().await.unwrap().into_event_cache_store(); + event_cache_store.test_load_previous_chunk().await; + } + #[async_test] async fn test_linked_chunk_incremental_loading() { let event_cache_store = diff --git a/crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs b/crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs index 890715694..eca87a8fd 100644 --- a/crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs +++ b/crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs @@ -12,16 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License -use assert_matches::assert_matches; use matrix_sdk_base::{ - event_cache::{ - Gap, - store::{ - EventCacheStore, - integration_tests::{check_test_event, make_test_event}, - }, - }, - linked_chunk::{ChunkContent, ChunkIdentifier, LinkedChunkId, Position, Update}, + event_cache::{Gap, store::EventCacheStore}, + linked_chunk::{ChunkIdentifier, LinkedChunkId, Update}, }; use matrix_sdk_test::DEFAULT_TEST_ROOM_ID; @@ -53,59 +46,6 @@ pub async fn test_add_gap_chunk_and_delete_it_immediately(store: IndexeddbEventC assert_eq!(chunks.len(), 1); } -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`] /// @@ -150,13 +90,6 @@ macro_rules! indexeddb_event_cache_store_integration_tests { ) .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 - } } }; } diff --git a/crates/matrix-sdk-sqlite/src/event_cache_store.rs b/crates/matrix-sdk-sqlite/src/event_cache_store.rs index 35bcdd601..5a231cfee 100644 --- a/crates/matrix-sdk-sqlite/src/event_cache_store.rs +++ b/crates/matrix-sdk-sqlite/src/event_cache_store.rs @@ -1633,16 +1633,13 @@ mod tests { use matrix_sdk_base::{ event_cache::store::{ EventCacheStore, EventCacheStoreError, IntoEventCacheStore, - integration_tests::{ - EventCacheStoreIntegrationTests, check_test_event, make_test_event, - }, + integration_tests::EventCacheStoreIntegrationTests, }, event_cache_store_integration_tests, event_cache_store_integration_tests_time, - linked_chunk::{ChunkContent, ChunkIdentifier, LinkedChunkId, Position, Update}, + linked_chunk::{ChunkIdentifier, LinkedChunkId, Update}, }; use matrix_sdk_test::{DEFAULT_TEST_ROOM_ID, async_test}; use once_cell::sync::Lazy; - use ruma::room_id; use tempfile::{TempDir, tempdir}; use super::SqliteEventCacheStore; @@ -1806,84 +1803,6 @@ mod tests { let chunks = store.load_all_chunks(linked_chunk_id).await.unwrap(); assert!(chunks.is_empty()); } - - #[async_test] - async fn test_load_previous_chunk() { - let room_id = room_id!("!r0:matrix.org"); - let linked_chunk_id = LinkedChunkId::Room(room_id); - let event = |msg: &str| make_test_event(room_id, msg); - let store = get_event_cache_store().await.expect("creating cache store failed"); - - // 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. - { - store - .handle_linked_chunk_updates( - linked_chunk_id, - vec![Update::NewItemsChunk { - previous: None, - new: ChunkIdentifier::new(42), - next: None, - }], - ) - .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. - { - store - .handle_linked_chunk_updates( - linked_chunk_id, - 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")], - }, - ], - ) - .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"); - }); - }); - } - } } #[cfg(test)]