Add thread notification with server assistance (MSC3773) (#9400)

Co-authored-by: Janne Mareike Koschinski <janne@kuschku.de>

test/RoomNotifs-test.ts

@@ -16,10 +16,15 @@ limitations under the License.
 
 import { mocked } from 'jest-mock';
 import { ConditionKind, PushRuleActionName, TweakName } from "matrix-js-sdk/src/@types/PushRules";
+import { NotificationCountType, Room } from 'matrix-js-sdk/src/models/room';
 
-import { stubClient } from "./test-utils";
+import { mkEvent, stubClient } from "./test-utils";
 import { MatrixClientPeg } from "../src/MatrixClientPeg";
-import { getRoomNotifsState, RoomNotifState } from "../src/RoomNotifs";
+import {
+    getRoomNotifsState,
+    RoomNotifState,
+    getUnreadNotificationCount,
+} from "../src/RoomNotifs";
 
 describe("RoomNotifs test", () => {
     beforeEach(() => {
@@ -83,4 +88,74 @@ describe("RoomNotifs test", () => {
         });
         expect(getRoomNotifsState("!roomId:server")).toBe(RoomNotifState.AllMessagesLoud);
     });
+
+    describe("getUnreadNotificationCount", () => {
+        const ROOM_ID = "!roomId:example.org";
+        const THREAD_ID = "$threadId";
+
+        let cli;
+        let room: Room;
+        beforeEach(() => {
+            cli = MatrixClientPeg.get();
+            room = new Room(ROOM_ID, cli, cli.getUserId());
+        });
+
+        it("counts room notification type", () => {
+            expect(getUnreadNotificationCount(room, NotificationCountType.Total)).toBe(0);
+            expect(getUnreadNotificationCount(room, NotificationCountType.Highlight)).toBe(0);
+        });
+
+        it("counts notifications type", () => {
+            room.setUnreadNotificationCount(NotificationCountType.Total, 2);
+            room.setUnreadNotificationCount(NotificationCountType.Highlight, 1);
+
+            expect(getUnreadNotificationCount(room, NotificationCountType.Total)).toBe(2);
+            expect(getUnreadNotificationCount(room, NotificationCountType.Highlight)).toBe(1);
+        });
+
+        it("counts predecessor highlight", () => {
+            room.setUnreadNotificationCount(NotificationCountType.Total, 2);
+            room.setUnreadNotificationCount(NotificationCountType.Highlight, 1);
+
+            const OLD_ROOM_ID = "!oldRoomId:example.org";
+            const oldRoom = new Room(OLD_ROOM_ID, cli, cli.getUserId());
+            oldRoom.setUnreadNotificationCount(NotificationCountType.Total, 10);
+            oldRoom.setUnreadNotificationCount(NotificationCountType.Highlight, 6);
+
+            cli.getRoom.mockReset().mockReturnValue(oldRoom);
+
+            const predecessorEvent = mkEvent({
+                event: true,
+                type: "m.room.create",
+                room: ROOM_ID,
+                user: cli.getUserId(),
+                content: {
+                    creator: cli.getUserId(),
+                    room_version: "5",
+                    predecessor: {
+                        room_id: OLD_ROOM_ID,
+                        event_id: "$someevent",
+                    },
+                },
+                ts: Date.now(),
+            });
+            room.addLiveEvents([predecessorEvent]);
+
+            expect(getUnreadNotificationCount(room, NotificationCountType.Total)).toBe(8);
+            expect(getUnreadNotificationCount(room, NotificationCountType.Highlight)).toBe(7);
+        });
+
+        it("counts thread notification type", () => {
+            expect(getUnreadNotificationCount(room, NotificationCountType.Total, THREAD_ID)).toBe(0);
+            expect(getUnreadNotificationCount(room, NotificationCountType.Highlight, THREAD_ID)).toBe(0);
+        });
+
+        it("counts notifications type", () => {
+            room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total, 2);
+            room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 1);
+
+            expect(getUnreadNotificationCount(room, NotificationCountType.Total, THREAD_ID)).toBe(2);
+            expect(getUnreadNotificationCount(room, NotificationCountType.Highlight, THREAD_ID)).toBe(1);
+        });
+    });
 });

