Split MediaStore trait from EventCacheStore.

Rename `EventCacheStoreMedia` to `MediaStoreInner`.
Move relevant tests into `MediaStoreIntegrationTests`.

Author: Shrey Patel

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

@@ -29,24 +29,17 @@ use matrix_sdk_common::{
 };
 use matrix_sdk_test::{ALICE, DEFAULT_TEST_ROOM_ID, event_factory::EventFactory};
 use ruma::{
-    EventId, RoomId,
-    api::client::media::get_content_thumbnail::v3::Method,
-    event_id,
+    EventId, RoomId, event_id,
     events::{
-        AnyMessageLikeEvent, AnyTimelineEvent,
-        relation::RelationType,
-        room::{MediaSource, message::RoomMessageEventContentWithoutRelation},
+        AnyMessageLikeEvent, AnyTimelineEvent, relation::RelationType,
+        room::message::RoomMessageEventContentWithoutRelation,
     },
-    mxc_uri,
     push::Action,
-    room_id, uint,
+    room_id,
 };
 
-use super::{DynEventCacheStore, media::IgnoreMediaRetentionPolicy};
-use crate::{
-    event_cache::{Gap, store::DEFAULT_CHUNK_CAPACITY},
-    media::{MediaFormat, MediaRequestParameters, MediaThumbnailSettings},
-};
+use super::DynEventCacheStore;
+use crate::event_cache::{Gap, store::DEFAULT_CHUNK_CAPACITY};
 
 /// Create a test event with all data filled, for testing that linked chunk
 /// correctly stores event data.
