diff --git a/changelog.d/19781.misc b/changelog.d/19781.misc
new file mode 100644
index 0000000000..63c2482ded
--- /dev/null
+++ b/changelog.d/19781.misc
@@ -0,0 +1 @@
+Fix up event-construction in tests ahead of the Rust event port.
diff --git a/tests/api/test_filtering.py b/tests/api/test_filtering.py
index 7742a06b4c..8c17e98c0d 100644
--- a/tests/api/test_filtering.py
+++ b/tests/api/test_filtering.py
@@ -36,7 +36,7 @@ from synapse.util.clock import Clock
 from synapse.util.frozenutils import freeze
 
 from tests import unittest
-from tests.events.test_utils import MockEvent
+from tests.test_utils.event_builders import make_test_event
 
 user_id = UserID.from_string("@test_user:test")
 user2_id = UserID.from_string("@test_user2:test")
@@ -134,18 +134,22 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_definition_types_works_with_literals(self) -> None:
         definition = {"types": ["m.room.message", "org.matrix.foo.bar"]}
-        event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="m.room.message", room_id="!foo:bar"
+        )
 
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
     def test_definition_types_works_with_wildcards(self) -> None:
         definition = {"types": ["m.*", "org.matrix.foo.bar"]}
-        event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="m.room.message", room_id="!foo:bar"
+        )
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
     def test_definition_types_works_with_unknowns(self) -> None:
         definition = {"types": ["m.room.message", "org.matrix.foo.bar"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="now.for.something.completely.different",
             room_id="!foo:bar",
@@ -154,19 +158,23 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_definition_not_types_works_with_literals(self) -> None:
         definition = {"not_types": ["m.room.message", "org.matrix.foo.bar"]}
-        event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="m.room.message", room_id="!foo:bar"
+        )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_not_types_works_with_wildcards(self) -> None:
         definition = {"not_types": ["m.room.message", "org.matrix.*"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar", type="org.matrix.custom.event", room_id="!foo:bar"
         )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_not_types_works_with_unknowns(self) -> None:
         definition = {"not_types": ["m.*", "org.*"]}
-        event = MockEvent(sender="@foo:bar", type="com.nom.nom.nom", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="com.nom.nom.nom", room_id="!foo:bar"
+        )
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
     def test_definition_not_types_takes_priority_over_types(self) -> None:
@@ -174,33 +182,35 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "not_types": ["m.*", "org.*"],
             "types": ["m.room.message", "m.room.topic"],
         }
-        event = MockEvent(sender="@foo:bar", type="m.room.topic", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="m.room.topic", room_id="!foo:bar"
+        )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_senders_works_with_literals(self) -> None:
         definition = {"senders": ["@flibble:wibble"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@flibble:wibble", type="com.nom.nom.nom", room_id="!foo:bar"
         )
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
     def test_definition_senders_works_with_unknowns(self) -> None:
         definition = {"senders": ["@flibble:wibble"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@challenger:appears", type="com.nom.nom.nom", room_id="!foo:bar"
         )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_not_senders_works_with_literals(self) -> None:
         definition = {"not_senders": ["@flibble:wibble"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@flibble:wibble", type="com.nom.nom.nom", room_id="!foo:bar"
         )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_not_senders_works_with_unknowns(self) -> None:
         definition = {"not_senders": ["@flibble:wibble"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@challenger:appears", type="com.nom.nom.nom", room_id="!foo:bar"
         )
         self.assertTrue(Filter(self.hs, definition)._check(event))
@@ -210,21 +220,21 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "not_senders": ["@misspiggy:muppets"],
             "senders": ["@kermit:muppets", "@misspiggy:muppets"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@misspiggy:muppets", type="m.room.topic", room_id="!foo:bar"
         )
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
     def test_definition_rooms_works_with_literals(self) -> None:
         definition = {"rooms": ["!secretbase:unknown"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar", type="m.room.message", room_id="!secretbase:unknown"
         )
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
     def test_definition_rooms_works_with_unknowns(self) -> None:
         definition = {"rooms": ["!secretbase:unknown"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!anothersecretbase:unknown",
@@ -233,7 +243,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_definition_not_rooms_works_with_literals(self) -> None:
         definition = {"not_rooms": ["!anothersecretbase:unknown"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!anothersecretbase:unknown",
@@ -242,7 +252,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_definition_not_rooms_works_with_unknowns(self) -> None:
         definition = {"not_rooms": ["!secretbase:unknown"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!anothersecretbase:unknown",
@@ -254,7 +264,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "not_rooms": ["!secretbase:unknown"],
             "rooms": ["!secretbase:unknown"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar", type="m.room.message", room_id="!secretbase:unknown"
         )
         self.assertFalse(Filter(self.hs, definition)._check(event))
@@ -268,7 +278,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "types": ["m.room.message", "muppets.kermit.*"],
             "not_types": ["muppets.misspiggy.*"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@kermit:muppets",  # yup
             type="m.room.message",  # yup
             room_id="!stage:unknown",  # yup
@@ -284,7 +294,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "types": ["m.room.message", "muppets.kermit.*"],
             "not_types": ["muppets.misspiggy.*"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@misspiggy:muppets",  # nope
             type="m.room.message",  # yup
             room_id="!stage:unknown",  # yup
@@ -300,7 +310,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "types": ["m.room.message", "muppets.kermit.*"],
             "not_types": ["muppets.misspiggy.*"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@kermit:muppets",  # yup
             type="m.room.message",  # yup
             room_id="!piggyshouse:muppets",  # nope
@@ -316,7 +326,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
             "types": ["m.room.message", "muppets.kermit.*"],
             "not_types": ["muppets.misspiggy.*"],
         }
-        event = MockEvent(
+        event = make_test_event(
             sender="@kermit:muppets",  # yup
             type="muppets.misspiggy.kisses",  # nope
             room_id="!stage:unknown",  # yup
@@ -325,7 +335,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_filter_labels(self) -> None:
         definition = {"org.matrix.labels": ["#fun"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -334,7 +344,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -344,7 +354,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
         # check it works with frozen dictionaries too
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -354,7 +364,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
     def test_filter_not_labels(self) -> None:
         definition = {"org.matrix.not_labels": ["#fun"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -363,7 +373,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -375,7 +385,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
     @unittest.override_config({"experimental_features": {"msc3874_enabled": True}})
     def test_filter_rel_type(self) -> None:
         definition = {"org.matrix.msc3874.rel_types": ["m.thread"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -384,7 +394,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -393,7 +403,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -405,7 +415,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
     @unittest.override_config({"experimental_features": {"msc3874_enabled": True}})
     def test_filter_not_rel_type(self) -> None:
         definition = {"org.matrix.msc3874.not_rel_types": ["m.thread"]}
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -414,7 +424,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertFalse(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -423,7 +433,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
 
         self.assertTrue(Filter(self.hs, definition)._check(event))
 
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar",
             type="m.room.message",
             room_id="!secretbase:unknown",
@@ -494,7 +504,9 @@ class FilteringTestCase(unittest.HomeserverTestCase):
                 user_id=user_id, user_filter=user_filter_json
             )
         )
-        event = MockEvent(sender="@foo:bar", type="m.room.topic", room_id="!foo:bar")
+        event = make_test_event(
+            sender="@foo:bar", type="m.room.topic", room_id="!foo:bar"
+        )
         events = [event]
 
         user_filter = self.get_success(
@@ -511,7 +523,7 @@ class FilteringTestCase(unittest.HomeserverTestCase):
                 user_id=user_id, user_filter=user_filter_json
             )
         )
-        event = MockEvent(
+        event = make_test_event(
             sender="@foo:bar", type="org.matrix.custom.event", room_id="!foo:bar"
         )
         events = [event]
@@ -542,14 +554,14 @@ class FilteringTestCase(unittest.HomeserverTestCase):
     def test_filter_relations(self) -> None:
         events = [
             # An event without a relation.
-            MockEvent(
+            make_test_event(
                 event_id="$no_relation",
                 sender="@foo:bar",
                 type="org.matrix.custom.event",
                 room_id="!foo:bar",
             ),
             # An event with a relation.
-            MockEvent(
+            make_test_event(
                 event_id="$with_relation",
                 sender="@foo:bar",
                 type="org.matrix.custom.event",
diff --git a/tests/crypto/test_event_signing.py b/tests/crypto/test_event_signing.py
index 6ec0f64ffc..e4621b1c2b 100644
--- a/tests/crypto/test_event_signing.py
+++ b/tests/crypto/test_event_signing.py
@@ -34,10 +34,11 @@ from synapse.crypto.event_signing import (
     event_needs_resigning,
     resign_event,
 )
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.types import JsonDict
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 
 # Perform these tests using given secret key so we get entirely deterministic
 # signatures output that we can test against.
@@ -70,7 +71,7 @@ class EventSigningTestCase(unittest.TestCase):
             RoomVersions.V1, event_dict, HOSTNAME, self.signing_key
         )
 
-        event = make_event_from_dict(event_dict)
+        event = make_test_event(event_dict)
 
         self.assertTrue(hasattr(event, "hashes"))
         self.assertIn("sha256", event.hashes)
@@ -103,7 +104,7 @@ class EventSigningTestCase(unittest.TestCase):
             RoomVersions.V1, event_dict, HOSTNAME, self.signing_key
         )
 
-        event = make_event_from_dict(event_dict)
+        event = make_test_event(event_dict)
 
         self.assertTrue(hasattr(event, "hashes"))
         self.assertIn("sha256", event.hashes)
@@ -141,7 +142,7 @@ class EventResigningTestCase(unittest.TestCase):
         add_hashes_and_signatures(
             RoomVersions.V1, event_dict, HOSTNAME, self.signing_key
         )
-        event = make_event_from_dict(event_dict)
+        event = make_test_event(event_dict)
         self.assertIn(HOSTNAME, event.signatures)
         self.assertIn(KEY_NAME, event.signatures[HOSTNAME])
         signature = event.signatures[HOSTNAME][KEY_NAME]
@@ -171,7 +172,7 @@ class EventResigningTestCase(unittest.TestCase):
             "signatures": {},
             "unsigned": {"age_ts": 1000000},
         }
-        event = make_event_from_dict(event_dict)
+        event = make_test_event(event_dict)
         resigned_event = resign_event(event, HOSTNAME, signing_key_2)
         self.assertIn(HOSTNAME, resigned_event["signatures"])
         self.assertIn(key_name_2, resigned_event["signatures"][HOSTNAME])
@@ -188,7 +189,7 @@ class EventResigningTestCase(unittest.TestCase):
             "unsigned": {"age_ts": 1000000},
         }
         internal_metadata: JsonDict = {}
-        event_that_needs_resigning = make_event_from_dict(
+        event_that_needs_resigning = make_test_event(
             event_that_needs_resigning_dict,
             RoomVersions.V1,
             internal_metadata,
@@ -207,7 +208,7 @@ class EventResigningTestCase(unittest.TestCase):
         events_that_dont_need_resigning: list[TestCase] = [
             {
                 "name": "sender domain isn't ours",
-                "event": make_event_from_dict(
+                "event": make_test_event(
                     {**event_that_needs_resigning_dict, "sender": "@u:somewhereelse"},
                     RoomVersions.V1,
                     internal_metadata,
@@ -215,7 +216,7 @@ class EventResigningTestCase(unittest.TestCase):
             },
             {
                 "name": "already signed with this key",
-                "event": make_event_from_dict(
+                "event": make_test_event(
                     {
                         **event_that_needs_resigning_dict,
                         "signatures": {
diff --git a/tests/events/test_auto_accept_invites.py b/tests/events/test_auto_accept_invites.py
index e0ebdf0bca..632d1dc4f6 100644
--- a/tests/events/test_auto_accept_invites.py
+++ b/tests/events/test_auto_accept_invites.py
@@ -33,7 +33,6 @@ from synapse.api.errors import SynapseError
 from synapse.config._base import RootConfig
 from synapse.config.auto_accept_invites import AutoAcceptInvitesConfig
 from synapse.events.auto_accept_invites import InviteAutoAccepter
-from synapse.federation.federation_base import event_from_pdu_json
 from synapse.handlers.sync import JoinedSyncResult, SyncRequestKey
 from synapse.module_api import ModuleApi
 from synapse.rest import admin
@@ -43,6 +42,7 @@ from synapse.types import StreamToken, UserID, UserInfo, create_requester
 from synapse.util.clock import Clock
 
 from tests.handlers.test_sync import generate_sync_config
+from tests.test_utils.event_builders import make_test_pdu_event
 from tests.unittest import (
     FederatingHomeserverTestCase,
     HomeserverTestCase,
@@ -182,7 +182,7 @@ class AutoAcceptInvitesTestCase(FederatingHomeserverTestCase):
         )
         room_version = self.get_success(self.store.get_room_version(room_id))
 
-        invite_event = event_from_pdu_json(
+        invite_event = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "content": {"membership": "invite"},
@@ -308,7 +308,7 @@ class AutoAcceptInvitesTestCase(FederatingHomeserverTestCase):
             remote_server = "otherserver"
             remote_user = "@otheruser:" + remote_server
 
-            invite_event = event_from_pdu_json(
+            invite_event = make_test_pdu_event(
                 {
                     "type": EventTypes.Member,
                     "content": {"membership": "invite"},
diff --git a/tests/events/test_utils.py b/tests/events/test_utils.py
index a402dd70d1..8f78ae4944 100644
--- a/tests/events/test_utils.py
+++ b/tests/events/test_utils.py
@@ -26,7 +26,7 @@ from parameterized import parameterized
 
 from synapse.api.constants import EventContentFields
 from synapse.api.room_versions import RoomVersions
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.events.utils import (
     FilteredEvent,
     PowerLevelsContent,
@@ -42,31 +42,16 @@ from synapse.events.utils import (
 from synapse.types import JsonDict, create_requester
 from synapse.util.frozenutils import freeze
 
+from tests.test_utils.event_builders import make_test_event
 from tests.unittest import HomeserverTestCase
 
 if TYPE_CHECKING:
     from synapse.server import HomeServer
 
 
-def MockEvent(**kwargs: Any) -> EventBase:
-    if "event_id" not in kwargs:
-        kwargs["event_id"] = "fake_event_id"
-    if "type" not in kwargs:
-        kwargs["type"] = "fake_type"
-    if "content" not in kwargs:
-        kwargs["content"] = {}
-
-    # Move internal metadata out so we can call make_event properly
-    internal_metadata = kwargs.get("internal_metadata")
-    if internal_metadata is not None:
-        kwargs.pop("internal_metadata")
-
-    return make_event_from_dict(kwargs, internal_metadata_dict=internal_metadata)
-
-
 class TestMaybeUpsertEventField(stdlib_unittest.TestCase):
     def test_update_okay(self) -> None:
-        event = make_event_from_dict({"event_id": "$1234"})
+        event = make_test_event({"event_id": "$1234"})
         success = maybe_upsert_event_field(
             event, event.unsigned, "replaces_state", "value"
         )
@@ -74,7 +59,7 @@ class TestMaybeUpsertEventField(stdlib_unittest.TestCase):
         self.assertEqual(event.unsigned["replaces_state"], "value")
 
     def test_update_not_okay(self) -> None:
-        event = make_event_from_dict({"event_id": "$1234"})
+        event = make_test_event({"event_id": "$1234"})
         LARGE_STRING = "a" * 100_000
         success = maybe_upsert_event_field(
             event, event.unsigned, "replaces_state", LARGE_STRING
@@ -83,7 +68,7 @@ class TestMaybeUpsertEventField(stdlib_unittest.TestCase):
         self.assertNotIn("replaces_state", event.unsigned)
 
     def test_update_not_okay_leaves_original_value(self) -> None:
-        event = make_event_from_dict(
+        event = make_test_event(
             {"event_id": "$1234", "unsigned": {"replaces_state": "value"}}
         )
         LARGE_STRING = "a" * 100_000
@@ -95,6 +80,20 @@ class TestMaybeUpsertEventField(stdlib_unittest.TestCase):
 
 
 class PruneEventTestCase(stdlib_unittest.TestCase):
+    # Fields that `make_test_event` fills in by default and that `prune_event`
+    # preserves as spec-required keep fields. Pruning tests only spell out the
+    # fields they care about; these are merged into the expected dict so each
+    # test stays focused on what it is actually checking.
+    _DEFAULT_KEPT_FIELDS: JsonDict = {
+        "sender": "@test:test",
+        "room_id": "!test:test",
+        "depth": 1,
+        "origin_server_ts": 1,
+        "hashes": {},
+        "auth_events": [],
+        "prev_events": [],
+    }
+
     def run_test(self, evdict: JsonDict, matchdict: JsonDict, **kwargs: Any) -> None:
         """
         Asserts that a new event constructed with `evdict` will look like
@@ -105,8 +104,9 @@ class PruneEventTestCase(stdlib_unittest.TestCase):
              matchdict: The expected resulting dictionary.
              kwargs: Additional keyword arguments used to create the event.
         """
+        expected = {**self._DEFAULT_KEPT_FIELDS, **matchdict}
         self.assertEqual(
-            prune_event(make_event_from_dict(evdict, **kwargs)).get_dict(), matchdict
+            prune_event(make_test_event(evdict, **kwargs)).get_dict(), expected
         )
 
     def test_minimal(self) -> None:
@@ -123,9 +123,6 @@ class PruneEventTestCase(stdlib_unittest.TestCase):
 
     def test_basic_keys(self) -> None:
         """Ensure that the keys that should be untouched are kept."""
-        # Note that some of the values below don't really make sense, but the
-        # pruning of events doesn't worry about the values of any fields (with
-        # the exception of the content field).
         self.run_test(
             {
                 "event_id": "$3:domain",
@@ -134,12 +131,12 @@ class PruneEventTestCase(stdlib_unittest.TestCase):
                 "sender": "@2:domain",
                 "state_key": "B",
                 "content": {"other_key": "foo"},
-                "hashes": "hashes",
+                "hashes": {"sha256": "abc"},
                 "signatures": {"domain": {"algo:1": "sigs"}},
                 "depth": 4,
-                "prev_events": "prev_events",
+                "prev_events": [],
                 "prev_state": "prev_state",
-                "auth_events": "auth_events",
+                "auth_events": [],
                 "origin": "domain",  # historical top-level field that still exists on old events
                 "origin_server_ts": 1234,
                 "membership": "join",
@@ -152,11 +149,11 @@ class PruneEventTestCase(stdlib_unittest.TestCase):
                 "room_id": "!1:domain",
                 "sender": "@2:domain",
                 "state_key": "B",
-                "hashes": "hashes",
+                "hashes": {"sha256": "abc"},
                 "depth": 4,
-                "prev_events": "prev_events",
+                "prev_events": [],
                 "prev_state": "prev_state",
-                "auth_events": "auth_events",
+                "auth_events": [],
                 "origin": "domain",  # historical top-level field that still exists on old events
                 "origin_server_ts": 1234,
                 "membership": "join",
@@ -625,7 +622,7 @@ class PruneEventTestCase(stdlib_unittest.TestCase):
 
 class CloneEventTestCase(stdlib_unittest.TestCase):
     def test_unsigned_is_copied(self) -> None:
-        original = make_event_from_dict(
+        original = make_test_event(
             {
                 "type": "A",
                 "event_id": "$test:domain",
@@ -679,7 +676,8 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_works_with_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(sender="@alice:localhost", room_id="!foo:bar"), ["room_id"]
+                make_test_event(sender="@alice:localhost", room_id="!foo:bar"),
+                ["room_id"],
             ),
             {"room_id": "!foo:bar"},
         )
@@ -687,7 +685,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_works_with_nested_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={"body": "A message"},
@@ -700,7 +698,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_works_with_dot_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={"key.with.dots": {}},
@@ -713,7 +711,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_works_with_nested_dot_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={
@@ -729,7 +727,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_nops_with_unknown_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={"foo": "bar"},
@@ -742,7 +740,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_nops_with_non_dict_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={"foo": ["I", "am", "an", "array"]},
@@ -755,7 +753,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_nops_with_array_keys(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     sender="@alice:localhost",
                     room_id="!foo:bar",
                     content={"foo": ["I", "am", "an", "array"]},
@@ -768,7 +766,7 @@ class SerializeEventTestCase(HomeserverTestCase):
     def test_event_fields_all_fields_if_empty(self) -> None:
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     type="foo",
                     event_id="test",
                     room_id="!foo:bar",
@@ -782,6 +780,9 @@ class SerializeEventTestCase(HomeserverTestCase):
                 "room_id": "!foo:bar",
                 "content": {"foo": "bar"},
                 "unsigned": {},
+                "sender": "@test:test",
+                "user_id": "@test:test",
+                "origin_server_ts": 1,
             },
         )
 
@@ -799,12 +800,12 @@ class SerializeEventTestCase(HomeserverTestCase):
         # Default behaviour should be *not* to include it
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     type="foo",
                     event_id="test",
                     room_id="!foo:bar",
                     content={"foo": "bar"},
-                    internal_metadata={"soft_failed": True},
+                    internal_metadata_dict={"soft_failed": True},
                 ),
                 [],
             ),
@@ -814,18 +815,21 @@ class SerializeEventTestCase(HomeserverTestCase):
                 "room_id": "!foo:bar",
                 "content": {"foo": "bar"},
                 "unsigned": {},
+                "sender": "@test:test",
+                "user_id": "@test:test",
+                "origin_server_ts": 1,
             },
         )
 
         # When asked though, we should set it
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     type="foo",
                     event_id="test",
                     room_id="!foo:bar",
                     content={"foo": "bar"},
-                    internal_metadata={"soft_failed": True},
+                    internal_metadata_dict={"soft_failed": True},
                 ),
                 [],
                 True,
@@ -836,16 +840,19 @@ class SerializeEventTestCase(HomeserverTestCase):
                 "room_id": "!foo:bar",
                 "content": {"foo": "bar"},
                 "unsigned": {"io.element.synapse.soft_failed": True},
+                "sender": "@test:test",
+                "user_id": "@test:test",
+                "origin_server_ts": 1,
             },
         )
         self.assertEqual(
             self.serialize(
-                MockEvent(
+                make_test_event(
                     type="foo",
                     event_id="test",
                     room_id="!foo:bar",
                     content={"foo": "bar"},
-                    internal_metadata={
+                    internal_metadata_dict={
                         "soft_failed": True,
                         "policy_server_spammy": True,
                     },
@@ -862,6 +869,9 @@ class SerializeEventTestCase(HomeserverTestCase):
                     "io.element.synapse.soft_failed": True,
                     "io.element.synapse.policy_server_spammy": True,
                 },
+                "sender": "@test:test",
+                "user_id": "@test:test",
+                "origin_server_ts": 1,
             },
         )
 
@@ -896,7 +906,7 @@ class SerializeEventTestCase(HomeserverTestCase):
 
         redaction_id = "$redaction_event_id"
 
-        event = MockEvent(
+        event = make_test_event(
             type="foo",
             event_id="test",
             room_id="!foo:bar",
@@ -904,7 +914,7 @@ class SerializeEventTestCase(HomeserverTestCase):
         )
         event.internal_metadata.redacted_by = redaction_id
 
-        redaction_event = MockEvent(
+        redaction_event = make_test_event(
             type="m.room.redaction",
             event_id=redaction_id,
             content={"redacts": "test"},
diff --git a/tests/federation/test_federation_base.py b/tests/federation/test_federation_base.py
index 1bc1da1feb..8b8c65a0c5 100644
--- a/tests/federation/test_federation_base.py
+++ b/tests/federation/test_federation_base.py
@@ -36,6 +36,9 @@ class FederationBaseTestCase(unittest.HomeserverTestCase):
             "type": "m.room.message",
             "room_id": "!r:domain",
             "sender": f"@u:{self.hs.config.server.server_name}",
+            "auth_events": [],
+            "prev_events": [],
+            "depth": 1,
             "signatures": {},
             "unsigned": {"age_ts": 1000000},
         }
diff --git a/tests/federation/test_federation_client.py b/tests/federation/test_federation_client.py
index 0535aed107..656665cb42 100644
--- a/tests/federation/test_federation_client.py
+++ b/tests/federation/test_federation_client.py
@@ -73,6 +73,7 @@ class FederationClientTest(FederatingHomeserverTestCase):
                 "content": {"creator": self.creator},
                 "prev_events": [],
                 "auth_events": [],
+                "depth": 1,
                 "origin_server_ts": 500,
             }
         )
@@ -85,6 +86,7 @@ class FederationClientTest(FederatingHomeserverTestCase):
                 "content": {"membership": "join"},
                 "prev_events": [],
                 "auth_events": [],
+                "depth": 2,
                 "origin_server_ts": 600,
             }
         )
@@ -97,6 +99,7 @@ class FederationClientTest(FederatingHomeserverTestCase):
                 "content": {},
                 "prev_events": [],
                 "auth_events": [],
+                "depth": 3,
                 "origin_server_ts": 700,
             }
         )
diff --git a/tests/federation/test_federation_out_of_band_membership.py b/tests/federation/test_federation_out_of_band_membership.py
index a1ab72b7a1..1707081863 100644
--- a/tests/federation/test_federation_out_of_band_membership.py
+++ b/tests/federation/test_federation_out_of_band_membership.py
@@ -33,11 +33,8 @@ from twisted.internet.testing import MemoryReactor
 
 from synapse.api.constants import EventContentFields, EventTypes, Membership
 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.utils import strip_event
-from synapse.federation.federation_base import (
-    event_from_pdu_json,
-)
 from synapse.federation.transport.client import SendJoinResponse
 from synapse.http.matrixfederationclient import (
     ByteParser,
@@ -53,6 +50,7 @@ from synapse.types.handlers.sliding_sync import (
 from synapse.util.clock import Clock
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event, make_test_pdu_event
 from tests.utils import test_timeout
 
 logger = logging.getLogger(__name__)
@@ -80,9 +78,7 @@ def required_state_json_to_state_map(required_state: Any) -> StateMap[EventBase]
                 "Each event in `required_state` should have a string `state_key`"
             )
 
-            state_map[(event_type, event_state_key)] = make_event_from_dict(
-                state_event_dict
-            )
+            state_map[(event_type, event_state_key)] = make_test_event(state_event_dict)
     else:
         # Yell because we're in a test and this is unexpected
         raise AssertionError("`required_state` should be a list of event dicts")
@@ -195,7 +191,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
         remote_room_id = f"!remote-room:{self.OTHER_SERVER_NAME}"
         room_version = RoomVersions.V10
 
-        room_create_event = make_event_from_dict(
+        room_create_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": remote_room_id,
@@ -217,7 +213,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
             room_version=room_version,
         )
 
-        creator_membership_event = make_event_from_dict(
+        creator_membership_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": remote_room_id,
@@ -235,7 +231,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
         )
 
         # From the remote homeserver, invite user1 on the local homserver
-        user1_invite_membership_event = make_event_from_dict(
+        user1_invite_membership_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": remote_room_id,
@@ -297,7 +293,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
                 # Prevent tight-looping to allow the `test_timeout` to work
                 time.sleep(0.1)
 
-        user1_join_membership_event_template = make_event_from_dict(
+        user1_join_membership_event_template = make_test_event(
             {
                 "room_id": remote_room_id,
                 "sender": local_user1_id,
@@ -377,7 +373,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
                 and parser is not None
             ):
                 # As the remote server, we need to sign the event before sending it back
-                user1_join_membership_event_signed = make_event_from_dict(
+                user1_join_membership_event_signed = make_test_event(
                     self.add_hashes_and_signatures_from_other_server(data),
                     room_version=room_version,
                 )
@@ -404,12 +400,12 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
 
             if path.startswith("/_matrix/federation/v1/send/") and data is not None:
                 for pdu in data.get("pdus", []):
-                    event = event_from_pdu_json(pdu, room_version)
+                    event = make_test_pdu_event(pdu, room_version)
                     collected_pdus_from_hs1_federation_send.add(event.event_id)
 
                 # Just acknowledge everything hs1 is trying to send hs2
                 return {
-                    event_from_pdu_json(pdu, room_version).event_id: {}
+                    make_test_pdu_event(pdu, room_version).event_id: {}
                     for pdu in data.get("pdus", [])
                 }
 
@@ -521,12 +517,12 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
         ) -> JsonDict | T:
             if path.startswith("/_matrix/federation/v1/send/") and data is not None:
                 for pdu in data.get("pdus", []):
-                    event = event_from_pdu_json(pdu, room_version)
+                    event = make_test_pdu_event(pdu, room_version)
                     collected_pdus_from_hs1_federation_send.add(event.event_id)
 
                 # Just acknowledge everything hs1 is trying to send hs2
                 return {
-                    event_from_pdu_json(pdu, room_version).event_id: {}
+                    make_test_pdu_event(pdu, room_version).event_id: {}
                     for pdu in data.get("pdus", [])
                 }
 
@@ -538,7 +534,7 @@ class OutOfBandMembershipTests(unittest.FederatingHomeserverTestCase):
         self.federation_http_client.put_json.side_effect = put_json
 
         # From the remote homeserver, invite user2 on the local homserver
-        user2_invite_membership_event = make_event_from_dict(
+        user2_invite_membership_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": remote_room_id,
diff --git a/tests/federation/test_federation_server.py b/tests/federation/test_federation_server.py
index 7b1a2a5adc..1bf0817bd2 100644
--- a/tests/federation/test_federation_server.py
+++ b/tests/federation/test_federation_server.py
@@ -31,8 +31,7 @@ from synapse.api.errors import FederationError
 from synapse.api.room_versions import KNOWN_ROOM_VERSIONS, RoomVersions
 from synapse.config.server import DEFAULT_ROOM_VERSION
 from synapse.crypto.event_signing import add_hashes_and_signatures
-from synapse.events import EventBase, make_event_from_dict
-from synapse.federation.federation_base import event_from_pdu_json
+from synapse.events import EventBase
 from synapse.http.types import QueryParams
 from synapse.logging.context import LoggingContext
 from synapse.rest import admin
@@ -43,6 +42,7 @@ from synapse.types import JsonDict
 from synapse.util.clock import Clock
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event, make_test_pdu_event
 from tests.unittest import override_config
 
 logger = logging.getLogger(__name__)
@@ -95,7 +95,7 @@ class FederationServerTests(unittest.FederatingHomeserverTestCase):
 
 
 def _create_acl_event(content: JsonDict) -> EventBase:
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": "!a:b",
             "event_id": "$a:b",
@@ -147,7 +147,7 @@ class MessageAcceptTests(unittest.FederatingHomeserverTestCase):
 
         # Join a remote user to the room that will attempt to send bad events
         self.remote_bad_user_id = f"@baduser:{self.OTHER_SERVER_NAME}"
-        self.remote_bad_user_join_event = make_event_from_dict(
+        self.remote_bad_user_join_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": self.room_id,
@@ -212,7 +212,7 @@ class MessageAcceptTests(unittest.FederatingHomeserverTestCase):
         )
 
         # Now lie about an event's prev_events
-        lying_event = make_event_from_dict(
+        lying_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "room_id": self.room_id,
@@ -732,7 +732,7 @@ class StripUnsignedFromEventsTestCase(unittest.TestCase):
             "auth_events": [],
             "unsigned": {"malicious garbage": "hackz", "more warez": "more hackz"},
         }
-        filtered_event = event_from_pdu_json(event1, RoomVersions.V1)
+        filtered_event = make_test_pdu_event(event1, RoomVersions.V1)
         # Make sure unauthorized fields are stripped from unsigned
         self.assertNotIn("more warez", filtered_event.unsigned)
 
@@ -754,7 +754,7 @@ class StripUnsignedFromEventsTestCase(unittest.TestCase):
             },
         }
 
-        filtered_event2 = event_from_pdu_json(event2, RoomVersions.V1, received_time=20)
+        filtered_event2 = make_test_pdu_event(event2, RoomVersions.V1, received_time=20)
         self.assertIn("age_ts", filtered_event2.unsigned)
         self.assertEqual(6, filtered_event2.unsigned["age_ts"])
         self.assertNotIn("more warez", filtered_event2.unsigned)
@@ -779,7 +779,7 @@ class StripUnsignedFromEventsTestCase(unittest.TestCase):
                 "invite_room_state": [],
             },
         }
-        filtered_event3 = event_from_pdu_json(event3, RoomVersions.V1, received_time=20)
+        filtered_event3 = make_test_pdu_event(event3, RoomVersions.V1, received_time=20)
         self.assertIn("age_ts", filtered_event3.unsigned)
         # Invite_room_state field is only permitted in event type m.room.member
         self.assertNotIn("invite_room_state", filtered_event3.unsigned)
diff --git a/tests/federation/transport/test_client.py b/tests/federation/transport/test_client.py
index 9a6bbabd35..881baa02a9 100644
--- a/tests/federation/transport/test_client.py
+++ b/tests/federation/transport/test_client.py
@@ -36,7 +36,16 @@ class SendJoinParserTestCase(TestCase):
     def test_two_writes(self) -> None:
         """Test that the parser can sensibly deserialise an input given in two slices."""
         parser = SendJoinParser(RoomVersions.V1, True)
+        common_event_fields = {
+            "sender": "@user:example.org",
+            "depth": 1,
+            "origin_server_ts": 1,
+            "hashes": {},
+            "auth_events": [],
+            "prev_events": [],
+        }
         parent_event = {
+            **common_event_fields,
             "content": {
                 "see_room_version_spec": "The event format changes depending on the room version."
             },
@@ -45,6 +54,7 @@ class SendJoinParserTestCase(TestCase):
             "type": "m.room.minimal_pdu",
         }
         state = {
+            **common_event_fields,
             "content": {
                 "see_room_version_spec": "The event format changes depending on the room version."
             },
diff --git a/tests/handlers/test_federation.py b/tests/handlers/test_federation.py
index 20ffed68f4..794c0a3185 100644
--- a/tests/handlers/test_federation.py
+++ b/tests/handlers/test_federation.py
@@ -35,8 +35,7 @@ from synapse.api.errors import (
     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.events import EventBase
 from synapse.federation.federation_client import SendJoinResult
 from synapse.rest import admin
 from synapse.rest.client import login, room
@@ -45,6 +44,7 @@ from synapse.storage.databases.main.events_worker import EventCacheEntry
 from synapse.util.clock import Clock
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event, make_test_pdu_event
 
 logger = logging.getLogger(__name__)
 
@@ -132,7 +132,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
         )
 
         # build and send an event which will be rejected
-        ev = event_from_pdu_json(
+        ev = make_test_pdu_event(
             {
                 "type": EventTypes.Message,
                 "content": {},
@@ -183,7 +183,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
         )
 
         # build and send an event which will be rejected
-        ev = event_from_pdu_json(
+        ev = make_test_pdu_event(
             {
                 "type": "org.matrix.test",
                 "state_key": "test_key",
@@ -227,7 +227,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
         room_version = self.get_success(self.store.get_room_version(room_id))
 
         # Build an event to backfill
-        event = event_from_pdu_json(
+        event = make_test_pdu_event(
             {
                 "type": EventTypes.Message,
                 "content": {"body": "hello world", "msgtype": "m.text"},
@@ -324,7 +324,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
         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(
+            return make_test_pdu_event(
                 {
                     "type": EventTypes.Member,
                     "content": {"membership": "invite"},
@@ -386,7 +386,7 @@ class FederationTestCase(unittest.FederatingHomeserverTestCase):
 class EventFromPduTestCase(TestCase):
     def test_valid_json(self) -> None:
         """Valid JSON should be turned into an event."""
-        ev = event_from_pdu_json(
+        ev = make_test_pdu_event(
             {
                 "type": EventTypes.Message,
                 "content": {"bool": True, "null": None, "int": 1, "str": "foobar"},
@@ -413,7 +413,7 @@ class EventFromPduTestCase(TestCase):
             float("nan"),
         ]:
             with self.assertRaises(SynapseError):
-                event_from_pdu_json(
+                make_test_pdu_event(
                     {
                         "type": EventTypes.Message,
                         "content": {"foo": value},
@@ -430,7 +430,7 @@ class EventFromPduTestCase(TestCase):
     def test_invalid_nested(self) -> None:
         """List and dictionaries are recursively searched."""
         with self.assertRaises(SynapseError):
-            event_from_pdu_json(
+            make_test_pdu_event(
                 {
                     "type": EventTypes.Message,
                     "content": {"foo": [{"bar": 2**56}]},
@@ -457,7 +457,7 @@ class PartialJoinTestCase(unittest.FederatingHomeserverTestCase):
 
         room_id = "!room:example.com"
 
-        EVENT_CREATE = make_event_from_dict(
+        EVENT_CREATE = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.create",
@@ -470,7 +470,7 @@ class PartialJoinTestCase(unittest.FederatingHomeserverTestCase):
             },
             room_version=RoomVersions.V10,
         )
-        EVENT_CREATOR_MEMBERSHIP = make_event_from_dict(
+        EVENT_CREATOR_MEMBERSHIP = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.member",
@@ -484,7 +484,7 @@ class PartialJoinTestCase(unittest.FederatingHomeserverTestCase):
             },
             room_version=RoomVersions.V10,
         )
-        EVENT_INVITATION_MEMBERSHIP = make_event_from_dict(
+        EVENT_INVITATION_MEMBERSHIP = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.member",
@@ -501,7 +501,7 @@ class PartialJoinTestCase(unittest.FederatingHomeserverTestCase):
             },
             room_version=RoomVersions.V10,
         )
-        membership_event = make_event_from_dict(
+        membership_event = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.member",
diff --git a/tests/handlers/test_federation_event.py b/tests/handlers/test_federation_event.py
index 1aaa86e2e8..9da9f52fb6 100644
--- a/tests/handlers/test_federation_event.py
+++ b/tests/handlers/test_federation_event.py
@@ -28,7 +28,6 @@ from synapse.event_auth import (
     check_state_dependent_auth_rules,
     check_state_independent_auth_rules,
 )
-from synapse.events import make_event_from_dict
 from synapse.events.snapshot import EventContext
 from synapse.federation.transport.client import StateRequestResponse
 from synapse.logging.context import LoggingContext
@@ -42,6 +41,7 @@ from synapse.util.clock import Clock
 
 from tests import unittest
 from tests.test_utils import event_injection
+from tests.test_utils.event_builders import make_test_event
 
 
 class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
@@ -127,7 +127,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
 
         # mock up a load of state events which we are missing
         state_events = [
-            make_event_from_dict(
+            make_test_event(
                 self.add_hashes_and_signatures_from_other_server(
                     {
                         "type": "test_state_type",
@@ -154,7 +154,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
         # mock up a prev event.
         # Depending on the test, we either persist this upfront (as an outlier),
         # or let the server request it.
-        prev_event = make_event_from_dict(
+        prev_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -191,7 +191,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
             self.mock_federation_transport_client.get_event.side_effect = get_event
 
         # mock up a regular event to pass into _process_pulled_event
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -301,7 +301,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
             )
         )
 
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -421,7 +421,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
             member_event.event_id,
         ]
 
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -524,7 +524,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
 
         # We purposely don't run `add_hashes_and_signatures_from_other_server`
         # over this because we want the signature check to fail.
-        pulled_event_without_signatures = make_event_from_dict(
+        pulled_event_without_signatures = make_test_event(
             {
                 "type": "test_regular_type",
                 "room_id": room_id,
@@ -540,7 +540,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
 
         # Create a regular event that should pass except for the
         # `pulled_event_without_signatures` in the `prev_event`.
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -720,7 +720,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
         ]
 
         # Create a regular event that should process
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "test_regular_type",
@@ -878,7 +878,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
         # accepted, but the local homeserver will reject.
         next_depth = 100
         next_timestamp = other_member_event.origin_server_ts + 100
-        rejected_power_levels_event = make_event_from_dict(
+        rejected_power_levels_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "m.room.power_levels",
@@ -927,7 +927,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
         # Then we create a kick event for a local user that cites the rejected power
         # levels event in its auth events. The kick event will be rejected solely
         # because of the rejected auth event and would otherwise be accepted.
-        rejected_kick_event = make_event_from_dict(
+        rejected_kick_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "m.room.member",
@@ -1042,7 +1042,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
 
         # Create a missing event, so that the local homeserver has to do a `/state` or
         # `/state_ids` request to pull state from the remote homeserver.
-        missing_event = make_event_from_dict(
+        missing_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "m.room.message",
@@ -1067,7 +1067,7 @@ class FederationEventHandlerTests(unittest.FederatingHomeserverTestCase):
         # The pulled event has two prev events, one of which is missing. We will make a
         # `/state` or `/state_ids` request to the remote homeserver to ask it for the
         # state before the missing prev event.
-        pulled_event = make_event_from_dict(
+        pulled_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
                     "type": "m.room.message",
diff --git a/tests/handlers/test_room_member.py b/tests/handlers/test_room_member.py
index 3890abdbc8..b550c2420b 100644
--- a/tests/handlers/test_room_member.py
+++ b/tests/handlers/test_room_member.py
@@ -9,9 +9,6 @@ from synapse.api.constants import AccountDataTypes, EventTypes, Membership
 from synapse.api.errors import Codes, LimitExceededError, SynapseError
 from synapse.crypto.event_signing import add_hashes_and_signatures
 from synapse.events import FrozenEventV3
-from synapse.federation.federation_base import (
-    event_from_pdu_json,
-)
 from synapse.federation.federation_client import SendJoinResult
 from synapse.server import HomeServer
 from synapse.types import UserID, create_requester
@@ -19,6 +16,7 @@ from synapse.util.clock import Clock
 
 from tests.replication._base import BaseMultiWorkerStreamTestCase
 from tests.server import make_request
+from tests.test_utils.event_builders import make_test_pdu_event
 from tests.unittest import (
     FederatingHomeserverTestCase,
     HomeserverTestCase,
@@ -549,7 +547,7 @@ class TestMSC4155InviteFiltering(FederatingHomeserverTestCase):
         )
         room_version = self.get_success(self.store.get_room_version(room_id))
 
-        invite_event = event_from_pdu_json(
+        invite_event = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "content": {"membership": "invite"},
@@ -595,7 +593,7 @@ class TestMSC4155InviteFiltering(FederatingHomeserverTestCase):
         )
         room_version = self.get_success(self.store.get_room_version(room_id))
 
-        invite_event = event_from_pdu_json(
+        invite_event = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "content": {"membership": "invite"},
@@ -710,7 +708,7 @@ class TestMSC4380InviteBlocking(FederatingHomeserverTestCase):
         )
         room_version = self.get_success(self.store.get_room_version(room_id))
 
-        invite_event = event_from_pdu_json(
+        invite_event = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "content": {"membership": "invite"},
diff --git a/tests/handlers/test_room_policy.py b/tests/handlers/test_room_policy.py
index 9adf0e38c2..2d3e917aef 100644
--- a/tests/handlers/test_room_policy.py
+++ b/tests/handlers/test_room_policy.py
@@ -22,7 +22,7 @@ from twisted.internet.testing import MemoryReactor
 from synapse.api.constants import EventTypes
 from synapse.api.errors import HttpResponseException, SynapseError
 from synapse.crypto.event_signing import compute_event_signature
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.handlers.room_policy import POLICY_SERVER_KEY_ID
 from synapse.rest import admin
 from synapse.rest.client import filter, login, room, sync
@@ -32,6 +32,7 @@ from synapse.util.clock import Clock
 
 from tests import unittest
 from tests.test_utils import event_injection
+from tests.test_utils.event_builders import make_test_event
 
 
 class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
@@ -75,7 +76,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
         self.signing_key = signedjson.key.generate_signing_key("policy_server")
 
         # Create some sample events
-        self.spammy_event = make_event_from_dict(
+        self.spammy_event = make_test_event(
             room_version=room_version,
             internal_metadata_dict={},
             event_dict={
@@ -88,7 +89,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
                 },
             },
         )
-        self.not_spammy_event = make_event_from_dict(
+        self.not_spammy_event = make_test_event(
             room_version=room_version,
             internal_metadata_dict={},
             event_dict={
@@ -272,7 +273,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
     def test_signed_event_is_not_spam(self) -> None:
         verify_key_str = encode_verify_key_base64(get_verify_key(self.signing_key))
         self._add_policy_server_to_room(public_key=verify_key_str)
-        event = make_event_from_dict(
+        event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
@@ -302,7 +303,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
     def test_ask_policy_server_to_sign_event_ok(self) -> None:
         verify_key_str = encode_verify_key_base64(get_verify_key(self.signing_key))
         self._add_policy_server_to_room(public_key=verify_key_str)
-        event = make_event_from_dict(
+        event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
@@ -324,7 +325,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
     def test_ask_policy_server_to_sign_event_refuses(self) -> None:
         verify_key_str = encode_verify_key_base64(get_verify_key(self.signing_key))
         self._add_policy_server_to_room(public_key=verify_key_str)
-        event = make_event_from_dict(
+        event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
@@ -353,7 +354,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
     def test_ask_policy_server_to_sign_event_cannot_reach(self) -> None:
         verify_key_str = encode_verify_key_base64(get_verify_key(self.signing_key))
         self._add_policy_server_to_room(public_key=verify_key_str)
-        event = make_event_from_dict(
+        event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
@@ -379,7 +380,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
         verify_key_str = encode_verify_key_base64(get_verify_key(self.signing_key))
         self._add_policy_server_to_room(public_key=verify_key_str)
         self.mock_federation_transport_client.ask_policy_server_to_sign_event.side_effect = self.policy_server_signs_event_with_wrong_key
-        unverified_event = make_event_from_dict(
+        unverified_event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
@@ -398,7 +399,7 @@ class RoomPolicyTestCase(unittest.FederatingHomeserverTestCase):
         )
         self.assertEqual(len(unverified_event.signatures), 1)
 
-        verified_event = make_event_from_dict(
+        verified_event = make_test_event(
             room_version=self.room_version,
             internal_metadata_dict={},
             event_dict={
diff --git a/tests/handlers/test_room_summary.py b/tests/handlers/test_room_summary.py
index ee65cb1afb..49076e69d8 100644
--- a/tests/handlers/test_room_summary.py
+++ b/tests/handlers/test_room_summary.py
@@ -35,7 +35,6 @@ from synapse.api.constants import (
 )
 from synapse.api.errors import AuthError, NotFoundError, SynapseError
 from synapse.api.room_versions import RoomVersions
-from synapse.events import make_event_from_dict
 from synapse.federation.transport.client import TransportLayerClient
 from synapse.handlers.room_summary import _child_events_comparison_key, _RoomEntry
 from synapse.rest import admin
@@ -45,6 +44,7 @@ from synapse.types import JsonDict, UserID, create_requester
 from synapse.util.clock import Clock
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 from tests.unittest import override_config
 
 
@@ -217,7 +217,7 @@ class SpaceSummaryTestCase(unittest.HomeserverTestCase):
         # Poke an invite over federation into the database.
         fed_handler = self.hs.get_federation_handler()
         fed_hostname = UserID.from_string(from_user).domain
-        event = make_event_from_dict(
+        event = make_test_event(
             {
                 "room_id": room_id,
                 "event_id": "!abcd:" + fed_hostname,
diff --git a/tests/handlers/test_sync.py b/tests/handlers/test_sync.py
index e4a4d59aeb..d2b2523321 100644
--- a/tests/handlers/test_sync.py
+++ b/tests/handlers/test_sync.py
@@ -32,7 +32,6 @@ from synapse.api.filtering import FilterCollection, Filtering
 from synapse.api.room_versions import RoomVersion, RoomVersions
 from synapse.events import EventBase
 from synapse.events.snapshot import EventContext
-from synapse.federation.federation_base import event_from_pdu_json
 from synapse.handlers.sync import (
     SyncConfig,
     SyncRequestKey,
@@ -55,6 +54,7 @@ from synapse.util.duration import Duration
 
 import tests.unittest
 import tests.utils
+from tests.test_utils.event_builders import make_test_pdu_event
 
 _request_key = 0
 
@@ -913,7 +913,7 @@ class SyncTestCase(tests.unittest.HomeserverTestCase):
         prev_events = self.get_success(self.store.get_prev_events_for_room(room_id))
 
         # create a call invite event
-        call_event = event_from_pdu_json(
+        call_event = make_test_pdu_event(
             {
                 "type": EventTypes.CallInvite,
                 "content": {},
@@ -961,7 +961,7 @@ class SyncTestCase(tests.unittest.HomeserverTestCase):
         priv_prev_events = self.get_success(
             self.store.get_prev_events_for_room(private_room_id)
         )
-        private_call_event = event_from_pdu_json(
+        private_call_event = make_test_pdu_event(
             {
                 "type": EventTypes.CallInvite,
                 "content": {},
diff --git a/tests/push/test_presentable_names.py b/tests/push/test_presentable_names.py
index 2558f2c0b2..2d382c8fab 100644
--- a/tests/push/test_presentable_names.py
+++ b/tests/push/test_presentable_names.py
@@ -23,11 +23,12 @@ from typing import Iterable, cast
 
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.room_versions import RoomVersions
-from synapse.events import EventBase, FrozenEvent
+from synapse.events import EventBase
 from synapse.push.presentable_names import calculate_room_name
 from synapse.types import StateKey, StateMap
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 
 
 class MockDataStore:
@@ -44,7 +45,7 @@ class MockDataStore:
         self._events = {}
 
         for i, (event_id, content) in enumerate(events):
-            self._events[event_id] = FrozenEvent(
+            self._events[event_id] = make_test_event(
                 {
                     "event_id": "$event_id",
                     "type": event_id[0],
@@ -59,7 +60,7 @@ class MockDataStore:
 
     async def get_event(
         self, event_id: str, allow_none: bool = False
-    ) -> FrozenEvent | None:
+    ) -> EventBase | None:
         assert allow_none, "Mock not configured for allow_none = False"
 
         # Decode the state key from the event ID.
diff --git a/tests/push/test_push_rule_evaluator.py b/tests/push/test_push_rule_evaluator.py
index a786d74bf1..2e389710b9 100644
--- a/tests/push/test_push_rule_evaluator.py
+++ b/tests/push/test_push_rule_evaluator.py
@@ -27,7 +27,6 @@ import synapse.rest.admin
 from synapse.api.constants import EventTypes, HistoryVisibility, Membership
 from synapse.api.room_versions import RoomVersions
 from synapse.appservice import ApplicationService
-from synapse.events import FrozenEvent, make_event_from_dict
 from synapse.push.bulk_push_rule_evaluator import _flatten_dict
 from synapse.push.httppusher import tweaks_for_actions
 from synapse.rest import admin
@@ -40,6 +39,7 @@ from synapse.util.clock import Clock
 from synapse.util.frozenutils import freeze
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 from tests.test_utils.event_injection import create_event, inject_member_event
 
 
@@ -81,7 +81,7 @@ class FlattenDictTestCase(unittest.TestCase):
 
     def test_event(self) -> None:
         """Events can also be flattened."""
-        event = make_event_from_dict(
+        event = make_test_event(
             {
                 "room_id": "!test:test",
                 "type": "m.room.message",
@@ -103,6 +103,10 @@ class FlattenDictTestCase(unittest.TestCase):
             "room_id": "!test:test",
             "sender": "@alice:test",
             "type": "m.room.message",
+            "depth": 1,
+            "origin_server_ts": 1,
+            "auth_events": [],
+            "prev_events": [],
         }
         self.assertEqual(expected, _flatten_dict(event))
 
@@ -121,24 +125,32 @@ class FlattenDictTestCase(unittest.TestCase):
         }
 
         # For a current room version, there's no special behavior.
-        event = make_event_from_dict(event_dict, room_version=RoomVersions.V8)
+        event = make_test_event(event_dict, room_version=RoomVersions.V8)
         expected = {
             "room_id": "!test:test",
             "sender": "@alice:test",
             "type": "m.room.message",
             "content.org\\.matrix\\.msc1767\\.markup": [],
+            "depth": 1,
+            "origin_server_ts": 1,
+            "auth_events": [],
+            "prev_events": [],
         }
         self.assertEqual(expected, _flatten_dict(event))
 
         # For a room version with extensible events, they parse out the text/plain
         # to a content.body property.
-        event = make_event_from_dict(event_dict, room_version=RoomVersions.MSC1767v10)
+        event = make_test_event(event_dict, room_version=RoomVersions.MSC1767v10)
         expected = {
             "content.body": "hello world!",
             "room_id": "!test:test",
             "sender": "@alice:test",
             "type": "m.room.message",
             "content.org\\.matrix\\.msc1767\\.markup": [],
+            "depth": 1,
+            "origin_server_ts": 1,
+            "auth_events": [],
+            "prev_events": [],
         }
         self.assertEqual(expected, _flatten_dict(event))
 
@@ -152,7 +164,7 @@ class PushRuleEvaluatorTestCase(unittest.TestCase):
         msc4210: bool = False,
         msc4306: bool = False,
     ) -> PushRuleEvaluator:
-        event = FrozenEvent(
+        event = make_test_event(
             {
                 "event_id": "$event_id",
                 "type": "m.room.history_visibility",
diff --git a/tests/rest/client/sliding_sync/test_sliding_sync.py b/tests/rest/client/sliding_sync/test_sliding_sync.py
index ac8dfd37d8..ebf41cd87c 100644
--- a/tests/rest/client/sliding_sync/test_sliding_sync.py
+++ b/tests/rest/client/sliding_sync/test_sliding_sync.py
@@ -30,7 +30,7 @@ from synapse.api.constants import (
     RoomTypes,
 )
 from synapse.api.room_versions import RoomVersions
-from synapse.events import EventBase, StrippedStateEvent, make_event_from_dict
+from synapse.events import EventBase, StrippedStateEvent
 from synapse.events.snapshot import EventContext
 from synapse.handlers.sliding_sync import StateValues
 from synapse.rest.client import account_data, devices, login, receipts, room, sync
@@ -47,6 +47,7 @@ from synapse.util.stringutils import random_string
 
 from tests import unittest
 from tests.server import FakeChannel, TimedOutException
+from tests.test_utils.event_builders import make_test_event
 from tests.test_utils.event_injection import create_event
 
 logger = logging.getLogger(__name__)
@@ -308,7 +309,7 @@ class SlidingSyncBase(unittest.HomeserverTestCase):
                 "invite_room_state": serialized_stripped_state_events
             }
 
-        invite_event = make_event_from_dict(
+        invite_event = make_test_event(
             invite_event_dict,
             room_version=RoomVersions.V10,
         )
diff --git a/tests/rest/client/test_third_party_rules.py b/tests/rest/client/test_third_party_rules.py
index 1709b27f67..b4fa71ece8 100644
--- a/tests/rest/client/test_third_party_rules.py
+++ b/tests/rest/client/test_third_party_rules.py
@@ -532,6 +532,7 @@ class ThirdPartyRulesTestCase(unittest.FederatingHomeserverTestCase):
                     "origin_server_ts": self.clock.time_msec(),
                     "prev_events": [],
                     "auth_events": [],
+                    "hashes": {},
                     "signatures": {},
                     "unsigned": {},
                 }
diff --git a/tests/state/test_v2.py b/tests/state/test_v2.py
index 85ce5bede2..8b3b919f44 100644
--- a/tests/state/test_v2.py
+++ b/tests/state/test_v2.py
@@ -33,7 +33,7 @@ from twisted.internet import defer
 from synapse.api.constants import EventTypes, JoinRules, Membership
 from synapse.api.room_versions import RoomVersions
 from synapse.event_auth import auth_types_for_event
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.state.v2 import (
     _get_auth_chain_difference,
     _get_power_level_for_sender,
@@ -45,6 +45,7 @@ from synapse.types import EventID, StateMap
 from synapse.util.duration import Duration
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 
 ALICE = "@alice:example.com"
 BOB = "@bob:example.com"
@@ -119,7 +120,7 @@ class FakeEvent:
         if self.state_key is not None:
             event_dict["state_key"] = self.state_key
 
-        return make_event_from_dict(event_dict)
+        return make_test_event(event_dict)
 
 
 # All graphs start with this set of events
@@ -878,7 +879,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
         on room version"""
         store = TestStateResolutionStore({})
         for room_version in [RoomVersions.V10, RoomVersions.V11]:
-            create_event = make_event_from_dict(
+            create_event = make_test_event(
                 {
                     "room_id": ROOM_ID,
                     "sender": ALICE,
@@ -894,9 +895,9 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                         else {}
                     ),
                 },
-                room_version,
+                room_version=room_version,
             )
-            member_event = make_event_from_dict(
+            member_event = make_test_event(
                 {
                     "room_id": ROOM_ID,
                     "sender": ALICE,
@@ -908,9 +909,9 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                     "auth_events": [create_event.event_id],
                     "prev_events": [create_event.event_id],
                 },
-                room_version,
+                room_version=room_version,
             )
-            pl_event = make_event_from_dict(
+            pl_event = make_test_event(
                 {
                     "room_id": ROOM_ID,
                     "sender": ALICE,
@@ -926,7 +927,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                     "auth_events": [create_event.event_id, member_event.event_id],
                     "prev_events": [member_event.event_id],
                 },
-                room_version,
+                room_version=room_version,
             )
 
             event_map = {
@@ -940,7 +941,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                 CHARLIE: 10,
             }
             for user_id, want_pl in want_pls.items():
-                test_event = make_event_from_dict(
+                test_event = make_test_event(
                     {
                         "room_id": ROOM_ID,
                         "sender": user_id,
@@ -954,7 +955,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                         ],
                         "prev_events": [pl_event.event_id],
                     },
-                    room_version,
+                    room_version=room_version,
                 )
                 event_map[test_event.event_id] = test_event
                 got_pl = self.successResultOf(
@@ -977,7 +978,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                 CHARLIE: 0,
             }
             for user_id, want_pl in want_pls.items():
-                test_event = make_event_from_dict(
+                test_event = make_test_event(
                     {
                         "room_id": ROOM_ID,
                         "sender": user_id,
@@ -991,7 +992,7 @@ class AuthChainDifferenceTestCase(unittest.TestCase):
                         ],
                         "prev_events": [pl_event.event_id],
                     },
-                    room_version,
+                    room_version=room_version,
                 )
                 got_pl = self.successResultOf(
                     defer.ensureDeferred(
diff --git a/tests/state/test_v21.py b/tests/state/test_v21.py
index 9f607176c9..6b4d2837ab 100644
--- a/tests/state/test_v21.py
+++ b/tests/state/test_v21.py
@@ -495,6 +495,7 @@ class StateResV21TestCase(unittest.HomeserverTestCase):
             "prev_events": prev_events,
             "auth_events": auth_events,
             "origin_server_ts": monotonic_timestamp(),
+            "hashes": {},
         }
         if event_type != EventTypes.Create:
             if room_id is None:
diff --git a/tests/storage/databases/main/test_events_worker.py b/tests/storage/databases/main/test_events_worker.py
index c786271c09..dd647d29d6 100644
--- a/tests/storage/databases/main/test_events_worker.py
+++ b/tests/storage/databases/main/test_events_worker.py
@@ -28,7 +28,6 @@ from twisted.internet.defer import CancelledError, Deferred, ensureDeferred
 from twisted.internet.testing import MemoryReactor
 
 from synapse.api.room_versions import EventFormatVersions, RoomVersions
-from synapse.events import make_event_from_dict
 from synapse.logging.context import LoggingContext
 from synapse.rest import admin
 from synapse.rest.client import login, room
@@ -42,6 +41,7 @@ from synapse.util.async_helpers import yieldable_gather_results
 from synapse.util.clock import Clock
 
 from tests import unittest
+from tests.test_utils.event_builders import make_test_event
 from tests.test_utils.event_injection import create_event, inject_event
 
 
@@ -377,7 +377,7 @@ class DatabaseOutageTestCase(unittest.HomeserverTestCase):
                 "type": f"test {idx}",
                 "room_id": self.room_id,
             }
-            event = make_event_from_dict(event_json, room_version=RoomVersions.V4)
+            event = make_test_event(event_json, room_version=RoomVersions.V4)
             event_id = event.event_id
             self.get_success(
                 self.store.db_pool.simple_upsert(
@@ -400,7 +400,7 @@ class DatabaseOutageTestCase(unittest.HomeserverTestCase):
                     {"event_id": event_id},
                     {
                         "room_id": self.room_id,
-                        "json": json.dumps(event_json),
+                        "json": json.dumps(event.get_dict()),
                         "internal_metadata": "{}",
                         "format_version": EventFormatVersions.ROOM_V4_PLUS,
                     },
diff --git a/tests/storage/test_events.py b/tests/storage/test_events.py
index 7d1c96f97f..c511ac9252 100644
--- a/tests/storage/test_events.py
+++ b/tests/storage/test_events.py
@@ -26,13 +26,13 @@ from twisted.internet.testing import MemoryReactor
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.room_versions import RoomVersions
 from synapse.events import EventBase
-from synapse.federation.federation_base import event_from_pdu_json
 from synapse.rest import admin
 from synapse.rest.client import login, room
 from synapse.server import HomeServer
 from synapse.types import StateMap
 from synapse.util.clock import Clock
 
+from tests.test_utils.event_builders import make_test_pdu_event
 from tests.unittest import HomeserverTestCase
 
 logger = logging.getLogger(__name__)
@@ -142,7 +142,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
 
         # Fudge a remote event and persist it. This will be the extremity before
         # the gap.
-        self.remote_event_1 = event_from_pdu_json(
+        self.remote_event_1 = make_test_pdu_event(
             {
                 "type": EventTypes.Message,
                 "state_key": "@user:other",
@@ -198,7 +198,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other",
@@ -237,7 +237,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         )
 
         # Fudge a second event which points to an event we don't have.
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Message,
                 "state_key": "@user:other",
@@ -286,7 +286,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other2",
@@ -322,7 +322,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other2",
@@ -367,7 +367,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other2",
@@ -415,7 +415,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other2",
@@ -455,7 +455,7 @@ class ExtremPruneTestCase(HomeserverTestCase):
         # Fudge a second event which points to an event we don't have. This is a
         # state event so that the state changes (otherwise we won't prune the
         # extremity as they'll have the same state group).
-        remote_event_2 = event_from_pdu_json(
+        remote_event_2 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": "@user:other2",
@@ -514,7 +514,7 @@ class InvalideUsersInRoomCacheTestCase(HomeserverTestCase):
 
         # Fudge a join event for a remote user.
         remote_user = "@user:other"
-        remote_event_1 = event_from_pdu_json(
+        remote_event_1 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": remote_user,
@@ -561,7 +561,7 @@ class InvalideUsersInRoomCacheTestCase(HomeserverTestCase):
 
         # Fudge a join event for a remote user.
         remote_user = "@user:other"
-        remote_event_1 = event_from_pdu_json(
+        remote_event_1 = make_test_pdu_event(
             {
                 "type": EventTypes.Member,
                 "state_key": remote_user,
diff --git a/tests/storage/test_msc4242_state_dag.py b/tests/storage/test_msc4242_state_dag.py
index 6720c1d659..2150bc0996 100644
--- a/tests/storage/test_msc4242_state_dag.py
+++ b/tests/storage/test_msc4242_state_dag.py
@@ -19,15 +19,13 @@ from twisted.test.proto_helpers import MemoryReactor
 from synapse.api.constants import EventTypes
 from synapse.api.errors import SynapseError
 from synapse.api.room_versions import RoomVersions
-from synapse.events import (
-    make_event_from_dict,
-)
 from synapse.events.py_protocol import MSC4242Event, supports_msc4242_state_dag
 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
 
 
@@ -156,7 +154,7 @@ class MSC4242EventPersistenceStateDagsStoreTestCase(HomeserverTestCase):
         prev_state_events: list[str],
         rejected: bool = False,
     ) -> tuple[MSC4242Event, EventContext]:
-        ev = make_event_from_dict(
+        ev = make_test_event(
             {
                 "prev_state_events": prev_state_events,
                 "content": {
diff --git a/tests/storage/test_sliding_sync_tables.py b/tests/storage/test_sliding_sync_tables.py
index 39226ff9be..67b8d1138f 100644
--- a/tests/storage/test_sliding_sync_tables.py
+++ b/tests/storage/test_sliding_sync_tables.py
@@ -27,7 +27,7 @@ from twisted.internet.testing import MemoryReactor
 
 from synapse.api.constants import EventContentFields, EventTypes, Membership, RoomTypes
 from synapse.api.room_versions import RoomVersions
-from synapse.events import EventBase, StrippedStateEvent, make_event_from_dict
+from synapse.events import EventBase, StrippedStateEvent
 from synapse.events.snapshot import EventContext
 from synapse.rest import admin
 from synapse.rest.client import login, room, sync
@@ -46,6 +46,7 @@ from synapse.types.storage import _BackgroundUpdates
 from synapse.util.clock import Clock
 
 from tests.rest.client.sliding_sync.test_sliding_sync import SlidingSyncBase
+from tests.test_utils.event_builders import make_test_event
 from tests.test_utils.event_injection import create_event
 
 logger = logging.getLogger(__name__)
@@ -240,7 +241,7 @@ class SlidingSyncTablesTestCaseBase(SlidingSyncBase):
             "prev_events": [],
         }
 
-        kick_event = make_event_from_dict(
+        kick_event = make_test_event(
             kick_event_dict,
             room_version=RoomVersions.V10,
         )
diff --git a/tests/test_event_auth.py b/tests/test_event_auth.py
index 9258f0d4dc..4537186ee6 100644
--- a/tests/test_event_auth.py
+++ b/tests/test_event_auth.py
@@ -29,11 +29,12 @@ from synapse import event_auth
 from synapse.api.constants import EventContentFields, RejectedReason
 from synapse.api.errors import AuthError, SynapseError
 from synapse.api.room_versions import EventFormatVersions, RoomVersion, RoomVersions
-from synapse.events import EventBase, event_exists_in_state_dag, make_event_from_dict
+from synapse.events import EventBase, event_exists_in_state_dag
 from synapse.storage.databases.main.events_worker import EventRedactBehaviour
 from synapse.types import JsonDict, get_domain_from_id
 
 from tests.test_utils import get_awaitable_result
+from tests.test_utils.event_builders import make_test_event
 
 
 class _StubEventSourceStore:
@@ -128,7 +129,7 @@ class EventAuthTestCase(unittest.TestCase):
 
         # we make both a good event and a bad event, to check that we are rejecting
         # the bad event for the reason we think we are.
-        good_event = make_event_from_dict(
+        good_event = make_test_event(
             {
                 "room_id": TEST_ROOM_ID,
                 "type": "m.room.create",
@@ -143,7 +144,7 @@ class EventAuthTestCase(unittest.TestCase):
             },
             room_version=RoomVersions.V9,
         )
-        bad_event = make_event_from_dict(
+        bad_event = make_test_event(
             {**good_event.get_dict(), "prev_events": ["$fakeevent"]},
             room_version=RoomVersions.V9,
         )
@@ -387,7 +388,7 @@ class EventAuthTestCase(unittest.TestCase):
         creator = "@creator:example.com"
         room_version = RoomVersions.MSC4242v12
 
-        create_event = make_event_from_dict(
+        create_event = make_test_event(
             {
                 "type": "m.room.create",
                 "sender": creator,
@@ -398,7 +399,7 @@ class EventAuthTestCase(unittest.TestCase):
             },
             room_version,
         )
-        create_event_2 = make_event_from_dict(
+        create_event_2 = make_test_event(
             {
                 "type": "m.room.create",
                 "sender": creator,
@@ -411,7 +412,7 @@ class EventAuthTestCase(unittest.TestCase):
         )
         room_id = create_event.room_id
         another_room_id = create_event_2.room_id
-        join_event = make_event_from_dict(
+        join_event = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.member",
@@ -424,7 +425,7 @@ class EventAuthTestCase(unittest.TestCase):
             room_version,
             {"calculated_auth_event_ids": [create_event.event_id]},
         )
-        event_in_another_room = make_event_from_dict(
+        event_in_another_room = make_test_event(
             {
                 "room_id": another_room_id,
                 "type": "m.room.join_rules",
@@ -437,7 +438,7 @@ class EventAuthTestCase(unittest.TestCase):
             room_version,
             {"calculated_auth_event_ids": [create_event.event_id, join_event.event_id]},
         )
-        msg_event = make_event_from_dict(
+        msg_event = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.message",
@@ -449,7 +450,7 @@ class EventAuthTestCase(unittest.TestCase):
             room_version,
             {"calculated_auth_event_ids": [create_event.event_id, join_event.event_id]},
         )
-        rejected_event = make_event_from_dict(
+        rejected_event = make_test_event(
             {
                 "room_id": room_id,
                 "type": "m.room.name",
@@ -470,7 +471,7 @@ class EventAuthTestCase(unittest.TestCase):
             RejectingTestCase(
                 name="create event has prev_state_events",
                 events_in_store=[],
-                test_event=make_event_from_dict(
+                test_event=make_test_event(
                     {
                         "type": "m.room.create",
                         "sender": creator,
@@ -486,7 +487,7 @@ class EventAuthTestCase(unittest.TestCase):
             RejectingTestCase(
                 name="prev_state_event belongs in a different room",
                 events_in_store=[create_event, join_event, event_in_another_room],
-                test_event=make_event_from_dict(
+                test_event=make_test_event(
                     {
                         "room_id": room_id,
                         "type": "m.room.name",
@@ -508,7 +509,7 @@ class EventAuthTestCase(unittest.TestCase):
             RejectingTestCase(
                 name="prev_state_event is a message event",
                 events_in_store=[create_event, join_event, msg_event],
-                test_event=make_event_from_dict(
+                test_event=make_test_event(
                     {
                         "room_id": room_id,
                         "type": "m.room.name",
@@ -530,7 +531,7 @@ class EventAuthTestCase(unittest.TestCase):
             RejectingTestCase(
                 name="prev_state_event was rejected",
                 events_in_store=[create_event, join_event, rejected_event],
-                test_event=make_event_from_dict(
+                test_event=make_test_event(
                     {
                         "room_id": room_id,
                         "type": "m.room.name",
@@ -892,7 +893,7 @@ class EventAuthTestCase(unittest.TestCase):
 
     def test_room_v10_rejects_string_power_levels(self) -> None:
         pl_event_content = {"users_default": "42"}
-        pl_event = make_event_from_dict(
+        pl_event = make_test_event(
             {
                 "room_id": TEST_ROOM_ID,
                 **_maybe_get_event_id_dict_for_room_version(RoomVersions.V10),
@@ -906,7 +907,7 @@ class EventAuthTestCase(unittest.TestCase):
         )
 
         pl_event2_content = {"events": {"m.room.name": "42", "m.room.power_levels": 42}}
-        pl_event2 = make_event_from_dict(
+        pl_event2 = make_test_event(
             {
                 "room_id": TEST_ROOM_ID,
                 **_maybe_get_event_id_dict_for_room_version(RoomVersions.V10),
@@ -936,7 +937,7 @@ class EventAuthTestCase(unittest.TestCase):
         """
 
         def create_event(pl_event_content: dict[str, Any]) -> EventBase:
-            return make_event_from_dict(
+            return make_test_event(
                 {
                     "room_id": TEST_ROOM_ID,
                     **_maybe_get_event_id_dict_for_room_version(RoomVersions.V10),
@@ -1049,7 +1050,7 @@ class EventAuthTestCase(unittest.TestCase):
                     "signatures": {"test.com": {"ed25519:0": "some9signature"}},
                 }
                 base.update(ev)
-                event = make_event_from_dict(base, RoomVersions.V10)
+                event = make_test_event(base, RoomVersions.V10)
                 got = event_exists_in_state_dag(event)
                 self.assertEqual(
                     got, should_exist, f"{ev} should_exist={should_exist} but got {got}"
@@ -1068,7 +1069,7 @@ def _create_event(
     room_version: RoomVersion,
     user_id: str,
 ) -> EventBase:
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": TEST_ROOM_ID,
             **_maybe_get_event_id_dict_for_room_version(room_version),
@@ -1089,7 +1090,7 @@ def _member_event(
     sender: str | None = None,
     additional_content: dict | None = None,
 ) -> EventBase:
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": TEST_ROOM_ID,
             **_maybe_get_event_id_dict_for_room_version(room_version),
@@ -1122,7 +1123,7 @@ def _power_levels_event(
     sender: str,
     content: JsonDict,
 ) -> EventBase:
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": TEST_ROOM_ID,
             **_maybe_get_event_id_dict_for_room_version(room_version),
@@ -1145,7 +1146,7 @@ def _alias_event(room_version: RoomVersion, sender: str, **kwargs: Any) -> Event
         "content": {"aliases": []},
     }
     data.update(**kwargs)
-    return make_event_from_dict(data, room_version=room_version)
+    return make_test_event(data, room_version=room_version)
 
 
 def _build_auth_dict_for_room_version(
@@ -1164,7 +1165,7 @@ def _random_state_event(
 ) -> EventBase:
     if auth_events is None:
         auth_events = []
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": TEST_ROOM_ID,
             **_maybe_get_event_id_dict_for_room_version(room_version),
@@ -1181,7 +1182,7 @@ def _random_state_event(
 def _join_rules_event(
     room_version: RoomVersion, sender: str, join_rule: str
 ) -> EventBase:
-    return make_event_from_dict(
+    return make_test_event(
         {
             "room_id": TEST_ROOM_ID,
             **_maybe_get_event_id_dict_for_room_version(room_version),
diff --git a/tests/test_state.py b/tests/test_state.py
index 0ca88aef74..0a6720d6ef 100644
--- a/tests/test_state.py
+++ b/tests/test_state.py
@@ -32,7 +32,7 @@ from twisted.internet import defer
 from synapse.api.auth.internal import InternalAuth
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.room_versions import RoomVersions
-from synapse.events import EventBase, make_event_from_dict
+from synapse.events import EventBase
 from synapse.events.snapshot import EventContext
 from synapse.state import StateHandler, StateResolutionHandler, _make_state_cache_entry
 from synapse.types import JsonDict, MutableStateMap, StateMap
@@ -41,6 +41,7 @@ from synapse.util.macaroons import MacaroonGenerator
 
 from tests import unittest
 from tests.server import get_clock
+from tests.test_utils.event_builders import make_test_event
 from tests.utils import default_config
 
 _next_event_id = 1000
@@ -82,7 +83,7 @@ def create_event(
 
     d.update(kwargs)
 
-    return make_event_from_dict(d)
+    return make_test_event(d)
 
 
 class _DummyStore:
diff --git a/tests/test_utils/event_builders.py b/tests/test_utils/event_builders.py
new file mode 100644
index 0000000000..a8eb586c1f
--- /dev/null
+++ b/tests/test_utils/event_builders.py
@@ -0,0 +1,117 @@
+#
+# This file is licensed under the Affero General Public License (AGPL) version 3.
+#
+# Copyright (C) 2026 Element Creations Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# See the GNU Affero General Public License for more details:
+# <https://www.gnu.org/licenses/agpl-3.0.html>.
+#
+
+from typing import TypedDict
+
+from typing_extensions import NotRequired, Unpack
+
+from synapse.api.room_versions import (
+    RoomVersion,
+    RoomVersions,
+)
+from synapse.events import EventBase, make_event_from_dict
+from synapse.federation.federation_base import event_from_pdu_json
+from synapse.types import JsonDict
+
+
+def default_event_fields(room_version: RoomVersion) -> JsonDict:
+    """Return default values for every field required by `room_version`."""
+
+    # We need to include entries for every required field for the room version.
+    # Note that they don't necessarily have to be valid values, just enough to
+    # allow us to construct the event class. (Ideally we'd build a fully valid
+    # event, but this is fine for now.)
+    defaults: JsonDict = {
+        "type": "m.test",
+        "sender": "@test:test",
+        "content": {},
+        "depth": 1,
+        "origin_server_ts": 1,
+        "hashes": {},
+        "prev_events": [],
+        "room_id": "!test:test",
+    }
+
+    # MSC4242 versions require prev_state_events but not auth_events.
+    if room_version.msc4242_state_dags:
+        defaults["prev_state_events"] = []
+    else:
+        defaults["auth_events"] = []
+
+    if room_version == RoomVersions.V1:
+        # V1 requires an event_id field, but later versions don't.
+        defaults["event_id"] = "$test_event_id:matrix.org"
+
+    return defaults
+
+
+def make_test_event(
+    event_dict: JsonDict | None = None,
+    room_version: RoomVersion = RoomVersions.V1,
+    internal_metadata_dict: JsonDict | None = None,
+    rejected_reason: str | None = None,
+    **fields: Unpack["_EventFields"],
+) -> EventBase:
+    """Build an `EventBase` with defaults for the strict-required fields.
+
+    Pass an `event_dict` and/or `**fields` keyword arguments — both are
+    merged on top of the format-version defaults from
+    `default_event_fields`. Explicit values win over defaults, and
+    `**fields` wins over `event_dict` so call sites can override a
+    shared base dict with one-off tweaks.
+    """
+    merged: JsonDict = {
+        **default_event_fields(room_version),
+        **(event_dict or {}),
+        **fields,
+    }
+    return make_event_from_dict(
+        merged,
+        room_version=room_version,
+        internal_metadata_dict=internal_metadata_dict,
+        rejected_reason=rejected_reason,
+    )
+
+
+def make_test_pdu_event(
+    pdu: JsonDict,
+    room_version: RoomVersion,
+    received_time: int | None = None,
+) -> EventBase:
+    """Wrapper around `event_from_pdu_json` for test PDU dicts.
+
+    Federation-side test fixtures often omit fields the strict Rust ctor
+    requires (e.g. `hashes`, `auth_events`, `prev_events`, `depth`)
+    because those tests focus on transport/auth flow rather than event
+    well-formedness. This helper layers in the same format-version
+    defaults as `make_test_event` before delegating.
+    """
+    pdu = {**default_event_fields(room_version), **pdu}
+    return event_from_pdu_json(pdu, room_version, received_time=received_time)
+
+
+class _EventFields(TypedDict):
+    """Type for `kwargs` in `make_test_event`."""
+
+    event_id: NotRequired[str]
+    type: NotRequired[str]
+    sender: NotRequired[str]
+    content: NotRequired[JsonDict]
+    depth: NotRequired[int]
+    origin_server_ts: NotRequired[int]
+    hashes: NotRequired[dict[str, str]]
+    auth_events: NotRequired[list[str]]
+    prev_events: NotRequired[list[str]]
+    prev_state_events: NotRequired[list[str]]
+    room_id: NotRequired[str]