test/components/structures/RoomStatusBar-test.tsx

@@ -0,0 +1,91 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient, PendingEventOrdering } from "matrix-js-sdk/src/client";
+import { EventStatus, MatrixEvent } from "matrix-js-sdk/src/models/event";
+import { Room } from "matrix-js-sdk/src/models/room";
+
+import { getUnsentMessages } from "../../../src/components/structures/RoomStatusBar";
+import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
+import { mkEvent, stubClient } from "../../test-utils/test-utils";
+import { mkThread } from "../../test-utils/threads";
+
+describe("RoomStatusBar", () => {
+    const ROOM_ID = "!roomId:example.org";
+    let room: Room;
+    let client: MatrixClient;
+    let event: MatrixEvent;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        stubClient();
+        client = MatrixClientPeg.get();
+        room = new Room(ROOM_ID, client, client.getUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+        event = mkEvent({
+            event: true,
+            type: "m.room.message",
+            user: "@user1:server",
+            room: "!room1:server",
+            content: {},
+        });
+        event.status = EventStatus.NOT_SENT;
+    });
+
+    describe("getUnsentMessages", () => {
+        it("returns no unsent messages", () => {
+            expect(getUnsentMessages(room)).toHaveLength(0);
+        });
+
+        it("checks the event status", () => {
+            room.addPendingEvent(event, "123");
+
+            expect(getUnsentMessages(room)).toHaveLength(1);
+            event.status = EventStatus.SENT;
+
+            expect(getUnsentMessages(room)).toHaveLength(0);
+        });
+
+        it("only returns events related to a thread", () => {
+            room.addPendingEvent(event, "123");
+
+            const { rootEvent, events } = mkThread({
+                room,
+                client,
+                authorId: "@alice:example.org",
+                participantUserIds: ["@alice:example.org"],
+                length: 2,
+            });
+            rootEvent.status = EventStatus.NOT_SENT;
+            room.addPendingEvent(rootEvent, rootEvent.getId());
+            for (const event of events) {
+                event.status = EventStatus.NOT_SENT;
+                room.addPendingEvent(event, Date.now() + Math.random() + "");
+            }
+
+            const pendingEvents = getUnsentMessages(room, rootEvent.getId());
+
+            expect(pendingEvents[0].threadRootId).toBe(rootEvent.getId());
+            expect(pendingEvents[1].threadRootId).toBe(rootEvent.getId());
+            expect(pendingEvents[2].threadRootId).toBe(rootEvent.getId());
+
+            // Filters out the non thread events
+            expect(pendingEvents.every(ev => ev.getId() !== event.getId())).toBe(true);
+        });
+    });
+});

test/components/views/right_panel/RoomHeaderButtons-test.tsx