@@ -118,12 +111,6 @@ pub fn check_test_event(event: &TimelineEvent, text: &str) {
 /// `event_cache_store_integration_tests!` macro.
 #[allow(async_fn_in_trait)]
 pub trait EventCacheStoreIntegrationTests {
-    /// Test media content storage.
-    async fn test_media_content(&self);
-
-    /// Test replacing a MXID.
-    async fn test_replace_media_key(&self);
-
     /// Test handling updates to a linked chunk and reloading these updates from
     /// the store.
     async fn test_handle_updates_and_rebuild_linked_chunk(&self);
@@ -163,190 +150,6 @@ pub trait EventCacheStoreIntegrationTests {
 }
 
 impl EventCacheStoreIntegrationTests for DynEventCacheStore {
-    async fn test_media_content(&self) {
-        let uri = mxc_uri!("mxc://localhost/media");
-        let request_file = MediaRequestParameters {
-            source: MediaSource::Plain(uri.to_owned()),
-            format: MediaFormat::File,
-        };
-        let request_thumbnail = MediaRequestParameters {
-            source: MediaSource::Plain(uri.to_owned()),
-            format: MediaFormat::Thumbnail(MediaThumbnailSettings::with_method(
-                Method::Crop,
-                uint!(100),
-                uint!(100),
-            )),
-        };
-
-        let other_uri = mxc_uri!("mxc://localhost/media-other");
-        let request_other_file = MediaRequestParameters {
-            source: MediaSource::Plain(other_uri.to_owned()),
-            format: MediaFormat::File,
-        };
-
-        let content: Vec<u8> = "hello".into();
-        let thumbnail_content: Vec<u8> = "world".into();
-        let other_content: Vec<u8> = "foo".into();
-
-        // Media isn't present in the cache.
-        assert!(
-            self.get_media_content(&request_file).await.unwrap().is_none(),
-            "unexpected media found"
-        );
-        assert!(
-            self.get_media_content(&request_thumbnail).await.unwrap().is_none(),
-            "media not found"
-        );
-
-        // Let's add the media.
-        self.add_media_content(&request_file, content.clone(), IgnoreMediaRetentionPolicy::No)
-            .await
-            .expect("adding media failed");
-
-        // Media is present in the cache.
-        assert_eq!(
-            self.get_media_content(&request_file).await.unwrap().as_ref(),
-            Some(&content),
-            "media not found though added"
-        );
-        assert_eq!(
-            self.get_media_content_for_uri(uri).await.unwrap().as_ref(),
-            Some(&content),
-            "media not found by URI though added"
-        );
-
-        // Let's remove the media.
-        self.remove_media_content(&request_file).await.expect("removing media failed");
-
-        // Media isn't present in the cache.
-        assert!(
-            self.get_media_content(&request_file).await.unwrap().is_none(),
-            "media still there after removing"
-        );
-        assert!(
-            self.get_media_content_for_uri(uri).await.unwrap().is_none(),
-            "media still found by URI after removing"
-        );
-
-        // Let's add the media again.
-        self.add_media_content(&request_file, content.clone(), IgnoreMediaRetentionPolicy::No)
-            .await
-            .expect("adding media again failed");
-
-        assert_eq!(
-            self.get_media_content(&request_file).await.unwrap().as_ref(),
-            Some(&content),
-            "media not found after adding again"
-        );
-
-        // Let's add the thumbnail media.
-        self.add_media_content(
-            &request_thumbnail,
-            thumbnail_content.clone(),
-            IgnoreMediaRetentionPolicy::No,
-        )
-        .await
-        .expect("adding thumbnail failed");
-
-        // Media's thumbnail is present.
-        assert_eq!(
-            self.get_media_content(&request_thumbnail).await.unwrap().as_ref(),
-            Some(&thumbnail_content),
-            "thumbnail not found"
-        );
-
-        // We get a file with the URI, we don't know which one.
-        assert!(
-            self.get_media_content_for_uri(uri).await.unwrap().is_some(),
-            "media not found by URI though two where added"
-        );
-
-        // Let's add another media with a different URI.
-        self.add_media_content(
-            &request_other_file,
-            other_content.clone(),
-            IgnoreMediaRetentionPolicy::No,
-        )
-        .await
-        .expect("adding other media failed");
-
-        // Other file is present.
-        assert_eq!(
-            self.get_media_content(&request_other_file).await.unwrap().as_ref(),
-            Some(&other_content),
-            "other file not found"
-        );
-        assert_eq!(
-            self.get_media_content_for_uri(other_uri).await.unwrap().as_ref(),
-            Some(&other_content),
-            "other file not found by URI"
-        );
-
-        // Let's remove media based on URI.
-        self.remove_media_content_for_uri(uri).await.expect("removing all media for uri failed");
-
-        assert!(
-            self.get_media_content(&request_file).await.unwrap().is_none(),
-            "media wasn't removed"
-        );
-        assert!(
-            self.get_media_content(&request_thumbnail).await.unwrap().is_none(),
-            "thumbnail wasn't removed"
-        );
-        assert!(
-            self.get_media_content(&request_other_file).await.unwrap().is_some(),
-            "other media was removed"
-        );
-        assert!(
-            self.get_media_content_for_uri(uri).await.unwrap().is_none(),
-            "media found by URI wasn't removed"
-        );
-        assert!(
-            self.get_media_content_for_uri(other_uri).await.unwrap().is_some(),
-            "other media found by URI was removed"
-        );
-    }
-
-    async fn test_replace_media_key(&self) {
-        let uri = mxc_uri!("mxc://sendqueue.local/tr4n-s4ct-10n1-d");
-        let req = MediaRequestParameters {
-            source: MediaSource::Plain(uri.to_owned()),
-            format: MediaFormat::File,
-        };
-
-        let content = "hello".as_bytes().to_owned();
-
-        // Media isn't present in the cache.
-        assert!(self.get_media_content(&req).await.unwrap().is_none(), "unexpected media found");
-
-        // Add the media.
-        self.add_media_content(&req, content.clone(), IgnoreMediaRetentionPolicy::No)
-            .await
-            .expect("adding media failed");
-
-        // Sanity-check: media is found after adding it.
-        assert_eq!(self.get_media_content(&req).await.unwrap().unwrap(), b"hello");
-
-        // Replacing a media request works.
-        let new_uri = mxc_uri!("mxc://matrix.org/tr4n-s4ct-10n1-d");
-        let new_req = MediaRequestParameters {
-            source: MediaSource::Plain(new_uri.to_owned()),
-            format: MediaFormat::File,
-        };
-        self.replace_media_key(&req, &new_req)
-            .await
-            .expect("replacing the media request key failed");
-
-        // Finding with the previous request doesn't work anymore.
-        assert!(
-            self.get_media_content(&req).await.unwrap().is_none(),
-            "unexpected media found with the old key"
-        );
-
-        // Finding with the new request does work.
-        assert_eq!(self.get_media_content(&new_req).await.unwrap().unwrap(), b"hello");
-    }
-
     async fn test_handle_updates_and_rebuild_linked_chunk(&self) {
         let room_id = room_id!("!r0:matrix.org");
         let linked_chunk_id = LinkedChunkId::Room(room_id);
@@ -1333,20 +1136,6 @@ macro_rules! event_cache_store_integration_tests {
 
             use super::get_event_cache_store;
 
-            #[async_test]
-            async fn test_media_content() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_media_content().await;
-            }
-
-            #[async_test]
-            async fn test_replace_media_key() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_replace_media_key().await;
-            }
-
             #[async_test]
             async fn test_handle_updates_and_rebuild_linked_chunk() {
                 let event_cache_store =

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

@@ -36,11 +36,13 @@ use tracing::error;
 
 use super::{
     EventCacheStore, EventCacheStoreError, Result, compute_filters_string, extract_event_relation,
-    media::{EventCacheStoreMedia, IgnoreMediaRetentionPolicy, MediaRetentionPolicy, MediaService},
 };
 use crate::{
     event_cache::{Event, Gap},
-    media::{MediaRequestParameters, UniqueKey as _},
+    media::{
+        MediaRequestParameters, UniqueKey as _,
+        store::{IgnoreMediaRetentionPolicy, MediaRetentionPolicy, MediaService, MediaStoreInner},
+    },
 };
 
 /// In-memory, non-persistent implementation of the `EventCacheStore`.
@@ -372,7 +374,7 @@ impl EventCacheStore for MemoryStore {
 
 #[cfg_attr(target_family = "wasm", async_trait(?Send))]
 #[cfg_attr(not(target_family = "wasm"), async_trait)]
-impl EventCacheStoreMedia for MemoryStore {
+impl MediaStoreInner for MemoryStore {
     type Error = EventCacheStoreError;
 
     async fn media_retention_policy_inner(
@@ -578,13 +580,13 @@ impl EventCacheStoreMedia for MemoryStore {
 #[cfg(test)]
 mod tests {
     use super::{MemoryStore, Result};
-    use crate::event_cache_store_media_integration_tests;
+    use crate::media_store_inner_integration_tests;
 
     async fn get_event_cache_store() -> Result<MemoryStore> {
         Ok(MemoryStore::new())
     }
 
     event_cache_store_integration_tests!();
     event_cache_store_integration_tests_time!();
-    event_cache_store_media_integration_tests!(with_media_size_tests);
+    media_store_inner_integration_tests!(with_media_size_tests);
 }

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

@@ -24,7 +24,6 @@ use std::{fmt, ops::Deref, str::Utf8Error, sync::Arc};
 #[cfg(any(test, feature = "testing"))]
 #[macro_use]
 pub mod integration_tests;
-pub mod media;
 mod memory_store;
 mod traits;