Write initial test case

Author: justjanne

spec/integ/matrix-client-unread-notifications.spec.ts

@@ -18,8 +18,22 @@ import "fake-indexeddb/auto";
 
 import HttpBackend from "matrix-mock-request";
 
-import { Category, ISyncResponse, MatrixClient, NotificationCountType, Room } from "../../src";
+import {
+    Category,
+    ClientEvent,
+    EventType,
+    IStartClientOpts,
+    ISyncResponse,
+    MatrixClient,
+    MatrixEvent,
+    NotificationCountType,
+    RelationType,
+    Room,
+} from "../../src";
 import { TestClient } from "../TestClient";
+import { logger } from "../../src/logger";
+import { ReceiptType, WrappedReceipt } from "../../src/@types/read_receipts";
+import { mkThread } from "../test-utils/thread";
 
 describe("MatrixClient syncing", () => {
     const userA = "@alice:localhost";
@@ -51,6 +65,92 @@ describe("MatrixClient syncing", () => {
         return httpBackend!.stop();
     });
 
+    it("reactions in thread set the correct timeline to unread", async () => {
+        // start the client, and wait for it to initialise
+        function startClient(httpBackend: HttpBackend, client: MatrixClient, opts?: IStartClientOpts) {
+            httpBackend.when("GET", "/sync").respond(200, {
+                next_batch: "s_5_3",
+                rooms: {
+                    [Category.Join]: {},
+                    [Category.Leave]: {},
+                    [Category.Invite]: {},
+                },
+            });
+
+            client.startClient(opts);
+
+            // set up a promise which will resolve once the client is initialised
+            const prom = new Promise<void>((resolve) => {
+                client.on(ClientEvent.Sync, function (state) {
+                    logger.log("sync", state);
+                    if (state != "SYNCING") {
+                        return;
+                    }
+                    resolve();
+                });
+            });
+
+            return Promise.all([httpBackend.flushAllExpected(), prom]);
+        }
+
+        const roomId = "!room:localhost";
+        await startClient(httpBackend!, client!, { threadSupport: true });
+        const room = new Room(roomId, client!, selfUserId);
+        jest.spyOn(client!, "getRoom").mockImplementation((id) => (id === roomId ? room : null));
+        const thread = mkThread({ room, client: client!, authorId: selfUserId, participantUserIds: [selfUserId] });
+        const threadReply = thread.events.at(-1)!;
+        room.addLiveEvents([thread.rootEvent]);
+
+        const roomReceipt: WrappedReceipt = {
+            eventId: thread.rootEvent.getId()!,
+            data: {
+                ts: 1,
+            },
+        };
+
+        const threadReceipt: WrappedReceipt = {
+            eventId: threadReply.getId()!,
+            data: {
+                thread_id: thread.thread.id,
+                ts: 1,
+            },
+        };
+
+        room.addReceiptToStructure(roomReceipt.eventId, ReceiptType.Read, selfUserId, roomReceipt.data, false);
+        thread.thread.addReceiptToStructure(
+            threadReceipt.eventId,
+            ReceiptType.Read,
+            selfUserId,
+            threadReceipt.data,
+            false,
+        );
+
+        expect(room.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(thread.rootEvent.getId());
+        expect(thread.thread.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(threadReply.getId());
+
+        const reactionEventId = `$9-${Math.random()}-${Math.random()}`;
+        let lastEvent: MatrixEvent | null = null;
+        jest.spyOn(client! as any, "sendEventHttpRequest").mockImplementation((event) => {
+            lastEvent = event as MatrixEvent;
+            return { event_id: reactionEventId };
+        });
+
+        // we currently don't handle the case of a non-detached pending event list well!
+        await client!.sendEvent(roomId, EventType.Reaction, {
+            "m.relates_to": {
+                rel_type: RelationType.Annotation,
+                event_id: threadReply.getId(),
+                key: "",
+            },
+        });
+
+        expect(lastEvent!.getId()).toEqual(reactionEventId);
+        room.handleRemoteEcho(new MatrixEvent(lastEvent!.event), lastEvent!);
+
+        expect(room.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(thread.rootEvent.getId());
+        expect(thread.thread.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(reactionEventId);
+    });
+
     describe("Stuck unread notifications integration tests", () => {
         const ROOM_ID = "!room:localhost";