@@ -0,0 +1,97 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { render } from "@testing-library/react";
+import { MatrixClient, PendingEventOrdering } from "matrix-js-sdk/src/client";
+import { NotificationCountType, Room } from "matrix-js-sdk/src/models/room";
+import React from "react";
+
+import RoomHeaderButtons from "../../../../src/components/views/right_panel/RoomHeaderButtons";
+import { MatrixClientPeg } from "../../../../src/MatrixClientPeg";
+import SettingsStore from "../../../../src/settings/SettingsStore";
+import { stubClient } from "../../../test-utils";
+
+describe("RoomHeaderButtons-test.tsx", function() {
+    const ROOM_ID = "!roomId:example.org";
+    let room: Room;
+    let client: MatrixClient;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        stubClient();
+        client = MatrixClientPeg.get();
+        room = new Room(ROOM_ID, client, client.getUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+
+        jest.spyOn(SettingsStore, "getValue").mockImplementation((name: string) => {
+            if (name === "feature_thread") return true;
+        });
+    });
+
+    function getComponent(room: Room) {
+        return render(<RoomHeaderButtons
+            room={room}
+            excludedRightPanelPhaseButtons={[]}
+        />);
+    }
+
+    function getThreadButton(container) {
+        return container.querySelector(".mx_RightPanel_threadsButton");
+    }
+
+    function isIndicatorOfType(container, type: "red" | "gray") {
+        return container.querySelector(".mx_RightPanel_threadsButton .mx_Indicator")
+            .className
+            .includes(type);
+    }
+
+    it("shows the thread button", () => {
+        const { container } = getComponent(room);
+        expect(getThreadButton(container)).not.toBeNull();
+    });
+
+    it("hides the thread button", () => {
+        jest.spyOn(SettingsStore, "getValue").mockReset().mockReturnValue(false);
+        const { container } = getComponent(room);
+        expect(getThreadButton(container)).toBeNull();
+    });
+
+    it("room wide notification does not change the thread button", () => {
+        room.setUnreadNotificationCount(NotificationCountType.Highlight, 1);
+        room.setUnreadNotificationCount(NotificationCountType.Total, 1);
+
+        const { container } = getComponent(room);
+
+        expect(container.querySelector(".mx_RightPanel_threadsButton .mx_Indicator")).toBeNull();
+    });
+
+    it("room wide notification does not change the thread button", () => {
+        const { container } = getComponent(room);
+
+        room.setThreadUnreadNotificationCount("$123", NotificationCountType.Total, 1);
+        expect(isIndicatorOfType(container, "gray")).toBe(true);
+
+        room.setThreadUnreadNotificationCount("$123", NotificationCountType.Highlight, 1);
+        expect(isIndicatorOfType(container, "red")).toBe(true);
+
+        room.setThreadUnreadNotificationCount("$123", NotificationCountType.Total, 0);
+        room.setThreadUnreadNotificationCount("$123", NotificationCountType.Highlight, 0);
+
+        expect(container.querySelector(".mx_RightPanel_threadsButton .mx_Indicator")).toBeNull();
+    });
+});

test/components/views/rooms/EventTile-test.tsx

