task: Remove all usages of LinkedChunkBuilderTest.

This patch replaces all usages of `LinkedChunkBuilderTest` by
`from_all_chunks`.

Author: Hywan

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

@@ -21,10 +21,7 @@ use matrix_sdk_common::{
         AlgorithmInfo, DecryptedRoomEvent, EncryptionInfo, TimelineEvent, TimelineEventKind,
         VerificationState,
     },
-    linked_chunk::{
-        lazy_loader, ChunkContent, ChunkIdentifier as CId, LinkedChunk, LinkedChunkBuilderTest,
-        Position, RawChunk, Update,
-    },
+    linked_chunk::{lazy_loader, ChunkContent, ChunkIdentifier as CId, Position, Update},
 };
 use matrix_sdk_test::{event_factory::EventFactory, ALICE, DEFAULT_TEST_ROOM_ID};
 use ruma::{
@@ -34,7 +31,7 @@ use ruma::{
 
 use super::{media::IgnoreMediaRetentionPolicy, DynEventCacheStore};
 use crate::{
-    event_cache::{store::DEFAULT_CHUNK_CAPACITY, Event, Gap},
+    event_cache::{store::DEFAULT_CHUNK_CAPACITY, Gap},
     media::{MediaFormat, MediaRequestParameters, MediaThumbnailSettings},
 };
 
@@ -132,10 +129,6 @@ pub trait EventCacheStoreIntegrationTests {
     async fn test_filter_duplicated_events(&self);
 }
 
-fn rebuild_linked_chunk(raws: Vec<RawChunk<Event, Gap>>) -> Option<LinkedChunk<3, Event, Gap>> {
-    LinkedChunkBuilderTest::from_raw_parts(raws).build().unwrap()
-}
-
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl EventCacheStoreIntegrationTests for DynEventCacheStore {
@@ -359,8 +352,10 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
         .unwrap();
 
         // The linked chunk is correctly reloaded.
-        let raws = self.load_all_chunks(room_id).await.unwrap();
-        let lc = rebuild_linked_chunk(raws).expect("linked chunk not empty");
+        let lc =
+            lazy_loader::from_all_chunks::<3, _, _>(self.load_all_chunks(room_id).await.unwrap())
+                .unwrap()
+                .unwrap();
 
         let mut chunks = lc.chunks();
 
@@ -610,8 +605,11 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
 
     async fn test_rebuild_empty_linked_chunk(&self) {
         // When I rebuild a linked chunk from an empty store, it's empty.
-        let raw_parts = self.load_all_chunks(&DEFAULT_TEST_ROOM_ID).await.unwrap();
-        assert!(rebuild_linked_chunk(raw_parts).is_none());
+        let linked_chunk = lazy_loader::from_all_chunks::<3, _, _>(
+            self.load_all_chunks(&DEFAULT_TEST_ROOM_ID).await.unwrap(),
+        )
+        .unwrap();
+        assert!(linked_chunk.is_none());
     }
 
     async fn test_clear_all_rooms_chunks(&self) {
@@ -660,15 +658,23 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
         .unwrap();
 
         // Sanity check: both linked chunks can be reloaded.
-        assert!(rebuild_linked_chunk(self.load_all_chunks(r0).await.unwrap()).is_some());
-        assert!(rebuild_linked_chunk(self.load_all_chunks(r1).await.unwrap()).is_some());
+        assert!(lazy_loader::from_all_chunks::<3, _, _>(self.load_all_chunks(r0).await.unwrap())
+            .unwrap()
+            .is_some());
+        assert!(lazy_loader::from_all_chunks::<3, _, _>(self.load_all_chunks(r1).await.unwrap())
+            .unwrap()
+            .is_some());
 
         // Clear the chunks.
         self.clear_all_rooms_chunks().await.unwrap();
 
         // Both rooms now have no linked chunk.
-        assert!(rebuild_linked_chunk(self.load_all_chunks(r0).await.unwrap()).is_none());
-        assert!(rebuild_linked_chunk(self.load_all_chunks(r1).await.unwrap()).is_none());
+        assert!(lazy_loader::from_all_chunks::<3, _, _>(self.load_all_chunks(r0).await.unwrap())
+            .unwrap()
+            .is_none());
+        assert!(lazy_loader::from_all_chunks::<3, _, _>(self.load_all_chunks(r1).await.unwrap())
+            .unwrap()
+            .is_none());
     }
 
     async fn test_remove_room(&self) {

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

@@ -105,7 +105,6 @@ use std::{
 };
 
 pub use as_vector::*;
-pub use lazy_loader::{LinkedChunkBuilderTest, LinkedChunkBuilderTestError};
 pub use updates::*;
 
 /// Errors of [`LinkedChunk`].

crates/matrix-sdk-common/src/linked_chunk/relational.rs

@@ -499,8 +499,7 @@ mod tests {
     use assert_matches::assert_matches;
     use ruma::room_id;
 
-    use super::{ChunkIdentifier as CId, *};
-    use crate::linked_chunk::LinkedChunkBuilderTest;
+    use super::{super::lazy_loader::from_all_chunks, ChunkIdentifier as CId, *};
 
     #[test]
     fn test_new_items_chunk() {
@@ -1011,11 +1010,10 @@ mod tests {
         );
 
         // It correctly gets reloaded as such.
-        let raws = relational_linked_chunk.load_all_chunks(room_id).unwrap();
-        let lc = LinkedChunkBuilderTest::<3, _, _>::from_raw_parts(raws)
-            .build()
-            .expect("building succeeds")
-            .expect("this leads to a non-empty linked chunk");
+        let lc =
+            from_all_chunks::<3, _, _>(relational_linked_chunk.load_all_chunks(room_id).unwrap())
+                .expect("building succeeds")
+                .expect("this leads to a non-empty linked chunk");
 
         assert_items_eq!(lc, []);
     }
@@ -1046,11 +1044,10 @@ mod tests {
             ],
         );
 
-        let raws = relational_linked_chunk.load_all_chunks(room_id).unwrap();
-        let lc = LinkedChunkBuilderTest::<3, _, _>::from_raw_parts(raws)
-            .build()
-            .expect("building succeeds")
-            .expect("this leads to a non-empty linked chunk");
+        let lc =
+            from_all_chunks::<3, _, _>(relational_linked_chunk.load_all_chunks(room_id).unwrap())
+                .expect("building succeeds")
+                .expect("this leads to a non-empty linked chunk");
 
         // The linked chunk is correctly reloaded.
         assert_items_eq!(lc, ['a', 'b', 'c'] [-] ['d', 'e', 'f']);

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

@@ -1137,7 +1137,7 @@ mod tests {
     #[cfg(not(target_arch = "wasm32"))] // This uses the cross-process lock, so needs time support.
     #[async_test]
     async fn test_write_to_storage() {
-        use matrix_sdk_base::linked_chunk::LinkedChunkBuilderTest;
+        use matrix_sdk_base::linked_chunk::lazy_loader::from_all_chunks;
 
         let room_id = room_id!("!galette:saucisse.bzh");
         let f = EventFactory::new().room(room_id).sender(user_id!("@ben:saucisse.bzh"));
@@ -1175,9 +1175,10 @@ mod tests {
             .await
             .unwrap();
 
-        let raws = event_cache_store.load_all_chunks(room_id).await.unwrap();
         let linked_chunk =
-            LinkedChunkBuilderTest::<3, _, _>::from_raw_parts(raws).build().unwrap().unwrap();
+            from_all_chunks::<3, _, _>(event_cache_store.load_all_chunks(room_id).await.unwrap())
+                .unwrap()
+                .unwrap();
 
         assert_eq!(linked_chunk.chunks().count(), 3);
 
@@ -1208,7 +1209,7 @@ mod tests {
     #[cfg(not(target_arch = "wasm32"))] // This uses the cross-process lock, so needs time support.
     #[async_test]
     async fn test_write_to_storage_strips_bundled_relations() {
-        use matrix_sdk_base::linked_chunk::LinkedChunkBuilderTest;
+        use matrix_sdk_base::linked_chunk::lazy_loader::from_all_chunks;
         use ruma::events::BundledMessageLikeRelations;
 
         let room_id = room_id!("!galette:saucisse.bzh");
@@ -1265,9 +1266,10 @@ mod tests {
         }
 
         // The one in storage does not.
-        let raws = event_cache_store.load_all_chunks(room_id).await.unwrap();
         let linked_chunk =
-            LinkedChunkBuilderTest::<3, _, _>::from_raw_parts(raws).build().unwrap().unwrap();
+            from_all_chunks::<3, _, _>(event_cache_store.load_all_chunks(room_id).await.unwrap())
+                .unwrap()
+                .unwrap();
 
         assert_eq!(linked_chunk.chunks().count(), 1);
 
@@ -1293,7 +1295,7 @@ mod tests {
         use std::ops::ControlFlow;
 
         use eyeball_im::VectorDiff;
-        use matrix_sdk_base::linked_chunk::LinkedChunkBuilderTest;
+        use matrix_sdk_base::linked_chunk::lazy_loader::from_all_chunks;
 
         use crate::{assert_let_timeout, event_cache::RoomEventCacheUpdate};
 
@@ -1424,13 +1426,14 @@ mod tests {
         assert!(items.is_empty());
 
         // The event cache store too.
-        let raws = event_cache_store.load_all_chunks(room_id).await.unwrap();
-        let linked_chunk = LinkedChunkBuilderTest::<3, _, _>::from_raw_parts(raws).build().unwrap();
+        let linked_chunk =
+            from_all_chunks::<3, _, _>(event_cache_store.load_all_chunks(room_id).await.unwrap())
+                .unwrap()
+                .unwrap();
 
         // Note: while the event cache store could return `None` here, clearing it will
         // reset it to its initial form, maintaining the invariant that it
         // contains a single items chunk that's empty.
-        let linked_chunk = linked_chunk.unwrap();
         assert_eq!(linked_chunk.num_items(), 0);
     }