2024-06-04 03:49:27 +00:00
|
|
|
#
|
|
|
|
# This file is licensed under the Affero General Public License (AGPL) version 3.
|
|
|
|
#
|
|
|
|
# Copyright (C) 2024 New Vector, Ltd
|
|
|
|
#
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU Affero General Public License as
|
|
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
|
|
# License, or (at your option) any later version.
|
|
|
|
#
|
|
|
|
# See the GNU Affero General Public License for more details:
|
|
|
|
# <https://www.gnu.org/licenses/agpl-3.0.html>.
|
|
|
|
#
|
|
|
|
# Originally licensed under the Apache License, Version 2.0:
|
|
|
|
# <http://www.apache.org/licenses/LICENSE-2.0>.
|
|
|
|
#
|
|
|
|
# [This file includes modifications made by New Vector Limited]
|
|
|
|
#
|
|
|
|
#
|
2024-05-21 19:24:03 +00:00
|
|
|
from twisted.test.proto_helpers import MemoryReactor
|
|
|
|
|
2024-06-04 03:47:01 +00:00
|
|
|
from synapse.api.constants import EventTypes, JoinRules, Membership
|
2024-05-21 19:24:03 +00:00
|
|
|
from synapse.api.room_versions import RoomVersions
|
|
|
|
from synapse.rest import admin
|
|
|
|
from synapse.rest.client import knock, login, room
|
|
|
|
from synapse.server import HomeServer
|
|
|
|
from synapse.types import JsonDict, UserID
|
|
|
|
from synapse.util import Clock
|
|
|
|
|
|
|
|
from tests.unittest import HomeserverTestCase
|
|
|
|
|
|
|
|
|
|
|
|
class GetSyncRoomIdsForUserTestCase(HomeserverTestCase):
|
2024-05-28 20:51:05 +00:00
|
|
|
"""
|
|
|
|
Tests Sliding Sync handler `get_sync_room_ids_for_user()` to make sure it returns
|
|
|
|
the correct list of rooms IDs.
|
|
|
|
"""
|
2024-05-21 19:24:03 +00:00
|
|
|
|
|
|
|
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()
|
|
|
|
|
2024-05-21 20:05:19 +00:00
|
|
|
def test_no_rooms(self) -> None:
|
|
|
|
"""
|
|
|
|
Test when the user has never joined any rooms before
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
# user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
now_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=now_token,
|
|
|
|
to_token=now_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2024-05-21 22:37:46 +00:00
|
|
|
self.assertEqual(room_id_results, set())
|
2024-05-21 20:05:19 +00:00
|
|
|
|
2024-05-21 19:24:03 +00:00
|
|
|
def test_get_newly_joined_room(self) -> None:
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
Test that rooms that the user has newly_joined show up. newly_joined is when you
|
|
|
|
join after the `from_token` and <= `to_token`.
|
|
|
|
"""
|
2024-05-21 19:24:03 +00:00
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
before_room_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id = self.helper.create_room_as(user1_id, tok=user1_tok, is_public=True)
|
|
|
|
|
|
|
|
after_room_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room_token,
|
|
|
|
to_token=after_room_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
self.assertEqual(room_id_results, {room_id})
|
|
|
|
|
|
|
|
def test_get_already_joined_room(self) -> None:
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
Test that rooms that the user is already joined show up.
|
|
|
|
"""
|
2024-05-21 19:24:03 +00:00
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
room_id = self.helper.create_room_as(user1_id, tok=user1_tok, is_public=True)
|
|
|
|
|
|
|
|
after_room_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room_token,
|
|
|
|
to_token=after_room_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
self.assertEqual(room_id_results, {room_id})
|
|
|
|
|
|
|
|
def test_get_invited_banned_knocked_room(self) -> None:
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
Test that rooms that the user is invited to, banned from, and knocked on show
|
|
|
|
up.
|
|
|
|
"""
|
2024-05-21 19:24:03 +00:00
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
before_room_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Setup the invited room (user2 invites user1 to the room)
|
|
|
|
invited_room_id = self.helper.create_room_as(user2_id, tok=user2_tok)
|
|
|
|
self.helper.invite(invited_room_id, targ=user1_id, tok=user2_tok)
|
|
|
|
|
|
|
|
# Setup the ban room (user2 bans user1 from the room)
|
|
|
|
ban_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(ban_room_id, user1_id, tok=user1_tok)
|
|
|
|
self.helper.ban(ban_room_id, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
|
|
|
|
# Setup the knock room (user1 knocks on the room)
|
|
|
|
knock_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, room_version=RoomVersions.V7.identifier
|
|
|
|
)
|
|
|
|
self.helper.send_state(
|
|
|
|
knock_room_id,
|
|
|
|
EventTypes.JoinRules,
|
|
|
|
{"join_rule": JoinRules.KNOCK},
|
|
|
|
tok=user2_tok,
|
|
|
|
)
|
|
|
|
# User1 knocks on the room
|
|
|
|
channel = self.make_request(
|
|
|
|
"POST",
|
|
|
|
"/_matrix/client/r0/knock/%s" % (knock_room_id,),
|
|
|
|
b"{}",
|
|
|
|
user1_tok,
|
|
|
|
)
|
2024-06-04 03:47:01 +00:00
|
|
|
self.assertEqual(channel.code, 200, channel.result)
|
2024-05-21 19:24:03 +00:00
|
|
|
|
|
|
|
after_room_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room_token,
|
|
|
|
to_token=after_room_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Ensure that the invited, ban, and knock rooms show up
|
|
|
|
self.assertEqual(
|
|
|
|
room_id_results,
|
|
|
|
{
|
|
|
|
invited_room_id,
|
|
|
|
ban_room_id,
|
|
|
|
knock_room_id,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
2024-06-04 03:47:01 +00:00
|
|
|
def test_get_kicked_room(self) -> None:
|
|
|
|
"""
|
|
|
|
Test that a room that the user was kicked from still shows up. When the user
|
|
|
|
comes back to their client, they should see that they were kicked.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# Setup the kick room (user2 kicks user1 from the room)
|
|
|
|
kick_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(kick_room_id, user1_id, tok=user1_tok)
|
|
|
|
# Kick user1 from the room
|
|
|
|
self.helper.change_membership(
|
|
|
|
room=kick_room_id,
|
|
|
|
src=user2_id,
|
|
|
|
targ=user1_id,
|
|
|
|
tok=user2_tok,
|
|
|
|
membership=Membership.LEAVE,
|
|
|
|
extra_data={
|
|
|
|
"reason": "Bad manners",
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
after_kick_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_kick_token,
|
|
|
|
to_token=after_kick_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# The kicked room should show up
|
|
|
|
self.assertEqual(room_id_results, {kick_room_id})
|
|
|
|
|
|
|
|
def test_forgotten_rooms(self) -> None:
|
|
|
|
"""
|
|
|
|
Forgotten rooms do not show up even if we forget after the from/to range.
|
|
|
|
|
|
|
|
Ideally, we would be able to track when the `/forget` happens and apply it
|
|
|
|
accordingly in the token range but the forgotten flag is only an extra bool in
|
|
|
|
the `room_memberships` table.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# Setup a normal room that we leave. This won't show up in the sync response
|
|
|
|
# because we left it before our token but is good to check anyway.
|
|
|
|
leave_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(leave_room_id, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(leave_room_id, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
# Setup the ban room (user2 bans user1 from the room)
|
|
|
|
ban_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(ban_room_id, user1_id, tok=user1_tok)
|
|
|
|
self.helper.ban(ban_room_id, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
|
|
|
|
# Setup the kick room (user2 kicks user1 from the room)
|
|
|
|
kick_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(kick_room_id, user1_id, tok=user1_tok)
|
|
|
|
# Kick user1 from the room
|
|
|
|
self.helper.change_membership(
|
|
|
|
room=kick_room_id,
|
|
|
|
src=user2_id,
|
|
|
|
targ=user1_id,
|
|
|
|
tok=user2_tok,
|
|
|
|
membership=Membership.LEAVE,
|
|
|
|
extra_data={
|
|
|
|
"reason": "Bad manners",
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
before_room_forgets = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Forget the room after we already have our tokens. This doesn't change
|
|
|
|
# the membership event itself but will mark it internally in Synapse
|
|
|
|
channel = self.make_request(
|
|
|
|
"POST",
|
|
|
|
f"/_matrix/client/r0/rooms/{leave_room_id}/forget",
|
|
|
|
content={},
|
|
|
|
access_token=user1_tok,
|
|
|
|
)
|
|
|
|
self.assertEqual(channel.code, 200, channel.result)
|
|
|
|
channel = self.make_request(
|
|
|
|
"POST",
|
|
|
|
f"/_matrix/client/r0/rooms/{ban_room_id}/forget",
|
|
|
|
content={},
|
|
|
|
access_token=user1_tok,
|
|
|
|
)
|
|
|
|
self.assertEqual(channel.code, 200, channel.result)
|
|
|
|
channel = self.make_request(
|
|
|
|
"POST",
|
|
|
|
f"/_matrix/client/r0/rooms/{kick_room_id}/forget",
|
|
|
|
content={},
|
|
|
|
access_token=user1_tok,
|
|
|
|
)
|
|
|
|
self.assertEqual(channel.code, 200, channel.result)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room_forgets,
|
|
|
|
to_token=before_room_forgets,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# We shouldn't see the room because it was forgotten
|
|
|
|
self.assertEqual(room_id_results, set())
|
|
|
|
|
2024-05-21 19:24:03 +00:00
|
|
|
def test_only_newly_left_rooms_show_up(self) -> None:
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
Test that newly_left rooms still show up in the sync response but rooms that
|
2024-06-04 23:29:14 +00:00
|
|
|
were left before the `from_token` don't show up. See condition "2)" comments in
|
2024-05-21 20:05:19 +00:00
|
|
|
the `get_sync_room_ids_for_user` method.
|
|
|
|
"""
|
2024-05-21 19:24:03 +00:00
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
# Leave before we calculate the `from_token`
|
|
|
|
room_id1 = self.helper.create_room_as(user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
2024-05-21 20:05:19 +00:00
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
2024-05-21 19:24:03 +00:00
|
|
|
|
|
|
|
# Leave during the from_token/to_token range (newly_left)
|
|
|
|
room_id2 = self.helper.create_room_as(user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
2024-05-21 20:05:19 +00:00
|
|
|
after_room2_token = self.event_sources.get_current_token()
|
2024-05-21 19:24:03 +00:00
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
2024-05-21 20:05:19 +00:00
|
|
|
from_token=after_room1_token,
|
|
|
|
to_token=after_room2_token,
|
2024-05-21 19:24:03 +00:00
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2024-05-21 20:05:19 +00:00
|
|
|
# Only the newly_left room should show up
|
2024-05-21 19:24:03 +00:00
|
|
|
self.assertEqual(room_id_results, {room_id2})
|
2024-05-21 20:05:19 +00:00
|
|
|
|
|
|
|
def test_no_joins_after_to_token(self) -> None:
|
|
|
|
"""
|
2024-06-04 23:29:14 +00:00
|
|
|
Rooms we join after the `to_token` should *not* show up. See condition "1b)"
|
2024-05-21 20:05:19 +00:00
|
|
|
comments in the `get_sync_room_ids_for_user()` method.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
before_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id1 = self.helper.create_room_as(user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Room join after after our `to_token` shouldn't show up
|
|
|
|
room_id2 = self.helper.create_room_as(user1_id, tok=user1_tok)
|
|
|
|
_ = room_id2
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
|
|
|
def test_join_during_range_and_left_room_after_to_token(self) -> None:
|
|
|
|
"""
|
2024-05-21 22:37:46 +00:00
|
|
|
Room still shows up if we left the room but were joined during the
|
2024-06-04 23:29:14 +00:00
|
|
|
from_token/to_token. See condition "1a)" comments in the
|
2024-05-21 22:37:46 +00:00
|
|
|
`get_sync_room_ids_for_user()` method.
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
|
|
|
|
before_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
room_id1 = self.helper.create_room_as(user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Leave the room after we already have our tokens
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# We should still see the room because we were joined during the
|
|
|
|
# from_token/to_token time period.
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
|
|
|
def test_join_before_range_and_left_room_after_to_token(self) -> None:
|
|
|
|
"""
|
2024-05-21 22:37:46 +00:00
|
|
|
Room still shows up if we left the room but were joined before the `from_token`
|
2024-06-04 23:29:14 +00:00
|
|
|
so it should show up. See condition "1a)" comments in the
|
2024-05-21 22:37:46 +00:00
|
|
|
`get_sync_room_ids_for_user()` method.
|
2024-05-21 20:05:19 +00:00
|
|
|
"""
|
|
|
|
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)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Leave the room after we already have our tokens
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2024-05-21 22:37:46 +00:00
|
|
|
# We should still see the room because we were joined before the `from_token`
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
2024-06-04 03:47:01 +00:00
|
|
|
def test_kicked_before_range_and_left_after_to_token(self) -> None:
|
|
|
|
"""
|
|
|
|
Room still shows up if we left the room but were kicked before the `from_token`
|
2024-06-04 23:29:14 +00:00
|
|
|
so it should show up. See condition "1a)" comments in the
|
2024-06-04 03:47:01 +00:00
|
|
|
`get_sync_room_ids_for_user()` method.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# Setup the kick room (user2 kicks user1 from the room)
|
|
|
|
kick_room_id = self.helper.create_room_as(
|
|
|
|
user2_id, tok=user2_tok, is_public=True
|
|
|
|
)
|
|
|
|
self.helper.join(kick_room_id, user1_id, tok=user1_tok)
|
|
|
|
# Kick user1 from the room
|
|
|
|
self.helper.change_membership(
|
|
|
|
room=kick_room_id,
|
|
|
|
src=user2_id,
|
|
|
|
targ=user1_id,
|
|
|
|
tok=user2_tok,
|
|
|
|
membership=Membership.LEAVE,
|
|
|
|
extra_data={
|
|
|
|
"reason": "Bad manners",
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
after_kick_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Leave the room after we already have our tokens
|
|
|
|
#
|
|
|
|
# We have to join before we can leave (leave -> leave isn't a valid transition
|
|
|
|
# or at least it doesn't work in Synapse, 403 forbidden)
|
|
|
|
self.helper.join(kick_room_id, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(kick_room_id, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_kick_token,
|
|
|
|
to_token=after_kick_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# We shouldn't see the room because it was forgotten
|
|
|
|
self.assertEqual(room_id_results, {kick_room_id})
|
|
|
|
|
2024-05-21 22:37:46 +00:00
|
|
|
def test_newly_left_during_range_and_join_leave_after_to_token(self) -> None:
|
|
|
|
"""
|
|
|
|
Newly left room should show up. But we're also testing that joining and leaving
|
2024-06-04 23:29:14 +00:00
|
|
|
after the `to_token` doesn't mess with the results. See condition "2)" and "1a)"
|
|
|
|
comments in the `get_sync_room_ids_for_user()` method.
|
2024-05-21 22:37:46 +00:00
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
before_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join and leave the room during the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Join and leave the room after we already have our tokens
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room should still show up because it's newly_left during the from/to range
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
2024-06-04 23:29:14 +00:00
|
|
|
def test_newly_left_during_range_and_join_after_to_token(self) -> None:
|
|
|
|
"""
|
|
|
|
Newly left room should show up. But we're also testing that joining after the
|
|
|
|
`to_token` doesn't mess with the results. See condition "2)" and "1b)" comments
|
|
|
|
in the `get_sync_room_ids_for_user()` method.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
before_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join and leave the room during the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Join the room after we already have our tokens
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room should still show up because it's newly_left during the from/to range
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
2024-05-21 22:37:46 +00:00
|
|
|
def test_leave_before_range_and_join_leave_after_to_token(self) -> None:
|
|
|
|
"""
|
|
|
|
Old left room shouldn't show up. But we're also testing that joining and leaving
|
2024-06-04 23:29:14 +00:00
|
|
|
after the `to_token` doesn't mess with the results. See condition "1a)" comments
|
2024-05-21 22:37:46 +00:00
|
|
|
in the `get_sync_room_ids_for_user()` method.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join and leave the room before the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Join and leave the room after we already have our tokens
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room1_token,
|
2024-06-04 03:47:01 +00:00
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room shouldn't show up because it was left before the `from_token`
|
|
|
|
self.assertEqual(room_id_results, set())
|
|
|
|
|
|
|
|
def test_leave_before_range_and_join_after_to_token(self) -> None:
|
|
|
|
"""
|
|
|
|
Old left room shouldn't show up. But we're also testing that joining after the
|
2024-06-04 23:29:14 +00:00
|
|
|
`to_token` doesn't mess with the results. See condition "1b)" comments in the
|
2024-06-04 03:47:01 +00:00
|
|
|
`get_sync_room_ids_for_user()` method.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join and leave the room before the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Join the room after we already have our tokens
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room1_token,
|
2024-05-21 22:37:46 +00:00
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room shouldn't show up because it was left before the `from_token`
|
|
|
|
self.assertEqual(room_id_results, set())
|
|
|
|
|
|
|
|
def test_join_leave_multiple_times_during_range_and_after_to_token(
|
|
|
|
self,
|
|
|
|
) -> None:
|
|
|
|
"""
|
2024-05-22 18:18:13 +00:00
|
|
|
Join and leave multiple times shouldn't affect rooms from showing up. It just
|
|
|
|
matters that we were joined or newly_left in the from/to range. But we're also
|
|
|
|
testing that joining and leaving after the `to_token` doesn't mess with the
|
|
|
|
results.
|
2024-05-21 22:37:46 +00:00
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
before_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join, leave, join back to the room before the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Leave and Join the room multiple times after we already have our tokens
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room should show up because it was newly_left and joined during the from/to range
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
|
|
|
def test_join_leave_multiple_times_before_range_and_after_to_token(
|
|
|
|
self,
|
|
|
|
) -> None:
|
|
|
|
"""
|
2024-05-22 18:18:13 +00:00
|
|
|
Join and leave multiple times before the from/to range shouldn't affect rooms
|
|
|
|
from showing up. It just matters that we were joined or newly_left in the
|
|
|
|
from/to range. But we're also testing that joining and leaving after the
|
|
|
|
`to_token` doesn't mess with the results.
|
2024-05-21 22:37:46 +00:00
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
# Join, leave, join back to the room before the from/to range
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Leave and Join the room multiple times after we already have our tokens
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room should show up because we were joined before the from/to range
|
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
|
|
|
|
2024-05-22 18:18:13 +00:00
|
|
|
def test_invite_before_range_and_join_leave_after_to_token(
|
2024-05-21 22:37:46 +00:00
|
|
|
self,
|
|
|
|
) -> None:
|
|
|
|
"""
|
2024-05-22 18:18:13 +00:00
|
|
|
Make it look like we joined after the token range but we were invited before the
|
2024-06-04 23:29:14 +00:00
|
|
|
from/to range so the room should still show up. See condition "1a)" comments in
|
2024-05-22 18:18:13 +00:00
|
|
|
the `get_sync_room_ids_for_user()` method.
|
2024-05-21 22:37:46 +00:00
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
|
2024-05-23 19:23:49 +00:00
|
|
|
# Invited to the room before the token
|
2024-05-21 22:37:46 +00:00
|
|
|
self.helper.invite(room_id1, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
|
|
|
|
after_room1_token = self.event_sources.get_current_token()
|
|
|
|
|
2024-05-23 19:23:49 +00:00
|
|
|
# Join and leave the room after we already have our tokens
|
2024-05-21 22:37:46 +00:00
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=after_room1_token,
|
|
|
|
to_token=after_room1_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Room should show up because we were invited before the from/to range
|
2024-05-21 20:05:19 +00:00
|
|
|
self.assertEqual(room_id_results, {room_id1})
|
2024-05-23 19:23:49 +00:00
|
|
|
|
|
|
|
def test_multiple_rooms_are_not_confused(
|
|
|
|
self,
|
|
|
|
) -> None:
|
|
|
|
"""
|
|
|
|
Test that multiple rooms are not confused as we fixup the list. This test is
|
|
|
|
spawning from a real world bug in the code where I was accidentally using
|
|
|
|
`event.room_id` in one of the fix-up loops but the `event` being referenced was
|
|
|
|
actually from a different loop.
|
|
|
|
"""
|
|
|
|
user1_id = self.register_user("user1", "pass")
|
|
|
|
user1_tok = self.login(user1_id, "pass")
|
|
|
|
user2_id = self.register_user("user2", "pass")
|
|
|
|
user2_tok = self.login(user2_id, "pass")
|
|
|
|
|
|
|
|
# We create the room with user2 so the room isn't left with no members when we
|
|
|
|
# leave and can still re-join.
|
|
|
|
room_id1 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
room_id2 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
|
|
|
|
# Invited and left the room before the token
|
|
|
|
self.helper.invite(room_id1, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
# Invited to room2
|
|
|
|
self.helper.invite(room_id2, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
|
|
|
|
before_room3_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Invited and left room3 during the from/to range
|
|
|
|
room_id3 = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True)
|
|
|
|
self.helper.invite(room_id3, src=user2_id, targ=user1_id, tok=user2_tok)
|
|
|
|
self.helper.leave(room_id3, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
after_room3_token = self.event_sources.get_current_token()
|
|
|
|
|
|
|
|
# Join and leave the room after we already have our tokens
|
|
|
|
self.helper.join(room_id1, user1_id, tok=user1_tok)
|
|
|
|
self.helper.leave(room_id1, user1_id, tok=user1_tok)
|
|
|
|
# Leave room2
|
|
|
|
self.helper.leave(room_id2, user1_id, tok=user1_tok)
|
|
|
|
# Leave room3
|
|
|
|
self.helper.leave(room_id3, user1_id, tok=user1_tok)
|
|
|
|
|
|
|
|
room_id_results = self.get_success(
|
|
|
|
self.sliding_sync_handler.get_sync_room_ids_for_user(
|
|
|
|
UserID.from_string(user1_id),
|
|
|
|
from_token=before_room3_token,
|
|
|
|
to_token=after_room3_token,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
room_id_results,
|
|
|
|
{
|
|
|
|
# `room_id1` shouldn't show up because we left before the from/to range
|
|
|
|
#
|
|
|
|
# Room should show up because we were invited before the from/to range
|
|
|
|
room_id2,
|
|
|
|
# Room should show up because it was newly_left during the from/to range
|
|
|
|
room_id3,
|
|
|
|
},
|
|
|
|
)
|