@@ -0,0 +1,112 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { act, render } from "@testing-library/react";
+import { MatrixClient, PendingEventOrdering } from "matrix-js-sdk/src/client";
+import { MatrixEvent } from "matrix-js-sdk/src/models/event";
+import { NotificationCountType, Room } from "matrix-js-sdk/src/models/room";
+import React from "react";
+
+import EventTile, { EventTileProps } from "../../../../src/components/views/rooms/EventTile";
+import RoomContext, { TimelineRenderingType } from "../../../../src/contexts/RoomContext";
+import { MatrixClientPeg } from "../../../../src/MatrixClientPeg";
+import { getRoomContext, mkMessage, stubClient } from "../../../test-utils";
+import { mkThread } from "../../../test-utils/threads";
+
+describe("EventTile", () => {
+    const ROOM_ID = "!roomId:example.org";
+    let mxEvent: MatrixEvent;
+    let room: Room;
+    let client: MatrixClient;
+    // let changeEvent: (event: MatrixEvent) => void;
+
+    function TestEventTile(props: Partial<EventTileProps>) {
+        // const [event] = useState(mxEvent);
+        // Give a way for a test to update the event prop.
+        // changeEvent = setEvent;
+
+        return <EventTile
+            mxEvent={mxEvent}
+            {...props}
+        />;
+    }
+
+    function getComponent(
+        overrides: Partial<EventTileProps> = {},
+        renderingType: TimelineRenderingType = TimelineRenderingType.Room,
+    ) {
+        const context = getRoomContext(room, {
+            timelineRenderingType: renderingType,
+        });
+        return render(
+            <RoomContext.Provider value={context}>
+                <TestEventTile {...overrides} />
+            </RoomContext.Provider>,
+        );
+    }
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        stubClient();
+        client = MatrixClientPeg.get();
+
+        room = new Room(ROOM_ID, client, client.getUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+
+        jest.spyOn(client, "getRoom").mockReturnValue(room);
+
+        mxEvent = mkMessage({
+            room: room.roomId,
+            user: "@alice:example.org",
+            msg: "Hello world!",
+            event: true,
+        });
+    });
+
+    describe("EventTile renderingType: ThreadsList", () => {
+        beforeEach(() => {
+            const { rootEvent } = mkThread({
+                room,
+                client,
+                authorId: "@alice:example.org",
+                participantUserIds: ["@alice:example.org"],
+            });
+            mxEvent = rootEvent;
+        });
+
+        it("shows an unread notification bage", () => {
+            const { container } = getComponent({}, TimelineRenderingType.ThreadsList);
+
+            expect(container.getElementsByClassName("mx_NotificationBadge")).toHaveLength(0);
+
+            act(() => {
+                room.setThreadUnreadNotificationCount(mxEvent.getId(), NotificationCountType.Total, 3);
+            });
+
+            expect(container.getElementsByClassName("mx_NotificationBadge")).toHaveLength(1);
+            expect(container.getElementsByClassName("mx_NotificationBadge_highlighted")).toHaveLength(0);
+
+            act(() => {
+                room.setThreadUnreadNotificationCount(mxEvent.getId(), NotificationCountType.Highlight, 1);
+            });
+
+            expect(container.getElementsByClassName("mx_NotificationBadge")).toHaveLength(1);
+            expect(container.getElementsByClassName("mx_NotificationBadge_highlighted")).toHaveLength(1);
+        });
+    });
+});

test/components/views/rooms/NotificationBadge/NotificationBadge-test.tsx

@@ -0,0 +1,49 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { fireEvent, render } from "@testing-library/react";
+import React from "react";
+
+import {
+    StatelessNotificationBadge,
+} from "../../../../../src/components/views/rooms/NotificationBadge/StatelessNotificationBadge";
+import { NotificationColor } from "../../../../../src/stores/notifications/NotificationColor";
+
+describe("NotificationBadge", () => {
+    describe("StatelessNotificationBadge", () => {
+        it("lets you click it", () => {
+            const cb = jest.fn();
+
+            const { container } = render(<StatelessNotificationBadge
+                symbol=""
+                color={NotificationColor.Red}
+                count={5}
+                onClick={cb}
+                onMouseOver={cb}
+                onMouseLeave={cb}
+            />);
+
+            fireEvent.click(container.firstChild);
+            expect(cb).toHaveBeenCalledTimes(1);
+
+            fireEvent.mouseEnter(container.firstChild);
+            expect(cb).toHaveBeenCalledTimes(2);
+
+            fireEvent.mouseLeave(container.firstChild);
+            expect(cb).toHaveBeenCalledTimes(3);
+        });
+    });
+});

test/components/views/rooms/NotificationBadge/UnreadNotificationBadge-test.tsx

