diff --git a/spec/unit/models/event.spec.ts b/spec/unit/models/event.spec.ts
index bcc2b42a2..c3ac23ce4 100644
--- a/spec/unit/models/event.spec.ts
+++ b/spec/unit/models/event.spec.ts
@@ -70,112 +70,114 @@ describe("MatrixEvent", () => {
         expect(a.toSnapshot().isEquivalentTo(b)).toBe(false);
     });
 
-    it("should prune clearEvent when being redacted", () => {
-        const ev = new MatrixEvent({
-            type: "m.room.message",
-            content: {
-                body: "Test",
-            },
-            event_id: "$event1:server",
-        });
-
-        expect(ev.getContent().body).toBe("Test");
-        expect(ev.getWireContent().body).toBe("Test");
-        ev.makeEncrypted("m.room.encrypted", { ciphertext: "xyz" }, "", "");
-        expect(ev.getContent().body).toBe("Test");
-        expect(ev.getWireContent().body).toBeUndefined();
-        expect(ev.getWireContent().ciphertext).toBe("xyz");
-
-        const mockClient = {} as unknown as MockedObject<MatrixClient>;
-        const room = new Room("!roomid:e.xyz", mockClient, "myname");
-        const redaction = new MatrixEvent({
-            type: "m.room.redaction",
-            redacts: ev.getId(),
-        });
-
-        ev.makeRedacted(redaction, room);
-        expect(ev.getContent().body).toBeUndefined();
-        expect(ev.getWireContent().body).toBeUndefined();
-        expect(ev.getWireContent().ciphertext).toBeUndefined();
-    });
-
-    it("should remain in the main timeline when redacted", async () => {
-        // Given an event in the main timeline
-        const mockClient = {
-            supportsThreads: jest.fn().mockReturnValue(true),
-            decryptEventIfNeeded: jest.fn().mockReturnThis(),
-            getUserId: jest.fn().mockReturnValue("@user:server"),
-        } as unknown as MockedObject<MatrixClient>;
-        const room = new Room("!roomid:e.xyz", mockClient, "myname");
-        const ev = new MatrixEvent({
-            type: "m.room.message",
-            content: {
-                body: "Test",
-            },
-            event_id: "$event1:server",
-        });
-
-        await room.addLiveEvents([ev]);
-        await room.createThreadsTimelineSets();
-        expect(ev.threadRootId).toBeUndefined();
-        expect(mainTimelineLiveEventIds(room)).toEqual(["$event1:server"]);
-
-        // When I redact it
-        const redaction = new MatrixEvent({
-            type: "m.room.redaction",
-            redacts: ev.getId(),
-        });
-        ev.makeRedacted(redaction, room);
-
-        // Then it remains in the main timeline
-        expect(ev.threadRootId).toBeUndefined();
-        expect(mainTimelineLiveEventIds(room)).toEqual(["$event1:server"]);
-    });
-
-    it("should move into the main timeline when redacted", async () => {
-        // Given an event in a thread
-        const mockClient = {
-            supportsThreads: jest.fn().mockReturnValue(true),
-            decryptEventIfNeeded: jest.fn().mockReturnThis(),
-            getUserId: jest.fn().mockReturnValue("@user:server"),
-        } as unknown as MockedObject<MatrixClient>;
-        const room = new Room("!roomid:e.xyz", mockClient, "myname");
-        const threadRoot = new MatrixEvent({
-            type: "m.room.message",
-            content: {
-                body: "threadRoot",
-            },
-            event_id: "$threadroot:server",
-        });
-        const ev = new MatrixEvent({
-            type: "m.room.message",
-            content: {
-                "body": "Test",
-                "m.relates_to": {
-                    rel_type: THREAD_RELATION_TYPE.name,
-                    event_id: "$threadroot:server",
+    describe("redaction", () => {
+        it("should prune clearEvent when being redacted", () => {
+            const ev = new MatrixEvent({
+                type: "m.room.message",
+                content: {
+                    body: "Test",
                 },
-            },
-            event_id: "$event1:server",
+                event_id: "$event1:server",
+            });
+
+            expect(ev.getContent().body).toBe("Test");
+            expect(ev.getWireContent().body).toBe("Test");
+            ev.makeEncrypted("m.room.encrypted", { ciphertext: "xyz" }, "", "");
+            expect(ev.getContent().body).toBe("Test");
+            expect(ev.getWireContent().body).toBeUndefined();
+            expect(ev.getWireContent().ciphertext).toBe("xyz");
+
+            const mockClient = {} as unknown as MockedObject<MatrixClient>;
+            const room = new Room("!roomid:e.xyz", mockClient, "myname");
+            const redaction = new MatrixEvent({
+                type: "m.room.redaction",
+                redacts: ev.getId(),
+            });
+
+            ev.makeRedacted(redaction, room);
+            expect(ev.getContent().body).toBeUndefined();
+            expect(ev.getWireContent().body).toBeUndefined();
+            expect(ev.getWireContent().ciphertext).toBeUndefined();
         });
 
-        await room.addLiveEvents([threadRoot, ev]);
-        await room.createThreadsTimelineSets();
-        expect(ev.threadRootId).toEqual("$threadroot:server");
-        expect(mainTimelineLiveEventIds(room)).toEqual(["$threadroot:server"]);
-        expect(threadLiveEventIds(room, 0)).toEqual(["$threadroot:server", "$event1:server"]);
+        it("should remain in the main timeline when redacted", async () => {
+            // Given an event in the main timeline
+            const mockClient = {
+                supportsThreads: jest.fn().mockReturnValue(true),
+                decryptEventIfNeeded: jest.fn().mockReturnThis(),
+                getUserId: jest.fn().mockReturnValue("@user:server"),
+            } as unknown as MockedObject<MatrixClient>;
+            const room = new Room("!roomid:e.xyz", mockClient, "myname");
+            const ev = new MatrixEvent({
+                type: "m.room.message",
+                content: {
+                    body: "Test",
+                },
+                event_id: "$event1:server",
+            });
 
-        // When I redact it
-        const redaction = new MatrixEvent({
-            type: "m.room.redaction",
-            redacts: ev.getId(),
+            await room.addLiveEvents([ev]);
+            await room.createThreadsTimelineSets();
+            expect(ev.threadRootId).toBeUndefined();
+            expect(mainTimelineLiveEventIds(room)).toEqual(["$event1:server"]);
+
+            // When I redact it
+            const redaction = new MatrixEvent({
+                type: "m.room.redaction",
+                redacts: ev.getId(),
+            });
+            ev.makeRedacted(redaction, room);
+
+            // Then it remains in the main timeline
+            expect(ev.threadRootId).toBeUndefined();
+            expect(mainTimelineLiveEventIds(room)).toEqual(["$event1:server"]);
         });
-        ev.makeRedacted(redaction, room);
 
-        // Then it disappears from the thread and appears in the main timeline
-        expect(ev.threadRootId).toBeUndefined();
-        expect(mainTimelineLiveEventIds(room)).toEqual(["$threadroot:server", "$event1:server"]);
-        expect(threadLiveEventIds(room, 0)).not.toContain("$event1:server");
+        it("should move into the main timeline when redacted", async () => {
+            // Given an event in a thread
+            const mockClient = {
+                supportsThreads: jest.fn().mockReturnValue(true),
+                decryptEventIfNeeded: jest.fn().mockReturnThis(),
+                getUserId: jest.fn().mockReturnValue("@user:server"),
+            } as unknown as MockedObject<MatrixClient>;
+            const room = new Room("!roomid:e.xyz", mockClient, "myname");
+            const threadRoot = new MatrixEvent({
+                type: "m.room.message",
+                content: {
+                    body: "threadRoot",
+                },
+                event_id: "$threadroot:server",
+            });
+            const ev = new MatrixEvent({
+                type: "m.room.message",
+                content: {
+                    "body": "Test",
+                    "m.relates_to": {
+                        rel_type: THREAD_RELATION_TYPE.name,
+                        event_id: "$threadroot:server",
+                    },
+                },
+                event_id: "$event1:server",
+            });
+
+            await room.addLiveEvents([threadRoot, ev]);
+            await room.createThreadsTimelineSets();
+            expect(ev.threadRootId).toEqual("$threadroot:server");
+            expect(mainTimelineLiveEventIds(room)).toEqual(["$threadroot:server"]);
+            expect(threadLiveEventIds(room, 0)).toEqual(["$threadroot:server", "$event1:server"]);
+
+            // When I redact it
+            const redaction = new MatrixEvent({
+                type: "m.room.redaction",
+                redacts: ev.getId(),
+            });
+            ev.makeRedacted(redaction, room);
+
+            // Then it disappears from the thread and appears in the main timeline
+            expect(ev.threadRootId).toBeUndefined();
+            expect(mainTimelineLiveEventIds(room)).toEqual(["$threadroot:server", "$event1:server"]);
+            expect(threadLiveEventIds(room, 0)).not.toContain("$event1:server");
+        });
     });
 
     describe("applyVisibilityEvent", () => {