Fix tests after porting EventBase to Rust

Adapt tests that mutated Python event internals (`_event_id`, `_dict`,
direct attribute assignment, `FrozenEventV3(...)` construction) to work
with the new Rust-backed `Event` class:

- Rebuild events via `make_event_from_dict` / `make_test_event` instead
  of patching attributes in place.
- Plumb `rejected_reason` through `_join_rules_event` rather than
  assigning to `rejected_reason` after construction.
- Replace the hand-built event in `test_msc4242_state_dag` with a
  `Mock(spec=EventBase)` since the test only needs a handful of
  attributes.
- Add `# type: ignore` for the deprecated `event.user_id` / `event[key]`
  accessors and for assigning to `event.content`.
- In `make_test_event`, drop the default `room_id` for v11+ create
  events so each gets a distinct hash-derived room ID.

Author: erikjohnston

tests/events/test_py_protocol.py

@@ -16,28 +16,28 @@
 from unittest.mock import Mock
 
 from synapse.api.room_versions import RoomVersion, RoomVersions
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.events.py_protocol import (
     EventProtocol,
     MSC4242Event,
     all_supports_msc4242_state_dag,
     supports_msc4242_state_dag,
 )
 
+from tests.test_utils.event_builders import make_test_event
 from tests.unittest import TestCase
 
 
 def _make_event(room_version: RoomVersion) -> EventBase:
     """Helper to make an EventBase with the given room version."""
-    event_dict = {
-        "content": {},
-        "sender": "@user:example.com",
-        "type": "m.room.message",
-        "room_id": "!room:example.com",
-    }
-    if room_version.msc4242_state_dags:
-        event_dict["prev_state_events"] = []
-    return make_event_from_dict(event_dict, room_version=room_version)
+    return make_test_event(
+        {
+            "sender": "@user:example.com",
+            "type": "m.room.message",
+            "room_id": "!room:example.com",
+        },
+        room_version=room_version,
+    )
 
 
 class TestMetaClass(TestCase):

tests/handlers/test_device.py

@@ -36,7 +36,7 @@
 from synapse.api.room_versions import RoomVersions
 from synapse.appservice import ApplicationService
 from synapse.crypto.event_signing import add_hashes_and_signatures
-from synapse.events import EventBase, FrozenEventV3
+from synapse.events import EventBase, make_event_from_dict
 from synapse.federation.federation_client import SendJoinResult
 from synapse.federation.transport.client import (
     StateRequestResponse,
@@ -677,7 +677,7 @@ def _build_public_room(self) -> StateMap[EventBase]:
             self.REMOTE1_SERVER_SIGNATURE_KEY,
         )
 
-        create_event = FrozenEventV3(create_event_dict, room_version, {}, None)
+        create_event = make_event_from_dict(create_event_dict, room_version)
         events.append(create_event)
 
         room_version = self.hs.config.server.default_room_version
@@ -700,7 +700,7 @@ def _build_public_room(self) -> StateMap[EventBase]:
             self.hs.hostname,
             self.hs.signing_key,
         )
-        join_event = FrozenEventV3(join_event_dict, room_version, {}, None)
+        join_event = make_event_from_dict(join_event_dict, room_version)
         events.append(join_event)
 
         # Then set the join rules to public
@@ -722,7 +722,7 @@ def _build_public_room(self) -> StateMap[EventBase]:
             self.REMOTE1_SERVER_NAME,
             self.REMOTE1_SERVER_SIGNATURE_KEY,
         )
-        join_rules_event = FrozenEventV3(join_rules_event_dict, room_version, {}, None)
+        join_rules_event = make_event_from_dict(join_rules_event_dict, room_version)
         events.append(join_rules_event)
 
         return {(event.type, event.state_key): event for event in events}
@@ -733,7 +733,7 @@ def _build_signed_join_event(
         user: str,
         signing_key: SigningKey,
         state: StateMap[EventBase],
-    ) -> FrozenEventV3:
+    ) -> EventBase:
         """Build a join event for the local user, signed by the local server."""
 
         latest_event = max(state.values(), key=lambda e: e.depth)
@@ -759,7 +759,7 @@ def _build_signed_join_event(
             get_domain_from_id(user),
             signing_key,
         )