@@ -0,0 +1,132 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import React from "react";
+import "jest-mock";
+import { screen, act, render } from "@testing-library/react";
+import { MatrixClient, PendingEventOrdering } from "matrix-js-sdk/src/client";
+import { NotificationCountType, Room } from "matrix-js-sdk/src/models/room";
+import { mocked } from "jest-mock";
+import { EventStatus } from "matrix-js-sdk/src/models/event-status";
+
+import {
+    UnreadNotificationBadge,
+} from "../../../../../src/components/views/rooms/NotificationBadge/UnreadNotificationBadge";
+import { mkMessage, stubClient } from "../../../../test-utils/test-utils";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+import * as RoomNotifs from "../../../../../src/RoomNotifs";
+
+jest.mock("../../../../../src/RoomNotifs");
+jest.mock('../../../../../src/RoomNotifs', () => ({
+    ...(jest.requireActual('../../../../../src/RoomNotifs') as Object),
+    getRoomNotifsState: jest.fn(),
+}));
+
+const ROOM_ID = "!roomId:example.org";
+let THREAD_ID;
+
+describe("UnreadNotificationBadge", () => {
+    let mockClient: MatrixClient;
+    let room: Room;
+
+    function getComponent(threadId?: string) {
+        return <UnreadNotificationBadge room={room} threadId={threadId} />;
+    }
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        stubClient();
+        mockClient = mocked(MatrixClientPeg.get());
+
+        room = new Room(ROOM_ID, mockClient, mockClient.getUserId() ?? "", {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+        room.setUnreadNotificationCount(NotificationCountType.Total, 1);
+        room.setUnreadNotificationCount(NotificationCountType.Highlight, 0);
+
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total, 1);
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 0);
+
+        jest.spyOn(RoomNotifs, "getRoomNotifsState").mockReturnValue(RoomNotifs.RoomNotifState.AllMessages);
+    });
+
+    it("renders unread notification badge", () => {
+        const { container } = render(getComponent());
+
+        expect(container.querySelector(".mx_NotificationBadge_visible")).toBeTruthy();
+        expect(container.querySelector(".mx_NotificationBadge_highlighted")).toBeFalsy();
+
+        act(() => {
+            room.setUnreadNotificationCount(NotificationCountType.Highlight, 1);
+        });
+
+        expect(container.querySelector(".mx_NotificationBadge_highlighted")).toBeTruthy();
+    });
+
+    it("renders unread thread notification badge", () => {
+        const { container } = render(getComponent(THREAD_ID));
+
+        expect(container.querySelector(".mx_NotificationBadge_visible")).toBeTruthy();
+        expect(container.querySelector(".mx_NotificationBadge_highlighted")).toBeFalsy();
+
+        act(() => {
+            room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 1);
+        });
+
+        expect(container.querySelector(".mx_NotificationBadge_highlighted")).toBeTruthy();
+    });
+
+    it("hides unread notification badge", () => {
+        act(() => {
+            room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total, 0);
+            room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 0);
+            const { container } = render(getComponent(THREAD_ID));
+            expect(container.querySelector(".mx_NotificationBadge_visible")).toBeFalsy();
+        });
+    });
+
+    it("adds a warning for unsent messages", () => {
+        const evt = mkMessage({
+            room: room.roomId,
+            user: "@alice:example.org",
+            msg: "Hello world!",
+            event: true,
+        });
+        evt.status = EventStatus.NOT_SENT;
+
+        room.addPendingEvent(evt, "123");
+
+        render(getComponent());
+
+        expect(screen.queryByText("!")).not.toBeNull();
+    });
+
+    it("adds a warning for invites", () => {
+        jest.spyOn(room, "getMyMembership").mockReturnValue("invite");
+        render(getComponent());
+        expect(screen.queryByText("!")).not.toBeNull();
+    });
+
+    it("hides counter for muted rooms", () => {
+        jest.spyOn(RoomNotifs, "getRoomNotifsState")
+            .mockReset()
+            .mockReturnValue(RoomNotifs.RoomNotifState.Mute);
+
+        const { container } = render(getComponent());
+        expect(container.querySelector(".mx_NotificationBadge")).toBeNull();
+    });
+});

test/stores/notifications/RoomNotificationState-test.ts

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { Room } from "matrix-js-sdk/src/models/room";
-import { MatrixEventEvent, MatrixEvent } from "matrix-js-sdk/src/matrix";
+import { MatrixEventEvent, MatrixEvent, MatrixClient } from "matrix-js-sdk/src/matrix";
 
 import { stubClient } from "../../test-utils";
 import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
