PrivateCoffee/element-web
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

Revert "Check each thread for unread messages. (#9723)" (#9745)

Browse source 
* Revert "Check each thread for unread messages. (#9723)"

This reverts commit 9de5654353.

* ts strict
This commit is contained in:
Germain 2022-12-13 14:59:52 +00:00 committed by GitHub
parent f0ed784c23
commit 9668a24ca7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 105 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
src/Unread.ts
View file

@ -15,7 +15,6 @@ limitations under the License.
*/ */
import { Room } from "matrix-js-sdk/src/models/room"; import { Room } from "matrix-js-sdk/src/models/room";
import { Thread } from "matrix-js-sdk/src/models/thread";
import { MatrixEvent } from "matrix-js-sdk/src/models/event"; import { MatrixEvent } from "matrix-js-sdk/src/models/event";
import { EventType } from "matrix-js-sdk/src/@types/event"; import { EventType } from "matrix-js-sdk/src/@types/event";
import { M_BEACON } from "matrix-js-sdk/src/@types/beacon"; import { M_BEACON } from "matrix-js-sdk/src/@types/beacon";
@ -60,34 +59,36 @@ export function doesRoomHaveUnreadMessages(room: Room): boolean {
return false; return false;
} }
for (const timeline of [room, ...room.getThreads()]) {
// If the current timeline has unread messages, we're done.
if (doesRoomOrThreadHaveUnreadMessages(timeline)) {
return true;
}
}
// If we got here then no timelines were found with unread messages.
return false;
}
function doesRoomOrThreadHaveUnreadMessages(room: Room | Thread): boolean {
const myUserId = MatrixClientPeg.get().getUserId(); const myUserId = MatrixClientPeg.get().getUserId();
// as we don't send RRs for our own messages, make sure we special case that
// if *we* sent the last message into the room, we consider it not unread!
// Should fix: https://github.com/vector-im/element-web/issues/3263
// https://github.com/vector-im/element-web/issues/2427
// ...and possibly some of the others at
// https://github.com/vector-im/element-web/issues/3363
if (room.timeline.at(-1)?.getSender() === myUserId) {
return false;
}
// get the most recent read receipt sent by our account. // get the most recent read receipt sent by our account.
// N.B. this is NOT a read marker (RM, aka "read up to marker"), // N.B. this is NOT a read marker (RM, aka "read up to marker"),
// despite the name of the method :(( // despite the name of the method :((
const readUpToId = room.getEventReadUpTo(myUserId!); const readUpToId = room.getEventReadUpTo(myUserId!);
if (!SettingsStore.getValue("feature_thread")) {
// as we don't send RRs for our own messages, make sure we special case that
// if *we* sent the last message into the room, we consider it not unread!
// Should fix: https://github.com/vector-im/element-web/issues/3263
// https://github.com/vector-im/element-web/issues/2427
// ...and possibly some of the others at
// https://github.com/vector-im/element-web/issues/3363
if (room.timeline.length && room.timeline[room.timeline.length - 1].getSender() === myUserId) {
return false;
}
}
// if the read receipt relates to an event is that part of a thread
// we consider that there are no unread messages
// This might be a false negative, but probably the best we can do until
// the read receipts have evolved to cater for threads
if (readUpToId) {
const event = room.findEventById(readUpToId);
if (event?.getThread()) {
return false;
}
}
// this just looks at whatever history we have, which if we've only just started // this just looks at whatever history we have, which if we've only just started
// up probably won't be very much, so if the last couple of events are ones that // up probably won't be very much, so if the last couple of events are ones that
// don't count, we don't know if there are any events that do count between where // don't count, we don't know if there are any events that do count between where

370
test/Unread-test.ts
View file

@ -15,306 +15,100 @@ limitations under the License.
*/ */
import { mocked } from "jest-mock"; import { mocked } from "jest-mock";
import { MatrixEvent, EventType, MsgType, Room } from "matrix-js-sdk/src/matrix"; import { MatrixEvent, EventType, MsgType } from "matrix-js-sdk/src/matrix";
import { ReceiptType } from "matrix-js-sdk/src/@types/read_receipts";
import { haveRendererForEvent } from "../src/events/EventTileFactory"; import { haveRendererForEvent } from "../src/events/EventTileFactory";
import { makeBeaconEvent, mkEvent, stubClient } from "./test-utils"; import { getMockClientWithEventEmitter, makeBeaconEvent, mockClientMethodsUser } from "./test-utils";
import { mkThread } from "./test-utils/threads"; import { eventTriggersUnreadCount } from "../src/Unread";
import { doesRoomHaveUnreadMessages, eventTriggersUnreadCount } from "../src/Unread";
import { MatrixClientPeg } from "../src/MatrixClientPeg";
jest.mock("../src/events/EventTileFactory", () => ({ jest.mock("../src/events/EventTileFactory", () => ({
haveRendererForEvent: jest.fn(), haveRendererForEvent: jest.fn(),
})); }));
describe("Unread", () => { describe("eventTriggersUnreadCount()", () => {
// A different user.
const aliceId = "@alice:server.org"; const aliceId = "@alice:server.org";
stubClient(); const bobId = "@bob:server.org";
const client = MatrixClientPeg.get();
describe("eventTriggersUnreadCount()", () => { // mock user credentials
// setup events getMockClientWithEventEmitter({
const alicesMessage = new MatrixEvent({ ...mockClientMethodsUser(bobId),
type: EventType.RoomMessage,
sender: aliceId,
content: {
msgtype: MsgType.Text,
body: "Hello from Alice",
},
});
const ourMessage = new MatrixEvent({
type: EventType.RoomMessage,
sender: client.getUserId()!,
content: {
msgtype: MsgType.Text,
body: "Hello from Bob",
},
});
const redactedEvent = new MatrixEvent({
type: EventType.RoomMessage,
sender: aliceId,
});
redactedEvent.makeRedacted(redactedEvent);
beforeEach(() => {
jest.clearAllMocks();
mocked(haveRendererForEvent).mockClear().mockReturnValue(false);
});
it("returns false when the event was sent by the current user", () => {
expect(eventTriggersUnreadCount(ourMessage)).toBe(false);
// returned early before checking renderer
expect(haveRendererForEvent).not.toHaveBeenCalled();
});
it("returns false for a redacted event", () => {
expect(eventTriggersUnreadCount(redactedEvent)).toBe(false);
// returned early before checking renderer
expect(haveRendererForEvent).not.toHaveBeenCalled();
});
it("returns false for an event without a renderer", () => {
mocked(haveRendererForEvent).mockReturnValue(false);
expect(eventTriggersUnreadCount(alicesMessage)).toBe(false);
expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
});
it("returns true for an event with a renderer", () => {
mocked(haveRendererForEvent).mockReturnValue(true);
expect(eventTriggersUnreadCount(alicesMessage)).toBe(true);
expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
});
it("returns false for beacon locations", () => {
const beaconLocationEvent = makeBeaconEvent(aliceId);
expect(eventTriggersUnreadCount(beaconLocationEvent)).toBe(false);
expect(haveRendererForEvent).not.toHaveBeenCalled();
});
const noUnreadEventTypes = [
EventType.RoomMember,
EventType.RoomThirdPartyInvite,
EventType.CallAnswer,
EventType.CallHangup,
EventType.RoomCanonicalAlias,
EventType.RoomServerAcl,
];
it.each(noUnreadEventTypes)(
"returns false without checking for renderer for events with type %s",
(eventType) => {
const event = new MatrixEvent({
type: eventType,
sender: aliceId,
});
expect(eventTriggersUnreadCount(event)).toBe(false);
expect(haveRendererForEvent).not.toHaveBeenCalled();
},
);
}); });
describe("doesRoomHaveUnreadMessages()", () => { // setup events
let room: Room; const alicesMessage = new MatrixEvent({
let event: MatrixEvent; type: EventType.RoomMessage,
const roomId = "!abc:server.org"; sender: aliceId,
const myId = client.getUserId()!; content: {
msgtype: MsgType.Text,
body: "Hello from Alice",
},
});
beforeAll(() => { const bobsMessage = new MatrixEvent({
client.supportsExperimentalThreads = () => true; type: EventType.RoomMessage,
}); sender: bobId,
content: {
beforeEach(() => { msgtype: MsgType.Text,
// Create a room and initial event in it. body: "Hello from Bob",
room = new Room(roomId, client, myId); },
event = mkEvent({ });
event: true,
type: "m.room.message", const redactedEvent = new MatrixEvent({
user: aliceId, type: EventType.RoomMessage,
room: roomId, sender: aliceId,
content: {}, });
}); redactedEvent.makeRedacted(redactedEvent);
room.addLiveEvents([event]);
beforeEach(() => {
// Don't care about the code path of hidden events. jest.clearAllMocks();
mocked(haveRendererForEvent).mockClear().mockReturnValue(true); mocked(haveRendererForEvent).mockClear().mockReturnValue(false);
}); });
it("returns true for a room with no receipts", () => { it("returns false when the event was sent by the current user", () => {
expect(doesRoomHaveUnreadMessages(room)).toBe(true); expect(eventTriggersUnreadCount(bobsMessage)).toBe(false);
}); // returned early before checking renderer
expect(haveRendererForEvent).not.toHaveBeenCalled();
it("returns false for a room when the latest event was sent by the current user", () => { });
event = mkEvent({
event: true, it("returns false for a redacted event", () => {
type: "m.room.message", expect(eventTriggersUnreadCount(redactedEvent)).toBe(false);
user: myId, // returned early before checking renderer
room: roomId, expect(haveRendererForEvent).not.toHaveBeenCalled();
content: {}, });
});
// Only for timeline events. it("returns false for an event without a renderer", () => {
room.addLiveEvents([event]); mocked(haveRendererForEvent).mockReturnValue(false);
expect(eventTriggersUnreadCount(alicesMessage)).toBe(false);
expect(doesRoomHaveUnreadMessages(room)).toBe(false); expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
}); });
it("returns false for a room when the read receipt is at the latest event", () => { it("returns true for an event with a renderer", () => {
const receipt = new MatrixEvent({ mocked(haveRendererForEvent).mockReturnValue(true);
type: "m.receipt", expect(eventTriggersUnreadCount(alicesMessage)).toBe(true);
room_id: "!foo:bar", expect(haveRendererForEvent).toHaveBeenCalledWith(alicesMessage, false);
content: { });
[event.getId()!]: {
[ReceiptType.Read]: { it("returns false for beacon locations", () => {
[myId]: { ts: 1 }, const beaconLocationEvent = makeBeaconEvent(aliceId);
}, expect(eventTriggersUnreadCount(beaconLocationEvent)).toBe(false);
}, expect(haveRendererForEvent).not.toHaveBeenCalled();
}, });
});
room.addReceipt(receipt); const noUnreadEventTypes = [
EventType.RoomMember,
expect(doesRoomHaveUnreadMessages(room)).toBe(false); EventType.RoomThirdPartyInvite,
}); EventType.CallAnswer,
EventType.CallHangup,
it("returns true for a room when the read receipt is earlier than the latest event", () => { EventType.RoomCanonicalAlias,
const receipt = new MatrixEvent({ EventType.RoomServerAcl,
type: "m.receipt", ];
room_id: "!foo:bar",
content: { it.each(noUnreadEventTypes)("returns false without checking for renderer for events with type %s", (eventType) => {
[event.getId()!]: { const event = new MatrixEvent({
[ReceiptType.Read]: { type: eventType,
[myId]: { ts: 1 }, sender: aliceId,
},
},
},
});
room.addReceipt(receipt);
const event2 = mkEvent({
event: true,
type: "m.room.message",
user: aliceId,
room: roomId,
content: {},
});
// Only for timeline events.
room.addLiveEvents([event2]);
expect(doesRoomHaveUnreadMessages(room)).toBe(true);
});
it("returns true for a room with an unread message in a thread", () => {
// Mark the main timeline as read.
const receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[event.getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1 },
},
},
},
});
room.addReceipt(receipt);
// Create a thread as a different user.
mkThread({ room, client, authorId: myId, participantUserIds: [aliceId] });
expect(doesRoomHaveUnreadMessages(room)).toBe(true);
});
it("returns false for a room when the latest thread event was sent by the current user", () => {
// Mark the main timeline as read.
const receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[event.getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1 },
},
},
},
});
room.addReceipt(receipt);
// Create a thread as the current user.
mkThread({ room, client, authorId: myId, participantUserIds: [myId] });
expect(doesRoomHaveUnreadMessages(room)).toBe(false);
});
it("returns false for a room with read thread messages", () => {
// Mark the main timeline as read.
let receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[event.getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1 },
},
},
},
});
room.addReceipt(receipt);
// Create threads.
const { rootEvent, events } = mkThread({ room, client, authorId: myId, participantUserIds: [aliceId] });
// Mark the thread as read.
receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[events[events.length - 1].getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1, thread_id: rootEvent.getId()! },
},
},
},
});
room.addReceipt(receipt);
expect(doesRoomHaveUnreadMessages(room)).toBe(false);
});
it("returns true for a room when read receipt is not on the latest thread messages", () => {
// Mark the main timeline as read.
let receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[event.getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1 },
},
},
},
});
room.addReceipt(receipt);
// Create threads.
const { rootEvent, events } = mkThread({ room, client, authorId: myId, participantUserIds: [aliceId] });
// Mark the thread as read.
receipt = new MatrixEvent({
type: "m.receipt",
room_id: "!foo:bar",
content: {
[events[0].getId()!]: {
[ReceiptType.Read]: {
[myId]: { ts: 1, threadId: rootEvent.getId()! },
},
},
},
});
room.addReceipt(receipt);
expect(doesRoomHaveUnreadMessages(room)).toBe(true);
}); });
expect(eventTriggersUnreadCount(event)).toBe(false);
expect(haveRendererForEvent).not.toHaveBeenCalled();
}); });
}); });