Move to integration tests

1 files changed, 2 insertions, 395 deletions

diff --git a/tests/handlers/test_sliding_sync.py b/tests/handlers/test_sliding_sync.py
index 5e91be0026..a7aa9bb8af 100644
--- a/tests/handlers/test_sliding_sync.py
+++ b/tests/handlers/test_sliding_sync.py
@@ -19,7 +19,7 @@
 #
 import logging
 from copy import deepcopy
-from typing import Dict, Optional, Tuple
+from typing import Dict, Optional
 from unittest.mock import patch
 
 from parameterized import parameterized
@@ -46,13 +46,7 @@ from synapse.rest import admin
 from synapse.rest.client import knock, login, room
 from synapse.server import HomeServer
 from synapse.storage.util.id_generators import MultiWriterIdGenerator
-from synapse.types import (
-    JsonDict,
-    SlidingSyncStreamToken,
-    StreamToken,
-    UserID,
-    create_requester,
-)
+from synapse.types import JsonDict, StreamToken, UserID
 from synapse.types.handlers import SlidingSyncConfig
 from synapse.util import Clock
 
@@ -3765,390 +3759,3 @@ class SortRoomsTestCase(HomeserverTestCase):
             # We only care about the *latest* event in the room.
             [room_id1, room_id2],
         )