@@ -24,12 +24,16 @@ import * as testUtils from "../../test-utils";
 import { NotificationStateEvents } from "../../../src/stores/notifications/NotificationState";
 
 describe("RoomNotificationState", () => {
-    stubClient();
-    const client = MatrixClientPeg.get();
+    let testRoom: Room;
+    let client: MatrixClient;
+
+    beforeEach(() => {
+        stubClient();
+        client = MatrixClientPeg.get();
+        testRoom = testUtils.mkStubRoom("$aroomid", "Test room", client);
+    });
 
     it("Updates on event decryption", () => {
-        const testRoom = testUtils.mkStubRoom("$aroomid", "Test room", client);
-
         const roomNotifState = new RoomNotificationState(testRoom as any as Room);
         const listener = jest.fn();
         roomNotifState.addListener(NotificationStateEvents.Update, listener);
@@ -40,4 +44,9 @@ describe("RoomNotificationState", () => {
         client.emit(MatrixEventEvent.Decrypted, testEvent);
         expect(listener).toHaveBeenCalled();
     });
+
+    it("removes listeners", () => {
+        const roomNotifState = new RoomNotificationState(testRoom as any as Room);
+        expect(() => roomNotifState.destroy()).not.toThrow();
+    });
 });

test/stores/notifications/RoomNotificationStateStore-test.ts

@@ -0,0 +1,60 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { PendingEventOrdering } from "matrix-js-sdk/src/client";
+import { Feature, ServerSupport } from "matrix-js-sdk/src/feature";
+import { Room } from "matrix-js-sdk/src/models/room";
+
+import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
+import { RoomNotificationStateStore } from "../../../src/stores/notifications/RoomNotificationStateStore";
+import { stubClient } from "../../test-utils";
+
+describe("RoomNotificationStateStore", () => {
+    const ROOM_ID = "!roomId:example.org";
+
+    let room;
+    let client;
+
+    beforeEach(() => {
+        stubClient();
+        client = MatrixClientPeg.get();
+        room = new Room(ROOM_ID, client, client.getUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+    });
+
+    it("does not use legacy thread notification store", () => {
+        client.canSupport.set(Feature.ThreadUnreadNotifications, ServerSupport.Stable);
+        expect(RoomNotificationStateStore.instance.getThreadsRoomState(room)).toBeNull();
+    });
+
+    it("use legacy thread notification store", () => {
+        client.canSupport.set(Feature.ThreadUnreadNotifications, ServerSupport.Unsupported);
+        expect(RoomNotificationStateStore.instance.getThreadsRoomState(room)).not.toBeNull();
+    });
+
+    it("does not use legacy thread notification store", () => {
+        client.canSupport.set(Feature.ThreadUnreadNotifications, ServerSupport.Stable);
+        RoomNotificationStateStore.instance.getRoomState(room);
+        expect(RoomNotificationStateStore.instance.getThreadsRoomState(room)).toBeNull();
+    });
+
+    it("use legacy thread notification store", () => {
+        client.canSupport.set(Feature.ThreadUnreadNotifications, ServerSupport.Unsupported);
+        RoomNotificationStateStore.instance.getRoomState(room);
+        expect(RoomNotificationStateStore.instance.getThreadsRoomState(room)).not.toBeNull();
+    });
+});

test/test-utils/threads.ts

@@ -106,7 +106,7 @@ export const mkThread = ({
     participantUserIds,
     length = 2,
     ts = 1,
-}: MakeThreadProps): { thread: Thread, rootEvent: MatrixEvent } => {
+}: MakeThreadProps): { thread: Thread, rootEvent: MatrixEvent, events: MatrixEvent[] } => {
     const { rootEvent, events } = makeThreadEvents({
         roomId: room.roomId,
         authorId,
@@ -120,5 +120,5 @@ export const mkThread = ({
     // So that we do not have to mock the thread loading
     thread.initialEventsFetched = true;
 
-    return { thread, rootEvent };
+    return { thread, rootEvent, events };
 };