-        return FrozenEventV3(join_event_dict, room_version, {}, None)
+        return make_event_from_dict(join_event_dict, room_version)
 
     @parameterized.expand([("not_pruned", False), ("pruned", True)])
     @patch(

tests/module_api/test_api.py

@@ -841,10 +841,10 @@ def test_event_deprecated_methods(self) -> None:
         create_event = state[(EventTypes.Create, "")]
 
         # `.user_id` is a deprecated alias for `.sender`.
-        self.assertEqual(create_event.user_id, user_id)
+        self.assertEqual(create_event.user_id, user_id)  # type: ignore[attr-defined]
 
         # The event supports looking up keys via `__getitem__` although deprecated
-        self.assertEqual(create_event["room_id"], room_id)
+        self.assertEqual(create_event["room_id"], room_id)  # type: ignore[index]
 
 
 class ModuleApiWorkerTestCase(BaseModuleApiTestCase, BaseMultiWorkerStreamTestCase):

tests/rest/client/test_third_party_rules.py

@@ -236,7 +236,7 @@ def test_cannot_modify_event(self) -> None:
         async def check(
             ev: EventBase, state: StateMap[EventBase]
         ) -> tuple[bool, JsonDict | None]:
-            ev.content = {"x": "y"}
+            ev.content = {"x": "y"}  # type: ignore[misc]
             return True, None
 
         self.hs.get_module_api_callbacks().third_party_event_rules._check_event_allowed_callbacks = [

tests/storage/test_msc4242_state_dag.py

@@ -19,13 +19,13 @@
 from synapse.api.constants import EventTypes
 from synapse.api.errors import SynapseError
 from synapse.api.room_versions import RoomVersions
-from synapse.events.py_protocol import MSC4242Event, supports_msc4242_state_dag
+from synapse.events import EventBase
+from synapse.events.py_protocol import MSC4242Event
 from synapse.events.snapshot import EventContext
 from synapse.rest.client import room
 from synapse.server import HomeServer
 from synapse.util.clock import Clock
 
-from tests.test_utils.event_builders import make_test_event
 from tests.unittest import HomeserverTestCase, override_config
 
 
@@ -154,21 +154,11 @@ def _make_event(
         prev_state_events: list[str],
         rejected: bool = False,
     ) -> tuple[MSC4242Event, EventContext]:
-        ev = make_test_event(
-            {
-                "prev_state_events": prev_state_events,
-                "content": {
-                    "membership": "join",
-                },
-                "sender": "@unimportant:info",
-                "state_key": "@unimportant:info",
-                "type": "m.room.member",
-                "room_id": self.room_id,
-            },
-            room_version=RoomVersions.MSC4242v12,
-        )
-        ev._event_id = id  # type: ignore[attr-defined]
-        assert supports_msc4242_state_dag(ev)
+        ev = Mock(spec=EventBase)
+        ev.event_id = id
+        ev.prev_state_events = prev_state_events
+        ev.state_key = "@unimportant:info"
+        ev.is_state.return_value = True
         ctx = Mock()
         ctx.rejected = rejected
         return ev, ctx

tests/storage/test_redaction.py

@@ -26,7 +26,7 @@
 
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.room_versions import RoomVersion, RoomVersions
-from synapse.events import EventBase
+from synapse.events import EventBase, make_event_from_dict
 from synapse.events.builder import EventBuilder
 from synapse.server import HomeServer
 from synapse.synapse_rust.events import EventInternalMetadata
@@ -238,11 +238,16 @@ async def build(
                     prev_event_ids=prev_event_ids, auth_event_ids=auth_event_ids
                 )
 
-                built_event._event_id = self._event_id  # type: ignore[attr-defined]
-                built_event._dict["event_id"] = self._event_id
-                assert built_event.event_id == self._event_id
+                event_dict = built_event.get_dict()
+                event_dict["event_id"] = self._event_id
+                rebuilt_event = make_event_from_dict(
+                    event_dict,
+                    room_version=built_event.room_version,
+                    internal_metadata_dict=built_event.internal_metadata.get_dict(),
+                )
+                assert rebuilt_event.event_id == self._event_id
 
-                return built_event
+                return rebuilt_event
 
             @property
             def room_id(self) -> str:

tests/test_event_auth.py

@@ -93,8 +93,8 @@ def test_rejected_auth_events(self) -> None:
             RoomVersions.V9,
             creator,
             "public",
+            rejected_reason="stinky",
         )
-        rejected_join_rules.rejected_reason = "stinky"
         auth_events.append(rejected_join_rules)
         event_store.add_event(rejected_join_rules)
 
@@ -1180,7 +1180,10 @@ def _random_state_event(
 
 
 def _join_rules_event(
-    room_version: RoomVersion, sender: str, join_rule: str
+    room_version: RoomVersion,
+    sender: str,
+    join_rule: str,
+    rejected_reason: str | None = None,
 ) -> EventBase:
     return make_test_event(
         {
@@ -1194,6 +1197,7 @@ def _join_rules_event(
             },
         },
         room_version=room_version,
+        rejected_reason=rejected_reason,
     )
 
 

tests/test_utils/event_builders.py

@@ -76,6 +76,20 @@ def make_test_event(
         **(event_dict or {}),
         **fields,
     }
+
+    # For room versions where the create event's room_id is derived from its
+    # event ID (v11+ format), omit the default room_id on create events so each
+    # create event ends up with a distinct room_id.
+    #
+    # We can't do this in the `default_event_fields` as we don't know the event
+    # type at that point.
+    if (
+        room_version.msc4291_room_ids_as_hashes
+        and merged["type"] == "m.room.create"
+        and merged["state_key"] == ""
+    ):
+        merged.pop("room_id", None)
+
     return make_event_from_dict(
         merged,
         room_version=room_version,