1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911 |
- # Copyright 2020 Dirk Klimpel
- #
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
- #
- # http://www.apache.org/licenses/LICENSE-2.0
- #
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
- import json
- import time
- import urllib.parse
- from typing import List, Optional
- from unittest.mock import AsyncMock, Mock
- from parameterized import parameterized
- from twisted.internet.task import deferLater
- from twisted.test.proto_helpers import MemoryReactor
- import synapse.rest.admin
- from synapse.api.constants import EventTypes, Membership, RoomTypes
- from synapse.api.errors import Codes
- from synapse.handlers.pagination import (
- PURGE_ROOM_ACTION_NAME,
- SHUTDOWN_AND_PURGE_ROOM_ACTION_NAME,
- )
- from synapse.rest.client import directory, events, knock, login, room, sync
- from synapse.server import HomeServer
- from synapse.types import UserID
- from synapse.util import Clock
- from synapse.util.task_scheduler import TaskScheduler
- from tests import unittest
- """Tests admin REST events for /rooms paths."""
- ONE_HOUR_IN_S = 3600
- class DeleteRoomTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- login.register_servlets,
- events.register_servlets,
- room.register_servlets,
- knock.register_servlets,
- sync.register_servlets,
- room.register_deprecated_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self.event_creation_handler = hs.get_event_creation_handler()
- self.task_scheduler = hs.get_task_scheduler()
- hs.config.consent.user_consent_version = "1"
- consent_uri_builder = Mock()
- consent_uri_builder.build_user_consent_uri.return_value = "http://example.com"
- self.event_creation_handler._consent_uri_builder = consent_uri_builder
- self.store = hs.get_datastores().main
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.other_user = self.register_user("user", "pass")
- self.other_user_tok = self.login("user", "pass")
- # Mark the admin user as having consented
- self.get_success(self.store.user_set_consent_version(self.admin_user, "1"))
- self.room_id = self.helper.create_room_as(
- self.other_user, tok=self.other_user_tok
- )
- self.url = "/_synapse/admin/v1/rooms/%s" % self.room_id
- def test_requester_is_no_admin(self) -> None:
- """
- If the user is not a server admin, an error 403 is returned.
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- {},
- access_token=self.other_user_tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- def test_room_does_not_exist(self) -> None:
- """
- Check that unknown rooms/server return 200
- """
- url = "/_synapse/admin/v1/rooms/%s" % "!unknown:test"
- channel = self.make_request(
- "DELETE",
- url,
- {},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- def test_room_is_not_valid(self) -> None:
- """
- Check that invalid room names, return an error 400.
- """
- url = "/_synapse/admin/v1/rooms/%s" % "invalidroom"
- channel = self.make_request(
- "DELETE",
- url,
- {},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "invalidroom is not a legal room ID",
- channel.json_body["error"],
- )
- def test_new_room_user_does_not_exist(self) -> None:
- """
- Tests that the user ID must be from local server but it does not have to exist.
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": "@unknown:test"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("new_room_id", channel.json_body)
- self.assertIn("kicked_users", channel.json_body)
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- def test_new_room_user_is_not_local(self) -> None:
- """
- Check that only local users can create new room to move members.
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": "@not:exist.bla"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "User must be our own: @not:exist.bla",
- channel.json_body["error"],
- )
- def test_block_is_not_bool(self) -> None:
- """
- If parameter `block` is not boolean, return an error
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"block": "NotBool"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.BAD_JSON, channel.json_body["errcode"])
- def test_purge_is_not_bool(self) -> None:
- """
- If parameter `purge` is not boolean, return an error
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"purge": "NotBool"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.BAD_JSON, channel.json_body["errcode"])
- def test_purge_room_and_block(self) -> None:
- """Test to purge a room and block it.
- Members will not be moved to a new room and will not receive a message.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": True, "purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(None, channel.json_body["new_room_id"])
- self.assertEqual(self.other_user, channel.json_body["kicked_users"][0])
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=True)
- self._has_no_members(self.room_id)
- def test_purge_room_and_not_block(self) -> None:
- """Test to purge a room and do not block it.
- Members will not be moved to a new room and will not receive a message.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": False, "purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(None, channel.json_body["new_room_id"])
- self.assertEqual(self.other_user, channel.json_body["kicked_users"][0])
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=False)
- self._has_no_members(self.room_id)
- def test_purge_room_unjoined(self) -> None:
- """Test to purge a room when there are invited or knocked users."""
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- self.helper.send_state(
- self.room_id,
- EventTypes.JoinRules,
- {"join_rule": "knock"},
- tok=self.other_user_tok,
- )
- # Invite a user.
- invited_user = self.register_user("invited", "pass")
- self.helper.invite(
- self.room_id, self.other_user, invited_user, tok=self.other_user_tok
- )
- # Have a user knock.
- knocked_user = self.register_user("knocked", "pass")
- knocked_user_tok = self.login("knocked", "pass")
- self.helper.knock(self.room_id, knocked_user, tok=knocked_user_tok)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": False, "purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(None, channel.json_body["new_room_id"])
- self.assertCountEqual(
- [self.other_user, invited_user, knocked_user],
- channel.json_body["kicked_users"],
- )
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=False)
- self._has_no_members(self.room_id)
- def test_block_room_and_not_purge(self) -> None:
- """Test to block a room without purging it.
- Members will not be moved to a new room and will not receive a message.
- The room will not be purged.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": True, "purge": False},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(None, channel.json_body["new_room_id"])
- self.assertEqual(self.other_user, channel.json_body["kicked_users"][0])
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=True)
- self._has_no_members(self.room_id)
- @parameterized.expand([(True,), (False,)])
- def test_block_unknown_room(self, purge: bool) -> None:
- """
- We can block an unknown room. In this case, the `purge` argument
- should be ignored.
- """
- room_id = "!unknown:test"
- # The room isn't already in the blocked rooms table
- self._is_blocked(room_id, expect=False)
- # Request the room be blocked.
- channel = self.make_request(
- "DELETE",
- f"/_synapse/admin/v1/rooms/{room_id}",
- {"block": True, "purge": purge},
- access_token=self.admin_user_tok,
- )
- # The room is now blocked.
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self._is_blocked(room_id)
- def test_shutdown_room_consent(self) -> None:
- """Test that we can shutdown rooms with local users who have not
- yet accepted the privacy policy. This used to fail when we tried to
- force part the user from the old room.
- Members will be moved to a new room and will receive a message.
- """
- self.event_creation_handler._block_events_without_consent_error = None
- # Assert one user in room
- users_in_room = self.get_success(self.store.get_users_in_room(self.room_id))
- self.assertEqual([self.other_user], users_in_room)
- # Enable require consent to send events
- self.event_creation_handler._block_events_without_consent_error = "Error"
- # Assert that the user is getting consent error
- self.helper.send(
- self.room_id,
- body="foo",
- tok=self.other_user_tok,
- expect_code=403,
- )
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- # Test that the admin can still send shutdown
- channel = self.make_request(
- "DELETE",
- self.url,
- {"new_room_user_id": self.admin_user},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(self.other_user, channel.json_body["kicked_users"][0])
- self.assertIn("new_room_id", channel.json_body)
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- # Test that member has moved to new room
- self._is_member(
- room_id=channel.json_body["new_room_id"], user_id=self.other_user
- )
- self._is_purged(self.room_id)
- self._has_no_members(self.room_id)
- def test_shutdown_room_block_peek(self) -> None:
- """Test that a world_readable room can no longer be peeked into after
- it has been shut down.
- Members will be moved to a new room and will receive a message.
- """
- self.event_creation_handler._block_events_without_consent_error = None
- # Enable world readable
- url = "rooms/%s/state/m.room.history_visibility" % (self.room_id,)
- channel = self.make_request(
- "PUT",
- url.encode("ascii"),
- {"history_visibility": "world_readable"},
- access_token=self.other_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- # Test that the admin can still send shutdown
- channel = self.make_request(
- "DELETE",
- self.url,
- {"new_room_user_id": self.admin_user},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(self.other_user, channel.json_body["kicked_users"][0])
- self.assertIn("new_room_id", channel.json_body)
- self.assertIn("failed_to_kick_users", channel.json_body)
- self.assertIn("local_aliases", channel.json_body)
- # Test that member has moved to new room
- self._is_member(
- room_id=channel.json_body["new_room_id"], user_id=self.other_user
- )
- self._is_purged(self.room_id)
- self._has_no_members(self.room_id)
- # Assert we can no longer peek into the room
- self._assert_peek(self.room_id, expect_code=403)
- def test_room_delete_send(self) -> None:
- """Test that sending into a deleted room returns a 403"""
- channel = self.make_request(
- "DELETE",
- self.url,
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.helper.send(
- self.room_id, "test message", expect_code=403, tok=self.other_user_tok
- )
- def _is_blocked(self, room_id: str, expect: bool = True) -> None:
- """Assert that the room is blocked or not"""
- d = self.store.is_room_blocked(room_id)
- if expect:
- self.assertTrue(self.get_success(d))
- else:
- self.assertIsNone(self.get_success(d))
- def _has_no_members(self, room_id: str) -> None:
- """Assert there is now no longer anyone in the room"""
- users_in_room = self.get_success(self.store.get_users_in_room(room_id))
- self.assertEqual([], users_in_room)
- def _is_member(self, room_id: str, user_id: str) -> None:
- """Test that user is member of the room"""
- users_in_room = self.get_success(self.store.get_users_in_room(room_id))
- self.assertIn(user_id, users_in_room)
- def _is_purged(self, room_id: str) -> None:
- """Test that the following tables have been purged of all rows related to the room."""
- for table in PURGE_TABLES:
- count = self.get_success(
- self.store.db_pool.simple_select_one_onecol(
- table=table,
- keyvalues={"room_id": room_id},
- retcol="COUNT(*)",
- desc="test_purge_room",
- )
- )
- self.assertEqual(count, 0, msg=f"Rows not purged in {table}")
- def _assert_peek(self, room_id: str, expect_code: int) -> None:
- """Assert that the admin user can (or cannot) peek into the room."""
- url = "rooms/%s/initialSync" % (room_id,)
- channel = self.make_request(
- "GET", url.encode("ascii"), access_token=self.admin_user_tok
- )
- self.assertEqual(expect_code, channel.code, msg=channel.json_body)
- url = "events?timeout=0&room_id=" + room_id
- channel = self.make_request(
- "GET", url.encode("ascii"), access_token=self.admin_user_tok
- )
- self.assertEqual(expect_code, channel.code, msg=channel.json_body)
- class DeleteRoomV2TestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- login.register_servlets,
- events.register_servlets,
- room.register_servlets,
- room.register_deprecated_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self.event_creation_handler = hs.get_event_creation_handler()
- self.task_scheduler = hs.get_task_scheduler()
- hs.config.consent.user_consent_version = "1"
- consent_uri_builder = Mock()
- consent_uri_builder.build_user_consent_uri.return_value = "http://example.com"
- self.event_creation_handler._consent_uri_builder = consent_uri_builder
- self.store = hs.get_datastores().main
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.other_user = self.register_user("user", "pass")
- self.other_user_tok = self.login("user", "pass")
- # Mark the admin user as having consented
- self.get_success(self.store.user_set_consent_version(self.admin_user, "1"))
- self.room_id = self.helper.create_room_as(
- self.other_user, tok=self.other_user_tok
- )
- self.url = f"/_synapse/admin/v2/rooms/{self.room_id}"
- self.url_status_by_room_id = (
- f"/_synapse/admin/v2/rooms/{self.room_id}/delete_status"
- )
- self.url_status_by_delete_id = "/_synapse/admin/v2/rooms/delete_status/"
- self.room_member_handler = hs.get_room_member_handler()
- self.pagination_handler = hs.get_pagination_handler()
- @parameterized.expand(
- [
- ("DELETE", "/_synapse/admin/v2/rooms/%s"),
- ("GET", "/_synapse/admin/v2/rooms/%s/delete_status"),
- ("GET", "/_synapse/admin/v2/rooms/delete_status/%s"),
- ]
- )
- def test_requester_is_no_admin(self, method: str, url: str) -> None:
- """
- If the user is not a server admin, an error 403 is returned.
- """
- channel = self.make_request(
- method,
- url % self.room_id,
- content={},
- access_token=self.other_user_tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- def test_room_does_not_exist(self) -> None:
- """
- Check that unknown rooms/server return 200
- This is important, as it allows incomplete vestiges of rooms to be cleared up
- even if the create event/etc is missing.
- """
- room_id = "!unknown:test"
- channel = self.make_request(
- "DELETE",
- f"/_synapse/admin/v2/rooms/{room_id}",
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- # get status
- channel = self.make_request(
- "GET",
- f"/_synapse/admin/v2/rooms/{room_id}/delete_status",
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(1, len(channel.json_body["results"]))
- self.assertEqual("complete", channel.json_body["results"][0]["status"])
- self.assertEqual(delete_id, channel.json_body["results"][0]["delete_id"])
- @parameterized.expand(
- [
- ("DELETE", "/_synapse/admin/v2/rooms/%s"),
- ("GET", "/_synapse/admin/v2/rooms/%s/delete_status"),
- ]
- )
- def test_room_is_not_valid(self, method: str, url: str) -> None:
- """
- Check that invalid room names, return an error 400.
- """
- channel = self.make_request(
- method,
- url % "invalidroom",
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "invalidroom is not a legal room ID",
- channel.json_body["error"],
- )
- def test_new_room_user_does_not_exist(self) -> None:
- """
- Tests that the user ID must be from local server but it does not have to exist.
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": "@unknown:test"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user, expect_new_room=True)
- def test_new_room_user_is_not_local(self) -> None:
- """
- Check that only local users can create new room to move members.
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": "@not:exist.bla"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "User must be our own: @not:exist.bla",
- channel.json_body["error"],
- )
- def test_block_is_not_bool(self) -> None:
- """
- If parameter `block` is not boolean, return an error
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"block": "NotBool"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.BAD_JSON, channel.json_body["errcode"])
- def test_purge_is_not_bool(self) -> None:
- """
- If parameter `purge` is not boolean, return an error
- """
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"purge": "NotBool"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.BAD_JSON, channel.json_body["errcode"])
- def test_delete_expired_status(self) -> None:
- """Test that the task status is removed after expiration."""
- # first task, do not purge, that we can create a second task
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"purge": False},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id1 = channel.json_body["delete_id"]
- # go ahead
- self.reactor.advance(TaskScheduler.KEEP_TASKS_FOR_MS / 1000 / 2)
- # second task
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id2 = channel.json_body["delete_id"]
- # get status
- channel = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(2, len(channel.json_body["results"]))
- self.assertEqual("complete", channel.json_body["results"][0]["status"])
- self.assertEqual("complete", channel.json_body["results"][1]["status"])
- delete_ids = {delete_id1, delete_id2}
- self.assertTrue(channel.json_body["results"][0]["delete_id"] in delete_ids)
- delete_ids.remove(channel.json_body["results"][0]["delete_id"])
- self.assertTrue(channel.json_body["results"][1]["delete_id"] in delete_ids)
- # get status after more than clearing time for first task
- # second task is not cleared
- self.reactor.advance(TaskScheduler.KEEP_TASKS_FOR_MS / 1000 / 2)
- channel = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(1, len(channel.json_body["results"]))
- self.assertEqual("complete", channel.json_body["results"][0]["status"])
- self.assertEqual(delete_id2, channel.json_body["results"][0]["delete_id"])
- # get status after more than clearing time for all tasks
- self.reactor.advance(TaskScheduler.KEEP_TASKS_FOR_MS / 1000 / 2)
- channel = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(404, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
- def test_delete_same_room_twice(self) -> None:
- """Test that the call for delete a room at second time gives an exception."""
- body = {"new_room_user_id": self.admin_user}
- # Mock PaginationHandler.purge_room to sleep for 100s, so we have time to do a second call
- # before the purge is over. Note that it doesn't purge anymore, but we don't care.
- async def purge_room(room_id: str, force: bool) -> None:
- await deferLater(self.hs.get_reactor(), 100, lambda: None)
- self.pagination_handler.purge_room = AsyncMock(side_effect=purge_room) # type: ignore[method-assign]
- # first call to delete room
- # and do not wait for finish the task
- first_channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content=body,
- access_token=self.admin_user_tok,
- )
- # second call to delete room
- second_channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content=body,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, second_channel.code, msg=second_channel.json_body)
- self.assertEqual(Codes.UNKNOWN, second_channel.json_body["errcode"])
- self.assertEqual(
- f"Purge already in progress for {self.room_id}",
- second_channel.json_body["error"],
- )
- # get result of first call
- first_channel.await_result()
- self.assertEqual(200, first_channel.code, msg=first_channel.json_body)
- self.assertIn("delete_id", first_channel.json_body)
- # wait for purge_room to finish
- self.pump(1)
- # check status after finish the task
- self._test_result(
- first_channel.json_body["delete_id"],
- self.other_user,
- expect_new_room=True,
- )
- def test_purge_room_and_block(self) -> None:
- """Test to purge a room and block it.
- Members will not be moved to a new room and will not receive a message.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": True, "purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user)
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=True)
- self._has_no_members(self.room_id)
- def test_purge_room_and_not_block(self) -> None:
- """Test to purge a room and do not block it.
- Members will not be moved to a new room and will not receive a message.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": False, "purge": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user)
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=False)
- self._has_no_members(self.room_id)
- def test_block_room_and_not_purge(self) -> None:
- """Test to block a room without purging it.
- Members will not be moved to a new room and will not receive a message.
- The room will not be purged.
- """
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Test that room is not blocked
- self._is_blocked(self.room_id, expect=False)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- channel = self.make_request(
- "DELETE",
- self.url.encode("ascii"),
- content={"block": True, "purge": False},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user)
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- self._is_blocked(self.room_id, expect=True)
- self._has_no_members(self.room_id)
- def test_shutdown_room_consent(self) -> None:
- """Test that we can shutdown rooms with local users who have not
- yet accepted the privacy policy. This used to fail when we tried to
- force part the user from the old room.
- Members will be moved to a new room and will receive a message.
- """
- self.event_creation_handler._block_events_without_consent_error = None
- # Assert one user in room
- users_in_room = self.get_success(self.store.get_users_in_room(self.room_id))
- self.assertEqual([self.other_user], users_in_room)
- # Enable require consent to send events
- self.event_creation_handler._block_events_without_consent_error = "Error"
- # Assert that the user is getting consent error
- self.helper.send(
- self.room_id,
- body="foo",
- tok=self.other_user_tok,
- expect_code=403,
- )
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- # Test that the admin can still send shutdown
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": self.admin_user},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user, expect_new_room=True)
- channel = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(1, len(channel.json_body["results"]))
- # Test that member has moved to new room
- self._is_member(
- room_id=channel.json_body["results"][0]["shutdown_room"]["new_room_id"],
- user_id=self.other_user,
- )
- self._is_purged(self.room_id)
- self._has_no_members(self.room_id)
- def test_shutdown_room_block_peek(self) -> None:
- """Test that a world_readable room can no longer be peeked into after
- it has been shut down.
- Members will be moved to a new room and will receive a message.
- """
- self.event_creation_handler._block_events_without_consent_error = None
- # Enable world readable
- url = "rooms/%s/state/m.room.history_visibility" % (self.room_id,)
- channel = self.make_request(
- "PUT",
- url.encode("ascii"),
- content={"history_visibility": "world_readable"},
- access_token=self.other_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Test that room is not purged
- with self.assertRaises(AssertionError):
- self._is_purged(self.room_id)
- # Assert one user in room
- self._is_member(room_id=self.room_id, user_id=self.other_user)
- # Test that the admin can still send shutdown
- channel = self.make_request(
- "DELETE",
- self.url,
- content={"new_room_user_id": self.admin_user},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("delete_id", channel.json_body)
- delete_id = channel.json_body["delete_id"]
- self._test_result(delete_id, self.other_user, expect_new_room=True)
- channel = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(1, len(channel.json_body["results"]))
- # Test that member has moved to new room
- self._is_member(
- room_id=channel.json_body["results"][0]["shutdown_room"]["new_room_id"],
- user_id=self.other_user,
- )
- self._is_purged(self.room_id)
- self._has_no_members(self.room_id)
- # Assert we can no longer peek into the room
- self._assert_peek(self.room_id, expect_code=403)
- @unittest.override_config({"forgotten_room_retention_period": "1d"})
- def test_purge_forgotten_room(self) -> None:
- # Create a test room
- room_id = self.helper.create_room_as(
- self.admin_user,
- tok=self.admin_user_tok,
- )
- self.helper.leave(room_id, user=self.admin_user, tok=self.admin_user_tok)
- self.get_success(
- self.room_member_handler.forget(
- UserID.from_string(self.admin_user), room_id
- )
- )
- # Test that room is not yet purged
- with self.assertRaises(AssertionError):
- self._is_purged(room_id)
- # Advance 24 hours in the future, past the `forgotten_room_retention_period`
- self.reactor.advance(24 * ONE_HOUR_IN_S)
- self._is_purged(room_id)
- def test_scheduled_purge_room(self) -> None:
- # Create a test room
- room_id = self.helper.create_room_as(
- self.admin_user,
- tok=self.admin_user_tok,
- )
- self.helper.leave(room_id, user=self.admin_user, tok=self.admin_user_tok)
- # Schedule a purge 10 seconds in the future
- self.get_success(
- self.task_scheduler.schedule_task(
- PURGE_ROOM_ACTION_NAME,
- resource_id=room_id,
- timestamp=self.clock.time_msec() + 10 * 1000,
- )
- )
- # Test that room is not yet purged
- with self.assertRaises(AssertionError):
- self._is_purged(room_id)
- # Wait for next scheduler run
- self.reactor.advance(TaskScheduler.SCHEDULE_INTERVAL_MS)
- self._is_purged(room_id)
- def test_schedule_shutdown_room(self) -> None:
- # Create a test room
- room_id = self.helper.create_room_as(
- self.other_user,
- tok=self.other_user_tok,
- )
- # Schedule a shutdown 10 seconds in the future
- delete_id = self.get_success(
- self.task_scheduler.schedule_task(
- SHUTDOWN_AND_PURGE_ROOM_ACTION_NAME,
- resource_id=room_id,
- params={
- "requester_user_id": self.admin_user,
- "new_room_user_id": self.admin_user,
- "new_room_name": None,
- "message": None,
- "block": False,
- "purge": True,
- "force_purge": True,
- },
- timestamp=self.clock.time_msec() + 10 * 1000,
- )
- )
- # Test that room is not yet shutdown
- self._is_member(room_id, self.other_user)
- # Test that room is not yet purged
- with self.assertRaises(AssertionError):
- self._is_purged(room_id)
- # Wait for next scheduler run
- self.reactor.advance(TaskScheduler.SCHEDULE_INTERVAL_MS)
- # Test that all users has been kicked (room is shutdown)
- self._has_no_members(room_id)
- self._is_purged(room_id)
- # Retrieve delete results
- result = self.make_request(
- "GET",
- self.url_status_by_delete_id + delete_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, result.code, msg=result.json_body)
- # Check that the user is in kicked_users
- self.assertIn(
- self.other_user, result.json_body["shutdown_room"]["kicked_users"]
- )
- new_room_id = result.json_body["shutdown_room"]["new_room_id"]
- self.assertTrue(new_room_id)
- # Check that the user is actually in the new room
- self._is_member(new_room_id, self.other_user)
- def _is_blocked(self, room_id: str, expect: bool = True) -> None:
- """Assert that the room is blocked or not"""
- d = self.store.is_room_blocked(room_id)
- if expect:
- self.assertTrue(self.get_success(d))
- else:
- self.assertIsNone(self.get_success(d))
- def _has_no_members(self, room_id: str) -> None:
- """Assert there is now no longer anyone in the room"""
- users_in_room = self.get_success(self.store.get_users_in_room(room_id))
- self.assertEqual([], users_in_room)
- def _is_member(self, room_id: str, user_id: str) -> None:
- """Test that user is member of the room"""
- users_in_room = self.get_success(self.store.get_users_in_room(room_id))
- self.assertIn(user_id, users_in_room)
- def _is_purged(self, room_id: str) -> None:
- """Test that the following tables have been purged of all rows related to the room."""
- for table in PURGE_TABLES:
- count = self.get_success(
- self.store.db_pool.simple_select_one_onecol(
- table=table,
- keyvalues={"room_id": room_id},
- retcol="COUNT(*)",
- desc="test_purge_room",
- )
- )
- self.assertEqual(count, 0, msg=f"Rows not purged in {table}")
- def _assert_peek(self, room_id: str, expect_code: int) -> None:
- """Assert that the admin user can (or cannot) peek into the room."""
- url = f"rooms/{room_id}/initialSync"
- channel = self.make_request(
- "GET", url.encode("ascii"), access_token=self.admin_user_tok
- )
- self.assertEqual(expect_code, channel.code, msg=channel.json_body)
- url = "events?timeout=0&room_id=" + room_id
- channel = self.make_request(
- "GET", url.encode("ascii"), access_token=self.admin_user_tok
- )
- self.assertEqual(expect_code, channel.code, msg=channel.json_body)
- def _test_result(
- self,
- delete_id: str,
- kicked_user: str,
- expect_new_room: bool = False,
- ) -> None:
- """
- Test that the result is the expected.
- Uses both APIs (status by room_id and delete_id)
- Args:
- delete_id: id of this purge
- kicked_user: a user_id which is kicked from the room
- expect_new_room: if we expect that a new room was created
- """
- # get information by room_id
- channel_room_id = self.make_request(
- "GET",
- self.url_status_by_room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel_room_id.code, msg=channel_room_id.json_body)
- self.assertEqual(1, len(channel_room_id.json_body["results"]))
- self.assertEqual(
- delete_id, channel_room_id.json_body["results"][0]["delete_id"]
- )
- # get information by delete_id
- channel_delete_id = self.make_request(
- "GET",
- self.url_status_by_delete_id + delete_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(
- 200,
- channel_delete_id.code,
- msg=channel_delete_id.json_body,
- )
- # test values that are the same in both responses
- for content in [
- channel_room_id.json_body["results"][0],
- channel_delete_id.json_body,
- ]:
- self.assertEqual("complete", content["status"])
- self.assertEqual(kicked_user, content["shutdown_room"]["kicked_users"][0])
- self.assertIn("failed_to_kick_users", content["shutdown_room"])
- self.assertIn("local_aliases", content["shutdown_room"])
- self.assertNotIn("error", content)
- if expect_new_room:
- self.assertIsNotNone(content["shutdown_room"]["new_room_id"])
- else:
- self.assertIsNone(content["shutdown_room"]["new_room_id"])
- class RoomTestCase(unittest.HomeserverTestCase):
- """Test /room admin API."""
- servlets = [
- synapse.rest.admin.register_servlets,
- login.register_servlets,
- room.register_servlets,
- directory.register_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- # Create user
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- def test_list_rooms(self) -> None:
- """Test that we can list rooms"""
- # Create 3 test rooms
- total_rooms = 3
- room_ids = []
- for _ in range(total_rooms):
- room_id = self.helper.create_room_as(
- self.admin_user,
- tok=self.admin_user_tok,
- is_public=True,
- )
- room_ids.append(room_id)
- room_ids.sort()
- # Request the list of rooms
- url = "/_synapse/admin/v1/rooms"
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- # Check request completed successfully
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Check that response json body contains a "rooms" key
- self.assertTrue(
- "rooms" in channel.json_body,
- msg="Response body does not " "contain a 'rooms' key",
- )
- # Check that 3 rooms were returned
- self.assertEqual(3, len(channel.json_body["rooms"]), msg=channel.json_body)
- # Check their room_ids match
- returned_room_ids = [room["room_id"] for room in channel.json_body["rooms"]]
- self.assertEqual(room_ids, returned_room_ids)
- # Check that all fields are available
- for r in channel.json_body["rooms"]:
- self.assertIn("name", r)
- self.assertIn("canonical_alias", r)
- self.assertIn("joined_members", r)
- self.assertIn("joined_local_members", r)
- self.assertIn("version", r)
- self.assertIn("creator", r)
- self.assertIn("encryption", r)
- self.assertIs(r["federatable"], True)
- self.assertIs(r["public"], True)
- self.assertIn("join_rules", r)
- self.assertIn("guest_access", r)
- self.assertIn("history_visibility", r)
- self.assertIn("state_events", r)
- self.assertIn("room_type", r)
- self.assertIsNone(r["room_type"])
- # Check that the correct number of total rooms was returned
- self.assertEqual(channel.json_body["total_rooms"], total_rooms)
- # Check that the offset is correct
- # Should be 0 as we aren't paginating
- self.assertEqual(channel.json_body["offset"], 0)
- # Check that the prev_batch parameter is not present
- self.assertNotIn("prev_batch", channel.json_body)
- # We shouldn't receive a next token here as there's no further rooms to show
- self.assertNotIn("next_batch", channel.json_body)
- def test_list_rooms_pagination(self) -> None:
- """Test that we can get a full list of rooms through pagination"""
- # Create 5 test rooms
- total_rooms = 5
- room_ids = []
- for _ in range(total_rooms):
- room_id = self.helper.create_room_as(
- self.admin_user, tok=self.admin_user_tok
- )
- room_ids.append(room_id)
- # Set the name of the rooms so we get a consistent returned ordering
- for idx, room_id in enumerate(room_ids):
- self.helper.send_state(
- room_id,
- "m.room.name",
- {"name": str(idx)},
- tok=self.admin_user_tok,
- )
- # Request the list of rooms
- returned_room_ids = []
- start = 0
- limit = 2
- run_count = 0
- should_repeat = True
- while should_repeat:
- run_count += 1
- url = "/_synapse/admin/v1/rooms?from=%d&limit=%d&order_by=%s" % (
- start,
- limit,
- "name",
- )
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertTrue("rooms" in channel.json_body)
- for r in channel.json_body["rooms"]:
- returned_room_ids.append(r["room_id"])
- # Check that the correct number of total rooms was returned
- self.assertEqual(channel.json_body["total_rooms"], total_rooms)
- # Check that the offset is correct
- # We're only getting 2 rooms each page, so should be 2 * last run_count
- self.assertEqual(channel.json_body["offset"], 2 * (run_count - 1))
- if run_count > 1:
- # Check the value of prev_batch is correct
- self.assertEqual(channel.json_body["prev_batch"], 2 * (run_count - 2))
- if "next_batch" not in channel.json_body:
- # We have reached the end of the list
- should_repeat = False
- else:
- # Make another query with an updated start value
- start = channel.json_body["next_batch"]
- # We should've queried the endpoint 3 times
- self.assertEqual(
- run_count,
- 3,
- msg="Should've queried 3 times for 5 rooms with limit 2 per query",
- )
- # Check that we received all of the room ids
- self.assertEqual(room_ids, returned_room_ids)
- url = "/_synapse/admin/v1/rooms?from=%d&limit=%d" % (start, limit)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- def test_correct_room_attributes(self) -> None:
- """Test the correct attributes for a room are returned"""
- # Create a test room
- room_id = self.helper.create_room_as(
- self.admin_user,
- tok=self.admin_user_tok,
- extra_content={"creation_content": {"type": RoomTypes.SPACE}},
- )
- test_alias = "#test:test"
- test_room_name = "something"
- # Have another user join the room
- user_2 = self.register_user("user4", "pass")
- user_tok_2 = self.login("user4", "pass")
- self.helper.join(room_id, user_2, tok=user_tok_2)
- # Create a new alias to this room
- url = "/_matrix/client/r0/directory/room/%s" % (urllib.parse.quote(test_alias),)
- channel = self.make_request(
- "PUT",
- url.encode("ascii"),
- {"room_id": room_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Set this new alias as the canonical alias for this room
- self.helper.send_state(
- room_id,
- "m.room.aliases",
- {"aliases": [test_alias]},
- tok=self.admin_user_tok,
- state_key="test",
- )
- self.helper.send_state(
- room_id,
- "m.room.canonical_alias",
- {"alias": test_alias},
- tok=self.admin_user_tok,
- )
- # Set a name for the room
- self.helper.send_state(
- room_id,
- "m.room.name",
- {"name": test_room_name},
- tok=self.admin_user_tok,
- )
- # Request the list of rooms
- url = "/_synapse/admin/v1/rooms"
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Check that rooms were returned
- self.assertTrue("rooms" in channel.json_body)
- rooms = channel.json_body["rooms"]
- # Check that only one room was returned
- self.assertEqual(len(rooms), 1)
- # And that the value of the total_rooms key was correct
- self.assertEqual(channel.json_body["total_rooms"], 1)
- # Check that the offset is correct
- # We're not paginating, so should be 0
- self.assertEqual(channel.json_body["offset"], 0)
- # Check that there is no `prev_batch`
- self.assertNotIn("prev_batch", channel.json_body)
- # Check that there is no `next_batch`
- self.assertNotIn("next_batch", channel.json_body)
- # Check that all provided attributes are set
- r = rooms[0]
- self.assertEqual(room_id, r["room_id"])
- self.assertEqual(test_room_name, r["name"])
- self.assertEqual(test_alias, r["canonical_alias"])
- self.assertEqual(RoomTypes.SPACE, r["room_type"])
- def test_room_list_sort_order(self) -> None:
- """Test room list sort ordering. alphabetical name versus number of members,
- reversing the order, etc.
- """
- def _order_test(
- order_type: str,
- expected_room_list: List[str],
- reverse: bool = False,
- ) -> None:
- """Request the list of rooms in a certain order. Assert that order is what
- we expect
- Args:
- order_type: The type of ordering to give the server
- expected_room_list: The list of room_ids in the order we expect to get
- back from the server
- """
- # Request the list of rooms in the given order
- url = "/_synapse/admin/v1/rooms?order_by=%s" % (order_type,)
- if reverse:
- url += "&dir=b"
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Check that rooms were returned
- self.assertTrue("rooms" in channel.json_body)
- rooms = channel.json_body["rooms"]
- # Check for the correct total_rooms value
- self.assertEqual(channel.json_body["total_rooms"], 3)
- # Check that the offset is correct
- # We're not paginating, so should be 0
- self.assertEqual(channel.json_body["offset"], 0)
- # Check that there is no `prev_batch`
- self.assertNotIn("prev_batch", channel.json_body)
- # Check that there is no `next_batch`
- self.assertNotIn("next_batch", channel.json_body)
- # Check that rooms were returned in alphabetical order
- returned_order = [r["room_id"] for r in rooms]
- self.assertListEqual(expected_room_list, returned_order) # order is checked
- # Create 3 test rooms
- room_id_1 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_id_2 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_id_3 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- # Also create a list sorted by IDs for properties that are equal (and thus sorted by room_id)
- sorted_by_room_id_asc = [room_id_1, room_id_2, room_id_3]
- sorted_by_room_id_asc.sort()
- sorted_by_room_id_desc = sorted_by_room_id_asc.copy()
- sorted_by_room_id_desc.reverse()
- # Set room names in alphabetical order. room 1 -> A, 2 -> B, 3 -> C
- self.helper.send_state(
- room_id_1,
- "m.room.name",
- {"name": "A"},
- tok=self.admin_user_tok,
- )
- self.helper.send_state(
- room_id_2,
- "m.room.name",
- {"name": "B"},
- tok=self.admin_user_tok,
- )
- self.helper.send_state(
- room_id_3,
- "m.room.name",
- {"name": "C"},
- tok=self.admin_user_tok,
- )
- # Set room canonical room aliases
- self._set_canonical_alias(room_id_1, "#A_alias:test", self.admin_user_tok)
- self._set_canonical_alias(room_id_2, "#B_alias:test", self.admin_user_tok)
- self._set_canonical_alias(room_id_3, "#C_alias:test", self.admin_user_tok)
- # Set room member size in the reverse order. room 1 -> 1 member, 2 -> 2, 3 -> 3
- user_1 = self.register_user("bob1", "pass")
- user_1_tok = self.login("bob1", "pass")
- self.helper.join(room_id_2, user_1, tok=user_1_tok)
- user_2 = self.register_user("bob2", "pass")
- user_2_tok = self.login("bob2", "pass")
- self.helper.join(room_id_3, user_2, tok=user_2_tok)
- user_3 = self.register_user("bob3", "pass")
- user_3_tok = self.login("bob3", "pass")
- self.helper.join(room_id_3, user_3, tok=user_3_tok)
- # Test different sort orders, with forward and reverse directions
- _order_test("name", [room_id_1, room_id_2, room_id_3])
- _order_test("name", [room_id_3, room_id_2, room_id_1], reverse=True)
- _order_test("canonical_alias", [room_id_1, room_id_2, room_id_3])
- _order_test("canonical_alias", [room_id_3, room_id_2, room_id_1], reverse=True)
- # Note: joined_member counts are sorted in descending order when dir=f
- _order_test("joined_members", [room_id_3, room_id_2, room_id_1])
- _order_test("joined_members", [room_id_1, room_id_2, room_id_3], reverse=True)
- # Note: joined_local_member counts are sorted in descending order when dir=f
- _order_test("joined_local_members", [room_id_3, room_id_2, room_id_1])
- _order_test(
- "joined_local_members", [room_id_1, room_id_2, room_id_3], reverse=True
- )
- # Note: versions are sorted in descending order when dir=f
- _order_test("version", sorted_by_room_id_asc, reverse=True)
- _order_test("version", sorted_by_room_id_desc)
- _order_test("creator", sorted_by_room_id_asc)
- _order_test("creator", sorted_by_room_id_desc, reverse=True)
- _order_test("encryption", sorted_by_room_id_asc)
- _order_test("encryption", sorted_by_room_id_desc, reverse=True)
- _order_test("federatable", sorted_by_room_id_asc)
- _order_test("federatable", sorted_by_room_id_desc, reverse=True)
- _order_test("public", sorted_by_room_id_asc)
- _order_test("public", sorted_by_room_id_desc, reverse=True)
- _order_test("join_rules", sorted_by_room_id_asc)
- _order_test("join_rules", sorted_by_room_id_desc, reverse=True)
- _order_test("guest_access", sorted_by_room_id_asc)
- _order_test("guest_access", sorted_by_room_id_desc, reverse=True)
- _order_test("history_visibility", sorted_by_room_id_asc)
- _order_test("history_visibility", sorted_by_room_id_desc, reverse=True)
- # Note: state_event counts are sorted in descending order when dir=f
- _order_test("state_events", [room_id_3, room_id_2, room_id_1])
- _order_test("state_events", [room_id_1, room_id_2, room_id_3], reverse=True)
- def test_search_term(self) -> None:
- """Test that searching for a room works correctly"""
- # Create two test rooms
- room_id_1 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_id_2 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_name_1 = "something"
- room_name_2 = "LoremIpsum"
- # Set the name for each room
- self.helper.send_state(
- room_id_1,
- "m.room.name",
- {"name": room_name_1},
- tok=self.admin_user_tok,
- )
- self.helper.send_state(
- room_id_2,
- "m.room.name",
- {"name": room_name_2},
- tok=self.admin_user_tok,
- )
- self._set_canonical_alias(room_id_1, "#Room_Alias1:test", self.admin_user_tok)
- def _search_test(
- expected_room_id: Optional[str],
- search_term: str,
- expected_http_code: int = 200,
- ) -> None:
- """Search for a room and check that the returned room's id is a match
- Args:
- expected_room_id: The room_id expected to be returned by the API. Set
- to None to expect zero results for the search
- search_term: The term to search for room names with
- expected_http_code: The expected http code for the request
- """
- url = "/_synapse/admin/v1/rooms?search_term=%s" % (search_term,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(expected_http_code, channel.code, msg=channel.json_body)
- if expected_http_code != 200:
- return
- # Check that rooms were returned
- self.assertTrue("rooms" in channel.json_body)
- rooms = channel.json_body["rooms"]
- # Check that the expected number of rooms were returned
- expected_room_count = 1 if expected_room_id else 0
- self.assertEqual(len(rooms), expected_room_count)
- self.assertEqual(channel.json_body["total_rooms"], expected_room_count)
- # Check that the offset is correct
- # We're not paginating, so should be 0
- self.assertEqual(channel.json_body["offset"], 0)
- # Check that there is no `prev_batch`
- self.assertNotIn("prev_batch", channel.json_body)
- # Check that there is no `next_batch`
- self.assertNotIn("next_batch", channel.json_body)
- if expected_room_id:
- # Check that the first returned room id is correct
- r = rooms[0]
- self.assertEqual(expected_room_id, r["room_id"])
- # Test searching by room name
- _search_test(room_id_1, "something")
- _search_test(room_id_1, "thing")
- _search_test(room_id_2, "LoremIpsum")
- _search_test(room_id_2, "lorem")
- # Test case insensitive
- _search_test(room_id_1, "SOMETHING")
- _search_test(room_id_1, "THING")
- _search_test(room_id_2, "LOREMIPSUM")
- _search_test(room_id_2, "LOREM")
- _search_test(None, "foo")
- _search_test(None, "bar")
- _search_test(None, "", expected_http_code=400)
- # Test that the whole room id returns the room
- _search_test(room_id_1, room_id_1)
- # Test that the search by room_id is case sensitive
- _search_test(None, room_id_1.lower())
- # Test search part of local part of room id do not match
- _search_test(None, room_id_1[1:10])
- # Test that whole room alias return no result, because of domain
- _search_test(None, "#Room_Alias1:test")
- # Test search local part of alias
- _search_test(room_id_1, "alias1")
- def test_search_term_non_ascii(self) -> None:
- """Test that searching for a room with non-ASCII characters works correctly"""
- # Create test room
- room_id = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_name = "ж"
- # Set the name for the room
- self.helper.send_state(
- room_id,
- "m.room.name",
- {"name": room_name},
- tok=self.admin_user_tok,
- )
- # make the request and test that the response is what we wanted
- search_term = urllib.parse.quote("ж", "utf-8")
- url = "/_synapse/admin/v1/rooms?search_term=%s" % (search_term,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(room_id, channel.json_body["rooms"][0].get("room_id"))
- self.assertEqual("ж", channel.json_body["rooms"][0].get("name"))
- def test_single_room(self) -> None:
- """Test that a single room can be requested correctly"""
- # Create two test rooms
- room_id_1 = self.helper.create_room_as(
- self.admin_user, tok=self.admin_user_tok, is_public=True
- )
- room_id_2 = self.helper.create_room_as(
- self.admin_user, tok=self.admin_user_tok, is_public=False
- )
- room_name_1 = "something"
- room_name_2 = "else"
- # Set the name for each room
- self.helper.send_state(
- room_id_1,
- "m.room.name",
- {"name": room_name_1},
- tok=self.admin_user_tok,
- )
- self.helper.send_state(
- room_id_2,
- "m.room.name",
- {"name": room_name_2},
- tok=self.admin_user_tok,
- )
- url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("room_id", channel.json_body)
- self.assertIn("name", channel.json_body)
- self.assertIn("topic", channel.json_body)
- self.assertIn("avatar", channel.json_body)
- self.assertIn("canonical_alias", channel.json_body)
- self.assertIn("joined_members", channel.json_body)
- self.assertIn("joined_local_members", channel.json_body)
- self.assertIn("joined_local_devices", channel.json_body)
- self.assertIn("version", channel.json_body)
- self.assertIn("creator", channel.json_body)
- self.assertIn("encryption", channel.json_body)
- self.assertIn("federatable", channel.json_body)
- self.assertIn("public", channel.json_body)
- self.assertIn("join_rules", channel.json_body)
- self.assertIn("guest_access", channel.json_body)
- self.assertIn("history_visibility", channel.json_body)
- self.assertIn("state_events", channel.json_body)
- self.assertIn("room_type", channel.json_body)
- self.assertIn("forgotten", channel.json_body)
- self.assertEqual(room_id_1, channel.json_body["room_id"])
- self.assertIs(True, channel.json_body["federatable"])
- self.assertIs(True, channel.json_body["public"])
- def test_single_room_devices(self) -> None:
- """Test that `joined_local_devices` can be requested correctly"""
- room_id_1 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(1, channel.json_body["joined_local_devices"])
- # Have another user join the room
- user_1 = self.register_user("foo", "pass")
- user_tok_1 = self.login("foo", "pass")
- self.helper.join(room_id_1, user_1, tok=user_tok_1)
- url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(2, channel.json_body["joined_local_devices"])
- # leave room
- self.helper.leave(room_id_1, self.admin_user, tok=self.admin_user_tok)
- self.helper.leave(room_id_1, user_1, tok=user_tok_1)
- url = "/_synapse/admin/v1/rooms/%s" % (room_id_1,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(0, channel.json_body["joined_local_devices"])
- def test_room_members(self) -> None:
- """Test that room members can be requested correctly"""
- # Create two test rooms
- room_id_1 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- room_id_2 = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- # Have another user join the room
- user_1 = self.register_user("foo", "pass")
- user_tok_1 = self.login("foo", "pass")
- self.helper.join(room_id_1, user_1, tok=user_tok_1)
- # Have another user join the room
- user_2 = self.register_user("bar", "pass")
- user_tok_2 = self.login("bar", "pass")
- self.helper.join(room_id_1, user_2, tok=user_tok_2)
- self.helper.join(room_id_2, user_2, tok=user_tok_2)
- # Have another user join the room
- user_3 = self.register_user("foobar", "pass")
- user_tok_3 = self.login("foobar", "pass")
- self.helper.join(room_id_2, user_3, tok=user_tok_3)
- url = "/_synapse/admin/v1/rooms/%s/members" % (room_id_1,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertCountEqual(
- ["@admin:test", "@foo:test", "@bar:test"], channel.json_body["members"]
- )
- self.assertEqual(channel.json_body["total"], 3)
- url = "/_synapse/admin/v1/rooms/%s/members" % (room_id_2,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertCountEqual(
- ["@admin:test", "@bar:test", "@foobar:test"], channel.json_body["members"]
- )
- self.assertEqual(channel.json_body["total"], 3)
- def test_room_state(self) -> None:
- """Test that room state can be requested correctly"""
- # Create two test rooms
- room_id = self.helper.create_room_as(self.admin_user, tok=self.admin_user_tok)
- url = "/_synapse/admin/v1/rooms/%s/state" % (room_id,)
- channel = self.make_request(
- "GET",
- url.encode("ascii"),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertIn("state", channel.json_body)
- # testing that the state events match is painful and not done here. We assume that
- # the create_room already does the right thing, so no need to verify that we got
- # the state events it created.
- def _set_canonical_alias(
- self, room_id: str, test_alias: str, admin_user_tok: str
- ) -> None:
- # Create a new alias to this room
- url = "/_matrix/client/r0/directory/room/%s" % (urllib.parse.quote(test_alias),)
- channel = self.make_request(
- "PUT",
- url.encode("ascii"),
- {"room_id": room_id},
- access_token=admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Set this new alias as the canonical alias for this room
- self.helper.send_state(
- room_id,
- "m.room.aliases",
- {"aliases": [test_alias]},
- tok=admin_user_tok,
- state_key="test",
- )
- self.helper.send_state(
- room_id,
- "m.room.canonical_alias",
- {"alias": test_alias},
- tok=admin_user_tok,
- )
- def test_get_joined_members_after_leave_room(self) -> None:
- """Test that requesting room members after leaving the room raises a 403 error."""
- # create the room
- user = self.register_user("foo", "pass")
- user_tok = self.login("foo", "pass")
- room_id = self.helper.create_room_as(user, tok=user_tok)
- self.helper.leave(room_id, user, tok=user_tok)
- # delete the rooms and get joined roomed membership
- url = f"/_matrix/client/r0/rooms/{room_id}/joined_members"
- channel = self.make_request("GET", url.encode("ascii"), access_token=user_tok)
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- class RoomMessagesTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- login.register_servlets,
- room.register_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.user = self.register_user("foo", "pass")
- self.user_tok = self.login("foo", "pass")
- self.room_id = self.helper.create_room_as(self.user, tok=self.user_tok)
- def test_timestamp_to_event(self) -> None:
- """Test that providing the current timestamp can get the last event."""
- self.helper.send(self.room_id, body="message 1", tok=self.user_tok)
- second_event_id = self.helper.send(
- self.room_id, body="message 2", tok=self.user_tok
- )["event_id"]
- ts = str(round(time.time() * 1000))
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/timestamp_to_event?dir=b&ts=%s"
- % (self.room_id, ts),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code)
- self.assertIn("event_id", channel.json_body)
- self.assertEqual(second_event_id, channel.json_body["event_id"])
- def test_topo_token_is_accepted(self) -> None:
- """Test Topo Token is accepted."""
- token = "t1-0_0_0_0_0_0_0_0_0_0"
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?from=%s" % (self.room_id, token),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code)
- self.assertIn("start", channel.json_body)
- self.assertEqual(token, channel.json_body["start"])
- self.assertIn("chunk", channel.json_body)
- self.assertIn("end", channel.json_body)
- def test_stream_token_is_accepted_for_fwd_pagianation(self) -> None:
- """Test that stream token is accepted for forward pagination."""
- token = "s0_0_0_0_0_0_0_0_0_0"
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?from=%s" % (self.room_id, token),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code)
- self.assertIn("start", channel.json_body)
- self.assertEqual(token, channel.json_body["start"])
- self.assertIn("chunk", channel.json_body)
- self.assertIn("end", channel.json_body)
- def test_room_messages_backward(self) -> None:
- """Test room messages can be retrieved by an admin that isn't in the room."""
- latest_event_id = self.helper.send(
- self.room_id, body="message 1", tok=self.user_tok
- )["event_id"]
- # Check that we get the first and second message when querying /messages.
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?dir=b" % (self.room_id,),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(channel.code, 200, channel.json_body)
- chunk = channel.json_body["chunk"]
- self.assertEqual(len(chunk), 6, [event["content"] for event in chunk])
- # in backwards, this is the first event
- self.assertEqual(chunk[0]["event_id"], latest_event_id)
- def test_room_messages_forward(self) -> None:
- """Test room messages can be retrieved by an admin that isn't in the room."""
- latest_event_id = self.helper.send(
- self.room_id, body="message 1", tok=self.user_tok
- )["event_id"]
- # Check that we get the first and second message when querying /messages.
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?dir=f" % (self.room_id,),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(channel.code, 200, channel.json_body)
- chunk = channel.json_body["chunk"]
- self.assertEqual(len(chunk), 6, [event["content"] for event in chunk])
- # in forward, this is the last event
- self.assertEqual(chunk[5]["event_id"], latest_event_id)
- def test_room_messages_purge(self) -> None:
- """Test room messages can be retrieved by an admin that isn't in the room."""
- 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, body="message 1", tok=self.user_tok
- )["event_id"]
- first_token = self.get_success(
- store.get_topological_token_for_event(first_event_id)
- )
- first_token_str = 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, body="message 2", tok=self.user_tok
- )["event_id"]
- second_token = self.get_success(
- store.get_topological_token_for_event(second_event_id)
- )
- second_token_str = 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, body="message 3", tok=self.user_tok)
- # Check that we get the first and second message when querying /messages.
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?from=%s&dir=b&filter=%s"
- % (
- self.room_id,
- second_token_str,
- json.dumps({"types": [EventTypes.Message]}),
- ),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(channel.code, 200, channel.json_body)
- chunk = channel.json_body["chunk"]
- self.assertEqual(len(chunk), 2, [event["content"] for event in chunk])
- # Purge every event before the second event.
- self.get_success(
- pagination_handler.purge_history(
- room_id=self.room_id,
- token=second_token_str,
- delete_local_events=True,
- )
- )
- # Check that we only get the second message through /message now that the first
- # has been purged.
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?from=%s&dir=b&filter=%s"
- % (
- self.room_id,
- second_token_str,
- json.dumps({"types": [EventTypes.Message]}),
- ),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(channel.code, 200, channel.json_body)
- chunk = channel.json_body["chunk"]
- self.assertEqual(len(chunk), 1, [event["content"] for event in chunk])
- # 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(
- "GET",
- "/_synapse/admin/v1/rooms/%s/messages?from=%s&dir=b&filter=%s"
- % (
- self.room_id,
- first_token_str,
- json.dumps({"types": [EventTypes.Message]}),
- ),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(channel.code, 200, channel.json_body)
- chunk = channel.json_body["chunk"]
- self.assertEqual(len(chunk), 0, [event["content"] for event in chunk])
- class JoinAliasRoomTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- room.register_servlets,
- login.register_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.creator = self.register_user("creator", "test")
- self.creator_tok = self.login("creator", "test")
- self.second_user_id = self.register_user("second", "test")
- self.second_tok = self.login("second", "test")
- self.public_room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=True
- )
- self.url = f"/_synapse/admin/v1/join/{self.public_room_id}"
- def test_requester_is_no_admin(self) -> None:
- """
- If the user is not a server admin, an error 403 is returned.
- """
- channel = self.make_request(
- "POST",
- self.url,
- content={"user_id": self.second_user_id},
- access_token=self.second_tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- def test_invalid_parameter(self) -> None:
- """
- If a parameter is missing, return an error
- """
- channel = self.make_request(
- "POST",
- self.url,
- content={"unknown_parameter": "@unknown:test"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.MISSING_PARAM, channel.json_body["errcode"])
- def test_local_user_does_not_exist(self) -> None:
- """
- Tests that a lookup for a user that does not exist returns a 404
- """
- channel = self.make_request(
- "POST",
- self.url,
- content={"user_id": "@unknown:test"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(404, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.NOT_FOUND, channel.json_body["errcode"])
- def test_remote_user(self) -> None:
- """
- Check that only local user can join rooms.
- """
- channel = self.make_request(
- "POST",
- self.url,
- content={"user_id": "@not:exist.bla"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "This endpoint can only be used with local users",
- channel.json_body["error"],
- )
- def test_room_does_not_exist(self) -> None:
- """
- Check that unknown rooms/server return error 404.
- """
- url = "/_synapse/admin/v1/join/!unknown:test"
- channel = self.make_request(
- "POST",
- url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(404, channel.code, msg=channel.json_body)
- self.assertEqual(
- "Can't join remote room because no servers that are in the room have been provided.",
- channel.json_body["error"],
- )
- def test_room_is_not_valid(self) -> None:
- """
- Check that invalid room names, return an error 400.
- """
- url = "/_synapse/admin/v1/join/invalidroom"
- channel = self.make_request(
- "POST",
- url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "invalidroom was not legal room ID or room alias",
- channel.json_body["error"],
- )
- def test_join_public_room(self) -> None:
- """
- Test joining a local user to a public room with "JoinRules.PUBLIC"
- """
- channel = self.make_request(
- "POST",
- self.url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(self.public_room_id, channel.json_body["room_id"])
- # Validate if user is a member of the room
- channel = self.make_request(
- "GET",
- "/_matrix/client/r0/joined_rooms",
- access_token=self.second_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(self.public_room_id, channel.json_body["joined_rooms"][0])
- def test_join_private_room_if_not_member(self) -> None:
- """
- Test joining a local user to a private room with "JoinRules.INVITE"
- when server admin is not member of this room.
- """
- private_room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=False
- )
- url = f"/_synapse/admin/v1/join/{private_room_id}"
- channel = self.make_request(
- "POST",
- url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- def test_join_private_room_if_member(self) -> None:
- """
- Test joining a local user to a private room with "JoinRules.INVITE",
- when server admin is member of this room.
- """
- private_room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=False
- )
- self.helper.invite(
- room=private_room_id,
- src=self.creator,
- targ=self.admin_user,
- tok=self.creator_tok,
- )
- self.helper.join(
- room=private_room_id, user=self.admin_user, tok=self.admin_user_tok
- )
- # Validate if server admin is a member of the room
- channel = self.make_request(
- "GET",
- "/_matrix/client/r0/joined_rooms",
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
- # Join user to room.
- url = f"/_synapse/admin/v1/join/{private_room_id}"
- channel = self.make_request(
- "POST",
- url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(private_room_id, channel.json_body["room_id"])
- # Validate if user is a member of the room
- channel = self.make_request(
- "GET",
- "/_matrix/client/r0/joined_rooms",
- access_token=self.second_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
- def test_join_private_room_if_owner(self) -> None:
- """
- Test joining a local user to a private room with "JoinRules.INVITE",
- when server admin is owner of this room.
- """
- private_room_id = self.helper.create_room_as(
- self.admin_user, tok=self.admin_user_tok, is_public=False
- )
- url = f"/_synapse/admin/v1/join/{private_room_id}"
- channel = self.make_request(
- "POST",
- url,
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(private_room_id, channel.json_body["room_id"])
- # Validate if user is a member of the room
- channel = self.make_request(
- "GET",
- "/_matrix/client/r0/joined_rooms",
- access_token=self.second_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(private_room_id, channel.json_body["joined_rooms"][0])
- def test_context_as_non_admin(self) -> None:
- """
- Test that, without being admin, one cannot use the context admin API
- """
- # Create a room.
- user_id = self.register_user("test", "test")
- user_tok = self.login("test", "test")
- self.register_user("test_2", "test")
- user_tok_2 = self.login("test_2", "test")
- room_id = self.helper.create_room_as(user_id, tok=user_tok)
- # Populate the room with events.
- events = []
- for i in range(30):
- events.append(
- self.helper.send_event(
- room_id, "com.example.test", content={"index": i}, tok=user_tok
- )
- )
- # Now attempt to find the context using the admin API without being admin.
- midway = (len(events) - 1) // 2
- for tok in [user_tok, user_tok_2]:
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/context/%s"
- % (room_id, events[midway]["event_id"]),
- access_token=tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- def test_context_as_admin(self) -> None:
- """
- Test that, as admin, we can find the context of an event without having joined the room.
- """
- # Create a room. We're not part of it.
- user_id = self.register_user("test", "test")
- user_tok = self.login("test", "test")
- room_id = self.helper.create_room_as(user_id, tok=user_tok)
- # Populate the room with events.
- events = []
- for i in range(30):
- events.append(
- self.helper.send_event(
- room_id, "com.example.test", content={"index": i}, tok=user_tok
- )
- )
- # Now let's fetch the context for this room.
- midway = (len(events) - 1) // 2
- channel = self.make_request(
- "GET",
- "/_synapse/admin/v1/rooms/%s/context/%s"
- % (room_id, events[midway]["event_id"]),
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertEqual(
- channel.json_body["event"]["event_id"], events[midway]["event_id"]
- )
- for found_event in channel.json_body["events_before"]:
- for j, posted_event in enumerate(events):
- if found_event["event_id"] == posted_event["event_id"]:
- self.assertTrue(j < midway)
- break
- else:
- self.fail("Event %s from events_before not found" % j)
- for found_event in channel.json_body["events_after"]:
- for j, posted_event in enumerate(events):
- if found_event["event_id"] == posted_event["event_id"]:
- self.assertTrue(j > midway)
- break
- else:
- self.fail("Event %s from events_after not found" % j)
- class MakeRoomAdminTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- room.register_servlets,
- login.register_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.creator = self.register_user("creator", "test")
- self.creator_tok = self.login("creator", "test")
- self.second_user_id = self.register_user("second", "test")
- self.second_tok = self.login("second", "test")
- self.public_room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=True
- )
- self.url = "/_synapse/admin/v1/rooms/{}/make_room_admin".format(
- self.public_room_id
- )
- def test_public_room(self) -> None:
- """Test that getting admin in a public room works."""
- room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=True
- )
- channel = self.make_request(
- "POST",
- f"/_synapse/admin/v1/rooms/{room_id}/make_room_admin",
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Now we test that we can join the room and ban a user.
- self.helper.join(room_id, self.admin_user, tok=self.admin_user_tok)
- self.helper.change_membership(
- room_id,
- self.admin_user,
- "@test:test",
- Membership.BAN,
- tok=self.admin_user_tok,
- )
- def test_private_room(self) -> None:
- """Test that getting admin in a private room works and we get invited."""
- room_id = self.helper.create_room_as(
- self.creator,
- tok=self.creator_tok,
- is_public=False,
- )
- channel = self.make_request(
- "POST",
- f"/_synapse/admin/v1/rooms/{room_id}/make_room_admin",
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Now we test that we can join the room (we should have received an
- # invite) and can ban a user.
- self.helper.join(room_id, self.admin_user, tok=self.admin_user_tok)
- self.helper.change_membership(
- room_id,
- self.admin_user,
- "@test:test",
- Membership.BAN,
- tok=self.admin_user_tok,
- )
- def test_other_user(self) -> None:
- """Test that giving admin in a public room works to a non-admin user works."""
- room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=True
- )
- channel = self.make_request(
- "POST",
- f"/_synapse/admin/v1/rooms/{room_id}/make_room_admin",
- content={"user_id": self.second_user_id},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- # Now we test that we can join the room and ban a user.
- self.helper.join(room_id, self.second_user_id, tok=self.second_tok)
- self.helper.change_membership(
- room_id,
- self.second_user_id,
- "@test:test",
- Membership.BAN,
- tok=self.second_tok,
- )
- def test_not_enough_power(self) -> None:
- """Test that we get a sensible error if there are no local room admins."""
- room_id = self.helper.create_room_as(
- self.creator, tok=self.creator_tok, is_public=True
- )
- # The creator drops admin rights in the room.
- pl = self.helper.get_state(
- room_id, EventTypes.PowerLevels, tok=self.creator_tok
- )
- pl["users"][self.creator] = 0
- self.helper.send_state(
- room_id, EventTypes.PowerLevels, body=pl, tok=self.creator_tok
- )
- channel = self.make_request(
- "POST",
- f"/_synapse/admin/v1/rooms/{room_id}/make_room_admin",
- content={},
- access_token=self.admin_user_tok,
- )
- # We expect this to fail with a 400 as there are no room admins.
- #
- # (Note we assert the error message to ensure that it's not denied for
- # some other reason)
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- channel.json_body["error"],
- "No local admin user in room with power to update power levels.",
- )
- class BlockRoomTestCase(unittest.HomeserverTestCase):
- servlets = [
- synapse.rest.admin.register_servlets,
- room.register_servlets,
- login.register_servlets,
- ]
- def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
- self._store = hs.get_datastores().main
- self.admin_user = self.register_user("admin", "pass", admin=True)
- self.admin_user_tok = self.login("admin", "pass")
- self.other_user = self.register_user("user", "pass")
- self.other_user_tok = self.login("user", "pass")
- self.room_id = self.helper.create_room_as(
- self.other_user, tok=self.other_user_tok
- )
- self.url = "/_synapse/admin/v1/rooms/%s/block"
- @parameterized.expand([("PUT",), ("GET",)])
- def test_requester_is_no_admin(self, method: str) -> None:
- """If the user is not a server admin, an error 403 is returned."""
- channel = self.make_request(
- method,
- self.url % self.room_id,
- content={},
- access_token=self.other_user_tok,
- )
- self.assertEqual(403, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.FORBIDDEN, channel.json_body["errcode"])
- @parameterized.expand([("PUT",), ("GET",)])
- def test_room_is_not_valid(self, method: str) -> None:
- """Check that invalid room names, return an error 400."""
- channel = self.make_request(
- method,
- self.url % "invalidroom",
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(
- "invalidroom is not a legal room ID",
- channel.json_body["error"],
- )
- def test_block_is_not_valid(self) -> None:
- """If parameter `block` is not valid, return an error."""
- # `block` is not valid
- channel = self.make_request(
- "PUT",
- self.url % self.room_id,
- content={"block": "NotBool"},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.BAD_JSON, channel.json_body["errcode"])
- # `block` is not set
- channel = self.make_request(
- "PUT",
- self.url % self.room_id,
- content={},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.MISSING_PARAM, channel.json_body["errcode"])
- # no content is send
- channel = self.make_request(
- "PUT",
- self.url % self.room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(400, channel.code, msg=channel.json_body)
- self.assertEqual(Codes.NOT_JSON, channel.json_body["errcode"])
- def test_block_room(self) -> None:
- """Test that block a room is successful."""
- def _request_and_test_block_room(room_id: str) -> None:
- self._is_blocked(room_id, expect=False)
- channel = self.make_request(
- "PUT",
- self.url % room_id,
- content={"block": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertTrue(channel.json_body["block"])
- self._is_blocked(room_id, expect=True)
- # known internal room
- _request_and_test_block_room(self.room_id)
- # unknown internal room
- _request_and_test_block_room("!unknown:test")
- # unknown remote room
- _request_and_test_block_room("!unknown:remote")
- def test_block_room_twice(self) -> None:
- """Test that block a room that is already blocked is successful."""
- self._is_blocked(self.room_id, expect=False)
- for _ in range(2):
- channel = self.make_request(
- "PUT",
- self.url % self.room_id,
- content={"block": True},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertTrue(channel.json_body["block"])
- self._is_blocked(self.room_id, expect=True)
- def test_unblock_room(self) -> None:
- """Test that unblock a room is successful."""
- def _request_and_test_unblock_room(room_id: str) -> None:
- self._block_room(room_id)
- channel = self.make_request(
- "PUT",
- self.url % room_id,
- content={"block": False},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertFalse(channel.json_body["block"])
- self._is_blocked(room_id, expect=False)
- # known internal room
- _request_and_test_unblock_room(self.room_id)
- # unknown internal room
- _request_and_test_unblock_room("!unknown:test")
- # unknown remote room
- _request_and_test_unblock_room("!unknown:remote")
- def test_unblock_room_twice(self) -> None:
- """Test that unblock a room that is not blocked is successful."""
- self._block_room(self.room_id)
- for _ in range(2):
- channel = self.make_request(
- "PUT",
- self.url % self.room_id,
- content={"block": False},
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertFalse(channel.json_body["block"])
- self._is_blocked(self.room_id, expect=False)
- def test_get_blocked_room(self) -> None:
- """Test get status of a blocked room"""
- def _request_blocked_room(room_id: str) -> None:
- self._block_room(room_id)
- channel = self.make_request(
- "GET",
- self.url % room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertTrue(channel.json_body["block"])
- self.assertEqual(self.other_user, channel.json_body["user_id"])
- # known internal room
- _request_blocked_room(self.room_id)
- # unknown internal room
- _request_blocked_room("!unknown:test")
- # unknown remote room
- _request_blocked_room("!unknown:remote")
- def test_get_unblocked_room(self) -> None:
- """Test get status of a unblocked room"""
- def _request_unblocked_room(room_id: str) -> None:
- self._is_blocked(room_id, expect=False)
- channel = self.make_request(
- "GET",
- self.url % room_id,
- access_token=self.admin_user_tok,
- )
- self.assertEqual(200, channel.code, msg=channel.json_body)
- self.assertFalse(channel.json_body["block"])
- self.assertNotIn("user_id", channel.json_body)
- # known internal room
- _request_unblocked_room(self.room_id)
- # unknown internal room
- _request_unblocked_room("!unknown:test")
- # unknown remote room
- _request_unblocked_room("!unknown:remote")
- def _is_blocked(self, room_id: str, expect: bool = True) -> None:
- """Assert that the room is blocked or not"""
- d = self._store.is_room_blocked(room_id)
- if expect:
- self.assertTrue(self.get_success(d))
- else:
- self.assertIsNone(self.get_success(d))
- def _block_room(self, room_id: str) -> None:
- """Block a room in database"""
- self.get_success(self._store.block_room(room_id, self.other_user))
- self._is_blocked(room_id, expect=True)
- PURGE_TABLES = [
- "current_state_events",
- "event_backward_extremities",
- "event_forward_extremities",
- "event_json",
- "event_push_actions",
- "event_search",
- "events",
- "receipts_graph",
- "receipts_linearized",
- "room_aliases",
- "room_depth",
- "room_memberships",
- "room_stats_state",
- "room_stats_current",
- "room_stats_earliest_token",
- "rooms",
- "stream_ordering_to_exterm",
- "users_in_public_rooms",
- "users_who_share_private_rooms",
- "appservice_room_list",
- "e2e_room_keys",
- "event_push_summary",
- "pusher_throttle",
- "room_account_data",
- "room_tags",
- # "state_groups", # Current impl leaves orphaned state groups around.
- "state_groups_state",
- "federation_inbound_events_staging",
- ]
|