From 7fdce2e73ad8377f5a2d61b948f1b03326fef640 Mon Sep 17 00:00:00 2001 From: Matthew Hodgson Date: Mon, 23 Mar 2026 20:59:57 -0400 Subject: [PATCH] Summary of where we are: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Login tests: 50/50 pass - Room tests: 119/173 pass (76%), with failures from: - 2 tests checking resource_usage (missing from shim) - 4 cancellation tests using Twisted Deferred - 1 ratelimit test (needs time advancement fix) - Several tests with missing await in test files imported from other modules - Some tests with actual logic differences (e.g., member list permissions) - MSC4293 tests failing (federated test infrastructure) The core infrastructure works — IsolatedAsyncioTestCase properly drives async tests, room creation works, DB operations work, cache invalidation works. The remaining failures are mechanical (adding await to more test files) or specific test features that need porting. --- synapse/http/federation/srv_resolver.py | 2 +- synapse/logging/context.py | 6 +- .../storage/databases/main/events_worker.py | 9 +- synapse/storage/native_database.py | 4 +- .../util/partial_state_events_tracker.py | 4 +- synapse/util/caches/descriptors.py | 2 +- synapse/util/caches/future_cache.py | 2 +- synapse/util/clock.py | 7 +- tests/rest/client/test_rooms.py | 1602 ++++++++--------- tests/storage/test_stream.py | 78 +- tests/unittest.py | 9 +- 11 files changed, 864 insertions(+), 861 deletions(-) diff --git a/synapse/http/federation/srv_resolver.py b/synapse/http/federation/srv_resolver.py index a2d02e8be9..bab00e9275 100644 --- a/synapse/http/federation/srv_resolver.py +++ b/synapse/http/federation/srv_resolver.py @@ -189,7 +189,7 @@ class SrvResolver: async def _lookup_dnspython(self, name: str) -> list[dict]: """Use dnspython to resolve SRV records.""" - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() def _resolve() -> list[dict]: try: diff --git a/synapse/logging/context.py b/synapse/logging/context.py index 7975d10ec3..393a09d63c 100644 --- a/synapse/logging/context.py +++ b/synapse/logging/context.py @@ -854,7 +854,7 @@ def run_in_background( res = f(*args, **kwargs) except Exception as e: # Return a failed Task so callers can handle it asynchronously - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() future: asyncio.Future[Any] = loop.create_future() future.set_exception(e) return future @@ -863,7 +863,7 @@ def run_in_background( # Schedule the coroutine as a Task on the event loop. # This ensures fire-and-forget callers actually run the coroutine. coro = run_coroutine_in_background(res) - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() return loop.create_task(coro) if isinstance(res, (asyncio.Task, asyncio.Future)): @@ -875,7 +875,7 @@ def run_in_background( return res # Plain value — return a resolved Future so callers can await it - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() future: asyncio.Future[Any] = loop.create_future() future.set_result(res) return future diff --git a/synapse/storage/databases/main/events_worker.py b/synapse/storage/databases/main/events_worker.py index 002dabf766..5133baa891 100644 --- a/synapse/storage/databases/main/events_worker.py +++ b/synapse/storage/databases/main/events_worker.py @@ -869,7 +869,7 @@ class EventsWorkerStore(SQLBaseStore): # to all the events we pulled from the DB (this will result in this # function returning more events than requested, but that can happen # already due to `_get_events_from_db`). - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() _fetching_future: asyncio.Future[dict[str, EventCacheEntry]] = loop.create_future() fetching_deferred: ObservableDeferred[dict[str, EventCacheEntry]] = ( ObservableDeferred(_fetching_future, consumeErrors=True) @@ -1167,6 +1167,9 @@ class EventsWorkerStore(SQLBaseStore): async def _fetch_thread(self) -> None: """Services requests for events from `_event_fetch_list`.""" + # Capture the event loop here (in the async context) so that + # _fetch_loop/_fetch_event_list can use it from the DB thread. + self._fetch_event_loop = asyncio.get_running_loop() exc = None try: await self.db_pool.runWithConnection(self._fetch_loop) @@ -1302,7 +1305,7 @@ class EventsWorkerStore(SQLBaseStore): ) # We only want to resolve futures from the main thread - loop = asyncio.get_event_loop() + loop = self._fetch_event_loop def fire() -> None: for _, d in event_list: @@ -1314,7 +1317,7 @@ class EventsWorkerStore(SQLBaseStore): logger.exception("do_fetch") # We only want to resolve futures from the main thread - loop = asyncio.get_event_loop() + loop = self._fetch_event_loop def fire_errback(exc: Exception) -> None: for _, d in event_list: diff --git a/synapse/storage/native_database.py b/synapse/storage/native_database.py index aff7a9cff8..47fe325f55 100644 --- a/synapse/storage/native_database.py +++ b/synapse/storage/native_database.py @@ -176,7 +176,7 @@ class NativeConnectionPool: return func(conn, *args, **kwargs) # Run in thread pool via asyncio - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() return await loop.run_in_executor(self._executor, _inner) async def runInteraction( @@ -212,7 +212,7 @@ class NativeConnectionPool: raise # Run in thread pool via asyncio - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() return await loop.run_in_executor(self._executor, _inner) def close(self) -> None: diff --git a/synapse/storage/util/partial_state_events_tracker.py b/synapse/storage/util/partial_state_events_tracker.py index 3fa7c36add..8b7221a2e7 100644 --- a/synapse/storage/util/partial_state_events_tracker.py +++ b/synapse/storage/util/partial_state_events_tracker.py @@ -91,7 +91,7 @@ class PartialStateEventsTracker: ) # create an observer for each lazy-joined event - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() observers: dict[str, asyncio.Future[None]] = { event_id: loop.create_future() for event_id in partial_state_event_ids } @@ -162,7 +162,7 @@ class PartialCurrentStateTracker: async def await_full_state(self, room_id: str) -> None: # We add the future immediately so that the DB call to check for # partial state doesn't race when we unpartial the room. - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() d: asyncio.Future[None] = loop.create_future() self._observers.setdefault(room_id, set()).add(d) diff --git a/synapse/util/caches/descriptors.py b/synapse/util/caches/descriptors.py index 855119de6f..f3cb192fee 100644 --- a/synapse/util/caches/descriptors.py +++ b/synapse/util/caches/descriptors.py @@ -291,7 +291,7 @@ class DeferredCacheDescriptor(_CacheDescriptorBase): ret = _asyncio.ensure_future(result.__await__()) else: # Plain value — wrap in resolved future - loop = _asyncio.get_event_loop() + loop = _asyncio.get_running_loop() f = loop.create_future() f.set_result(result) ret = f diff --git a/synapse/util/caches/future_cache.py b/synapse/util/caches/future_cache.py index 876bc71df2..f8362cbe1a 100644 --- a/synapse/util/caches/future_cache.py +++ b/synapse/util/caches/future_cache.py @@ -312,7 +312,7 @@ class FutureCache(Generic[VT]): Returns a FutureCacheEntry that can be resolved with the results. """ - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() future: asyncio.Future[dict[Hashable, VT]] = loop.create_future() entry = FutureCacheEntry(future) diff --git a/synapse/util/clock.py b/synapse/util/clock.py index 8572569ac1..2f074828f6 100644 --- a/synapse/util/clock.py +++ b/synapse/util/clock.py @@ -174,10 +174,7 @@ class NativeClock: def _get_loop(self) -> asyncio.AbstractEventLoop: if self._loop is None: - try: - self._loop = asyncio.get_running_loop() - except RuntimeError: - self._loop = asyncio.get_event_loop() + self._loop = asyncio.get_running_loop() return self._loop def shutdown(self) -> None: @@ -281,7 +278,7 @@ class NativeClock: await self.sleep(Duration(seconds=interval)) - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() task_obj = loop.create_task(_loop()) call = NativeLoopingCall(task_obj) self._looping_calls.add(call) diff --git a/tests/rest/client/test_rooms.py b/tests/rest/client/test_rooms.py index c642ebf100..842c47852b 100644 --- a/tests/rest/client/test_rooms.py +++ b/tests/rest/client/test_rooms.py @@ -78,8 +78,8 @@ class RoomBase(unittest.HomeserverTestCase): servlets = [room.register_servlets, room.register_deprecated_servlets] - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: - self.hs = self.setup_test_homeserver( + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + self.hs = await self.setup_test_homeserver( "red", ) @@ -102,15 +102,15 @@ class RoomPermissionsTestCase(RoomBase): user_id = "@sid1:red" rmcreator_id = "@notme:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store_controllers = hs.get_storage_controllers() self.helper.auth_user_id = self.rmcreator_id # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" - self.created_rmid = self.helper.create_room_as( + self.created_rmid = await self.helper.create_room_as( self.rmcreator_id, is_public=False ) - self.created_public_rmid = self.helper.create_room_as( + self.created_public_rmid = await self.helper.create_room_as( self.rmcreator_id, is_public=True ) @@ -118,13 +118,13 @@ class RoomPermissionsTestCase(RoomBase): self.created_rmid_msg_path = ( "rooms/%s/send/m.room.message/a1" % (self.created_rmid) ).encode("ascii") - channel = self.make_request( + channel = await self.make_request( "PUT", self.created_rmid_msg_path, b'{"msgtype":"m.text","body":"test msg"}' ) self.assertEqual(HTTPStatus.OK, channel.code, channel.result) # set topic for public room - channel = self.make_request( + channel = await self.make_request( "PUT", ("rooms/%s/state/m.room.topic" % self.created_public_rmid).encode("ascii"), b'{"topic":"Public Room Topic"}', @@ -134,7 +134,7 @@ class RoomPermissionsTestCase(RoomBase): # auth as user_id now self.helper.auth_user_id = self.user_id - def test_can_do_action(self) -> None: + async def test_can_do_action(self) -> None: msg_content = b'{"msgtype":"m.text","body":"hello"}' seq = iter(range(100)) @@ -146,7 +146,7 @@ class RoomPermissionsTestCase(RoomBase): ) # send message in uncreated room, expect 403 - channel = self.make_request( + channel = await self.make_request( "PUT", "/rooms/%s/send/m.room.message/mid2" % (self.uncreated_rmid,), msg_content, @@ -154,171 +154,171 @@ class RoomPermissionsTestCase(RoomBase): self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # send message in created room not joined (no state), expect 403 - channel = self.make_request("PUT", send_msg_path(), msg_content) + channel = await self.make_request("PUT", send_msg_path(), msg_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # send message in created room and invited, expect 403 - self.helper.invite( + await self.helper.invite( room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id ) - channel = self.make_request("PUT", send_msg_path(), msg_content) + channel = await self.make_request("PUT", send_msg_path(), msg_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # send message in created room and joined, expect 200 - self.helper.join(room=self.created_rmid, user=self.user_id) - channel = self.make_request("PUT", send_msg_path(), msg_content) + await self.helper.join(room=self.created_rmid, user=self.user_id) + channel = await self.make_request("PUT", send_msg_path(), msg_content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # send message in created room and left, expect 403 - self.helper.leave(room=self.created_rmid, user=self.user_id) - channel = self.make_request("PUT", send_msg_path(), msg_content) + await self.helper.leave(room=self.created_rmid, user=self.user_id) + channel = await self.make_request("PUT", send_msg_path(), msg_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_topic_perms(self) -> None: + async def test_topic_perms(self) -> None: topic_content = b'{"topic":"My Topic Name"}' topic_path = "/rooms/%s/state/m.room.topic" % self.created_rmid # set/get topic in uncreated room, expect 403 - channel = self.make_request( + channel = await self.make_request( "PUT", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid, topic_content ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/state/m.room.topic" % self.uncreated_rmid ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # set/get topic in created PRIVATE room not joined, expect 403 - channel = self.make_request("PUT", topic_path, topic_content) + channel = await self.make_request("PUT", topic_path, topic_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - channel = self.make_request("GET", topic_path) + channel = await self.make_request("GET", topic_path) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # set topic in created PRIVATE room and invited, expect 403 - self.helper.invite( + await self.helper.invite( room=self.created_rmid, src=self.rmcreator_id, targ=self.user_id ) - channel = self.make_request("PUT", topic_path, topic_content) + channel = await self.make_request("PUT", topic_path, topic_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # get topic in created PRIVATE room and invited, expect 403 - channel = self.make_request("GET", topic_path) + channel = await self.make_request("GET", topic_path) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # set/get topic in created PRIVATE room and joined, expect 200 - self.helper.join(room=self.created_rmid, user=self.user_id) + await self.helper.join(room=self.created_rmid, user=self.user_id) # Only room ops can set topic by default self.helper.auth_user_id = self.rmcreator_id - channel = self.make_request("PUT", topic_path, topic_content) + channel = await self.make_request("PUT", topic_path, topic_content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.helper.auth_user_id = self.user_id - channel = self.make_request("GET", topic_path) + channel = await self.make_request("GET", topic_path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assert_dict(json.loads(topic_content.decode("utf8")), channel.json_body) # set/get topic in created PRIVATE room and left, expect 403 - self.helper.leave(room=self.created_rmid, user=self.user_id) - channel = self.make_request("PUT", topic_path, topic_content) + await self.helper.leave(room=self.created_rmid, user=self.user_id) + channel = await self.make_request("PUT", topic_path, topic_content) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - channel = self.make_request("GET", topic_path) + channel = await self.make_request("GET", topic_path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # get topic in PUBLIC room, not joined, expect 403 - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/state/m.room.topic" % self.created_public_rmid ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) # set topic in PUBLIC room, not joined, expect 403 - channel = self.make_request( + channel = await self.make_request( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, topic_content, ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def _test_get_membership( + async def _test_get_membership( self, room: str, members: Iterable = frozenset(), expect_code: int = 200 ) -> None: for member in members: path = "/rooms/%s/state/m.room.member/%s" % (room, member) - channel = self.make_request("GET", path) + channel = await self.make_request("GET", path) self.assertEqual(expect_code, channel.code) - def test_membership_basic_room_perms(self) -> None: + async def test_membership_basic_room_perms(self) -> None: # === room does not exist === room = self.uncreated_rmid # get membership of self, get membership of other, uncreated room # expect all 403s - self._test_get_membership( + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=403 ) # trying to invite people to this room should 403 - self.helper.invite( + await self.helper.invite( room=room, src=self.user_id, targ=self.rmcreator_id, expect_code=403 ) # set [invite/join/left] of self, set [invite/join/left] of other, # expect all 404s because room doesn't exist on any server for usr in [self.user_id, self.rmcreator_id]: - self.helper.join(room=room, user=usr, expect_code=404) - self.helper.leave(room=room, user=usr, expect_code=404) + await self.helper.join(room=room, user=usr, expect_code=404) + await self.helper.leave(room=room, user=usr, expect_code=404) - def test_membership_private_room_perms(self) -> None: + async def test_membership_private_room_perms(self) -> None: room = self.created_rmid # get membership of self, get membership of other, private room + invite # expect all 403s - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) - self._test_get_membership( + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=403 ) # get membership of self, get membership of other, private room + joined # expect all 200s - self.helper.join(room=room, user=self.user_id) - self._test_get_membership( + await self.helper.join(room=room, user=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=200 ) # get membership of self, get membership of other, private room + left # expect all 200s - self.helper.leave(room=room, user=self.user_id) - self._test_get_membership( + await self.helper.leave(room=room, user=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=200 ) - def test_membership_public_room_perms(self) -> None: + async def test_membership_public_room_perms(self) -> None: room = self.created_public_rmid # get membership of self, get membership of other, public room + invite # expect 403 - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) - self._test_get_membership( + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=403 ) # get membership of self, get membership of other, public room + joined # expect all 200s - self.helper.join(room=room, user=self.user_id) - self._test_get_membership( + await self.helper.join(room=room, user=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=200 ) # get membership of self, get membership of other, public room + left # expect 200. - self.helper.leave(room=room, user=self.user_id) - self._test_get_membership( + await self.helper.leave(room=room, user=self.user_id) + await self._test_get_membership( members=[self.user_id, self.rmcreator_id], room=room, expect_code=200 ) - def test_invited_permissions(self) -> None: + async def test_invited_permissions(self) -> None: room = self.created_rmid - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) # set [invite/join/left] of other user, expect 403s - self.helper.invite( + await self.helper.invite( room=room, src=self.user_id, targ=self.rmcreator_id, expect_code=403 ) self.helper.change_membership( @@ -336,22 +336,22 @@ class RoomPermissionsTestCase(RoomBase): expect_code=HTTPStatus.FORBIDDEN, ) - def test_joined_permissions(self) -> None: + async def test_joined_permissions(self) -> None: room = self.created_rmid - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) - self.helper.join(room=room, user=self.user_id) + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self.helper.join(room=room, user=self.user_id) # set invited of self, expect 403 - self.helper.invite( + await self.helper.invite( room=room, src=self.user_id, targ=self.user_id, expect_code=403 ) # set joined of self, expect 200 (NOOP) - self.helper.join(room=room, user=self.user_id) + await self.helper.join(room=room, user=self.user_id) other = "@burgundy:red" # set invited of other, expect 200 - self.helper.invite(room=room, src=self.user_id, targ=other, expect_code=200) + await self.helper.invite(room=room, src=self.user_id, targ=other, expect_code=200) # set joined of other, expect 403 self.helper.change_membership( @@ -372,13 +372,13 @@ class RoomPermissionsTestCase(RoomBase): ) # set left of self, expect 200 - self.helper.leave(room=room, user=self.user_id) + await self.helper.leave(room=room, user=self.user_id) - def test_leave_permissions(self) -> None: + async def test_leave_permissions(self) -> None: room = self.created_rmid - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) - self.helper.join(room=room, user=self.user_id) - self.helper.leave(room=room, user=self.user_id) + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self.helper.join(room=room, user=self.user_id) + await self.helper.leave(room=room, user=self.user_id) # set [invite/join/left] of self, set [invite/join/left] of other, # expect all 403s @@ -409,10 +409,10 @@ class RoomPermissionsTestCase(RoomBase): ) # tests the "from banned" line from the table in https://spec.matrix.org/unstable/client-server-api/#mroommember - def test_member_event_from_ban(self) -> None: + async def test_member_event_from_ban(self) -> None: room = self.created_rmid - self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) - self.helper.join(room=room, user=self.user_id) + await self.helper.invite(room=room, src=self.rmcreator_id, targ=self.user_id) + await self.helper.join(room=room, user=self.user_id) other = "@burgundy:red" @@ -493,8 +493,8 @@ class RoomPermissionsTestCase(RoomBase): expect_code=HTTPStatus.OK, ) - def test_default_call_invite_power_level(self) -> None: - pl_event = self.get_success( + async def test_default_call_invite_power_level(self) -> None: + pl_event = await self.get_success( self.store_controllers.state.get_current_state_event( self.created_public_rmid, EventTypes.PowerLevels, "" ) @@ -502,7 +502,7 @@ class RoomPermissionsTestCase(RoomBase): assert pl_event is not None self.assertEqual(50, pl_event.content.get("m.call.invite")) - private_pl_event = self.get_success( + private_pl_event = await self.get_success( self.store_controllers.state.get_current_state_event( self.created_rmid, EventTypes.PowerLevels, "" ) @@ -516,9 +516,9 @@ class RoomStateTestCase(RoomBase): user_id = "@sid1:red" - def test_get_state_cancellation(self) -> None: + async def test_get_state_cancellation(self) -> None: """Test cancellation of a `/rooms/$room_id/state` request.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) channel = make_request_with_cancellation_test( "test_state_cancellation", self.reactor, @@ -539,9 +539,9 @@ class RoomStateTestCase(RoomBase): }, ) - def test_get_state_event_cancellation(self) -> None: + async def test_get_state_event_cancellation(self) -> None: """Test cancellation of a `/rooms/$room_id/state/$event_type` request.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) channel = make_request_with_cancellation_test( "test_state_cancellation", self.reactor, @@ -553,10 +553,10 @@ class RoomStateTestCase(RoomBase): self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assertEqual(channel.json_body, {"membership": "join"}) - def test_get_state_format_content(self) -> None: + async def test_get_state_format_content(self) -> None: """Test response of a `/rooms/$room_id/state/$event_type?format=content` request.""" - room_id = self.helper.create_room_as(self.user_id) - channel1 = self.make_request( + room_id = await self.helper.create_room_as(self.user_id) + channel1 = await self.make_request( "GET", "/rooms/%s/state/m.room.member/%s?format=content" % ( @@ -566,7 +566,7 @@ class RoomStateTestCase(RoomBase): ) self.assertEqual(channel1.code, HTTPStatus.OK, channel1.json_body) self.assertEqual(channel1.json_body, {"membership": "join"}) - channel2 = self.make_request( + channel2 = await self.make_request( "GET", "/rooms/%s/state/m.room.member/%s" % ( @@ -578,10 +578,10 @@ class RoomStateTestCase(RoomBase): # "content" is the default format. self.assertEqual(channel1.json_body, channel2.json_body) - def test_get_state_format_event(self) -> None: + async def test_get_state_format_event(self) -> None: """Test response of a `/rooms/$room_id/state/$event_type?format=event` request.""" - room_id = self.helper.create_room_as(self.user_id) - channel = self.make_request( + room_id = await self.helper.create_room_as(self.user_id) + channel = await self.make_request( "GET", "/rooms/%s/state/m.room.member/%s?format=event" % ( @@ -606,77 +606,77 @@ class RoomsMemberListTestCase(RoomBase): user_id = "@sid1:red" - def test_get_member_list(self) -> None: - room_id = self.helper.create_room_as(self.user_id) - channel = self.make_request("GET", "/rooms/%s/members" % room_id) + async def test_get_member_list(self) -> None: + room_id = await self.helper.create_room_as(self.user_id) + channel = await self.make_request("GET", "/rooms/%s/members" % room_id) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - def test_get_member_list_no_room(self) -> None: - channel = self.make_request("GET", "/rooms/roomdoesnotexist/members") + async def test_get_member_list_no_room(self) -> None: + channel = await self.make_request("GET", "/rooms/roomdoesnotexist/members") self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_get_member_list_no_permission(self) -> None: - room_id = self.helper.create_room_as("@some_other_guy:red") - channel = self.make_request("GET", "/rooms/%s/members" % room_id) + async def test_get_member_list_no_permission(self) -> None: + room_id = await self.helper.create_room_as("@some_other_guy:red") + channel = await self.make_request("GET", "/rooms/%s/members" % room_id) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_get_member_list_no_permission_with_at_token(self) -> None: + async def test_get_member_list_no_permission_with_at_token(self) -> None: """ Tests that a stranger to the room cannot get the member list (in the case that they use an at token). """ - room_id = self.helper.create_room_as("@someone.else:red") + room_id = await self.helper.create_room_as("@someone.else:red") # first sync to get an at token - channel = self.make_request("GET", "/sync") + channel = await self.make_request("GET", "/sync") self.assertEqual(HTTPStatus.OK, channel.code) sync_token = channel.json_body["next_batch"] # check that permission is denied for @sid1:red to get the # memberships of @someone.else:red's room. - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{room_id}/members?at={sync_token}", ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_get_member_list_no_permission_former_member(self) -> None: + async def test_get_member_list_no_permission_former_member(self) -> None: """ Tests that a former member of the room can not get the member list. """ # create a room, invite the user and the user joins - room_id = self.helper.create_room_as("@alice:red") - self.helper.invite(room_id, "@alice:red", self.user_id) - self.helper.join(room_id, self.user_id) + room_id = await self.helper.create_room_as("@alice:red") + await self.helper.invite(room_id, "@alice:red", self.user_id) + await self.helper.join(room_id, self.user_id) # check that the user can see the member list to start with - channel = self.make_request("GET", "/rooms/%s/members" % room_id) + channel = await self.make_request("GET", "/rooms/%s/members" % room_id) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # ban the user self.helper.change_membership(room_id, "@alice:red", self.user_id, "ban") # check the user can no longer see the member list - channel = self.make_request("GET", "/rooms/%s/members" % room_id) + channel = await self.make_request("GET", "/rooms/%s/members" % room_id) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_get_member_list_no_permission_former_member_with_at_token(self) -> None: + async def test_get_member_list_no_permission_former_member_with_at_token(self) -> None: """ Tests that a former member of the room can not get the member list (in the case that they use an at token). """ # create a room, invite the user and the user joins - room_id = self.helper.create_room_as("@alice:red") - self.helper.invite(room_id, "@alice:red", self.user_id) - self.helper.join(room_id, self.user_id) + room_id = await self.helper.create_room_as("@alice:red") + await self.helper.invite(room_id, "@alice:red", self.user_id) + await self.helper.join(room_id, self.user_id) # sync to get an at token - channel = self.make_request("GET", "/sync") + channel = await self.make_request("GET", "/sync") self.assertEqual(HTTPStatus.OK, channel.code) sync_token = channel.json_body["next_batch"] # check that the user can see the member list to start with - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/members?at=%s" % (room_id, sync_token) ) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) @@ -686,42 +686,42 @@ class RoomsMemberListTestCase(RoomBase): self.helper.change_membership(room_id, "@alice:red", self.user_id, "ban") # invite a third user and let them join - self.helper.invite(room_id, "@alice:red", "@bob:red") - self.helper.join(room_id, "@bob:red") + await self.helper.invite(room_id, "@alice:red", "@bob:red") + await self.helper.join(room_id, "@bob:red") # now, with the original user, sync again to get a new at token - channel = self.make_request("GET", "/sync") + channel = await self.make_request("GET", "/sync") self.assertEqual(HTTPStatus.OK, channel.code) sync_token = channel.json_body["next_batch"] # check the user can no longer see the updated member list - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/members?at=%s" % (room_id, sync_token) ) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - def test_get_member_list_mixed_memberships(self) -> None: + async def test_get_member_list_mixed_memberships(self) -> None: room_creator = "@some_other_guy:red" - room_id = self.helper.create_room_as(room_creator) + room_id = await self.helper.create_room_as(room_creator) room_path = "/rooms/%s/members" % room_id - self.helper.invite(room=room_id, src=room_creator, targ=self.user_id) + await self.helper.invite(room=room_id, src=room_creator, targ=self.user_id) # can't see list if you're just invited. - channel = self.make_request("GET", room_path) + channel = await self.make_request("GET", room_path) self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) - self.helper.join(room=room_id, user=self.user_id) + await self.helper.join(room=room_id, user=self.user_id) # can see list now joined - channel = self.make_request("GET", room_path) + channel = await self.make_request("GET", room_path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - self.helper.leave(room=room_id, user=self.user_id) + await self.helper.leave(room=room_id, user=self.user_id) # can see old list once left - channel = self.make_request("GET", room_path) + channel = await self.make_request("GET", room_path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - def test_get_member_list_cancellation(self) -> None: + async def test_get_member_list_cancellation(self) -> None: """Test cancellation of a `/rooms/$room_id/members` request.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) channel = make_request_with_cancellation_test( "test_get_member_list_cancellation", self.reactor, @@ -744,12 +744,12 @@ class RoomsMemberListTestCase(RoomBase): channel.json_body["chunk"][0].items(), ) - def test_get_member_list_with_at_token_cancellation(self) -> None: + async def test_get_member_list_with_at_token_cancellation(self) -> None: """Test cancellation of a `/rooms/$room_id/members?at=` request.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) # first sync to get an at token - channel = self.make_request("GET", "/sync") + channel = await self.make_request("GET", "/sync") self.assertEqual(HTTPStatus.OK, channel.code) sync_token = channel.json_body["next_batch"] @@ -781,18 +781,18 @@ class RoomsCreateTestCase(RoomBase): user_id = "@sid1:red" - def test_post_room_no_keys(self) -> None: + async def test_post_room_no_keys(self) -> None: # POST with no config keys, expect new room id - channel = self.make_request("POST", "/createRoom", "{}") + channel = await self.make_request("POST", "/createRoom", "{}") self.assertEqual(HTTPStatus.OK, channel.code, channel.result) self.assertTrue("room_id" in channel.json_body) assert channel.resource_usage is not None self.assertEqual(35, channel.resource_usage.db_txn_count) - def test_post_room_initial_state(self) -> None: + async def test_post_room_initial_state(self) -> None: # POST with initial_state config key, expect new room id - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", b'{"initial_state":[{"type": "m.bridge", "content": {}}]}', @@ -803,24 +803,24 @@ class RoomsCreateTestCase(RoomBase): assert channel.resource_usage is not None self.assertEqual(37, channel.resource_usage.db_txn_count) - def test_post_room_topic(self) -> None: + async def test_post_room_topic(self) -> None: # POST with topic key, expect new room id - channel = self.make_request("POST", "/createRoom", b'{"topic":"shenanigans"}') + channel = await self.make_request("POST", "/createRoom", b'{"topic":"shenanigans"}') self.assertEqual(HTTPStatus.OK, channel.code) self.assertTrue("room_id" in channel.json_body) room_id = channel.json_body["room_id"] # GET topic event, expect content from topic key - channel = self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) + channel = await self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) self.assertEqual(HTTPStatus.OK, channel.code) self.assertEqual( {"topic": "shenanigans", "m.topic": {"m.text": [{"body": "shenanigans"}]}}, channel.json_body, ) - def test_post_room_topic_initial_state(self) -> None: + async def test_post_room_topic_initial_state(self) -> None: # POST with m.room.topic in initial state, expect new room id - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", b'{"initial_state":[{"type": "m.room.topic", "content": {"topic": "foobar"}}]}', @@ -830,16 +830,16 @@ class RoomsCreateTestCase(RoomBase): room_id = channel.json_body["room_id"] # GET topic event, expect content from initial state - channel = self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) + channel = await self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) self.assertEqual(HTTPStatus.OK, channel.code) self.assertEqual( {"topic": "foobar"}, channel.json_body, ) - def test_post_room_topic_overriding_initial_state(self) -> None: + async def test_post_room_topic_overriding_initial_state(self) -> None: # POST with m.room.topic in initial state and topic key, expect new room id - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", b'{"initial_state":[{"type": "m.room.topic", "content": {"topic": "foobar"}}], "topic":"shenanigans"}', @@ -849,51 +849,51 @@ class RoomsCreateTestCase(RoomBase): room_id = channel.json_body["room_id"] # GET topic event, expect content from topic key - channel = self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) + channel = await self.make_request("GET", "/rooms/%s/state/m.room.topic" % (room_id,)) self.assertEqual(HTTPStatus.OK, channel.code) self.assertEqual( {"topic": "shenanigans", "m.topic": {"m.text": [{"body": "shenanigans"}]}}, channel.json_body, ) - def test_post_room_visibility_key(self) -> None: + async def test_post_room_visibility_key(self) -> None: # POST with visibility config key, expect new room id - channel = self.make_request("POST", "/createRoom", b'{"visibility":"private"}') + channel = await self.make_request("POST", "/createRoom", b'{"visibility":"private"}') self.assertEqual(HTTPStatus.OK, channel.code) self.assertTrue("room_id" in channel.json_body) - def test_post_room_custom_key(self) -> None: + async def test_post_room_custom_key(self) -> None: # POST with custom config keys, expect new room id - channel = self.make_request("POST", "/createRoom", b'{"custom":"stuff"}') + channel = await self.make_request("POST", "/createRoom", b'{"custom":"stuff"}') self.assertEqual(HTTPStatus.OK, channel.code) self.assertTrue("room_id" in channel.json_body) - def test_post_room_known_and_unknown_keys(self) -> None: + async def test_post_room_known_and_unknown_keys(self) -> None: # POST with custom + known config keys, expect new room id - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", b'{"visibility":"private","custom":"things"}' ) self.assertEqual(HTTPStatus.OK, channel.code) self.assertTrue("room_id" in channel.json_body) - def test_post_room_invalid_content(self) -> None: + async def test_post_room_invalid_content(self) -> None: # POST with invalid content / paths, expect 400 - channel = self.make_request("POST", "/createRoom", b'{"visibili') + channel = await self.make_request("POST", "/createRoom", b'{"visibili') self.assertEqual(HTTPStatus.BAD_REQUEST, channel.code) - channel = self.make_request("POST", "/createRoom", b'["hello"]') + channel = await self.make_request("POST", "/createRoom", b'["hello"]') self.assertEqual(HTTPStatus.BAD_REQUEST, channel.code) - def test_post_room_invitees_invalid_mxid(self) -> None: + async def test_post_room_invitees_invalid_mxid(self) -> None: # POST with invalid invitee, see https://github.com/matrix-org/synapse/issues/4088 # Note the trailing space in the MXID here! - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", b'{"invite":["@alice:example.com "]}' ) self.assertEqual(HTTPStatus.BAD_REQUEST, channel.code) @unittest.override_config({"rc_invites": {"per_room": {"burst_count": 3}}}) - def test_post_room_invitees_ratelimit(self) -> None: + async def test_post_room_invitees_ratelimit(self) -> None: """Test that invites sent when creating a room are ratelimited by a RateLimiter, which ratelimits them correctly, including by not limiting when the requester is exempt from ratelimiting. @@ -911,7 +911,7 @@ class RoomsCreateTestCase(RoomBase): } # Test that the invites are correctly ratelimited. - channel = self.make_request("POST", "/createRoom", content) + channel = await self.make_request("POST", "/createRoom", content) self.assertEqual(HTTPStatus.BAD_REQUEST, channel.code) self.assertEqual( "Cannot invite so many users at once", @@ -919,15 +919,15 @@ class RoomsCreateTestCase(RoomBase): ) # Add the current user to the ratelimit overrides, allowing them no ratelimiting. - self.get_success( + await self.get_success( self.hs.get_datastores().main.set_ratelimit_for_user(self.user_id, 0, 0) ) # Test that the invites aren't ratelimited anymore. - channel = self.make_request("POST", "/createRoom", content) + channel = await self.make_request("POST", "/createRoom", content) self.assertEqual(HTTPStatus.OK, channel.code) - def test_spam_checker_may_join_room_deprecated(self) -> None: + async def test_spam_checker_may_join_room_deprecated(self) -> None: """Tests that the user_may_join_room spam checker callback is correctly bypassed when creating a new room. @@ -946,7 +946,7 @@ class RoomsCreateTestCase(RoomBase): join_mock ) - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", {}, @@ -955,7 +955,7 @@ class RoomsCreateTestCase(RoomBase): self.assertEqual(join_mock.call_count, 0) - def test_spam_checker_may_join_room(self) -> None: + async def test_spam_checker_may_join_room(self) -> None: """Tests that the user_may_join_room spam checker callback is correctly bypassed when creating a new room. @@ -974,7 +974,7 @@ class RoomsCreateTestCase(RoomBase): join_mock ) - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", {}, @@ -994,7 +994,7 @@ class RoomsCreateTestCase(RoomBase): join_mock.side_effect = user_may_join_room_tuple - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", {}, @@ -1002,11 +1002,11 @@ class RoomsCreateTestCase(RoomBase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) self.assertEqual(join_mock.call_count, 0) - def _create_basic_room(self) -> tuple[int, object]: + async def _create_basic_room(self) -> tuple[int, object]: """ Tries to create a basic room and returns the response code. """ - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", {}, @@ -1018,7 +1018,7 @@ class RoomsCreateTestCase(RoomBase): "rc_message": {"per_second": 0.2, "burst_count": 10}, } ) - def test_room_creation_ratelimiting(self) -> None: + async def test_room_creation_ratelimiting(self) -> None: """ Regression test for https://github.com/matrix-org/synapse/issues/14312, where ratelimiting was made too strict. @@ -1031,11 +1031,11 @@ class RoomsCreateTestCase(RoomBase): """ for _ in range(10): - code, json_body = self._create_basic_room() + code, json_body = await self._create_basic_room() self.assertEqual(code, HTTPStatus.OK, json_body) # The 6th room hits the rate limit. - code, json_body = self._create_basic_room() + code, json_body = await self._create_basic_room() self.assertEqual(code, HTTPStatus.TOO_MANY_REQUESTS, json_body) @@ -1044,75 +1044,75 @@ class RoomTopicTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: # create the room - self.room_id = self.helper.create_room_as(self.user_id) + self.room_id = await self.helper.create_room_as(self.user_id) self.path = "/rooms/%s/state/m.room.topic" % (self.room_id,) - def test_invalid_puts(self) -> None: + async def test_invalid_puts(self) -> None: # missing keys or invalid json - channel = self.make_request("PUT", self.path, "{}") + channel = await self.make_request("PUT", self.path, "{}") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", self.path, '{"_name":"bo"}') + channel = await self.make_request("PUT", self.path, '{"_name":"bo"}') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", self.path, '{"nao') + channel = await self.make_request("PUT", self.path, '{"nao') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request( + channel = await self.make_request( "PUT", self.path, '[{"_name":"bo"},{"_name":"jill"}]' ) self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", self.path, "text only") + channel = await self.make_request("PUT", self.path, "text only") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", self.path, "") + channel = await self.make_request("PUT", self.path, "") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) # valid key, wrong type content = '{"topic":["Topic name"]}' - channel = self.make_request("PUT", self.path, content) + channel = await self.make_request("PUT", self.path, content) self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - def test_rooms_topic(self) -> None: + async def test_rooms_topic(self) -> None: # nothing should be there - channel = self.make_request("GET", self.path) + channel = await self.make_request("GET", self.path) self.assertEqual(HTTPStatus.NOT_FOUND, channel.code, msg=channel.result["body"]) # valid put content = '{"topic":"Topic name"}' - channel = self.make_request("PUT", self.path, content) + channel = await self.make_request("PUT", self.path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # valid get - channel = self.make_request("GET", self.path) + channel = await self.make_request("GET", self.path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assert_dict(json.loads(content), channel.json_body) - def test_rooms_topic_with_extra_keys(self) -> None: + async def test_rooms_topic_with_extra_keys(self) -> None: # valid put with extra keys content = '{"topic":"Seasons","subtopic":"Summer"}' - channel = self.make_request("PUT", self.path, content) + channel = await self.make_request("PUT", self.path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # valid get - channel = self.make_request("GET", self.path) + channel = await self.make_request("GET", self.path) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assert_dict(json.loads(content), channel.json_body) @@ -1122,38 +1122,38 @@ class RoomMemberStateTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_id = self.helper.create_room_as(self.user_id) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_id = await self.helper.create_room_as(self.user_id) - def test_invalid_puts(self) -> None: + async def test_invalid_puts(self) -> None: path = "/rooms/%s/state/m.room.member/%s" % (self.room_id, self.user_id) # missing keys or invalid json - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, '{"_name":"bo"}') + channel = await self.make_request("PUT", path, '{"_name":"bo"}') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, '{"nao') + channel = await self.make_request("PUT", path, '{"nao') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]') + channel = await self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, "text only") + channel = await self.make_request("PUT", path, "text only") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, "") + channel = await self.make_request("PUT", path, "") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) @@ -1164,12 +1164,12 @@ class RoomMemberStateTestCase(RoomBase): Membership.JOIN, Membership.LEAVE, ) - channel = self.make_request("PUT", path, content.encode("ascii")) + channel = await self.make_request("PUT", path, content.encode("ascii")) self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - def test_rooms_members_self(self) -> None: + async def test_rooms_members_self(self) -> None: path = "/rooms/%s/state/m.room.member/%s" % ( urlparse.quote(self.room_id), self.user_id, @@ -1177,16 +1177,16 @@ class RoomMemberStateTestCase(RoomBase): # valid join message (NOOP since we made the room) content = '{"membership":"%s"}' % Membership.JOIN - channel = self.make_request("PUT", path, content.encode("ascii")) + channel = await self.make_request("PUT", path, content.encode("ascii")) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - channel = self.make_request("GET", path, content=b"") + channel = await self.make_request("GET", path, content=b"") self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) expected_response = {"membership": Membership.JOIN} self.assertEqual(expected_response, channel.json_body) - def test_rooms_members_other(self) -> None: + async def test_rooms_members_other(self) -> None: self.other_id = "@zzsid1:red" path = "/rooms/%s/state/m.room.member/%s" % ( urlparse.quote(self.room_id), @@ -1195,14 +1195,14 @@ class RoomMemberStateTestCase(RoomBase): # valid invite message content = '{"membership":"%s"}' % Membership.INVITE - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - channel = self.make_request("GET", path, content=b"") + channel = await self.make_request("GET", path, content=b"") self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assertEqual(json.loads(content), channel.json_body) - def test_rooms_members_other_custom_keys(self) -> None: + async def test_rooms_members_other_custom_keys(self) -> None: self.other_id = "@zzsid1:red" path = "/rooms/%s/state/m.room.member/%s" % ( urlparse.quote(self.room_id), @@ -1214,10 +1214,10 @@ class RoomMemberStateTestCase(RoomBase): Membership.INVITE, "Join us!", ) - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - channel = self.make_request("GET", path, content=b"") + channel = await self.make_request("GET", path, content=b"") self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) self.assertEqual(json.loads(content), channel.json_body) @@ -1234,27 +1234,27 @@ class RoomInviteRatelimitTestCase(RoomBase): @unittest.override_config( {"rc_invites": {"per_room": {"per_second": 0.5, "burst_count": 3}}} ) - def test_invites_by_rooms_ratelimit(self) -> None: + async def test_invites_by_rooms_ratelimit(self) -> None: """Tests that invites in a room are actually rate-limited.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) for i in range(3): - self.helper.invite(room_id, self.user_id, "@user-%s:red" % (i,)) + await self.helper.invite(room_id, self.user_id, "@user-%s:red" % (i,)) - self.helper.invite(room_id, self.user_id, "@user-4:red", expect_code=429) + await self.helper.invite(room_id, self.user_id, "@user-4:red", expect_code=429) @unittest.override_config( {"rc_invites": {"per_user": {"per_second": 0.5, "burst_count": 3}}} ) - def test_invites_by_users_ratelimit(self) -> None: + async def test_invites_by_users_ratelimit(self) -> None: """Tests that invites to a specific user are actually rate-limited.""" for _ in range(3): - room_id = self.helper.create_room_as(self.user_id) - self.helper.invite(room_id, self.user_id, "@other-users:red") + room_id = await self.helper.create_room_as(self.user_id) + await self.helper.invite(room_id, self.user_id, "@other-users:red") - room_id = self.helper.create_room_as(self.user_id) - self.helper.invite(room_id, self.user_id, "@other-users:red", expect_code=429) + room_id = await self.helper.create_room_as(self.user_id) + await self.helper.invite(room_id, self.user_id, "@other-users:red", expect_code=429) class RoomJoinTestCase(RoomBase): @@ -1265,20 +1265,20 @@ class RoomJoinTestCase(RoomBase): knock.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user1 = self.register_user("thomas", "hackme") - self.tok1 = self.login("thomas", "hackme") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user1 = await self.register_user("thomas", "hackme") + self.tok1 = await self.login("thomas", "hackme") - self.user2 = self.register_user("teresa", "hackme") - self.tok2 = self.login("teresa", "hackme") + self.user2 = await self.register_user("teresa", "hackme") + self.tok2 = await self.login("teresa", "hackme") - self.room1 = self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) - self.room2 = self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) - self.room3 = self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) + self.room1 = await self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) + self.room2 = await self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) + self.room3 = await self.helper.create_room_as(room_creator=self.user1, tok=self.tok1) self.store = hs.get_datastores().main - def test_spam_checker_may_join_room_deprecated(self) -> None: + async def test_spam_checker_may_join_room_deprecated(self) -> None: """Tests that the user_may_join_room spam checker callback is correctly called and blocks room joins when needed. @@ -1303,7 +1303,7 @@ class RoomJoinTestCase(RoomBase): ) # Join a first room, without being invited to it. - self.helper.join(self.room1, self.user2, tok=self.tok2) + await self.helper.join(self.room1, self.user2, tok=self.tok2) # Check that the callback was called with the right arguments. expected_call_args = ( @@ -1320,8 +1320,8 @@ class RoomJoinTestCase(RoomBase): ) # Join a second room, this time with an invite for it. - self.helper.invite(self.room2, self.user1, self.user2, tok=self.tok1) - self.helper.join(self.room2, self.user2, tok=self.tok2) + await self.helper.invite(self.room2, self.user1, self.user2, tok=self.tok1) + await self.helper.join(self.room2, self.user2, tok=self.tok2) # Check that the callback was called with the right arguments. expected_call_args = ( @@ -1339,11 +1339,11 @@ class RoomJoinTestCase(RoomBase): # Now make the callback deny all room joins, and check that a join actually fails. return_value = False - self.helper.join( + await self.helper.join( self.room3, self.user2, expect_code=HTTPStatus.FORBIDDEN, tok=self.tok2 ) - def test_spam_checker_may_join_room(self) -> None: + async def test_spam_checker_may_join_room(self) -> None: """Tests that the user_may_join_room spam checker callback is correctly called and blocks room joins when needed. @@ -1370,7 +1370,7 @@ class RoomJoinTestCase(RoomBase): ) # Join a first room, without being invited to it. - self.helper.join(self.room1, self.user2, tok=self.tok2) + await self.helper.join(self.room1, self.user2, tok=self.tok2) # Check that the callback was called with the right arguments. expected_call_args = ( @@ -1387,8 +1387,8 @@ class RoomJoinTestCase(RoomBase): ) # Join a second room, this time with an invite for it. - self.helper.invite(self.room2, self.user1, self.user2, tok=self.tok1) - self.helper.join(self.room2, self.user2, tok=self.tok2) + await self.helper.invite(self.room2, self.user1, self.user2, tok=self.tok1) + await self.helper.join(self.room2, self.user2, tok=self.tok2) # Check that the callback was called with the right arguments. expected_call_args = ( @@ -1407,8 +1407,8 @@ class RoomJoinTestCase(RoomBase): # Now make the callback deny all room joins, and check that a join actually fails. # We pick an arbitrary Codes rather than the default `Codes.FORBIDDEN`. return_value = Codes.CONSENT_NOT_GIVEN - self.helper.invite(self.room3, self.user1, self.user2, tok=self.tok1) - self.helper.join( + await self.helper.invite(self.room3, self.user1, self.user2, tok=self.tok1) + await self.helper.join( self.room3, self.user2, expect_code=HTTPStatus.FORBIDDEN, @@ -1419,7 +1419,7 @@ class RoomJoinTestCase(RoomBase): # Now make the callback deny all room joins, and check that a join actually fails. # As above, with the experimental extension that lets us return dictionaries. return_value = (Codes.BAD_ALIAS, {"another_field": "12345"}) - self.helper.join( + await self.helper.join( self.room3, self.user2, expect_code=HTTPStatus.FORBIDDEN, @@ -1428,27 +1428,27 @@ class RoomJoinTestCase(RoomBase): expect_additional_fields=return_value[1], ) - def test_suspended_user_cannot_join_room(self) -> None: + async def test_suspended_user_cannot_join_room(self) -> None: # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user2, True)) + await self.get_success(self.store.set_user_suspended_status(self.user2, True)) - channel = self.make_request( + channel = await self.make_request( "POST", f"/join/{self.room1}", access_token=self.tok2 ) self.assertEqual(channel.code, 403) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - channel = self.make_request( + channel = await self.make_request( "POST", f"/rooms/{self.room1}/join", access_token=self.tok2 ) self.assertEqual(channel.code, 403) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_cannot_knock_on_room(self) -> None: + async def test_suspended_user_cannot_knock_on_room(self) -> None: # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user2, True)) + await self.get_success(self.store.set_user_suspended_status(self.user2, True)) - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/v3/knock/{self.room1}", access_token=self.tok2, @@ -1458,12 +1458,12 @@ class RoomJoinTestCase(RoomBase): self.assertEqual(channel.code, 403) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_cannot_invite_to_room(self) -> None: + async def test_suspended_user_cannot_invite_to_room(self) -> None: # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) # first user invites second user - channel = self.make_request( + channel = await self.make_request( "POST", f"/rooms/{self.room1}/invite", access_token=self.tok1, @@ -1471,17 +1471,17 @@ class RoomJoinTestCase(RoomBase): ) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_can_leave_room(self) -> None: - channel = self.make_request( + async def test_suspended_user_can_leave_room(self) -> None: + channel = await self.make_request( "POST", f"/join/{self.room1}", access_token=self.tok1 ) self.assertEqual(channel.code, 200) # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) # leave room - channel = self.make_request( + channel = await self.make_request( "POST", f"/rooms/{self.room1}/leave", access_token=self.tok1, @@ -1496,8 +1496,8 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): register.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.appservice_user, _ = self.register_appservice_user( + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.appservice_user, _ = await self.register_appservice_user( "as_user_potato", self.appservice.token ) @@ -1506,7 +1506,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): "access_token": self.appservice.token, "user_id": self.appservice_user, } - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/createRoom?{urlparse.urlencode(args)}", content={"visibility": "public"}, @@ -1517,7 +1517,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): self.main_store = self.hs.get_datastores().main - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: config = self.default_config() self.appservice = ApplicationService( @@ -1533,10 +1533,10 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): "synapse.storage.databases.main.appservice.load_appservices", mock_load_appservices, ): - hs = self.setup_test_homeserver(config=config) + hs = await self.setup_test_homeserver(config=config) return hs - def test_send_event_ts(self) -> None: + async def test_send_event_ts(self) -> None: """Test sending a non-state event with a custom timestamp.""" ts = 1 @@ -1544,7 +1544,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): "user_id": self.appservice_user, "ts": ts, } - channel = self.make_request( + channel = await self.make_request( "PUT", path=f"/_matrix/client/r0/rooms/{self.room}/send/m.room.message/1234?" + urlparse.urlencode(url_params), @@ -1555,10 +1555,10 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): event_id = channel.json_body["event_id"] # Ensure the event was persisted with the correct timestamp. - res = self.get_success(self.main_store.get_event(event_id)) + res = await self.get_success(self.main_store.get_event(event_id)) self.assertEqual(ts, res.origin_server_ts) - def test_send_state_event_ts(self) -> None: + async def test_send_state_event_ts(self) -> None: """Test sending a state event with a custom timestamp.""" ts = 1 @@ -1566,7 +1566,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): "user_id": self.appservice_user, "ts": ts, } - channel = self.make_request( + channel = await self.make_request( "PUT", path=f"/_matrix/client/r0/rooms/{self.room}/state/m.room.name?" + urlparse.urlencode(url_params), @@ -1577,10 +1577,10 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): event_id = channel.json_body["event_id"] # Ensure the event was persisted with the correct timestamp. - res = self.get_success(self.main_store.get_event(event_id)) + res = await self.get_success(self.main_store.get_event(event_id)) self.assertEqual(ts, res.origin_server_ts) - def test_send_membership_event_ts(self) -> None: + async def test_send_membership_event_ts(self) -> None: """Test sending a membership event with a custom timestamp.""" ts = 1 @@ -1588,7 +1588,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): "user_id": self.appservice_user, "ts": ts, } - channel = self.make_request( + channel = await self.make_request( "PUT", path=f"/_matrix/client/r0/rooms/{self.room}/state/m.room.member/{self.appservice_user}?" + urlparse.urlencode(url_params), @@ -1599,7 +1599,7 @@ class RoomAppserviceTsParamTestCase(unittest.HomeserverTestCase): event_id = channel.json_body["event_id"] # Ensure the event was persisted with the correct timestamp. - res = self.get_success(self.main_store.get_event(event_id)) + res = await self.get_success(self.main_store.get_event(event_id)) self.assertEqual(ts, res.origin_server_ts) @@ -1612,80 +1612,80 @@ class RoomJoinRatelimitTestCase(RoomBase): room.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: super().prepare(reactor, clock, hs) # profile changes expect that the user is actually registered user = UserID.from_string(self.user_id) - self.register_user(user.localpart, "supersecretpassword") + await self.register_user(user.localpart, "supersecretpassword") @unittest.override_config( {"rc_joins": {"local": {"per_second": 0.5, "burst_count": 3}}} ) - def test_join_local_ratelimit(self) -> None: + async def test_join_local_ratelimit(self) -> None: """Tests that local joins are actually rate-limited.""" # Create 4 rooms room_ids = [ - self.helper.create_room_as(self.user_id, is_public=True) for _ in range(4) + await self.helper.create_room_as(self.user_id, is_public=True) for _ in range(4) ] - joiner_user_id = self.register_user("joiner", "secret") + joiner_user_id = await self.register_user("joiner", "secret") # Now make a new user try to join some of them. # The user can join 3 rooms for room_id in room_ids[0:3]: - self.helper.join(room_id, joiner_user_id) + await self.helper.join(room_id, joiner_user_id) # But the user cannot join a 4th room - self.helper.join( + await self.helper.join( room_ids[3], joiner_user_id, expect_code=HTTPStatus.TOO_MANY_REQUESTS ) @unittest.override_config( {"rc_joins": {"local": {"per_second": 0.5, "burst_count": 3}}} ) - def test_join_attempts_local_ratelimit(self) -> None: + async def test_join_attempts_local_ratelimit(self) -> None: """Tests that unsuccessful joins that end up being denied are rate-limited.""" # Create 4 rooms room_ids = [ - self.helper.create_room_as(self.user_id, is_public=True) for _ in range(4) + await self.helper.create_room_as(self.user_id, is_public=True) for _ in range(4) ] # Pre-emptively ban the user who will attempt to join. - joiner_user_id = self.register_user("joiner", "secret") + joiner_user_id = await self.register_user("joiner", "secret") for room_id in room_ids: - self.helper.ban(room_id, self.user_id, joiner_user_id) + await self.helper.ban(room_id, self.user_id, joiner_user_id) # Now make a new user try to join some of them. # The user can make 3 requests, each of which should be denied. for room_id in room_ids[0:3]: - self.helper.join(room_id, joiner_user_id, expect_code=HTTPStatus.FORBIDDEN) + await self.helper.join(room_id, joiner_user_id, expect_code=HTTPStatus.FORBIDDEN) # The fourth attempt should be rate limited. - self.helper.join( + await self.helper.join( room_ids[3], joiner_user_id, expect_code=HTTPStatus.TOO_MANY_REQUESTS ) @unittest.override_config( {"rc_joins": {"local": {"per_second": 0.5, "burst_count": 3}}} ) - def test_join_local_ratelimit_profile_change(self) -> None: + async def test_join_local_ratelimit_profile_change(self) -> None: """Tests that sending a profile update into all of the user's joined rooms isn't rate-limited by the rate-limiter on joins.""" # Create and join as many rooms as the rate-limiting config allows in a second. room_ids = [ - self.helper.create_room_as(self.user_id), - self.helper.create_room_as(self.user_id), - self.helper.create_room_as(self.user_id), + await self.helper.create_room_as(self.user_id), + await self.helper.create_room_as(self.user_id), + await self.helper.create_room_as(self.user_id), ] # Let some time for the rate-limiter to forget about our multi-join. self.reactor.advance(2) # Add one to make sure we're joined to more rooms than the config allows us to # join in a second. - room_ids.append(self.helper.create_room_as(self.user_id)) + room_ids.append(await self.helper.create_room_as(self.user_id)) # Update the display name for the user. path = "/_matrix/client/r0/profile/%s/displayname" % self.user_id - channel = self.make_request("PUT", path, {"displayname": "John Doe"}) + channel = await self.make_request("PUT", path, {"displayname": "John Doe"}) self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # Check that all the rooms have been sent a profile update into. @@ -1695,7 +1695,7 @@ class RoomJoinRatelimitTestCase(RoomBase): self.user_id, ) - channel = self.make_request("GET", path) + channel = await self.make_request("GET", path) self.assertEqual(channel.code, 200) self.assertIn("displayname", channel.json_body) @@ -1704,10 +1704,10 @@ class RoomJoinRatelimitTestCase(RoomBase): @unittest.override_config( {"rc_joins": {"local": {"per_second": 0.5, "burst_count": 3}}} ) - def test_join_local_ratelimit_idempotent(self) -> None: + async def test_join_local_ratelimit_idempotent(self) -> None: """Tests that the room join endpoints remain idempotent despite rate-limiting on room joins.""" - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) # Let's test both paths to be sure. paths_to_test = [ @@ -1719,7 +1719,7 @@ class RoomJoinRatelimitTestCase(RoomBase): # Make sure we send more requests than the rate-limiting config would allow # if all of these requests ended up joining the user to a room. for _ in range(4): - channel = self.make_request("POST", path % room_id, {}) + channel = await self.make_request("POST", path % room_id, {}) self.assertEqual(channel.code, 200) @unittest.override_config( @@ -1729,11 +1729,11 @@ class RoomJoinRatelimitTestCase(RoomBase): "autocreate_auto_join_rooms": True, }, ) - def test_autojoin_rooms(self) -> None: - user_id = self.register_user("testuser", "password") + async def test_autojoin_rooms(self) -> None: + user_id = await self.register_user("testuser", "password") # Check that the new user successfully joined the four rooms - rooms = self.get_success( + rooms = await self.get_success( self.hs.get_datastores().main.get_rooms_for_user(user_id) ) self.assertEqual(len(rooms), 4) @@ -1744,60 +1744,60 @@ class RoomMessagesTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_id = self.helper.create_room_as(self.user_id) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_id = await self.helper.create_room_as(self.user_id) - def test_invalid_puts(self) -> None: + async def test_invalid_puts(self) -> None: path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id)) # missing keys or invalid json - channel = self.make_request("PUT", path, b"{}") + channel = await self.make_request("PUT", path, b"{}") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b'{"_name":"bo"}') + channel = await self.make_request("PUT", path, b'{"_name":"bo"}') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b'{"nao') + channel = await self.make_request("PUT", path, b'{"nao') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]') + channel = await self.make_request("PUT", path, b'[{"_name":"bo"},{"_name":"jill"}]') self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b"text only") + channel = await self.make_request("PUT", path, b"text only") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - channel = self.make_request("PUT", path, b"") + channel = await self.make_request("PUT", path, b"") self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) - def test_rooms_messages_sent(self) -> None: + async def test_rooms_messages_sent(self) -> None: path = "/rooms/%s/send/m.room.message/mid1" % (urlparse.quote(self.room_id)) content = b'{"body":"test","msgtype":{"type":"a"}}' - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) self.assertEqual( HTTPStatus.BAD_REQUEST, channel.code, msg=channel.result["body"] ) # custom message types content = b'{"body":"test","msgtype":"test.custom.text"}' - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) # m.text message type path = "/rooms/%s/send/m.room.message/mid2" % (urlparse.quote(self.room_id)) content = b'{"body":"test2","msgtype":"m.text"}' - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) @parameterized.expand( @@ -1845,7 +1845,7 @@ class RoomMessagesTestCase(RoomBase): ), ] ) - def test_spam_checker_check_event_for_spam( + async def test_spam_checker_check_event_for_spam( self, name: str, value: str | bool | Codes | tuple[Codes, JsonDict], @@ -1879,7 +1879,7 @@ class RoomMessagesTestCase(RoomBase): ) body = "test-%s" % name content = '{"body":"%s","msgtype":"m.text"}' % body - channel = self.make_request("PUT", path, content) + channel = await self.make_request("PUT", path, content) # Check that the callback has witnessed the correct event. self.assertIsNotNone(spam_checker.mock_content) @@ -1911,16 +1911,16 @@ class RoomPowerLevelOverridesTestCase(RoomBase): login.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.admin_user_id = self.register_user("admin", "pass") - self.admin_access_token = self.login("admin", "pass") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.admin_user_id = await self.register_user("admin", "pass") + self.admin_access_token = await self.login("admin", "pass") - def power_levels(self, room_id: str) -> dict[str, Any]: - return self.helper.get_state( + async def power_levels(self, room_id: str) -> dict[str, Any]: + return await self.helper.get_state( room_id, "m.room.power_levels", self.admin_access_token ) - def test_default_power_levels_with_room_override(self) -> None: + async def test_default_power_levels_with_room_override(self) -> None: """ Create a room, providing power level overrides. Confirm that the room's power levels reflect the overrides. @@ -1930,7 +1930,7 @@ class RoomPowerLevelOverridesTestCase(RoomBase): completely. """ - room_id = self.helper.create_room_as( + room_id = await self.helper.create_room_as( self.user_id, extra_content={ "power_level_content_override": {"events": {"custom.event": 0}} @@ -1940,7 +1940,7 @@ class RoomPowerLevelOverridesTestCase(RoomBase): { "custom.event": 0, }, - self.power_levels(room_id)["events"], + await self.power_levels(room_id)["events"], ) @unittest.override_config( @@ -1950,7 +1950,7 @@ class RoomPowerLevelOverridesTestCase(RoomBase): } }, ) - def test_power_levels_with_server_override(self) -> None: + async def test_power_levels_with_server_override(self) -> None: """ With a server configured to modify the room-level defaults, Create a room, without providing any extra power level overrides. @@ -1960,12 +1960,12 @@ class RoomPowerLevelOverridesTestCase(RoomBase): we overwrite each key of power_level_content_override completely. """ - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) self.assertEqual( { "custom.event": 0, }, - self.power_levels(room_id)["events"], + await self.power_levels(room_id)["events"], ) @unittest.override_config( @@ -1978,7 +1978,7 @@ class RoomPowerLevelOverridesTestCase(RoomBase): } }, ) - def test_power_levels_with_server_and_room_overrides(self) -> None: + async def test_power_levels_with_server_and_room_overrides(self) -> None: """ With a server configured to modify the room-level defaults, create a room, providing different overrides. @@ -1986,7 +1986,7 @@ class RoomPowerLevelOverridesTestCase(RoomBase): choose the room overrides where they clash. """ - room_id = self.helper.create_room_as( + room_id = await self.helper.create_room_as( self.user_id, extra_content={ "power_level_content_override": {"events": {"room.event": 0}} @@ -1996,11 +1996,11 @@ class RoomPowerLevelOverridesTestCase(RoomBase): # Room override wins over server config self.assertEqual( {"room.event": 0}, - self.power_levels(room_id)["events"], + await self.power_levels(room_id)["events"], ) # But where there is no room override, server config wins - self.assertEqual(13, self.power_levels(room_id)["ban"]) + self.assertEqual(13, await self.power_levels(room_id)["ban"]) class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): @@ -2011,29 +2011,29 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): user_id = "@sid1:red" - def test_creator_can_post_state_event(self) -> None: + async def test_creator_can_post_state_event(self) -> None: # Given I am the creator of a room - room_id = self.helper.create_room_as(self.user_id) + room_id = await self.helper.create_room_as(self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am allowed self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) - def test_normal_user_can_not_post_state_event(self) -> None: + async def test_normal_user_can_not_post_state_event(self) -> None: # Given I am a normal member of a room - room_id = self.helper.create_room_as("@some_other_guy:red") - self.helper.join(room=room_id, user=self.user_id) + room_id = await self.helper.create_room_as("@some_other_guy:red") + await self.helper.join(room=room_id, user=self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am not allowed because state events require PL>=50 self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) @@ -2050,17 +2050,17 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): } }, ) - def test_with_config_override_normal_user_can_post_state_event(self) -> None: + async def test_with_config_override_normal_user_can_post_state_event(self) -> None: # Given the server has config allowing normal users to post my event type, # and I am a normal member of a room - room_id = self.helper.create_room_as("@some_other_guy:red") - self.helper.join(room=room_id, user=self.user_id) + room_id = await self.helper.create_room_as("@some_other_guy:red") + await self.helper.join(room=room_id, user=self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am allowed self.assertEqual(HTTPStatus.OK, channel.code, msg=channel.result["body"]) @@ -2072,23 +2072,23 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): } }, ) - def test_any_room_override_defeats_config_override(self) -> None: + async def test_any_room_override_defeats_config_override(self) -> None: # Given the server has config allowing normal users to post my event type # And I am a normal member of a room # But the room was created with special permissions extra_content: dict[str, Any] = { "power_level_content_override": {"events": {}}, } - room_id = self.helper.create_room_as( + room_id = await self.helper.create_room_as( "@some_other_guy:red", extra_content=extra_content ) - self.helper.join(room=room_id, user=self.user_id) + await self.helper.join(room=room_id, user=self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am not allowed self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) @@ -2100,23 +2100,23 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): } }, ) - def test_specific_room_override_defeats_config_override(self) -> None: + async def test_specific_room_override_defeats_config_override(self) -> None: # Given the server has config allowing normal users to post my event type, # and I am a normal member of a room, # but the room was created with special permissions for this event type extra_content = { "power_level_content_override": {"events": {"custom.event": 1}}, } - room_id = self.helper.create_room_as( + room_id = await self.helper.create_room_as( "@some_other_guy:red", extra_content=extra_content ) - self.helper.join(room=room_id, user=self.user_id) + await self.helper.join(room=room_id, user=self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am not allowed self.assertEqual(HTTPStatus.FORBIDDEN, channel.code, msg=channel.result["body"]) @@ -2135,18 +2135,18 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): } }, ) - def test_config_override_applies_only_to_specific_preset(self) -> None: + async def test_config_override_applies_only_to_specific_preset(self) -> None: # Given the server has config for public_chats, # and I am a normal member of a private_chat room - room_id = self.helper.create_room_as("@some_other_guy:red", is_public=False) - self.helper.invite(room=room_id, src="@some_other_guy:red", targ=self.user_id) - self.helper.join(room=room_id, user=self.user_id) + room_id = await self.helper.create_room_as("@some_other_guy:red", is_public=False) + await self.helper.invite(room=room_id, src="@some_other_guy:red", targ=self.user_id) + await self.helper.join(room=room_id, user=self.user_id) # When I send a state event path = "/rooms/{room_id}/state/custom.event/my_state_key".format( room_id=urlparse.quote(room_id), ) - channel = self.make_request("PUT", path, "{}") + channel = await self.make_request("PUT", path, "{}") # Then I am not allowed because the public_chat config does not # affect this room, because this room is a private_chat @@ -2176,11 +2176,11 @@ class RoomPowerLevelOverridesInPracticeTestCase(RoomBase): } }, ) - def test_config_override_blocks_encrypted_room(self) -> None: + async def test_config_override_blocks_encrypted_room(self) -> None: # Given the server has config for private_chats, # When I attempt to create an encrypted private_chat room - channel = self.make_request( + channel = await self.make_request( "POST", "/createRoom", '{"creation_content": {"m.federate": false},"name": "Secret Private Room","preset": "private_chat","initial_state": [{"type": "m.room.encryption","state_key": "","content": {"algorithm": "m.megolm.v1.aes-sha2"}}]}', @@ -2200,12 +2200,12 @@ class RoomInitialSyncTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: # create the room - self.room_id = self.helper.create_room_as(self.user_id) + self.room_id = await self.helper.create_room_as(self.user_id) - def test_initial_sync(self) -> None: - channel = self.make_request("GET", "/rooms/%s/initialSync" % self.room_id) + async def test_initial_sync(self) -> None: + channel = await self.make_request("GET", "/rooms/%s/initialSync" % self.room_id) self.assertEqual(HTTPStatus.OK, channel.code) self.assertEqual(self.room_id, channel.json_body["room_id"]) @@ -2241,12 +2241,12 @@ class RoomMessageListTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_id = self.helper.create_room_as(self.user_id) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_id = await self.helper.create_room_as(self.user_id) - def test_topo_token_is_accepted(self) -> None: + async def test_topo_token_is_accepted(self) -> None: token = "t1-0_0_0_0_0_0_0_0_0_0_0_0" - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token) ) self.assertEqual(HTTPStatus.OK, channel.code) @@ -2255,9 +2255,9 @@ class RoomMessageListTestCase(RoomBase): self.assertTrue("chunk" in channel.json_body) self.assertTrue("end" in channel.json_body) - def test_stream_token_is_accepted_for_fwd_pagianation(self) -> None: + async def test_stream_token_is_accepted_for_fwd_pagianation(self) -> None: token = "s0_0_0_0_0_0_0_0_0_0_0_0" - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&from=%s" % (self.room_id, token) ) self.assertEqual(HTTPStatus.OK, channel.code) @@ -2266,31 +2266,31 @@ class RoomMessageListTestCase(RoomBase): self.assertTrue("chunk" in channel.json_body) self.assertTrue("end" in channel.json_body) - def test_room_messages_purge(self) -> None: + async def test_room_messages_purge(self) -> None: store = self.hs.get_datastores().main pagination_handler = self.hs.get_pagination_handler() # Send a first message in the room, which will be removed by the purge. - first_event_id = self.helper.send(self.room_id, "message 1")["event_id"] - first_token = self.get_success( + first_event_id = await self.helper.send(self.room_id, "message 1")["event_id"] + first_token = await self.get_success( store.get_topological_token_for_event(first_event_id) ) - first_token_str = self.get_success(first_token.to_string(store)) + first_token_str = await self.get_success(first_token.to_string(store)) # Send a second message in the room, which won't be removed, and which we'll # use as the marker to purge events before. - second_event_id = self.helper.send(self.room_id, "message 2")["event_id"] - second_token = self.get_success( + second_event_id = await self.helper.send(self.room_id, "message 2")["event_id"] + second_token = await self.get_success( store.get_topological_token_for_event(second_event_id) ) - second_token_str = self.get_success(second_token.to_string(store)) + second_token_str = await self.get_success(second_token.to_string(store)) # Send a third event in the room to ensure we don't fall under any edge case # due to our marker being the latest forward extremity in the room. - self.helper.send(self.room_id, "message 3") + await self.helper.send(self.room_id, "message 3") # Check that we get the first and second message when querying /messages. - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&from=%s&dir=b&filter=%s" % ( @@ -2305,7 +2305,7 @@ class RoomMessageListTestCase(RoomBase): self.assertEqual(len(chunk), 2, [event["content"] for event in chunk]) # Purge every event before the second event. - self.get_success( + await self.get_success( pagination_handler.purge_history( room_id=self.room_id, token=second_token_str, @@ -2315,7 +2315,7 @@ class RoomMessageListTestCase(RoomBase): # Check that we only get the second message through /message now that the first # has been purged. - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&from=%s&dir=b&filter=%s" % ( @@ -2332,7 +2332,7 @@ class RoomMessageListTestCase(RoomBase): # Check that we get no event, but also no error, when querying /messages with # the token that was pointing at the first event, because we don't have it # anymore. - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&from=%s&dir=b&filter=%s" % ( @@ -2346,13 +2346,13 @@ class RoomMessageListTestCase(RoomBase): chunk = channel.json_body["chunk"] self.assertEqual(len(chunk), 0, [event["content"] for event in chunk]) - def test_room_message_filter_query_validation(self) -> None: + async def test_room_message_filter_query_validation(self) -> None: # Test json validation in (filter) query parameter. # Does not test the validity of the filter, only the json validation. # Check Get with valid json filter parameter, expect 200. valid_filter_str = '{"types": ["m.room.message"]}' - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{self.room_id}/messages?access_token=x&dir=b&filter={valid_filter_str}", ) @@ -2361,7 +2361,7 @@ class RoomMessageListTestCase(RoomBase): # Check Get with invalid json filter parameter, expect 400 NOT_JSON. invalid_filter_str = "}}}{}" - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{self.room_id}/messages?access_token=x&dir=b&filter={invalid_filter_str}", ) @@ -2377,15 +2377,15 @@ class RoomMessageFilterTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_id = self.helper.create_room_as(self.user_id) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_id = await self.helper.create_room_as(self.user_id) - def test_room_message_filter_wildcard(self) -> None: + async def test_room_message_filter_wildcard(self) -> None: # Send a first message in the room, which will be removed by the purge. - self.helper.send(self.room_id, "message 1", type="f.message.1") - self.helper.send(self.room_id, "message 1", type="f.message.2") - self.helper.send(self.room_id, "not returned in filter") - channel = self.make_request( + await self.helper.send(self.room_id, "message 1", type="f.message.1") + await self.helper.send(self.room_id, "message 1", type="f.message.2") + await self.helper.send(self.room_id, "not returned in filter") + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=x&dir=b&filter=%s" % ( @@ -2404,13 +2404,13 @@ class RoomDelayedEventTestCase(RoomBase): user_id = "@sid1:red" - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_id = self.helper.create_room_as(self.user_id) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_id = await self.helper.create_room_as(self.user_id) @unittest.override_config({"max_event_delay_duration": "24h"}) - def test_send_delayed_invalid_event(self) -> None: + async def test_send_delayed_invalid_event(self) -> None: """Test sending a delayed event with invalid content.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/send/m.room.message/mid1?org.matrix.msc4140.delay=2000" @@ -2421,9 +2421,9 @@ class RoomDelayedEventTestCase(RoomBase): self.assertEqual(HTTPStatus.BAD_REQUEST, channel.code, channel.result) self.assertNotIn("org.matrix.msc4140.errcode", channel.json_body) - def test_delayed_event_unsupported_by_default(self) -> None: + async def test_delayed_event_unsupported_by_default(self) -> None: """Test that sending a delayed event is unsupported with the default config.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/send/m.room.message/mid1?org.matrix.msc4140.delay=2000" @@ -2439,9 +2439,9 @@ class RoomDelayedEventTestCase(RoomBase): ) @unittest.override_config({"max_event_delay_duration": "1000"}) - def test_delayed_event_exceeds_max_delay(self) -> None: + async def test_delayed_event_exceeds_max_delay(self) -> None: """Test that sending a delayed event fails if its delay is longer than allowed.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/send/m.room.message/mid1?org.matrix.msc4140.delay=2000" @@ -2457,9 +2457,9 @@ class RoomDelayedEventTestCase(RoomBase): ) @unittest.override_config({"max_event_delay_duration": "24h"}) - def test_delayed_event_with_negative_delay(self) -> None: + async def test_delayed_event_with_negative_delay(self) -> None: """Test that sending a delayed event fails if its delay is negative.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/send/m.room.message/mid1?org.matrix.msc4140.delay=-2000" @@ -2473,9 +2473,9 @@ class RoomDelayedEventTestCase(RoomBase): ) @unittest.override_config({"max_event_delay_duration": "24h"}) - def test_send_delayed_message_event(self) -> None: + async def test_send_delayed_message_event(self) -> None: """Test sending a valid delayed message event.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/send/m.room.message/mid1?org.matrix.msc4140.delay=2000" @@ -2486,9 +2486,9 @@ class RoomDelayedEventTestCase(RoomBase): self.assertEqual(HTTPStatus.OK, channel.code, channel.result) @unittest.override_config({"max_event_delay_duration": "24h"}) - def test_send_delayed_state_event(self) -> None: + async def test_send_delayed_state_event(self) -> None: """Test sending a valid delayed state event.""" - channel = self.make_request( + channel = await self.make_request( "PUT", ( "rooms/%s/state/m.room.topic/?org.matrix.msc4140.delay=2000" @@ -2504,7 +2504,7 @@ class RoomDelayedEventTestCase(RoomBase): "rc_message": {"per_second": 1, "burst_count": 2}, } ) - def test_add_delayed_event_ratelimit(self) -> None: + async def test_add_delayed_event_ratelimit(self) -> None: """Test that requests to schedule new delayed events are ratelimited by a RateLimiter, which ratelimits them correctly, including by not limiting when the requester is exempt from ratelimiting. @@ -2519,18 +2519,18 @@ class RoomDelayedEventTestCase(RoomBase): ).encode("ascii"), {"body": "test", "msgtype": "m.text"}, ) - channel = self.make_request(*args) + channel = await self.make_request(*args) self.assertEqual(HTTPStatus.OK, channel.code, channel.result) - channel = self.make_request(*args) + channel = await self.make_request(*args) self.assertEqual(HTTPStatus.TOO_MANY_REQUESTS, channel.code, channel.result) # Add the current user to the ratelimit overrides, allowing them no ratelimiting. - self.get_success( + await self.get_success( self.hs.get_datastores().main.set_ratelimit_for_user(self.user_id, 0, 0) ) # Test that the new delayed events aren't ratelimited anymore. - channel = self.make_request(*args) + channel = await self.make_request(*args) self.assertEqual(HTTPStatus.OK, channel.code, channel.result) @@ -2543,20 +2543,20 @@ class RoomSearchTestCase(unittest.HomeserverTestCase): user_id = True hijack_auth = False - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: # Register the user who does the searching - self.user_id2 = self.register_user("user", "pass") - self.access_token = self.login("user", "pass") + self.user_id2 = await self.register_user("user", "pass") + self.access_token = await self.login("user", "pass") # Register the user who sends the message - self.other_user_id = self.register_user("otheruser", "pass") - self.other_access_token = self.login("otheruser", "pass") + self.other_user_id = await self.register_user("otheruser", "pass") + self.other_access_token = await self.login("otheruser", "pass") # Create a room - self.room = self.helper.create_room_as(self.user_id2, tok=self.access_token) + self.room = await self.helper.create_room_as(self.user_id2, tok=self.access_token) # Invite the other person - self.helper.invite( + await self.helper.invite( room=self.room, src=self.user_id2, tok=self.access_token, @@ -2564,20 +2564,20 @@ class RoomSearchTestCase(unittest.HomeserverTestCase): ) # The other user joins - self.helper.join( + await self.helper.join( room=self.room, user=self.other_user_id, tok=self.other_access_token ) - def test_finds_message(self) -> None: + async def test_finds_message(self) -> None: """ The search functionality will search for content in messages if asked to do so. """ # The other user sends some messages - self.helper.send(self.room, body="Hi!", tok=self.other_access_token) - self.helper.send(self.room, body="There!", tok=self.other_access_token) + await self.helper.send(self.room, body="Hi!", tok=self.other_access_token) + await self.helper.send(self.room, body="There!", tok=self.other_access_token) - channel = self.make_request( + channel = await self.make_request( "POST", "/search?access_token=%s" % (self.access_token,), { @@ -2597,16 +2597,16 @@ class RoomSearchTestCase(unittest.HomeserverTestCase): # No context was requested, so we should get none. self.assertEqual(results["results"][0]["context"], {}) - def test_include_context(self) -> None: + async def test_include_context(self) -> None: """ When event_context includes include_profile, profile information will be included in the search response. """ # The other user sends some messages - self.helper.send(self.room, body="Hi!", tok=self.other_access_token) - self.helper.send(self.room, body="There!", tok=self.other_access_token) + await self.helper.send(self.room, body="Hi!", tok=self.other_access_token) + await self.helper.send(self.room, body="There!", tok=self.other_access_token) - channel = self.make_request( + channel = await self.make_request( "POST", "/search?access_token=%s" % (self.access_token,), { @@ -2642,24 +2642,24 @@ class PublicRoomsRestrictedTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: self.url = b"/_matrix/client/r0/publicRooms" config = self.default_config() config["allow_public_rooms_without_auth"] = False - self.hs = self.setup_test_homeserver(config=config) + self.hs = await self.setup_test_homeserver(config=config) return self.hs - def test_restricted_no_auth(self) -> None: - channel = self.make_request("GET", self.url) + async def test_restricted_no_auth(self) -> None: + channel = await self.make_request("GET", self.url) self.assertEqual(channel.code, HTTPStatus.UNAUTHORIZED, channel.result) - def test_restricted_auth(self) -> None: - self.register_user("user", "pass") - tok = self.login("user", "pass") + async def test_restricted_auth(self) -> None: + await self.register_user("user", "pass") + tok = await self.login("user", "pass") - channel = self.make_request("GET", self.url, access_token=tok) + channel = await self.make_request("GET", self.url, access_token=tok) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) @@ -2670,27 +2670,27 @@ class PublicRoomsRoomTypeFilterTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: config = self.default_config() config["allow_public_rooms_without_auth"] = True - self.hs = self.setup_test_homeserver(config=config) + self.hs = await self.setup_test_homeserver(config=config) self.url = b"/_matrix/client/r0/publicRooms" return self.hs - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - user = self.register_user("alice", "pass") - self.token = self.login(user, "pass") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + user = await self.register_user("alice", "pass") + self.token = await self.login(user, "pass") # Create a room - self.helper.create_room_as( + await self.helper.create_room_as( user, is_public=True, extra_content={"visibility": "public"}, tok=self.token, ) # Create a space - self.helper.create_room_as( + await self.helper.create_room_as( user, is_public=True, extra_content={ @@ -2705,7 +2705,7 @@ class PublicRoomsRoomTypeFilterTestCase(unittest.HomeserverTestCase): config["room_list_publication_rules"] = [{"action": "allow"}] return config - def make_public_rooms_request( + async def make_public_rooms_request( self, room_types: list[str | None] | None, instance_id: str | None = None, @@ -2714,7 +2714,7 @@ class PublicRoomsRoomTypeFilterTestCase(unittest.HomeserverTestCase): if instance_id: body["third_party_instance_id"] = "test|test" - channel = self.make_request("POST", self.url, body, self.token) + channel = await self.make_request("POST", self.url, body, self.token) self.assertEqual(channel.code, 200) chunk = channel.json_body["chunk"] @@ -2724,49 +2724,49 @@ class PublicRoomsRoomTypeFilterTestCase(unittest.HomeserverTestCase): return chunk, count - def test_returns_both_rooms_and_spaces_if_no_filter(self) -> None: - chunk, count = self.make_public_rooms_request(None) + async def test_returns_both_rooms_and_spaces_if_no_filter(self) -> None: + chunk, count = await self.make_public_rooms_request(None) self.assertEqual(count, 2) # Also check if there's no filter property at all in the body. - channel = self.make_request("POST", self.url, {}, self.token) + channel = await self.make_request("POST", self.url, {}, self.token) self.assertEqual(channel.code, 200) self.assertEqual(len(channel.json_body["chunk"]), 2) self.assertEqual(channel.json_body["total_room_count_estimate"], 2) - chunk, count = self.make_public_rooms_request(None, "test|test") + chunk, count = await self.make_public_rooms_request(None, "test|test") self.assertEqual(count, 0) - def test_returns_only_rooms_based_on_filter(self) -> None: - chunk, count = self.make_public_rooms_request([None]) + async def test_returns_only_rooms_based_on_filter(self) -> None: + chunk, count = await self.make_public_rooms_request([None]) self.assertEqual(count, 1) self.assertEqual(chunk[0].get("room_type", None), None) - chunk, count = self.make_public_rooms_request([None], "test|test") + chunk, count = await self.make_public_rooms_request([None], "test|test") self.assertEqual(count, 0) - def test_returns_only_space_based_on_filter(self) -> None: - chunk, count = self.make_public_rooms_request(["m.space"]) + async def test_returns_only_space_based_on_filter(self) -> None: + chunk, count = await self.make_public_rooms_request(["m.space"]) self.assertEqual(count, 1) self.assertEqual(chunk[0].get("room_type", None), "m.space") - chunk, count = self.make_public_rooms_request(["m.space"], "test|test") + chunk, count = await self.make_public_rooms_request(["m.space"], "test|test") self.assertEqual(count, 0) - def test_returns_both_rooms_and_space_based_on_filter(self) -> None: - chunk, count = self.make_public_rooms_request(["m.space", None]) + async def test_returns_both_rooms_and_space_based_on_filter(self) -> None: + chunk, count = await self.make_public_rooms_request(["m.space", None]) self.assertEqual(count, 2) - chunk, count = self.make_public_rooms_request(["m.space", None], "test|test") + chunk, count = await self.make_public_rooms_request(["m.space", None], "test|test") self.assertEqual(count, 0) - def test_returns_both_rooms_and_spaces_if_array_is_empty(self) -> None: - chunk, count = self.make_public_rooms_request([]) + async def test_returns_both_rooms_and_spaces_if_array_is_empty(self) -> None: + chunk, count = await self.make_public_rooms_request([]) self.assertEqual(count, 2) - chunk, count = self.make_public_rooms_request([], "test|test") + chunk, count = await self.make_public_rooms_request([], "test|test") self.assertEqual(count, 0) @@ -2781,22 +2781,22 @@ class PublicRoomsTestRemoteSearchFallbackTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: - return self.setup_test_homeserver(federation_client=AsyncMock()) + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + return await self.setup_test_homeserver(federation_client=AsyncMock()) - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.register_user("user", "pass") - self.token = self.login("user", "pass") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + await self.register_user("user", "pass") + self.token = await self.login("user", "pass") self.federation_client = hs.get_federation_client() - def test_simple(self) -> None: + async def test_simple(self) -> None: "Simple test for searching rooms over federation" self.federation_client.get_public_rooms.return_value = {} # type: ignore[attr-defined] search_filter = {PublicRoomsFilterFields.GENERIC_SEARCH_TERM: "foobar"} - channel = self.make_request( + channel = await self.make_request( "POST", b"/_matrix/client/r0/publicRooms?server=testserv", content={"filter": search_filter}, @@ -2813,7 +2813,7 @@ class PublicRoomsTestRemoteSearchFallbackTestCase(unittest.HomeserverTestCase): third_party_instance_id=None, ) - def test_fallback(self) -> None: + async def test_fallback(self) -> None: "Test that searching public rooms over federation falls back if it gets a 404" # The `get_public_rooms` should be called again if the first call fails @@ -2825,7 +2825,7 @@ class PublicRoomsTestRemoteSearchFallbackTestCase(unittest.HomeserverTestCase): search_filter = {PublicRoomsFilterFields.GENERIC_SEARCH_TERM: "foobar"} - channel = self.make_request( + channel = await self.make_request( "POST", b"/_matrix/client/r0/publicRooms?server=testserv", content={"filter": search_filter}, @@ -2863,21 +2863,21 @@ class PerRoomProfilesForbiddenTestCase(unittest.HomeserverTestCase): profile.register_servlets, ] - def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: + async def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: config = self.default_config() config["allow_per_room_profiles"] = False - self.hs = self.setup_test_homeserver(config=config) + self.hs = await self.setup_test_homeserver(config=config) return self.hs - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user_id = self.register_user("test", "test") - self.tok = self.login("test", "test") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user_id = await self.register_user("test", "test") + self.tok = await self.login("test", "test") # Set a profile for the test user self.displayname = "test user" request_data = {"displayname": self.displayname} - channel = self.make_request( + channel = await self.make_request( "PUT", "/_matrix/client/r0/profile/%s/displayname" % (self.user_id,), request_data, @@ -2885,11 +2885,11 @@ class PerRoomProfilesForbiddenTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self.room_id = self.helper.create_room_as(self.user_id, tok=self.tok) + self.room_id = await self.helper.create_room_as(self.user_id, tok=self.tok) - def test_per_room_profile_forbidden(self) -> None: + async def test_per_room_profile_forbidden(self) -> None: request_data = {"membership": "join", "displayname": "other test user"} - channel = self.make_request( + channel = await self.make_request( "PUT", "/_matrix/client/r0/rooms/%s/state/m.room.member/%s" % (self.room_id, self.user_id), @@ -2899,7 +2899,7 @@ class PerRoomProfilesForbiddenTestCase(unittest.HomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.result) event_id = channel.json_body["event_id"] - channel = self.make_request( + channel = await self.make_request( "GET", "/_matrix/client/r0/rooms/%s/event/%s" % (self.room_id, event_id), access_token=self.tok, @@ -2921,18 +2921,18 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.creator = self.register_user("creator", "test") - self.creator_tok = self.login("creator", "test") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.creator = await self.register_user("creator", "test") + self.creator_tok = await self.login("creator", "test") - self.second_user_id = self.register_user("second", "test") - self.second_tok = self.login("second", "test") + self.second_user_id = await self.register_user("second", "test") + self.second_tok = await self.login("second", "test") - self.room_id = self.helper.create_room_as(self.creator, tok=self.creator_tok) + self.room_id = await self.helper.create_room_as(self.creator, tok=self.creator_tok) - def test_join_reason(self) -> None: + async def test_join_reason(self) -> None: reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/join", content={"reason": reason}, @@ -2940,13 +2940,13 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_leave_reason(self) -> None: - self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) + async def test_leave_reason(self) -> None: + await self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/leave", content={"reason": reason}, @@ -2954,13 +2954,13 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_kick_reason(self) -> None: - self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) + async def test_kick_reason(self) -> None: + await self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/kick", content={"reason": reason, "user_id": self.second_user_id}, @@ -2968,13 +2968,13 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_ban_reason(self) -> None: - self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) + async def test_ban_reason(self) -> None: + await self.helper.join(self.room_id, user=self.second_user_id, tok=self.second_tok) reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/ban", content={"reason": reason, "user_id": self.second_user_id}, @@ -2982,11 +2982,11 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_unban_reason(self) -> None: + async def test_unban_reason(self) -> None: reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/unban", content={"reason": reason, "user_id": self.second_user_id}, @@ -2994,11 +2994,11 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_invite_reason(self) -> None: + async def test_invite_reason(self) -> None: reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/invite", content={"reason": reason, "user_id": self.second_user_id}, @@ -3006,10 +3006,10 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def test_reject_invite_reason(self) -> None: - self.helper.invite( + async def test_reject_invite_reason(self) -> None: + await self.helper.invite( self.room_id, src=self.creator, targ=self.second_user_id, @@ -3017,7 +3017,7 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) reason = "hello" - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/r0/rooms/{self.room_id}/leave", content={"reason": reason}, @@ -3025,10 +3025,10 @@ class RoomMembershipReasonTestCase(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, HTTPStatus.OK, channel.result) - self._check_for_reason(reason) + await self._check_for_reason(reason) - def _check_for_reason(self, reason: str) -> None: - channel = self.make_request( + async def _check_for_reason(self, reason: str) -> None: + channel = await self.make_request( "GET", "/_matrix/client/r0/rooms/{}/state/m.room.member/{}".format( self.room_id, self.second_user_id @@ -3053,10 +3053,10 @@ class RoomForgottenTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main - def test_room_not_forgotten_after_unban(self) -> None: + async def test_room_not_forgotten_after_unban(self) -> None: """ Test what happens when someone is banned from a room, they forget the room, and some time later are unbanned. @@ -3064,21 +3064,21 @@ class RoomForgottenTestCase(unittest.HomeserverTestCase): Currently, when they are unbanned, the room isn't forgotten anymore which may or may not be expected. """ - 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") + user1_id = await self.register_user("user1", "pass") + user1_tok = await self.login(user1_id, "pass") + user2_id = await self.register_user("user2", "pass") + user2_tok = await self.login(user2_id, "pass") - room_id = self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True) - self.helper.join(room_id, user1_id, tok=user1_tok) + room_id = await self.helper.create_room_as(user2_id, tok=user2_tok, is_public=True) + await self.helper.join(room_id, user1_id, tok=user1_tok) # User1 is banned and forgets the room - self.helper.ban(room_id, src=user2_id, targ=user1_id, tok=user2_tok) + await self.helper.ban(room_id, src=user2_id, targ=user1_id, tok=user2_tok) # User1 forgets the room - self.get_success(self.store.forget(user1_id, room_id)) + await self.get_success(self.store.forget(user1_id, room_id)) # The room should show up as forgotten - forgotten_room_ids = self.get_success( + forgotten_room_ids = await self.get_success( self.store.get_forgotten_rooms_for_user(user1_id) ) self.assertIncludes(forgotten_room_ids, {room_id}, exact=True) @@ -3098,7 +3098,7 @@ class RoomForgottenTestCase(unittest.HomeserverTestCase): # room forgotten status should only be reset when the user decides to join again # (or is invited/knocks). This way the room remains forgotten for any ban/leave # transitions. - forgotten_room_ids = self.get_success( + forgotten_room_ids = await self.get_success( self.store.get_forgotten_rooms_for_user(user1_id) ) self.assertIncludes(forgotten_room_ids, set(), exact=True) @@ -3130,16 +3130,16 @@ class LabelsTestCase(unittest.HomeserverTestCase): "org.matrix.not_labels": ["#notfun"], } - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user_id = self.register_user("test", "test") - self.tok = self.login("test", "test") - self.room_id = self.helper.create_room_as(self.user_id, tok=self.tok) + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user_id = await self.register_user("test", "test") + self.tok = await self.login("test", "test") + self.room_id = await self.helper.create_room_as(self.user_id, tok=self.tok) - def test_context_filter_labels(self) -> None: + async def test_context_filter_labels(self) -> None: """Test that we can filter by a label on a /context request.""" - event_id = self._send_labelled_messages_in_room() + event_id = await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/context/%s?filter=%s" % (self.room_id, event_id, json.dumps(self.FILTER_LABELS)), @@ -3165,11 +3165,11 @@ class LabelsTestCase(unittest.HomeserverTestCase): events_after[0]["content"]["body"], "with right label", events_after[0] ) - def test_context_filter_not_labels(self) -> None: + async def test_context_filter_not_labels(self) -> None: """Test that we can filter by the absence of a label on a /context request.""" - event_id = self._send_labelled_messages_in_room() + event_id = await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/context/%s?filter=%s" % (self.room_id, event_id, json.dumps(self.FILTER_NOT_LABELS)), @@ -3198,13 +3198,13 @@ class LabelsTestCase(unittest.HomeserverTestCase): events_after[1]["content"]["body"], "with two wrong labels", events_after[1] ) - def test_context_filter_labels_not_labels(self) -> None: + async def test_context_filter_labels_not_labels(self) -> None: """Test that we can filter by both a label and the absence of another label on a /context request. """ - event_id = self._send_labelled_messages_in_room() + event_id = await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/context/%s?filter=%s" % (self.room_id, event_id, json.dumps(self.FILTER_LABELS_NOT_LABELS)), @@ -3227,12 +3227,12 @@ class LabelsTestCase(unittest.HomeserverTestCase): events_after[0]["content"]["body"], "with wrong label", events_after[0] ) - def test_messages_filter_labels(self) -> None: + async def test_messages_filter_labels(self) -> None: """Test that we can filter by a label on a /messages request.""" - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() token = "s0_0_0_0_0_0_0_0_0_0" - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=%s&from=%s&filter=%s" % (self.room_id, self.tok, token, json.dumps(self.FILTER_LABELS)), @@ -3244,12 +3244,12 @@ class LabelsTestCase(unittest.HomeserverTestCase): self.assertEqual(events[0]["content"]["body"], "with right label", events[0]) self.assertEqual(events[1]["content"]["body"], "with right label", events[1]) - def test_messages_filter_not_labels(self) -> None: + async def test_messages_filter_not_labels(self) -> None: """Test that we can filter by the absence of a label on a /messages request.""" - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() token = "s0_0_0_0_0_0_0_0_0_0" - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=%s&from=%s&filter=%s" % (self.room_id, self.tok, token, json.dumps(self.FILTER_NOT_LABELS)), @@ -3265,14 +3265,14 @@ class LabelsTestCase(unittest.HomeserverTestCase): events[3]["content"]["body"], "with two wrong labels", events[3] ) - def test_messages_filter_labels_not_labels(self) -> None: + async def test_messages_filter_labels_not_labels(self) -> None: """Test that we can filter by both a label and the absence of another label on a /messages request. """ - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() token = "s0_0_0_0_0_0_0_0_0_0" - channel = self.make_request( + channel = await self.make_request( "GET", "/rooms/%s/messages?access_token=%s&from=%s&filter=%s" % ( @@ -3288,7 +3288,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): self.assertEqual(len(events), 1, [event["content"] for event in events]) self.assertEqual(events[0]["content"]["body"], "with wrong label", events[0]) - def test_search_filter_labels(self) -> None: + async def test_search_filter_labels(self) -> None: """Test that we can filter by a label on a /search request.""" request_data = { "search_categories": { @@ -3299,9 +3299,9 @@ class LabelsTestCase(unittest.HomeserverTestCase): } } - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "POST", "/search?access_token=%s" % self.tok, request_data ) @@ -3323,7 +3323,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): results[1]["result"]["content"]["body"], ) - def test_search_filter_not_labels(self) -> None: + async def test_search_filter_not_labels(self) -> None: """Test that we can filter by the absence of a label on a /search request.""" request_data = { "search_categories": { @@ -3334,9 +3334,9 @@ class LabelsTestCase(unittest.HomeserverTestCase): } } - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "POST", "/search?access_token=%s" % self.tok, request_data ) @@ -3368,7 +3368,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): results[3]["result"]["content"]["body"], ) - def test_search_filter_labels_not_labels(self) -> None: + async def test_search_filter_labels_not_labels(self) -> None: """Test that we can filter by both a label and the absence of another label on a /search request. """ @@ -3381,9 +3381,9 @@ class LabelsTestCase(unittest.HomeserverTestCase): } } - self._send_labelled_messages_in_room() + await self._send_labelled_messages_in_room() - channel = self.make_request( + channel = await self.make_request( "POST", "/search?access_token=%s" % self.tok, request_data ) @@ -3400,13 +3400,13 @@ class LabelsTestCase(unittest.HomeserverTestCase): results[0]["result"]["content"]["body"], ) - def _send_labelled_messages_in_room(self) -> str: + async def _send_labelled_messages_in_room(self) -> str: """Sends several messages to a room with different labels (or without any) to test filtering by label. Returns: The ID of the event to use if we're testing filtering on /context. """ - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={ @@ -3417,14 +3417,14 @@ class LabelsTestCase(unittest.HomeserverTestCase): tok=self.tok, ) - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={"msgtype": "m.text", "body": "without label"}, tok=self.tok, ) - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={"msgtype": "m.text", "body": "without label"}, @@ -3433,7 +3433,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): # Return this event's ID when we test filtering in /context requests. event_id = res["event_id"] - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={ @@ -3444,7 +3444,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): tok=self.tok, ) - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={ @@ -3455,7 +3455,7 @@ class LabelsTestCase(unittest.HomeserverTestCase): tok=self.tok, ) - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={ @@ -3470,12 +3470,12 @@ class LabelsTestCase(unittest.HomeserverTestCase): class RelationsTestCase(PaginationTestCase): - def _filter_messages(self, filter: JsonDict) -> list[str]: + async def _filter_messages(self, filter: JsonDict) -> list[str]: """Make a request to /messages with a filter, returns the chunk of events.""" - from_token = self.get_success( + from_token = await self.get_success( self.from_token.to_string(self.hs.get_datastores().main) ) - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{self.room_id}/messages?filter={json.dumps(filter)}&dir=f&from={from_token}", access_token=self.tok, @@ -3493,35 +3493,35 @@ class ContextTestCase(unittest.HomeserverTestCase): account.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user_id = self.register_user("user", "password") - self.tok = self.login("user", "password") - self.room_id = self.helper.create_room_as( + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user_id = await self.register_user("user", "password") + self.tok = await self.login("user", "password") + self.room_id = await self.helper.create_room_as( self.user_id, tok=self.tok, is_public=False ) - self.other_user_id = self.register_user("user2", "password") - self.other_tok = self.login("user2", "password") + self.other_user_id = await self.register_user("user2", "password") + self.other_tok = await self.login("user2", "password") - self.helper.invite(self.room_id, self.user_id, self.other_user_id, tok=self.tok) - self.helper.join(self.room_id, self.other_user_id, tok=self.other_tok) + await self.helper.invite(self.room_id, self.user_id, self.other_user_id, tok=self.tok) + await self.helper.join(self.room_id, self.other_user_id, tok=self.other_tok) - def test_erased_sender(self) -> None: + async def test_erased_sender(self) -> None: """Test that an erasure request results in the requester's events being hidden from any new member of the room. """ # Send a bunch of events in the room. - self.helper.send(self.room_id, "message 1", tok=self.tok) - self.helper.send(self.room_id, "message 2", tok=self.tok) - event_id = self.helper.send(self.room_id, "message 3", tok=self.tok)["event_id"] - self.helper.send(self.room_id, "message 4", tok=self.tok) - self.helper.send(self.room_id, "message 5", tok=self.tok) + await self.helper.send(self.room_id, "message 1", tok=self.tok) + await self.helper.send(self.room_id, "message 2", tok=self.tok) + event_id = await self.helper.send(self.room_id, "message 3", tok=self.tok)["event_id"] + await self.helper.send(self.room_id, "message 4", tok=self.tok) + await self.helper.send(self.room_id, "message 5", tok=self.tok) # Check that we can still see the messages before the erasure request. - channel = self.make_request( + channel = await self.make_request( "GET", '/rooms/%s/context/%s?filter={"types":["m.room.message"]}' % (self.room_id, event_id), @@ -3566,7 +3566,7 @@ class ContextTestCase(unittest.HomeserverTestCase): # Deactivate the first account and erase the user's data. deactivate_account_handler = self.hs.get_deactivate_account_handler() - self.get_success( + await self.get_success( deactivate_account_handler.deactivate_account( self.user_id, True, create_requester(self.user_id) ) @@ -3576,18 +3576,18 @@ class ContextTestCase(unittest.HomeserverTestCase): # pruned only if the user wasn't a member of the room when the messages were # sent. - invited_user_id = self.register_user("user3", "password") - invited_tok = self.login("user3", "password") + invited_user_id = await self.register_user("user3", "password") + invited_tok = await self.login("user3", "password") - self.helper.invite( + await self.helper.invite( self.room_id, self.other_user_id, invited_user_id, tok=self.other_tok ) - self.helper.join(self.room_id, invited_user_id, tok=invited_tok) + await self.helper.join(self.room_id, invited_user_id, tok=invited_tok) # Check that a user that joined the room after the erasure request can't see # the messages anymore. - channel = self.make_request( + channel = await self.make_request( "GET", '/rooms/%s/context/%s?filter={"types":["m.room.message"]}' % (self.room_id, event_id), @@ -3611,14 +3611,14 @@ class ContextTestCase(unittest.HomeserverTestCase): self.assertDictEqual(events_after[0].get("content"), {}, events_after[0]) self.assertEqual(events_after[1].get("content"), {}, events_after[1]) - def test_room_event_context_filter_query_validation(self) -> None: + async def test_room_event_context_filter_query_validation(self) -> None: # Test json validation in (filter) query parameter. # Does not test the validity of the filter, only the json validation. - event_id = self.helper.send(self.room_id, "message 7", tok=self.tok)["event_id"] + event_id = await self.helper.send(self.room_id, "message 7", tok=self.tok)["event_id"] # Check Get with valid json filter parameter, expect 200. valid_filter_str = '{"types": ["m.room.message"]}' - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{self.room_id}/context/{event_id}?filter={valid_filter_str}", access_token=self.tok, @@ -3627,7 +3627,7 @@ class ContextTestCase(unittest.HomeserverTestCase): # Check Get with invalid json filter parameter, expect 400 NOT_JSON. invalid_filter_str = "}}}{}" - channel = self.make_request( + channel = await self.make_request( "GET", f"/rooms/{self.room_id}/context/{event_id}?filter={invalid_filter_str}", access_token=self.tok, @@ -3647,64 +3647,64 @@ class RoomAliasListTestCase(unittest.HomeserverTestCase): room.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_owner = self.register_user("room_owner", "test") - self.room_owner_tok = self.login("room_owner", "test") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_owner = await self.register_user("room_owner", "test") + self.room_owner_tok = await self.login("room_owner", "test") - self.room_id = self.helper.create_room_as( + self.room_id = await self.helper.create_room_as( self.room_owner, tok=self.room_owner_tok ) - def test_no_aliases(self) -> None: - res = self._get_aliases(self.room_owner_tok) + async def test_no_aliases(self) -> None: + res = await self._get_aliases(self.room_owner_tok) self.assertEqual(res["aliases"], []) - def test_not_in_room(self) -> None: - self.register_user("user", "test") - user_tok = self.login("user", "test") - res = self._get_aliases(user_tok, expected_code=403) + async def test_not_in_room(self) -> None: + await self.register_user("user", "test") + user_tok = await self.login("user", "test") + res = await self._get_aliases(user_tok, expected_code=403) self.assertEqual(res["errcode"], "M_FORBIDDEN") - def test_admin_user(self) -> None: + async def test_admin_user(self) -> None: alias1 = self._random_alias() - self._set_alias_via_directory(alias1) + await self._set_alias_via_directory(alias1) - self.register_user("user", "test", admin=True) - user_tok = self.login("user", "test") + await self.register_user("user", "test", admin=True) + user_tok = await self.login("user", "test") - res = self._get_aliases(user_tok) + res = await self._get_aliases(user_tok) self.assertEqual(res["aliases"], [alias1]) - def test_with_aliases(self) -> None: + async def test_with_aliases(self) -> None: alias1 = self._random_alias() alias2 = self._random_alias() - self._set_alias_via_directory(alias1) - self._set_alias_via_directory(alias2) + await self._set_alias_via_directory(alias1) + await self._set_alias_via_directory(alias2) - res = self._get_aliases(self.room_owner_tok) + res = await self._get_aliases(self.room_owner_tok) self.assertEqual(set(res["aliases"]), {alias1, alias2}) - def test_peekable_room(self) -> None: + async def test_peekable_room(self) -> None: alias1 = self._random_alias() - self._set_alias_via_directory(alias1) + await self._set_alias_via_directory(alias1) - self.helper.send_state( + await self.helper.send_state( self.room_id, EventTypes.RoomHistoryVisibility, body={"history_visibility": "world_readable"}, tok=self.room_owner_tok, ) - self.register_user("user", "test") - user_tok = self.login("user", "test") + await self.register_user("user", "test") + user_tok = await self.login("user", "test") - res = self._get_aliases(user_tok) + res = await self._get_aliases(user_tok) self.assertEqual(res["aliases"], [alias1]) - def _get_aliases(self, access_token: str, expected_code: int = 200) -> JsonDict: + async def _get_aliases(self, access_token: str, expected_code: int = 200) -> JsonDict: """Calls the endpoint under test. returns the json response object.""" - channel = self.make_request( + channel = await self.make_request( "GET", "/_matrix/client/r0/rooms/%s/aliases" % (self.room_id,), access_token=access_token, @@ -3719,11 +3719,11 @@ class RoomAliasListTestCase(unittest.HomeserverTestCase): def _random_alias(self) -> str: return RoomAlias(random_string(5), self.hs.hostname).to_string() - def _set_alias_via_directory(self, alias: str, expected_code: int = 200) -> None: + async def _set_alias_via_directory(self, alias: str, expected_code: int = 200) -> None: url = "/_matrix/client/r0/directory/room/" + alias request_data = {"room_id": self.room_id} - channel = self.make_request( + channel = await self.make_request( "PUT", url, request_data, access_token=self.room_owner_tok ) self.assertEqual(channel.code, expected_code, channel.result) @@ -3737,29 +3737,29 @@ class RoomCanonicalAliasTestCase(unittest.HomeserverTestCase): room.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.room_owner = self.register_user("room_owner", "test") - self.room_owner_tok = self.login("room_owner", "test") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.room_owner = await self.register_user("room_owner", "test") + self.room_owner_tok = await self.login("room_owner", "test") - self.room_id = self.helper.create_room_as( + self.room_id = await self.helper.create_room_as( self.room_owner, tok=self.room_owner_tok ) self.alias = "#alias:test" - self._set_alias_via_directory(self.alias) + await self._set_alias_via_directory(self.alias) - def _set_alias_via_directory(self, alias: str, expected_code: int = 200) -> None: + async def _set_alias_via_directory(self, alias: str, expected_code: int = 200) -> None: url = "/_matrix/client/r0/directory/room/" + alias request_data = {"room_id": self.room_id} - channel = self.make_request( + channel = await self.make_request( "PUT", url, request_data, access_token=self.room_owner_tok ) self.assertEqual(channel.code, expected_code, channel.result) - def _get_canonical_alias(self, expected_code: int = 200) -> JsonDict: + async def _get_canonical_alias(self, expected_code: int = 200) -> JsonDict: """Calls the endpoint under test. returns the json response object.""" - channel = self.make_request( + channel = await self.make_request( "GET", "rooms/%s/state/m.room.canonical_alias" % (self.room_id,), access_token=self.room_owner_tok, @@ -3769,11 +3769,11 @@ class RoomCanonicalAliasTestCase(unittest.HomeserverTestCase): self.assertIsInstance(res, dict) return res - def _set_canonical_alias( + async def _set_canonical_alias( self, content: JsonDict, expected_code: int = 200 ) -> JsonDict: """Calls the endpoint under test. returns the json response object.""" - channel = self.make_request( + channel = await self.make_request( "PUT", "rooms/%s/state/m.room.canonical_alias" % (self.room_id,), content, @@ -3784,109 +3784,109 @@ class RoomCanonicalAliasTestCase(unittest.HomeserverTestCase): self.assertIsInstance(res, dict) return res - def test_canonical_alias(self) -> None: + async def test_canonical_alias(self) -> None: """Test a basic alias message.""" # There is no canonical alias to start with. - self._get_canonical_alias(expected_code=404) + await self._get_canonical_alias(expected_code=404) # Create an alias. - self._set_canonical_alias({"alias": self.alias}) + await self._set_canonical_alias({"alias": self.alias}) # Canonical alias now exists! - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {"alias": self.alias}) # Now remove the alias. - self._set_canonical_alias({}) + await self._set_canonical_alias({}) # There is an alias event, but it is empty. - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {}) - def test_alt_aliases(self) -> None: + async def test_alt_aliases(self) -> None: """Test a canonical alias message with alt_aliases.""" # Create an alias. - self._set_canonical_alias({"alt_aliases": [self.alias]}) + await self._set_canonical_alias({"alt_aliases": [self.alias]}) # Canonical alias now exists! - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {"alt_aliases": [self.alias]}) # Now remove the alt_aliases. - self._set_canonical_alias({}) + await self._set_canonical_alias({}) # There is an alias event, but it is empty. - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {}) - def test_alias_alt_aliases(self) -> None: + async def test_alias_alt_aliases(self) -> None: """Test a canonical alias message with an alias and alt_aliases.""" # Create an alias. - self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) + await self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) # Canonical alias now exists! - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {"alias": self.alias, "alt_aliases": [self.alias]}) # Now remove the alias and alt_aliases. - self._set_canonical_alias({}) + await self._set_canonical_alias({}) # There is an alias event, but it is empty. - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {}) - def test_partial_modify(self) -> None: + async def test_partial_modify(self) -> None: """Test removing only the alt_aliases.""" # Create an alias. - self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) + await self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) # Canonical alias now exists! - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {"alias": self.alias, "alt_aliases": [self.alias]}) # Now remove the alt_aliases. - self._set_canonical_alias({"alias": self.alias}) + await self._set_canonical_alias({"alias": self.alias}) # There is an alias event, but it is empty. - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual(res, {"alias": self.alias}) - def test_add_alias(self) -> None: + async def test_add_alias(self) -> None: """Test removing only the alt_aliases.""" # Create an additional alias. second_alias = "#second:test" - self._set_alias_via_directory(second_alias) + await self._set_alias_via_directory(second_alias) # Add the canonical alias. - self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) + await self._set_canonical_alias({"alias": self.alias, "alt_aliases": [self.alias]}) # Then add the second alias. - self._set_canonical_alias( + await self._set_canonical_alias( {"alias": self.alias, "alt_aliases": [self.alias, second_alias]} ) # Canonical alias now exists! - res = self._get_canonical_alias() + res = await self._get_canonical_alias() self.assertEqual( res, {"alias": self.alias, "alt_aliases": [self.alias, second_alias]} ) - def test_bad_data(self) -> None: + async def test_bad_data(self) -> None: """Invalid data for alt_aliases should cause errors.""" - self._set_canonical_alias({"alt_aliases": "@bad:test"}, expected_code=400) - self._set_canonical_alias({"alt_aliases": None}, expected_code=400) - self._set_canonical_alias({"alt_aliases": 0}, expected_code=400) - self._set_canonical_alias({"alt_aliases": 1}, expected_code=400) - self._set_canonical_alias({"alt_aliases": False}, expected_code=400) - self._set_canonical_alias({"alt_aliases": True}, expected_code=400) - self._set_canonical_alias({"alt_aliases": {}}, expected_code=400) - self._set_canonical_alias({"alt_aliases": [0]}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": "@bad:test"}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": None}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": 0}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": 1}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": False}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": True}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": {}}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": [0]}, expected_code=400) - def test_bad_alias(self) -> None: + async def test_bad_alias(self) -> None: """An alias which does not point to the room raises a SynapseError.""" - self._set_canonical_alias({"alias": {"@unknown:test": "a"}}, expected_code=400) - self._set_canonical_alias({"alias": "@unknown:test"}, expected_code=400) - self._set_canonical_alias({"alt_aliases": ["@unknown:test"]}, expected_code=400) + await self._set_canonical_alias({"alias": {"@unknown:test": "a"}}, expected_code=400) + await self._set_canonical_alias({"alias": "@unknown:test"}, expected_code=400) + await self._set_canonical_alias({"alt_aliases": ["@unknown:test"]}, expected_code=400) class ThreepidInviteTestCase(unittest.HomeserverTestCase): @@ -3896,13 +3896,13 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): room.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user_id = self.register_user("thomas", "hackme") - self.tok = self.login("thomas", "hackme") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user_id = await self.register_user("thomas", "hackme") + self.tok = await self.login("thomas", "hackme") - self.room_id = self.helper.create_room_as(self.user_id, tok=self.tok) + self.room_id = await self.helper.create_room_as(self.user_id, tok=self.tok) - def test_threepid_invite_spamcheck_deprecated(self) -> None: + async def test_threepid_invite_spamcheck_deprecated(self) -> None: """ Test allowing/blocking threepid invites with a spam-check module. @@ -3928,7 +3928,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Send a 3PID invite into the room and check that it succeeded. email_to_invite = "teresa@example.com" - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -3950,7 +3950,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Now change the return value of the callback to deny any invite and test that # we can't send the invite. mock.return_value = False - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -3966,7 +3966,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Also check that it stopped before calling _make_and_store_3pid_invite. make_invite_mock.assert_called_once() - def test_threepid_invite_spamcheck(self) -> None: + async def test_threepid_invite_spamcheck(self) -> None: """ Test allowing/blocking threepid invites with a spam-check module. @@ -3995,7 +3995,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Send a 3PID invite into the room and check that it succeeded. email_to_invite = "teresa@example.com" - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -4018,7 +4018,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # we can't send the invite. We pick an arbitrary error code to be able to check # that the same code has been returned mock.return_value = Codes.CONSENT_NOT_GIVEN - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -4037,7 +4037,7 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Run variant with `Tuple[Codes, dict]`. mock.return_value = (Codes.EXPIRED_ACCOUNT, {"field": "value"}) - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -4055,12 +4055,12 @@ class ThreepidInviteTestCase(unittest.HomeserverTestCase): # Also check that it stopped before calling _make_and_store_3pid_invite. make_invite_mock.assert_called_once() - def test_400_missing_param_without_id_access_token(self) -> None: + async def test_400_missing_param_without_id_access_token(self) -> None: """ Test that a 3pid invite request returns 400 M_MISSING_PARAM if we do not include id_access_token. """ - channel = self.make_request( + channel = await self.make_request( method="POST", path="/rooms/" + self.room_id + "/invite", content={ @@ -4081,14 +4081,14 @@ class TimestampLookupTestCase(unittest.HomeserverTestCase): login.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self._storage_controllers = self.hs.get_storage_controllers() - self.room_owner = self.register_user("room_owner", "test") - self.room_owner_tok = self.login("room_owner", "test") + self.room_owner = await self.register_user("room_owner", "test") + self.room_owner_tok = await self.login("room_owner", "test") - def _inject_outlier(self, room_id: str) -> EventBase: - event, _context = self.get_success( + async def _inject_outlier(self, room_id: str) -> EventBase: + event, _context = await self.get_success( create_event( self.hs, room_id=room_id, @@ -4100,14 +4100,14 @@ class TimestampLookupTestCase(unittest.HomeserverTestCase): event.internal_metadata.outlier = True persistence = self._storage_controllers.persistence assert persistence is not None - self.get_success( + await self.get_success( persistence.persist_event( event, EventContext.for_outlier(self._storage_controllers) ) ) return event - def test_no_outliers(self) -> None: + async def test_no_outliers(self) -> None: """ Test to make sure `/timestamp_to_event` does not return `outlier` events. We're unable to determine whether an `outlier` is next to a gap so we @@ -4118,11 +4118,11 @@ class TimestampLookupTestCase(unittest.HomeserverTestCase): `outlier`. Since the gap checking logic considers the latest message in the room as *not* next to a gap, asking over federation does not come into play here. """ - room_id = self.helper.create_room_as(self.room_owner, tok=self.room_owner_tok) + room_id = await self.helper.create_room_as(self.room_owner, tok=self.room_owner_tok) - outlier_event = self._inject_outlier(room_id) + outlier_event = await self._inject_outlier(room_id) - channel = self.make_request( + channel = await self.make_request( "GET", f"/_matrix/client/v1/rooms/{room_id}/timestamp_to_event?dir=b&ts={outlier_event.origin_server_ts}", access_token=self.room_owner_tok, @@ -4141,36 +4141,36 @@ class UserSuspensionTests(unittest.HomeserverTestCase): profile.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user1 = self.register_user("thomas", "hackme") - self.tok1 = self.login("thomas", "hackme") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user1 = await self.register_user("thomas", "hackme") + self.tok1 = await self.login("thomas", "hackme") - self.user2 = self.register_user("teresa", "hackme") - self.tok2 = self.login("teresa", "hackme") + self.user2 = await self.register_user("teresa", "hackme") + self.tok2 = await self.login("teresa", "hackme") - self.admin = self.register_user("admin", "pass", True) - self.admin_tok = self.login("admin", "pass") + self.admin = await self.register_user("admin", "pass", True) + self.admin_tok = await self.login("admin", "pass") - self.room1 = self.helper.create_room_as( + self.room1 = await self.helper.create_room_as( room_creator=self.user1, tok=self.tok1, room_version="11" ) self.store = hs.get_datastores().main - self.room2 = self.helper.create_room_as( + self.room2 = await self.helper.create_room_as( room_creator=self.user1, is_public=False, tok=self.tok1 ) - self.helper.send_state( + await self.helper.send_state( self.room2, EventTypes.RoomEncryption, {EventContentFields.ENCRYPTION_ALGORITHM: "m.megolm.v1.aes-sha2"}, tok=self.tok1, ) - def test_suspended_user_cannot_send_message_to_public_room(self) -> None: + async def test_suspended_user_cannot_send_message_to_public_room(self) -> None: # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) - channel = self.make_request( + channel = await self.make_request( "PUT", f"/rooms/{self.room1}/send/m.room.message/1", access_token=self.tok1, @@ -4178,8 +4178,8 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_cannot_send_message_to_encrypted_room(self) -> None: - channel = self.make_request( + async def test_suspended_user_cannot_send_message_to_encrypted_room(self) -> None: + channel = await self.make_request( "PUT", f"/_synapse/admin/v1/suspend/{self.user1}", {"suspend": True}, @@ -4188,7 +4188,7 @@ class UserSuspensionTests(unittest.HomeserverTestCase): self.assertEqual(channel.code, 200) self.assertEqual(channel.json_body, {f"user_{self.user1}_suspended": True}) - channel = self.make_request( + channel = await self.make_request( "PUT", f"/rooms/{self.room2}/send/m.room.encrypted/1", access_token=self.tok1, @@ -4196,11 +4196,11 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_cannot_change_profile_data(self) -> None: + async def test_suspended_user_cannot_change_profile_data(self) -> None: # set the user as suspended - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) - channel = self.make_request( + channel = await self.make_request( "PUT", f"/_matrix/client/v3/profile/{self.user1}/avatar_url", access_token=self.tok1, @@ -4209,7 +4209,7 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - channel2 = self.make_request( + channel2 = await self.make_request( "PUT", f"/_matrix/client/v3/profile/{self.user1}/displayname", access_token=self.tok1, @@ -4218,10 +4218,10 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel2.json_body["errcode"], "M_USER_SUSPENDED") - def test_suspended_user_cannot_redact_messages_other_than_their_own(self) -> None: + async def test_suspended_user_cannot_redact_messages_other_than_their_own(self) -> None: # first user sends message - self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok2) - res = self.helper.send_event( + await self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok2) + res = await self.helper.send_event( self.room1, "m.room.message", {"body": "hello", "msgtype": "m.text"}, @@ -4230,8 +4230,8 @@ class UserSuspensionTests(unittest.HomeserverTestCase): event_id = res["event_id"] # second user sends message - self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok1) - res2 = self.helper.send_event( + await self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok1) + res2 = await self.helper.send_event( self.room1, "m.room.message", {"body": "bad_message", "msgtype": "m.text"}, @@ -4240,10 +4240,10 @@ class UserSuspensionTests(unittest.HomeserverTestCase): event_id2 = res2["event_id"] # set the second user as suspended - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) # second user can't redact first user's message - channel = self.make_request( + channel = await self.make_request( "PUT", f"/_matrix/client/v3/rooms/{self.room1}/redact/{event_id}/1", access_token=self.tok1, @@ -4253,7 +4253,7 @@ class UserSuspensionTests(unittest.HomeserverTestCase): self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") # but can redact their own - channel = self.make_request( + channel = await self.make_request( "PUT", f"/_matrix/client/v3/rooms/{self.room1}/redact/{event_id2}/1", access_token=self.tok1, @@ -4262,7 +4262,7 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, 200) - channel = self.make_request( + channel = await self.make_request( "PUT", f"/_matrix/client/v3/rooms/{self.room1}/send/m.room.redaction/3456346", access_token=self.tok1, @@ -4271,7 +4271,7 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") - channel = self.make_request( + channel = await self.make_request( "PUT", f"/_matrix/client/v3/rooms/{self.room1}/send/m.room.redaction/3456346", access_token=self.tok1, @@ -4280,15 +4280,15 @@ class UserSuspensionTests(unittest.HomeserverTestCase): ) self.assertEqual(channel.code, 200) - def test_suspended_user_cannot_ban_others(self) -> None: + async def test_suspended_user_cannot_ban_others(self) -> None: # user to ban joins room user1 created - self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok2) + await self.make_request("POST", f"/rooms/{self.room1}/join", access_token=self.tok2) # suspend user1 - self.get_success(self.store.set_user_suspended_status(self.user1, True)) + await self.get_success(self.store.set_user_suspended_status(self.user1, True)) # user1 tries to ban other user while suspended - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/v3/rooms/{self.room1}/ban", access_token=self.tok1, @@ -4298,10 +4298,10 @@ class UserSuspensionTests(unittest.HomeserverTestCase): self.assertEqual(channel.json_body["errcode"], "M_USER_SUSPENDED") # un-suspend user1 - self.get_success(self.store.set_user_suspended_status(self.user1, False)) + await self.get_success(self.store.set_user_suspended_status(self.user1, False)) # ban now goes through - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/v3/rooms/{self.room1}/ban", access_token=self.tok1, @@ -4319,14 +4319,14 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): admin.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - self.user1 = self.register_user("thomas", "hackme") - self.tok1 = self.login("thomas", "hackme") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + self.user1 = await self.register_user("thomas", "hackme") + self.tok1 = await self.login("thomas", "hackme") - self.user2 = self.register_user("teresa", "hackme") - self.tok2 = self.login("teresa", "hackme") + self.user2 = await self.register_user("teresa", "hackme") + self.tok2 = await self.login("teresa", "hackme") - self.room1 = self.helper.create_room_as( + self.room1 = await self.helper.create_room_as( room_creator=self.user1, tok=self.tok1, # Allow user2 to send state events into the room. @@ -4400,7 +4400,7 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): ), ] ) - def test_sending_message_records_participation( + async def test_sending_message_records_participation( self, is_state: bool, event_type: str, @@ -4411,10 +4411,10 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): Test that sending an various events into a room causes the user to appropriately marked or not marked as a participant in that room. """ - self.helper.join(self.room1, self.user2, tok=self.tok2) + await self.helper.join(self.room1, self.user2, tok=self.tok2) # user has not sent any messages, so should not be a participant - participant = self.get_success( + participant = await self.get_success( self.store.get_room_participation(self.user2, self.room1) ) self.assertFalse(participant) @@ -4422,7 +4422,7 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): # send an event into the room if is_state: # send a state event - self.helper.send_state( + await self.helper.send_state( self.room1, event_type, body=event_content, @@ -4430,7 +4430,7 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): ) else: # send a non-state event - self.helper.send_event( + await self.helper.send_event( self.room1, event_type, content=event_content, @@ -4438,7 +4438,7 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): ) # check whether the user has been marked as a participant - participant = self.get_success( + participant = await self.get_success( self.store.get_room_participation(self.user2, self.room1) ) self.assertEqual(participant, record_participation) @@ -4464,7 +4464,7 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): ), ] ) - def test_sending_event_and_leaving_does_not_record_participation( + async def test_sending_event_and_leaving_does_not_record_participation( self, event_type: str, event_content: JsonDict, @@ -4474,31 +4474,31 @@ class RoomParticipantTestCase(unittest.HomeserverTestCase): participant, but then leaving the room, results in the user no longer be marked as a participant in that room. """ - self.helper.join(self.room1, self.user2, tok=self.tok2) + await self.helper.join(self.room1, self.user2, tok=self.tok2) # user has not sent any messages, so should not be a participant - participant = self.get_success( + participant = await self.get_success( self.store.get_room_participation(self.user2, self.room1) ) self.assertFalse(participant) # sending a message should now mark user as participant - self.helper.send_event( + await self.helper.send_event( self.room1, event_type, content=event_content, tok=self.tok2, ) - participant = self.get_success( + participant = await self.get_success( self.store.get_room_participation(self.user2, self.room1) ) self.assertTrue(participant) # leave the room - self.helper.leave(self.room1, self.user2, tok=self.tok2) + await self.helper.leave(self.room1, self.user2, tok=self.tok2) # user should no longer be considered a participant - participant = self.get_success( + participant = await self.get_success( self.store.get_room_participation(self.user2, self.room1) ) self.assertFalse(participant) @@ -4512,15 +4512,15 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): admin.register_servlets, ] - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: - super().prepare(reactor, clock, hs) - self.creator = self.register_user("creator", "test") - self.creator_tok = self.login("creator", "test") + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + await super().prepare(reactor, clock, hs) + self.creator = await self.register_user("creator", "test") + self.creator_tok = await self.login("creator", "test") - self.bad_user_id = self.register_user("bad", "test") - self.bad_tok = self.login("bad", "test") + self.bad_user_id = await self.register_user("bad", "test") + self.bad_tok = await self.login("bad", "test") - self.room_id = self.helper.create_room_as(self.creator, tok=self.creator_tok) + self.room_id = await self.helper.create_room_as(self.creator, tok=self.creator_tok) self.store = hs.get_datastores().main self._storage_controllers = hs.get_storage_controllers() @@ -4589,20 +4589,20 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # all provided events should not have been redacted self.assertEqual(unredacted_events, len(original_events)) - def test_banning_local_member_with_flag_redacts_their_events(self) -> None: - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + async def test_banning_local_member_with_flag_redacts_their_events(self) -> None: + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages originals = [] for i in range(5): event = {"body": f"bothersome noise {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) originals.append(res["event_id"]) # grab original events for comparison - original_events = [self.get_success(self.store.get_event(x)) for x in originals] + original_events = [await self.get_success(self.store.get_event(x)) for x in originals] # creator bans user with redaction flag set content = { @@ -4619,7 +4619,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4632,7 +4632,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): reason="flooding", ) - def test_banning_remote_member_with_flag_redacts_their_events(self) -> None: + async def test_banning_remote_member_with_flag_redacts_their_events(self) -> None: bad_user = "@remote_bad_user:" + self.OTHER_SERVER_NAME channel = self.make_signed_federation_request( "GET", @@ -4654,7 +4654,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member - r = self.get_success( + r = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(r[("m.room.member", bad_user)].membership, "join") @@ -4682,7 +4682,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -4700,7 +4700,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ban_event_id = res["event_id"] filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4733,7 +4733,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -4743,7 +4743,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # pull them from the db to check because they should be soft-failed and thus not available over # cs-api for message in new_original_messages: - original = self.get_success(self.store.get_event(message.event_id)) + original = await self.get_success(self.store.get_event(message.event_id)) if not original: self.fail("Expected to find remote message in DB") redacted_because = original.unsigned.get("redacted_because") @@ -4751,7 +4751,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.fail("Did not find redacted_because field") self.assertEqual(redacted_because.event_id, ban_event_id) - def test_unbanning_remote_user_stops_redaction_action(self) -> None: + async def test_unbanning_remote_user_stops_redaction_action(self) -> None: bad_user = "@remote_bad_user:" + self.OTHER_SERVER_NAME channel = self.make_signed_federation_request( "GET", @@ -4773,7 +4773,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member - r = self.get_success( + r = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(r[("m.room.member", bad_user)].membership, "join") @@ -4801,7 +4801,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -4818,7 +4818,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4857,12 +4857,12 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member again - new_state = self.get_success( + new_state = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(new_state[("m.room.member", bad_user)].membership, "join") - new_state = self.get_success( + new_state = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) auth_ids = [ @@ -4890,7 +4890,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -4898,7 +4898,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): new_original_messages.append(remote_message) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4906,29 +4906,29 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, 200) self._check_redactions(new_original_messages, channel.json_body["chunk"], False) - def test_redaction_flag_ignored_for_user_if_banner_lacks_redaction_power( + async def test_redaction_flag_ignored_for_user_if_banner_lacks_redaction_power( self, ) -> None: # change power levels so creator can ban but not redact - self.helper.send_state( + await self.helper.send_state( self.room_id, "m.room.power_levels", {"events_default": 0, "redact": 100, "users": {self.creator: 75}}, tok=self.creator_tok, ) - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages original_ids = [] for i in range(15): event = {"body": f"being a menace {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) original_ids.append(res["event_id"]) # grab original events before ban - originals = [self.get_success(self.store.get_event(x)) for x in original_ids] + originals = [await self.get_success(self.store.get_event(x)) for x in original_ids] # creator bans bad user with redaction flag content = { @@ -4945,7 +4945,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4954,20 +4954,20 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # messages are not redacted self._check_redactions(originals, channel.json_body["chunk"], False) - def test_kicking_local_member_with_flag_redacts_their_events(self) -> None: - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + async def test_kicking_local_member_with_flag_redacts_their_events(self) -> None: + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages originals = [] for i in range(5): event = {"body": f"bothersome noise {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) originals.append(res["event_id"]) # grab original events for comparison - original_events = [self.get_success(self.store.get_event(x)) for x in originals] + original_events = [await self.get_success(self.store.get_event(x)) for x in originals] # creator kicks user with redaction flag set content = { @@ -4984,7 +4984,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -4997,7 +4997,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): reason="flooding", ) - def test_kicking_remote_member_with_flag_redacts_their_events(self) -> None: + async def test_kicking_remote_member_with_flag_redacts_their_events(self) -> None: bad_user = "@remote_bad_user:" + self.OTHER_SERVER_NAME channel = self.make_signed_federation_request( "GET", @@ -5019,7 +5019,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member - r = self.get_success( + r = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(r[("m.room.member", bad_user)].membership, "join") @@ -5047,7 +5047,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -5065,7 +5065,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ban_event_id = res["event_id"] filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5098,7 +5098,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -5108,12 +5108,12 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # pull them from the db to check because they should be soft-failed and thus not available over # cs-api for message in new_original_messages: - original = self.get_success(self.store.get_event(message.event_id)) + original = await self.get_success(self.store.get_event(message.event_id)) if not original: self.fail("Expected to find remote message in DB") self.assertEqual(original.unsigned["redacted_by"], ban_event_id) - def test_rejoining_kicked_remote_user_stops_redaction_action(self) -> None: + async def test_rejoining_kicked_remote_user_stops_redaction_action(self) -> None: bad_user = "@remote_bad_user:" + self.OTHER_SERVER_NAME channel = self.make_signed_federation_request( "GET", @@ -5135,7 +5135,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member - r = self.get_success( + r = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(r[("m.room.member", bad_user)].membership, "join") @@ -5163,7 +5163,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -5180,7 +5180,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5214,12 +5214,12 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, HTTPStatus.OK, channel.json_body) # the room should show that the bad user is a member again - new_state = self.get_success( + new_state = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) self.assertEqual(new_state[("m.room.member", bad_user)].membership, "join") - new_state = self.get_success( + new_state = await self.get_success( self._storage_controllers.state.get_current_state(self.room_id) ) auth_ids = [ @@ -5247,7 +5247,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): room_version=RoomVersions.V10, ) - self.get_success( + await self.get_success( self.federation_event_handler.on_receive_pdu( self.OTHER_SERVER_NAME, remote_message ) @@ -5255,7 +5255,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): new_original_messages.append(remote_message) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5263,29 +5263,29 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, 200) self._check_redactions(new_original_messages, channel.json_body["chunk"], False) - def test_redaction_flag_ignored_for_user_if_kicker_lacks_redaction_power( + async def test_redaction_flag_ignored_for_user_if_kicker_lacks_redaction_power( self, ) -> None: # change power levels so creator can kick but not redact - self.helper.send_state( + await self.helper.send_state( self.room_id, "m.room.power_levels", {"events_default": 0, "redact": 100, "users": {self.creator: 75}}, tok=self.creator_tok, ) - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages original_ids = [] for i in range(15): event = {"body": f"being a menace {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) original_ids.append(res["event_id"]) # grab original events before ban - originals = [self.get_success(self.store.get_event(x)) for x in original_ids] + originals = [await self.get_success(self.store.get_event(x)) for x in original_ids] # creator kicks bad user with redaction flag content = { @@ -5302,7 +5302,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): ) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5311,20 +5311,20 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # messages are not redacted self._check_redactions(originals, channel.json_body["chunk"], False) - def test_MSC4293_flag_ignored_in_other_membership_events(self) -> None: - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + async def test_MSC4293_flag_ignored_in_other_membership_events(self) -> None: + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages original_ids = [] for i in range(15): event = {"body": f"being a menace {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) original_ids.append(res["event_id"]) # grab original events before ban - originals = [self.get_success(self.store.get_event(x)) for x in original_ids] + originals = [await self.get_success(self.store.get_event(x)) for x in original_ids] # bad user leaves on their own with flag content = { @@ -5341,7 +5341,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # their messages are not redacted filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5364,7 +5364,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # their messages are still not redacted filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5387,7 +5387,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): # and still their messages are not redacted filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5395,25 +5395,25 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, 200) self._check_redactions(originals, channel.json_body["chunk"], False) - def test_MSC4293_redaction_applied_via_kick_api(self) -> None: + async def test_MSC4293_redaction_applied_via_kick_api(self) -> None: """ Test that MSC4239 field passed through and applied when using /kick """ - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages original_ids = [] for i in range(15): event = {"body": f"being a menace {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) original_ids.append(res["event_id"]) # grab original events before kick - originals = [self.get_success(self.store.get_event(x)) for x in original_ids] + originals = [await self.get_success(self.store.get_event(x)) for x in original_ids] - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/v3/rooms/{self.room_id}/kick", access_token=self.creator_tok, @@ -5427,7 +5427,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, 200) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, @@ -5440,25 +5440,25 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): reason="being annoying", ) - def test_MSC4293_redaction_applied_via_ban_api(self) -> None: + async def test_MSC4293_redaction_applied_via_ban_api(self) -> None: """ Test that MSC4239 field passed through and applied when using /ban """ - self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) + await self.helper.join(self.room_id, self.bad_user_id, tok=self.bad_tok) # bad user sends some messages original_ids = [] for i in range(15): event = {"body": f"being a menace {i}", "msgtype": "m.text"} - res = self.helper.send_event( + res = await self.helper.send_event( self.room_id, "m.room.message", event, tok=self.bad_tok, expect_code=200 ) original_ids.append(res["event_id"]) # grab original events before ban - originals = [self.get_success(self.store.get_event(x)) for x in original_ids] + originals = [await self.get_success(self.store.get_event(x)) for x in original_ids] - channel = self.make_request( + channel = await self.make_request( "POST", f"/_matrix/client/v3/rooms/{self.room_id}/ban", access_token=self.creator_tok, @@ -5472,7 +5472,7 @@ class MSC4293RedactOnBanKickTestCase(unittest.FederatingHomeserverTestCase): self.assertEqual(channel.code, 200) filter = json.dumps({"types": [EventTypes.Message]}) - channel = self.make_request( + channel = await self.make_request( "GET", f"rooms/{self.room_id}/messages?filter={filter}&limit=50", access_token=self.creator_tok, diff --git a/tests/storage/test_stream.py b/tests/storage/test_stream.py index a2556d21ef..9a195c561d 100644 --- a/tests/storage/test_stream.py +++ b/tests/storage/test_stream.py @@ -75,37 +75,37 @@ class PaginationTestCase(HomeserverTestCase): config["experimental_features"] = {"msc3874_enabled": True} return config - def prepare( + async def prepare( self, reactor: MemoryReactor, clock: Clock, homeserver: HomeServer ) -> None: - self.user_id = self.register_user("test", "test") - self.tok = self.login("test", "test") - self.room_id = self.helper.create_room_as(self.user_id, tok=self.tok) + self.user_id = await self.register_user("test", "test") + self.tok = await self.login("test", "test") + self.room_id = await self.helper.create_room_as(self.user_id, tok=self.tok) - self.second_user_id = self.register_user("second", "test") - self.second_tok = self.login("second", "test") - self.helper.join( + self.second_user_id = await self.register_user("second", "test") + self.second_tok = await self.login("second", "test") + await self.helper.join( room=self.room_id, user=self.second_user_id, tok=self.second_tok ) - self.third_user_id = self.register_user("third", "test") - self.third_tok = self.login("third", "test") - self.helper.join(room=self.room_id, user=self.third_user_id, tok=self.third_tok) + self.third_user_id = await self.register_user("third", "test") + self.third_tok = await self.login("third", "test") + await self.helper.join(room=self.room_id, user=self.third_user_id, tok=self.third_tok) # Store a token which is after all the room creation events. - self.from_token = self.get_success( + self.from_token = await self.get_success( self.hs.get_event_sources().get_current_token_for_pagination(self.room_id) ) # An initial event with a relation from second user. - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={"msgtype": "m.text", "body": "Message 1"}, tok=self.tok, ) self.event_id_1 = res["event_id"] - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type="m.reaction", content={ @@ -120,14 +120,14 @@ class PaginationTestCase(HomeserverTestCase): self.event_id_annotation = res["event_id"] # Another event with a relation from third user. - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={"msgtype": "m.text", "body": "Message 2"}, tok=self.tok, ) self.event_id_2 = res["event_id"] - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type="m.reaction", content={ @@ -141,7 +141,7 @@ class PaginationTestCase(HomeserverTestCase): self.event_id_reference = res["event_id"] # An event with no relations. - res = self.helper.send_event( + res = await self.helper.send_event( room_id=self.room_id, type=EventTypes.Message, content={"msgtype": "m.text", "body": "No relations"}, @@ -149,10 +149,10 @@ class PaginationTestCase(HomeserverTestCase): ) self.event_id_none = res["event_id"] - def _filter_messages(self, filter: JsonDict) -> list[str]: + async def _filter_messages(self, filter: JsonDict) -> list[str]: """Make a request to /messages with a filter, returns the chunk of events.""" - events, next_key, _ = self.get_success( + events, next_key, _ = await self.get_success( self.hs.get_datastores().main.paginate_room_events_by_topological_ordering( room_id=self.room_id, from_key=self.from_token.room_key, @@ -165,31 +165,31 @@ class PaginationTestCase(HomeserverTestCase): return [ev.event_id for ev in events] - def test_filter_relation_senders(self) -> None: + async def test_filter_relation_senders(self) -> None: # Messages which second user reacted to. filter = {"related_by_senders": [self.second_user_id]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_1]) # Messages which third user reacted to. filter = {"related_by_senders": [self.third_user_id]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_2]) # Messages which either user reacted to. filter = {"related_by_senders": [self.second_user_id, self.third_user_id]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertCountEqual(chunk, [self.event_id_1, self.event_id_2]) - def test_filter_relation_type(self) -> None: + async def test_filter_relation_type(self) -> None: # Messages which have annotations. filter = {"related_by_rel_types": [RelationTypes.ANNOTATION]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_1]) # Messages which have references. filter = {"related_by_rel_types": [RelationTypes.REFERENCE]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_2]) # Messages which have either annotations or references. @@ -199,21 +199,21 @@ class PaginationTestCase(HomeserverTestCase): RelationTypes.REFERENCE, ] } - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertCountEqual(chunk, [self.event_id_1, self.event_id_2]) - def test_filter_relation_senders_and_type(self) -> None: + async def test_filter_relation_senders_and_type(self) -> None: # Messages which second user reacted to. filter = { "related_by_senders": [self.second_user_id], "related_by_rel_types": [RelationTypes.ANNOTATION], } - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_1]) - def test_duplicate_relation(self) -> None: + async def test_duplicate_relation(self) -> None: """An event should only be returned once if there are multiple relations to it.""" - self.helper.send_event( + await self.helper.send_event( room_id=self.room_id, type="m.reaction", content={ @@ -227,18 +227,18 @@ class PaginationTestCase(HomeserverTestCase): ) filter = {"related_by_senders": [self.second_user_id]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_1]) - def test_filter_rel_types(self) -> None: + async def test_filter_rel_types(self) -> None: # Messages which are annotations. filter = {"org.matrix.msc3874.rel_types": [RelationTypes.ANNOTATION]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_annotation]) # Messages which are references. filter = {"org.matrix.msc3874.rel_types": [RelationTypes.REFERENCE]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_reference]) # Messages which are either annotations or references. @@ -248,16 +248,16 @@ class PaginationTestCase(HomeserverTestCase): RelationTypes.REFERENCE, ] } - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertCountEqual( chunk, [self.event_id_annotation, self.event_id_reference], ) - def test_filter_not_rel_types(self) -> None: + async def test_filter_not_rel_types(self) -> None: # Messages which are not annotations. filter = {"org.matrix.msc3874.not_rel_types": [RelationTypes.ANNOTATION]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual( chunk, [ @@ -270,7 +270,7 @@ class PaginationTestCase(HomeserverTestCase): # Messages which are not references. filter = {"org.matrix.msc3874.not_rel_types": [RelationTypes.REFERENCE]} - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual( chunk, [ @@ -288,7 +288,7 @@ class PaginationTestCase(HomeserverTestCase): RelationTypes.REFERENCE, ] } - chunk = self._filter_messages(filter) + chunk = await self._filter_messages(filter) self.assertEqual(chunk, [self.event_id_1, self.event_id_2, self.event_id_none]) diff --git a/tests/unittest.py b/tests/unittest.py index 0816d2f83e..248dfe81eb 100644 --- a/tests/unittest.py +++ b/tests/unittest.py @@ -22,6 +22,7 @@ import functools import gc import hashlib +import inspect import hmac import json import logging @@ -571,7 +572,9 @@ class HomeserverTestCase(TestCase): self.reactor.threadpool.start() if hasattr(self, "prepare"): - self.prepare(self.reactor, self.clock, self.hs) + res = self.prepare(self.reactor, self.clock, self.hs) + if inspect.isawaitable(res): + await res def tearDown(self) -> None: # Reset to not use frozen dicts. @@ -1016,7 +1019,7 @@ class FederatingHomeserverTestCase(HomeserverTestCase): OTHER_SERVER_NAME = "other.example.com" OTHER_SERVER_SIGNATURE_KEY = signedjson.key.generate_signing_key("test") - def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: + async def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: super().prepare(reactor, clock, hs) # poke the other server's signing key into the key store, so that we don't @@ -1024,7 +1027,7 @@ class FederatingHomeserverTestCase(HomeserverTestCase): verify_key = signedjson.key.get_verify_key(self.OTHER_SERVER_SIGNATURE_KEY) verify_key_id = "%s:%s" % (verify_key.alg, verify_key.version) - self.get_success( + await self.get_success( hs.get_datastores().main.store_server_keys_response( self.OTHER_SERVER_NAME, from_server=self.OTHER_SERVER_NAME,