123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791 |
- # Copyright 2019 The Matrix.org Foundation C.I.C.
- #
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
- #
- # http://www.apache.org/licenses/LICENSE-2.0
- #
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
- import logging
- from typing import Collection, Optional, cast
- from unittest import TestCase
- from unittest.mock import Mock, patch
- from twisted.internet.defer import Deferred
- from twisted.test.proto_helpers import MemoryReactor
- from synapse.api.constants import EventTypes
- from synapse.api.errors import (
- AuthError,
- Codes,
- LimitExceededError,
- NotFoundError,
- SynapseError,
- )
- from synapse.api.room_versions import RoomVersions
- from synapse.events import EventBase, make_event_from_dict
- from synapse.federation.federation_base import event_from_pdu_json
- from synapse.federation.federation_client import SendJoinResult
- from synapse.logging.context import LoggingContext, run_in_background
- from synapse.rest import admin
- from synapse.rest.client import login, room
- from synapse.server import HomeServer
- from synapse.storage.databases.main.events_worker import EventCacheEntry
- from synapse.util import Clock
- from synapse.util.stringutils import random_string
- from tests import unittest
- from tests.test_utils import event_injection, make_awaitable
- logger = logging.getLogger(__name__)
- def generate_fake_event_id() -> str:
- return "$fake_" + random_string(43)
- class FederationTestCase(unittest.FederatingHomeserverTestCase):
- servlets = [
- admin.register_servlets,
- login.register_servlets,
- room.register_servlets,
- ]
- def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
- hs = self.setup_test_homeserver(federation_http_client=None)
- self.handler = hs.get_federation_handler()
- self.store = hs.get_datastores().main
- return hs
- def test_exchange_revoked_invite(self) -> None:
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- # Send a 3PID invite event with an empty body so it's considered as a revoked one.
- invite_token = "sometoken"
- self.helper.send_state(
- room_id=room_id,
- event_type=EventTypes.ThirdPartyInvite,
- state_key=invite_token,
- body={},
- tok=tok,
- )
- d = self.handler.on_exchange_third_party_invite_request(
- event_dict={
- "type": EventTypes.Member,
- "room_id": room_id,
- "sender": user_id,
- "state_key": "@someone:example.org",
- "content": {
- "membership": "invite",
- "third_party_invite": {
- "display_name": "alice",
- "signed": {
- "mxid": "@alice:localhost",
- "token": invite_token,
- "signatures": {
- "magic.forest": {
- "ed25519:3": "fQpGIW1Snz+pwLZu6sTy2aHy/DYWWTspTJRPyNp0PKkymfIsNffysMl6ObMMFdIJhk6g6pwlIqZ54rxo8SLmAg"
- }
- },
- },
- },
- },
- },
- )
- failure = self.get_failure(d, AuthError).value
- self.assertEqual(failure.code, 403, failure)
- self.assertEqual(failure.errcode, Codes.FORBIDDEN, failure)
- self.assertEqual(failure.msg, "You are not invited to this room.")
- def test_rejected_message_event_state(self) -> None:
- """
- Check that we store the state group correctly for rejected non-state events.
- Regression test for #6289.
- """
- OTHER_SERVER = "otherserver"
- OTHER_USER = "@otheruser:" + OTHER_SERVER
- # create the room
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- room_version = self.get_success(self.store.get_room_version(room_id))
- # pretend that another server has joined
- join_event = self._build_and_send_join_event(OTHER_SERVER, OTHER_USER, room_id)
- # check the state group
- sg = self.get_success(
- self.store._get_state_group_for_event(join_event.event_id)
- )
- # build and send an event which will be rejected
- ev = event_from_pdu_json(
- {
- "type": EventTypes.Message,
- "content": {},
- "room_id": room_id,
- "sender": "@yetanotheruser:" + OTHER_SERVER,
- "depth": cast(int, join_event["depth"]) + 1,
- "prev_events": [join_event.event_id],
- "auth_events": [],
- "origin_server_ts": self.clock.time_msec(),
- },
- room_version,
- )
- with LoggingContext("send_rejected"):
- d = run_in_background(
- self.hs.get_federation_event_handler().on_receive_pdu, OTHER_SERVER, ev
- )
- self.get_success(d)
- # that should have been rejected
- e = self.get_success(self.store.get_event(ev.event_id, allow_rejected=True))
- self.assertIsNotNone(e.rejected_reason)
- # ... and the state group should be the same as before
- sg2 = self.get_success(self.store._get_state_group_for_event(ev.event_id))
- self.assertEqual(sg, sg2)
- def test_rejected_state_event_state(self) -> None:
- """
- Check that we store the state group correctly for rejected state events.
- Regression test for #6289.
- """
- OTHER_SERVER = "otherserver"
- OTHER_USER = "@otheruser:" + OTHER_SERVER
- # create the room
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- room_version = self.get_success(self.store.get_room_version(room_id))
- # pretend that another server has joined
- join_event = self._build_and_send_join_event(OTHER_SERVER, OTHER_USER, room_id)
- # check the state group
- sg = self.get_success(
- self.store._get_state_group_for_event(join_event.event_id)
- )
- # build and send an event which will be rejected
- ev = event_from_pdu_json(
- {
- "type": "org.matrix.test",
- "state_key": "test_key",
- "content": {},
- "room_id": room_id,
- "sender": "@yetanotheruser:" + OTHER_SERVER,
- "depth": cast(int, join_event["depth"]) + 1,
- "prev_events": [join_event.event_id],
- "auth_events": [],
- "origin_server_ts": self.clock.time_msec(),
- },
- room_version,
- )
- with LoggingContext("send_rejected"):
- d = run_in_background(
- self.hs.get_federation_event_handler().on_receive_pdu, OTHER_SERVER, ev
- )
- self.get_success(d)
- # that should have been rejected
- e = self.get_success(self.store.get_event(ev.event_id, allow_rejected=True))
- self.assertIsNotNone(e.rejected_reason)
- # ... and the state group should be the same as before
- sg2 = self.get_success(self.store._get_state_group_for_event(ev.event_id))
- self.assertEqual(sg, sg2)
- def test_backfill_with_many_backward_extremities(self) -> None:
- """
- Check that we can backfill with many backward extremities.
- The goal is to make sure that when we only use a portion
- of backwards extremities(the magic number is more than 5),
- no errors are thrown.
- Regression test, see #11027
- """
- # create the room
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- room_version = self.get_success(self.store.get_room_version(room_id))
- # we need a user on the remote server to be a member, so that we can send
- # extremity-causing events.
- remote_server_user_id = f"@user:{self.OTHER_SERVER_NAME}"
- self.get_success(
- event_injection.inject_member_event(
- self.hs, room_id, remote_server_user_id, "join"
- )
- )
- send_result = self.helper.send(room_id, "first message", tok=tok)
- ev1 = self.get_success(
- self.store.get_event(send_result["event_id"], allow_none=False)
- )
- current_state = self.get_success(
- self.store.get_events_as_list(
- (
- self.get_success(self.store.get_partial_current_state_ids(room_id))
- ).values()
- )
- )
- # Create "many" backward extremities. The magic number we're trying to
- # create more than is 5 which corresponds to the number of backward
- # extremities we slice off in `_maybe_backfill_inner`
- federation_event_handler = self.hs.get_federation_event_handler()
- auth_events = [
- ev
- for ev in current_state
- if (ev.type, ev.state_key)
- in {("m.room.create", ""), ("m.room.member", remote_server_user_id)}
- ]
- for _ in range(0, 8):
- event = make_event_from_dict(
- self.add_hashes_and_signatures_from_other_server(
- {
- "origin_server_ts": 1,
- "type": "m.room.message",
- "content": {
- "msgtype": "m.text",
- "body": "message connected to fake event",
- },
- "room_id": room_id,
- "sender": remote_server_user_id,
- "prev_events": [
- ev1.event_id,
- # We're creating an backward extremity each time thanks
- # to this fake event
- generate_fake_event_id(),
- ],
- "auth_events": [ev.event_id for ev in auth_events],
- "depth": ev1.depth + 1,
- },
- room_version,
- ),
- room_version,
- )
- # we poke this directly into _process_received_pdu, to avoid the
- # federation handler wanting to backfill the fake event.
- state_handler = self.hs.get_state_handler()
- context = self.get_success(
- state_handler.compute_event_context(
- event,
- state_ids_before_event={
- (e.type, e.state_key): e.event_id for e in current_state
- },
- partial_state=False,
- )
- )
- self.get_success(
- federation_event_handler._process_received_pdu(
- self.OTHER_SERVER_NAME,
- event,
- context,
- )
- )
- # we should now have 8 backwards extremities.
- backwards_extremities = self.get_success(
- self.store.db_pool.simple_select_list(
- "event_backward_extremities",
- keyvalues={"room_id": room_id},
- retcols=["event_id"],
- )
- )
- self.assertEqual(len(backwards_extremities), 8)
- current_depth = 1
- limit = 100
- with LoggingContext("receive_pdu"):
- # Make sure backfill still works
- d = run_in_background(
- self.hs.get_federation_handler().maybe_backfill,
- room_id,
- current_depth,
- limit,
- )
- self.get_success(d)
- def test_backfill_ignores_known_events(self) -> None:
- """
- Tests that events that we already know about are ignored when backfilling.
- """
- # Set up users
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- other_server = "otherserver"
- other_user = "@otheruser:" + other_server
- # Create a room to backfill events into
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- room_version = self.get_success(self.store.get_room_version(room_id))
- # Build an event to backfill
- event = event_from_pdu_json(
- {
- "type": EventTypes.Message,
- "content": {"body": "hello world", "msgtype": "m.text"},
- "room_id": room_id,
- "sender": other_user,
- "depth": 32,
- "prev_events": [],
- "auth_events": [],
- "origin_server_ts": self.clock.time_msec(),
- },
- room_version,
- )
- # Ensure the event is not already in the DB
- self.get_failure(
- self.store.get_event(event.event_id),
- NotFoundError,
- )
- # Backfill the event and check that it has entered the DB.
- # We mock out the FederationClient.backfill method, to pretend that a remote
- # server has returned our fake event.
- federation_client_backfill_mock = Mock(return_value=make_awaitable([event]))
- self.hs.get_federation_client().backfill = federation_client_backfill_mock # type: ignore[assignment]
- # We also mock the persist method with a side effect of itself. This allows us
- # to track when it has been called while preserving its function.
- persist_events_and_notify_mock = Mock(
- side_effect=self.hs.get_federation_event_handler().persist_events_and_notify
- )
- self.hs.get_federation_event_handler().persist_events_and_notify = ( # type: ignore[assignment]
- persist_events_and_notify_mock
- )
- # Small side-tangent. We populate the event cache with the event, even though
- # it is not yet in the DB. This is an invalid scenario that can currently occur
- # due to not properly invalidating the event cache.
- # See https://github.com/matrix-org/synapse/issues/13476.
- #
- # As a result, backfill should not rely on the event cache to check whether
- # we already have an event in the DB.
- # TODO: Remove this bit when the event cache is properly invalidated.
- cache_entry = EventCacheEntry(
- event=event,
- redacted_event=None,
- )
- self.store._get_event_cache.set_local((event.event_id,), cache_entry)
- # We now call FederationEventHandler.backfill (a separate method) to trigger
- # a backfill request. It should receive the fake event.
- self.get_success(
- self.hs.get_federation_event_handler().backfill(
- other_user,
- room_id,
- limit=10,
- extremities=[],
- )
- )
- # Check that our fake event was persisted.
- persist_events_and_notify_mock.assert_called_once()
- persist_events_and_notify_mock.reset_mock()
- # Now we repeat the backfill, having the homeserver receive the fake event
- # again.
- self.get_success(
- self.hs.get_federation_event_handler().backfill(
- other_user,
- room_id,
- limit=10,
- extremities=[],
- ),
- )
- # This time, we expect no event persistence to have occurred, as we already
- # have this event.
- persist_events_and_notify_mock.assert_not_called()
- @unittest.override_config(
- {"rc_invites": {"per_user": {"per_second": 0.5, "burst_count": 3}}}
- )
- def test_invite_by_user_ratelimit(self) -> None:
- """Tests that invites from federation to a particular user are
- actually rate-limited.
- """
- other_server = "otherserver"
- other_user = "@otheruser:" + other_server
- # create the room
- user_id = self.register_user("kermit", "test")
- tok = self.login("kermit", "test")
- def create_invite() -> EventBase:
- room_id = self.helper.create_room_as(room_creator=user_id, tok=tok)
- room_version = self.get_success(self.store.get_room_version(room_id))
- return event_from_pdu_json(
- {
- "type": EventTypes.Member,
- "content": {"membership": "invite"},
- "room_id": room_id,
- "sender": other_user,
- "state_key": "@user:test",
- "depth": 32,
- "prev_events": [],
- "auth_events": [],
- "origin_server_ts": self.clock.time_msec(),
- },
- room_version,
- )
- for _ in range(3):
- event = create_invite()
- self.get_success(
- self.handler.on_invite_request(
- other_server,
- event,
- event.room_version,
- )
- )
- event = create_invite()
- self.get_failure(
- self.handler.on_invite_request(
- other_server,
- event,
- event.room_version,
- ),
- exc=LimitExceededError,
- )
- def _build_and_send_join_event(
- self, other_server: str, other_user: str, room_id: str
- ) -> EventBase:
- join_event = self.get_success(
- self.handler.on_make_join_request(other_server, room_id, other_user)
- )
- # the auth code requires that a signature exists, but doesn't check that
- # signature... go figure.
- join_event.signatures[other_server] = {"x": "y"}
- with LoggingContext("send_join"):
- d = run_in_background(
- self.hs.get_federation_event_handler().on_send_membership_event,
- other_server,
- join_event,
- )
- self.get_success(d)
- # sanity-check: the room should show that the new user is a member
- r = self.get_success(self.store.get_partial_current_state_ids(room_id))
- self.assertEqual(r[(EventTypes.Member, other_user)], join_event.event_id)
- return join_event
- class EventFromPduTestCase(TestCase):
- def test_valid_json(self) -> None:
- """Valid JSON should be turned into an event."""
- ev = event_from_pdu_json(
- {
- "type": EventTypes.Message,
- "content": {"bool": True, "null": None, "int": 1, "str": "foobar"},
- "room_id": "!room:test",
- "sender": "@user:test",
- "depth": 1,
- "prev_events": [],
- "auth_events": [],
- "origin_server_ts": 1234,
- },
- RoomVersions.V6,
- )
- self.assertIsInstance(ev, EventBase)
- def test_invalid_numbers(self) -> None:
- """Invalid values for an integer should be rejected, all floats should be rejected."""
- for value in [
- -(2**53),
- 2**53,
- 1.0,
- float("inf"),
- float("-inf"),
- float("nan"),
- ]:
- with self.assertRaises(SynapseError):
- event_from_pdu_json(
- {
- "type": EventTypes.Message,
- "content": {"foo": value},
- "room_id": "!room:test",
- "sender": "@user:test",
- "depth": 1,
- "prev_events": [],
- "auth_events": [],
- "origin_server_ts": 1234,
- },
- RoomVersions.V6,
- )
- def test_invalid_nested(self) -> None:
- """List and dictionaries are recursively searched."""
- with self.assertRaises(SynapseError):
- event_from_pdu_json(
- {
- "type": EventTypes.Message,
- "content": {"foo": [{"bar": 2**56}]},
- "room_id": "!room:test",
- "sender": "@user:test",
- "depth": 1,
- "prev_events": [],
- "auth_events": [],
- "origin_server_ts": 1234,
- },
- RoomVersions.V6,
- )
- class PartialJoinTestCase(unittest.FederatingHomeserverTestCase):
- def test_failed_partial_join_is_clean(self) -> None:
- """
- Tests that, when failing to partial-join a room, we don't get stuck with
- a partial-state flag on a room.
- """
- fed_handler = self.hs.get_federation_handler()
- fed_client = fed_handler.federation_client
- room_id = "!room:example.com"
- EVENT_CREATE = make_event_from_dict(
- {
- "room_id": room_id,
- "type": "m.room.create",
- "sender": "@kristina:example.com",
- "state_key": "",
- "depth": 0,
- "content": {"creator": "@kristina:example.com", "room_version": "10"},
- "auth_events": [],
- "origin_server_ts": 1,
- },
- room_version=RoomVersions.V10,
- )
- EVENT_CREATOR_MEMBERSHIP = make_event_from_dict(
- {
- "room_id": room_id,
- "type": "m.room.member",
- "sender": "@kristina:example.com",
- "state_key": "@kristina:example.com",
- "content": {"membership": "join"},
- "depth": 1,
- "prev_events": [EVENT_CREATE.event_id],
- "auth_events": [EVENT_CREATE.event_id],
- "origin_server_ts": 1,
- },
- room_version=RoomVersions.V10,
- )
- EVENT_INVITATION_MEMBERSHIP = make_event_from_dict(
- {
- "room_id": room_id,
- "type": "m.room.member",
- "sender": "@kristina:example.com",
- "state_key": "@alice:test",
- "content": {"membership": "invite"},
- "depth": 2,
- "prev_events": [EVENT_CREATOR_MEMBERSHIP.event_id],
- "auth_events": [
- EVENT_CREATE.event_id,
- EVENT_CREATOR_MEMBERSHIP.event_id,
- ],
- "origin_server_ts": 1,
- },
- room_version=RoomVersions.V10,
- )
- membership_event = make_event_from_dict(
- {
- "room_id": room_id,
- "type": "m.room.member",
- "sender": "@alice:test",
- "state_key": "@alice:test",
- "content": {"membership": "join"},
- "prev_events": [EVENT_INVITATION_MEMBERSHIP.event_id],
- },
- RoomVersions.V10,
- )
- mock_make_membership_event = Mock(
- return_value=make_awaitable(
- (
- "example.com",
- membership_event,
- RoomVersions.V10,
- )
- )
- )
- mock_send_join = Mock(
- return_value=make_awaitable(
- SendJoinResult(
- membership_event,
- "example.com",
- state=[
- EVENT_CREATE,
- EVENT_CREATOR_MEMBERSHIP,
- EVENT_INVITATION_MEMBERSHIP,
- ],
- auth_chain=[
- EVENT_CREATE,
- EVENT_CREATOR_MEMBERSHIP,
- EVENT_INVITATION_MEMBERSHIP,
- ],
- partial_state=True,
- servers_in_room={"example.com"},
- )
- )
- )
- with patch.object(
- fed_client, "make_membership_event", mock_make_membership_event
- ), patch.object(fed_client, "send_join", mock_send_join):
- # Join and check that our join event is rejected
- # (The join event is rejected because it doesn't have any signatures)
- join_exc = self.get_failure(
- fed_handler.do_invite_join(["example.com"], room_id, "@alice:test", {}),
- SynapseError,
- )
- self.assertIn("Join event was rejected", str(join_exc))
- store = self.hs.get_datastores().main
- # Check that we don't have a left-over partial_state entry.
- self.assertFalse(
- self.get_success(store.is_partial_state_room(room_id)),
- f"Stale partial-stated room flag left over for {room_id} after a"
- f" failed do_invite_join!",
- )
- def test_duplicate_partial_state_room_syncs(self) -> None:
- """
- Tests that concurrent partial state syncs are not started for the same room.
- """
- is_partial_state = True
- end_sync: "Deferred[None]" = Deferred()
- async def is_partial_state_room(room_id: str) -> bool:
- return is_partial_state
- async def sync_partial_state_room(
- initial_destination: Optional[str],
- other_destinations: Collection[str],
- room_id: str,
- ) -> None:
- nonlocal end_sync
- try:
- await end_sync
- finally:
- end_sync = Deferred()
- mock_is_partial_state_room = Mock(side_effect=is_partial_state_room)
- mock_sync_partial_state_room = Mock(side_effect=sync_partial_state_room)
- fed_handler = self.hs.get_federation_handler()
- store = self.hs.get_datastores().main
- with patch.object(
- fed_handler, "_sync_partial_state_room", mock_sync_partial_state_room
- ), patch.object(store, "is_partial_state_room", mock_is_partial_state_room):
- # Start the partial state sync.
- fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 1)
- # Try to start another partial state sync.
- # Nothing should happen.
- fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 1)
- # End the partial state sync
- is_partial_state = False
- end_sync.callback(None)
- # The partial state sync should not be restarted.
- self.assertEqual(mock_sync_partial_state_room.call_count, 1)
- # The next attempt to start the partial state sync should work.
- is_partial_state = True
- fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 2)
- def test_partial_state_room_sync_restart(self) -> None:
- """
- Tests that partial state syncs are restarted when a second partial state sync
- was deduplicated and the first partial state sync fails.
- """
- is_partial_state = True
- end_sync: "Deferred[None]" = Deferred()
- async def is_partial_state_room(room_id: str) -> bool:
- return is_partial_state
- async def sync_partial_state_room(
- initial_destination: Optional[str],
- other_destinations: Collection[str],
- room_id: str,
- ) -> None:
- nonlocal end_sync
- try:
- await end_sync
- finally:
- end_sync = Deferred()
- mock_is_partial_state_room = Mock(side_effect=is_partial_state_room)
- mock_sync_partial_state_room = Mock(side_effect=sync_partial_state_room)
- fed_handler = self.hs.get_federation_handler()
- store = self.hs.get_datastores().main
- with patch.object(
- fed_handler, "_sync_partial_state_room", mock_sync_partial_state_room
- ), patch.object(store, "is_partial_state_room", mock_is_partial_state_room):
- # Start the partial state sync.
- fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 1)
- # Fail the partial state sync.
- # The partial state sync should not be restarted.
- end_sync.errback(Exception("Failed to request /state_ids"))
- self.assertEqual(mock_sync_partial_state_room.call_count, 1)
- # Start the partial state sync again.
- fed_handler._start_partial_state_room_sync("hs1", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 2)
- # Deduplicate another partial state sync.
- fed_handler._start_partial_state_room_sync("hs3", {"hs2"}, "room_id")
- self.assertEqual(mock_sync_partial_state_room.call_count, 2)
- # Fail the partial state sync.
- # It should restart with the latest parameters.
- end_sync.errback(Exception("Failed to request /state_ids"))
- self.assertEqual(mock_sync_partial_state_room.call_count, 3)
- mock_sync_partial_state_room.assert_called_with(
- initial_destination="hs3",
- other_destinations={"hs2"},
- room_id="room_id",
- )
|