-
-
-class GetRoomSyncDataTestCase(HomeserverTestCase):
-    """
-    Tests for Sliding Sync handler `get_room_sync_data()`
-    """
-
-    servlets = [
-        admin.register_servlets,
-        knock.register_servlets,
-        login.register_servlets,
-        room.register_servlets,
-    ]
-
-    def default_config(self) -> JsonDict:
-        config = super().default_config()
-        # Enable sliding sync
-        config["experimental_features"] = {"msc3575_enabled": True}
-        return config
-
-    def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
-        self.sliding_sync_handler = self.hs.get_sliding_sync_handler()
-        self.store = self.hs.get_datastores().main
-        self.event_sources = hs.get_event_sources()
-
-    def _create_sync_configs(
-        self,
-        user_id: str,
-        room_id: str,
-        timeline_limit: int = 5,
-    ) -> Tuple[SlidingSyncConfig, RoomSyncConfig, _RoomMembershipForUser]:
-        """Create the configs necessary to call `get_room_sync_data`"""
-        requester = create_requester(user_id, device_id="foo_device")
-        sync_config = SlidingSyncConfig(
-            user=requester.user,
-            requester=requester,
-            conn_id="conn_id",
-            lists={
-                "list": SlidingSyncConfig.SlidingSyncList(
-                    timeline_limit=timeline_limit,
-                    required_state=[
-                        (EventTypes.Name, ""),
-                    ],
-                ),
-            },
-            room_subscriptions={},
-            extensions=None,
-        )
-
-        room_sync_config = RoomSyncConfig(timeline_limit, {EventTypes.Name: {""}})
-
-        rooms = self.get_success(
-            self.store.get_rooms_for_local_user_where_membership_is(
-                user_id, membership_list=[Membership.JOIN]
-            )
-        )
-        room_for_user = rooms[0]
-        assert room_for_user.room_id == room_id
-
-        room_membership_for_user_at_to_token = _RoomMembershipForUser(
-            room_id=room_id,
-            event_id=room_for_user.event_id,
-            event_pos=room_for_user.event_pos,
-            membership=Membership.JOIN,
-            sender=user_id,
-            newly_joined=False,
-            newly_left=False,
-            is_dm=False,
-        )
-
-        return (sync_config, room_sync_config, room_membership_for_user_at_to_token)
-
-    def test_room_sync_data_initial(self) -> None:
-        """Tests getting room sync data with no from token"""
-
-        user1_id = self.register_user("user1", "pass")
-        user1_tok = self.login(user1_id, "pass")
-
-        room_id1 = self.helper.create_room_as(
-            user1_id,
-            tok=user1_tok,
-        )
-
-        sync_config, room_sync_config, room_membership_for_user_at_to_token = (
-            self._create_sync_configs(user1_id, room_id1, timeline_limit=5)
-        )
-
-        # Timeline limit is 5 so let's send 5 messages that we'll expect to get
-        # back.
-        expected_timeline = []
-        for _ in range(5):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        to_token = self.event_sources.get_current_token()
-
-        result = self.get_success(
-            self.sliding_sync_handler.get_room_sync_data(
-                sync_config,
-                room_id=room_id1,
-                room_sync_config=room_sync_config,
-                room_membership_for_user_at_to_token=room_membership_for_user_at_to_token,
-                from_token=None,
-                to_token=to_token,
-            )
-        )
-
-        self.assertTrue(result.initial)
-        self.assertTrue(result.limited)
-        self.assertEqual(
-            [e.event_id for e in result.timeline_events], expected_timeline
-        )
-
-    def test_room_sync_data_incremental_live(self) -> None:
-        """Test getting room data where we have previously sent down the room
-        and its state is considered LIVE"""
-        user1_id = self.register_user("user1", "pass")
-        user1_tok = self.login(user1_id, "pass")
-
-        room_id1 = self.helper.create_room_as(
-            user1_id,
-            tok=user1_tok,
-        )
-
-        sync_config, room_sync_config, room_membership_for_user_at_to_token = (
-            self._create_sync_configs(user1_id, room_id1)
-        )
-
-        # These messages are sent before the `from_token`, so we don't expect to
-        # see these messages.
-        for _ in range(5):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-
-        # Mark the room as having been sent down, and create an appropriate
-        # `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, None, sent_room_ids=[room_id1], unsent_room_ids=[]
-            )
-        )
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # These messages are sent after the `from_token`, so we expect to only
-        # see these messages.
-        expected_timeline = []
-        for _ in range(2):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        to_token = self.event_sources.get_current_token()
-
-        result = self.get_success(
-            self.sliding_sync_handler.get_room_sync_data(
-                sync_config,
-                room_id=room_id1,
-                room_sync_config=room_sync_config,
-                room_membership_for_user_at_to_token=room_membership_for_user_at_to_token,
-                from_token=from_token,
-                to_token=to_token,
-            )
-        )
-
-        self.assertFalse(result.initial)
-        self.assertFalse(result.limited)
-        self.assertEqual(
-            [e.event_id for e in result.timeline_events], expected_timeline
-        )
-
-    def test_room_sync_data_incremental_previously_not_limited(self) -> None:
-        """Test getting room data where we have previously sent down the room,
-        but we missed sending down some data previously and so its state is
-        considered PREVIOUSLY.
-
-        In this case there has been more than timeline limit events.
-        """
-        user1_id = self.register_user("user1", "pass")
-        user1_tok = self.login(user1_id, "pass")
-
-        room_id1 = self.helper.create_room_as(
-            user1_id,
-            tok=user1_tok,
-        )
-
-        sync_config, room_sync_config, room_membership_for_user_at_to_token = (
-            self._create_sync_configs(user1_id, room_id1)
-        )
-
-        # These messages are sent before the initial `from_token`, so we don't
-        # expect to see these messages.
-        for _ in range(5):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-
-        # Mark the room as having been sent down, and create an appropriate
-        # `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, None, sent_room_ids=[room_id1], unsent_room_ids=[]
-            )
-        )
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # These messages are sent after the initial `from_token`, so we expect
-        # to see these messages.
-        expected_timeline = []
-        for _ in range(2):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        # Mark the room as *not* having been sent down, and create a new
-        # `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, from_token, sent_room_ids=[], unsent_room_ids=[room_id1]
-            )
-        )
-
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # We should also receive new messages
-        for _ in range(2):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        to_token = self.event_sources.get_current_token()
-
-        result = self.get_success(
-            self.sliding_sync_handler.get_room_sync_data(
-                sync_config,
-                room_id=room_id1,
-                room_sync_config=room_sync_config,
-                room_membership_for_user_at_to_token=room_membership_for_user_at_to_token,
-                from_token=from_token,
-                to_token=to_token,
-            )
-        )
-
-        self.assertFalse(result.initial)
-        self.assertFalse(result.limited)
-        self.assertEqual(
-            [e.event_id for e in result.timeline_events], expected_timeline
-        )
-
-    def test_room_sync_data_incremental_previously_limited(self) -> None:
-        """Test getting room data where we have previously sent down the room,
-        but we missed sending down some data previously and so its state is
-        considered PREVIOUSLY.
-
-        In this case there has been fewer than timeline limit events.
-        """
-        user1_id = self.register_user("user1", "pass")
-        user1_tok = self.login(user1_id, "pass")
-
-        room_id1 = self.helper.create_room_as(
-            user1_id,
-            tok=user1_tok,
-        )
-
-        sync_config, room_sync_config, room_membership_for_user_at_to_token = (
-            self._create_sync_configs(user1_id, room_id1)
-        )
-
-        # These messages are sent before the initial `from_token`, so we don't
-        # expect to see these messages.
-        for _ in range(5):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-
-        # Mark the room as having been sent down, and create an appropriate
-        # `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, None, sent_room_ids=[room_id1], unsent_room_ids=[]
-            )
-        )
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # These messages are sent after the initial `from_token`, but are before
-        # the timeline limit, so we don't expect to see these messages.
-        for _ in range(5):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-
-        # ... but these messages are within the timeline limit, so we do expect
-        # to see them
-        expected_timeline = []
-        for _ in range(3):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        # Mark the room as *not* having been sent down, and create a new
-        # `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, from_token, sent_room_ids=[], unsent_room_ids=[room_id1]
-            )
-        )
-
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # We should also receive new messages
-        for _ in range(2):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        to_token = self.event_sources.get_current_token()
-
-        result = self.get_success(
-            self.sliding_sync_handler.get_room_sync_data(
-                sync_config,
-                room_id=room_id1,
-                room_sync_config=room_sync_config,
-                room_membership_for_user_at_to_token=room_membership_for_user_at_to_token,
-                from_token=from_token,
-                to_token=to_token,
-            )
-        )
-
-        self.assertFalse(result.initial)
-        self.assertTrue(result.limited)
-        self.assertEqual(
-            [e.event_id for e in result.timeline_events], expected_timeline
-        )
-
-    def test_room_sync_data_incremental_never(self) -> None:
-        """Test getting room data where we have not previously sent down the room,
-        so its state is considered NEVER.
-        """
-        user1_id = self.register_user("user1", "pass")
-        user1_tok = self.login(user1_id, "pass")
-
-        room_id1 = self.helper.create_room_as(
-            user1_id,
-            tok=user1_tok,
-        )
-
-        sync_config, room_sync_config, room_membership_for_user_at_to_token = (
-            self._create_sync_configs(user1_id, room_id1)
-        )
-
-        # We expect to see these messages even though they're before the
-        # `from_token`, as the room has not been sent down.
-        expected_timeline = []
-        for _ in range(2):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        # Create a new `from_token`.
-        connection_token = self.get_success(
-            self.sliding_sync_handler.connection_store.record_rooms(
-                sync_config, None, sent_room_ids=[], unsent_room_ids=[]
-            )
-        )
-        from_token = SlidingSyncStreamToken(
-            self.event_sources.get_current_token(), connection_token
-        )
-
-        # We should also receive new messages
-        for _ in range(3):
-            r = self.helper.send(room_id1, "message", tok=user1_tok)
-            expected_timeline.append(r["event_id"])
-
-        to_token = self.event_sources.get_current_token()
-
-        result = self.get_success(
-            self.sliding_sync_handler.get_room_sync_data(
-                sync_config,
-                room_id=room_id1,
-                room_sync_config=room_sync_config,
-                room_membership_for_user_at_to_token=room_membership_for_user_at_to_token,
-                from_token=from_token,
-                to_token=to_token,
-            )
-        )
-
-        self.assertTrue(result.initial)
-        self.assertTrue(result.limited)
-        self.assertEqual(
-            [e.event_id for e in result.timeline_events], expected_timeline
-        )