Move media retention tests out of rest tests (#16684)

* Move media retention tests out of rest tests

AFAICS this doesn't make any HTTP requests and so it ought not to belong
in `tests.rest`.

* Changelog

1 files changed, 0 insertions, 294 deletions

diff --git a/tests/rest/media/test_media_retention.py b/tests/rest/media/test_media_retention.py
deleted file mode 100644
index 27a663a23b..0000000000
--- a/tests/rest/media/test_media_retention.py
+++ /dev/null
@@ -1,294 +0,0 @@
-# Copyright 2022 The Matrix.org Foundation C.I.C.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import io
-from typing import Iterable, Optional
-
-from matrix_common.types.mxc_uri import MXCUri
-
-from twisted.test.proto_helpers import MemoryReactor
-
-from synapse.rest import admin
-from synapse.rest.client import login, register, room
-from synapse.server import HomeServer
-from synapse.types import UserID
-from synapse.util import Clock
-
-from tests import unittest
-from tests.unittest import override_config
-from tests.utils import MockClock
-
-
-class MediaRetentionTestCase(unittest.HomeserverTestCase):
-    ONE_DAY_IN_MS = 24 * 60 * 60 * 1000
-    THIRTY_DAYS_IN_MS = 30 * ONE_DAY_IN_MS
-
-    servlets = [
-        room.register_servlets,
-        login.register_servlets,
-        register.register_servlets,
-        admin.register_servlets_for_client_rest_resource,
-    ]
-
-    def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
-        # We need to be able to test advancing time in the homeserver, so we
-        # replace the test homeserver's default clock with a MockClock, which
-        # supports advancing time.
-        return self.setup_test_homeserver(clock=MockClock())
-
-    def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
-        self.remote_server_name = "remote.homeserver"
-        self.store = hs.get_datastores().main
-
-        # Create a user to upload media with
-        test_user_id = self.register_user("alice", "password")
-
-        # Inject media (recently accessed, old access, never accessed, old access
-        # quarantined media) into both the local store and the remote cache, plus
-        # one additional local media that is marked as protected from quarantine.
-        media_repository = hs.get_media_repository()
-        test_media_content = b"example string"
-
-        def _create_media_and_set_attributes(
-            last_accessed_ms: Optional[int],
-            is_quarantined: Optional[bool] = False,
-            is_protected: Optional[bool] = False,
-        ) -> MXCUri:
-            # "Upload" some media to the local media store
-            mxc_uri: MXCUri = self.get_success(
-                media_repository.create_content(
-                    media_type="text/plain",
-                    upload_name=None,
-                    content=io.BytesIO(test_media_content),
-                    content_length=len(test_media_content),
-                    auth_user=UserID.from_string(test_user_id),
-                )
-            )
-
-            # Set the last recently accessed time for this media
-            if last_accessed_ms is not None:
-                self.get_success(
-                    self.store.update_cached_last_access_time(
-                        local_media=(mxc_uri.media_id,),
-                        remote_media=(),
-                        time_ms=last_accessed_ms,
-                    )
-                )
-
-            if is_quarantined:
-                # Mark this media as quarantined
-                self.get_success(
-                    self.store.quarantine_media_by_id(
-                        server_name=self.hs.config.server.server_name,
-                        media_id=mxc_uri.media_id,
-                        quarantined_by="@theadmin:test",
-                    )
-                )
-
-            if is_protected:
-                # Mark this media as protected from quarantine
-                self.get_success(
-                    self.store.mark_local_media_as_safe(
-                        media_id=mxc_uri.media_id,
-                        safe=True,
-                    )
-                )
-
-            return mxc_uri
-
-        def _cache_remote_media_and_set_attributes(
-            media_id: str,
-            last_accessed_ms: Optional[int],
-            is_quarantined: Optional[bool] = False,
-        ) -> MXCUri:
-            # Pretend to cache some remote media
-            self.get_success(
-                self.store.store_cached_remote_media(
-                    origin=self.remote_server_name,
-                    media_id=media_id,
-                    media_type="text/plain",
-                    media_length=1,
-                    time_now_ms=clock.time_msec(),
-                    upload_name="testfile.txt",
-                    filesystem_id="abcdefg12345",
-                )
-            )
-
-            # Set the last recently accessed time for this media
-            if last_accessed_ms is not None:
-                self.get_success(
-                    hs.get_datastores().main.update_cached_last_access_time(
-                        local_media=(),
-                        remote_media=((self.remote_server_name, media_id),),
-                        time_ms=last_accessed_ms,
-                    )
-                )
-
-            if is_quarantined:
-                # Mark this media as quarantined
-                self.get_success(
-                    self.store.quarantine_media_by_id(
-                        server_name=self.remote_server_name,
-                        media_id=media_id,
-                        quarantined_by="@theadmin:test",
-                    )
-                )
-
-            return MXCUri(self.remote_server_name, media_id)
-
-        # Start with the local media store
-        self.local_recently_accessed_media = _create_media_and_set_attributes(
-            last_accessed_ms=self.THIRTY_DAYS_IN_MS,
-        )
-        self.local_not_recently_accessed_media = _create_media_and_set_attributes(
-            last_accessed_ms=self.ONE_DAY_IN_MS,
-        )
-        self.local_not_recently_accessed_quarantined_media = (
-            _create_media_and_set_attributes(
-                last_accessed_ms=self.ONE_DAY_IN_MS,
-                is_quarantined=True,
-            )
-        )
-        self.local_not_recently_accessed_protected_media = (
-            _create_media_and_set_attributes(
-                last_accessed_ms=self.ONE_DAY_IN_MS,
-                is_protected=True,
-            )
-        )
-        self.local_never_accessed_media = _create_media_and_set_attributes(
-            last_accessed_ms=None,
-        )
-
-        # And now the remote media store
-        self.remote_recently_accessed_media = _cache_remote_media_and_set_attributes(
-            media_id="a",
-            last_accessed_ms=self.THIRTY_DAYS_IN_MS,
-        )
-        self.remote_not_recently_accessed_media = (
-            _cache_remote_media_and_set_attributes(
-                media_id="b",
-                last_accessed_ms=self.ONE_DAY_IN_MS,
-            )
-        )
-        self.remote_not_recently_accessed_quarantined_media = (
-            _cache_remote_media_and_set_attributes(
-                media_id="c",
-                last_accessed_ms=self.ONE_DAY_IN_MS,
-                is_quarantined=True,
-            )
-        )
-        # Remote media will always have a "last accessed" attribute, as it would not
-        # be fetched from the remote homeserver unless instigated by a user.
-
-    @override_config(
-        {
-            "media_retention": {
-                # Enable retention for local media
-                "local_media_lifetime": "30d"
-                # Cached remote media should not be purged
-            }
-        }
-    )
-    def test_local_media_retention(self) -> None:
-        """
-        Tests that local media that have not been accessed recently is purged, while
-        cached remote media is unaffected.
-        """
-        # Advance 31 days (in seconds)
-        self.reactor.advance(31 * 24 * 60 * 60)
-
-        # Check that media has been correctly purged.
-        # Local media accessed <30 days ago should still exist.
-        # Remote media should be unaffected.
-        self._assert_if_mxc_uris_purged(
-            purged=[
-                self.local_not_recently_accessed_media,
-                self.local_never_accessed_media,
-            ],
-            not_purged=[
-                self.local_recently_accessed_media,
-                self.local_not_recently_accessed_quarantined_media,
-                self.local_not_recently_accessed_protected_media,
-                self.remote_recently_accessed_media,
-                self.remote_not_recently_accessed_media,
-                self.remote_not_recently_accessed_quarantined_media,
-            ],
-        )
-
-    @override_config(
-        {
-            "media_retention": {
-                # Enable retention for cached remote media
-                "remote_media_lifetime": "30d"
-                # Local media should not be purged
-            }
-        }
-    )
-    def test_remote_media_cache_retention(self) -> None:
-        """
-        Tests that entries from the remote media cache that have not been accessed
-        recently is purged, while local media is unaffected.
-        """
-        # Advance 31 days (in seconds)
-        self.reactor.advance(31 * 24 * 60 * 60)
-
-        # Check that media has been correctly purged.
-        # Local media should be unaffected.
-        # Remote media accessed <30 days ago should still exist.
-        self._assert_if_mxc_uris_purged(
-            purged=[
-                self.remote_not_recently_accessed_media,
-            ],
-            not_purged=[
-                self.remote_recently_accessed_media,
-                self.local_recently_accessed_media,
-                self.local_not_recently_accessed_media,
-                self.local_not_recently_accessed_quarantined_media,
-                self.local_not_recently_accessed_protected_media,
-                self.remote_not_recently_accessed_quarantined_media,
-                self.local_never_accessed_media,
-            ],
-        )
-
-    def _assert_if_mxc_uris_purged(
-        self, purged: Iterable[MXCUri], not_purged: Iterable[MXCUri]
-    ) -> None:
-        def _assert_mxc_uri_purge_state(mxc_uri: MXCUri, expect_purged: bool) -> None:
-            """Given an MXC URI, assert whether it has been purged or not."""
-            if mxc_uri.server_name == self.hs.config.server.server_name:
-                found_media = bool(
-                    self.get_success(self.store.get_local_media(mxc_uri.media_id))
-                )
-            else:
-                found_media = bool(
-                    self.get_success(
-                        self.store.get_cached_remote_media(
-                            mxc_uri.server_name, mxc_uri.media_id
-                        )
-                    )
-                )
-
-            if expect_purged:
-                self.assertFalse(found_media, msg=f"{mxc_uri} unexpectedly not purged")
-            else:
-                self.assertTrue(
-                    found_media,
-                    msg=f"{mxc_uri} unexpectedly purged",
-                )
-
-        # Assert that the given MXC URIs have either been correctly purged or not.
-        for mxc_uri in purged:
-            _assert_mxc_uri_purge_state(mxc_uri, expect_purged=True)
-        for mxc_uri in not_purged:
-            _assert_mxc_uri_purge_state(mxc_uri, expect_purged=False)