Add getLatestTimeline test for latest event being thread

spec/integ/matrix-client-event-timeline.spec.ts

@@ -741,6 +741,11 @@ describe("MatrixClient event timelines", function() {
     });
 
     describe("getLatestTimeline", function() {
+        beforeEach(() => {
+            // @ts-ignore
+            client.clientOpts.experimentalThreadSupport = true;
+        });
+
         it("should create a new timeline for new events", function() {
             const room = client.getRoom(roomId);
             const timelineSet = room.getTimelineSets()[0];
@@ -791,6 +796,64 @@ describe("MatrixClient event timelines", function() {
             ]);
         });
 
+        it("should successfully create a new timeline even when the latest event is a threaded reply", function() {
+            const room = client.getRoom(roomId);
+            const timelineSet = room.getTimelineSets()[0];
+            expect(timelineSet.thread).toBeUndefined();
+
+            const latestMessageId = 'threadedEvent1:bar';
+
+            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
+                .respond(200, function() {
+                    return {
+                        chunk: [{
+                            event_id: latestMessageId,
+                        }],
+                    };
+                });
+
+            httpBackend.when("GET", `/rooms/!foo%3Abar/context/${encodeURIComponent(latestMessageId)}`)
+                .respond(200, function() {
+                    return {
+                        start: "start_token",
+                        events_before: [THREAD_ROOT, EVENTS[0]],
+                        event: THREAD_REPLY,
+                        events_after: [],
+                        state: [
+                            ROOM_NAME_EVENT,
+                            USER_MEMBERSHIP_EVENT,
+                        ],
+                        end: "end_token",
+                    };
+                });
+
+            // Make it easy to debug when there is a mismatch of events. We care
+            // about the event ID for direct comparison and the content for a
+            // human readable description.
+            const eventPropertiesToCompare = (event) => {
+                return {
+                    eventId: event.event_id || event.getId(),
+                    contentBody: event.content?.body || event.getContent()?.body,
+                };
+            };
+            return Promise.all([
+                client.getLatestTimeline(timelineSet).then(function(tl) {
+                    const events = tl.getEvents();
+                    const expectedEvents = [EVENTS[0], THREAD_ROOT];
+                    expect(events.map(event => eventPropertiesToCompare(event)))
+                        .toEqual(expectedEvents.map(event => eventPropertiesToCompare(event)));
+                    // Sanity check: The threaded reply should not be in the timeline
+                    expect(events.find(e => e.getId() === THREAD_REPLY.event_id)).toBeFalsy();
+
+                    expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
+                        .toEqual("start_token");
+                    expect(tl.getPaginationToken(EventTimeline.FORWARDS))
+                        .toEqual("end_token");
+                }),
+                httpBackend.flushAllExpected(),
+            ]);
+        });
+
         it("should throw error when /messages does not return a message", () => {
             const room = client.getRoom(roomId);
             const timelineSet = room.getTimelineSets()[0];

src/client.ts

@@ -5334,9 +5334,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
         // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
         // anywhere, if it was later redacted, so we just return the timeline we first thought of.
-        return timelineSet.getTimelineForEvent(eventId)
-            ?? timelineSet.room.findThreadForEvent(event)?.liveTimeline // for Threads degraded support
-            ?? timeline;
+        return timelineSet.getTimelineForEvent(eventId) ?? timeline;
     }
 
     /**

src/models/event-timeline-set.ts

@@ -699,7 +699,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         // Make sure events don't get mixed in timelines they shouldn't be in
         // (e.g. a threaded message should not be in the main timeline).
         if (!this.canContain(event)) {
-            logger.warn(`EventTimelineSet.addEventToTimeline: Ignoring event=${event.getId()} that does not belong in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`);
+            logger.warn(`EventTimelineSet.addEventToTimeline: Ignoring event=${event.getId()} that does not belong " + 
+                "in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`);
             return;
         }