tests for thread list pagination

Author: justjanne

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

@@ -15,8 +15,19 @@ limitations under the License.
 */
 
 import * as utils from "../test-utils/test-utils";
-import { ClientEvent, EventTimeline, Filter, IEvent, MatrixClient, MatrixEvent, Room } from "../../src/matrix";
+import {
+    ClientEvent,
+    Direction,
+    EventTimeline,
+    EventTimelineSet,
+    Filter,
+    IEvent,
+    MatrixClient,
+    MatrixEvent,
+    Room,
+} from "../../src/matrix";
 import { logger } from "../../src/logger";
+import { encodeUri } from "../../src/utils";
 import { TestClient } from "../TestClient";
 import { FeatureSupport, Thread, THREAD_RELATION_TYPE } from "../../src/models/thread";
 
@@ -925,6 +936,154 @@ describe("MatrixClient event timelines", function() {
         });
     });
 
+    describe("paginateEventTimeline for thread list timeline", function() {
+        async function flushHttp<T>(promise: Promise<T>): Promise<T> {
+            return Promise.all([promise, httpBackend.flushAllExpected()]).then(([result]) => result);
+        }
+
+        describe("with server compatibility", function() {
+            async function testPagination(timelineSet: EventTimelineSet, direction: Direction) {
+                const RANDOM_TOKEN = "7280349c7bee430f91defe2a38a0a08c";
+                function respondToThreads() {
+                    httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/threads", {
+                        $roomId: roomId,
+                    })).respond(200, {
+                        chunk: [THREAD_ROOT],
+                        state: [],
+                        next_batch: RANDOM_TOKEN,
+                    });
+                }
+                function respondToContext() {
+                    httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/context/$eventId", {
+                        $roomId: roomId,
+                        $eventId: THREAD_ROOT.event_id!,
+                    })).respond(200, {
+                        end: "",
+                        start: "",
+                        state: [],
+                        events_before: [],
+                        events_after: [],
+                        event: THREAD_ROOT,
+                    });
+                }
+
+                respondToContext();
+                await flushHttp(client.getEventTimeline(timelineSet, THREAD_ROOT.event_id!));
+                respondToThreads();
+                const timeline = await flushHttp(client.getLatestTimeline(timelineSet));
+                expect(timeline).not.toBeNull();
+
+                respondToThreads();
+                const success = await flushHttp(client.paginateEventTimeline(timeline!, {
+                    backwards: direction === Direction.Backward,
+                }));
+                expect(success).toBeTruthy();
+                expect(timeline!.getEvents().length).toEqual(1);
+                expect(timeline!.getEvents()[0].event).toEqual(THREAD_ROOT);
+                expect(timeline!.getPaginationToken(direction)).toEqual(RANDOM_TOKEN);
+            }
+
+            it("should allow you to paginate all threads backwards", async function() {
+                // @ts-ignore
+                client.clientOpts.experimentalThreadSupport = true;
+                Thread.setServerSideSupport(FeatureSupport.Experimental);
+                Thread.setServerSideListSupport(FeatureSupport.Stable);
+
+                const room = client.getRoom(roomId);
+                const timelineSets = await (room?.createThreadsTimelineSets());
+                expect(timelineSets).not.toBeNull();
+                const [allThreads, myThreads] = timelineSets!;
+                await testPagination(allThreads, Direction.Backward);
+                await testPagination(myThreads, Direction.Backward);
+            });
+
+            it("should allow you to paginate all threads forwards", async function() {
+                // @ts-ignore
+                client.clientOpts.experimentalThreadSupport = true;
+                Thread.setServerSideSupport(FeatureSupport.Experimental);
+                Thread.setServerSideListSupport(FeatureSupport.Stable);
+
+                const room = client.getRoom(roomId);
+                const timelineSets = await (room?.createThreadsTimelineSets());
+                expect(timelineSets).not.toBeNull();
+                const [allThreads, myThreads] = timelineSets!;
+
+                await testPagination(allThreads, Direction.Forward);
+                await testPagination(myThreads, Direction.Forward);
+            });
+        });
+
+        describe("without server compatibility", function() {
+            async function testPagination(timelineSet: EventTimelineSet, direction: Direction) {
+                const RANDOM_TOKEN = "7280349c7bee430f91defe2a38a0a08c";
+                function respondToMessagesRequest() {
+                    httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/messages", {
+                        $roomId: roomId,
+                    })).respond(200, {
+                        chunk: [THREAD_ROOT],
+                        state: [],
+                        start: `${Direction.Forward}${RANDOM_TOKEN}2`,
+                        end: `${Direction.Backward}${RANDOM_TOKEN}2`,
+                    });
+                }
+                function respondToContext() {
+                    httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/context/$eventId", {
+                        $roomId: roomId,
+                        $eventId: THREAD_ROOT.event_id!,
+                    })).respond(200, {
+                        end: `${Direction.Forward}${RANDOM_TOKEN}1`,
+                        start: `${Direction.Backward}${RANDOM_TOKEN}1`,
+                        state: [],
+                        events_before: [],
+                        events_after: [],
+                        event: THREAD_ROOT,
+                    });
+                }
+
+                respondToContext();
+                httpBackend.when("GET", "/sync").respond(200, INITIAL_SYNC_DATA);
+                await flushHttp(client.getEventTimeline(timelineSet, THREAD_ROOT.event_id!));
+
+                respondToMessagesRequest();
+                const timeline = await flushHttp(client.getLatestTimeline(timelineSet));
+                expect(timeline).not.toBeNull();
+
+                respondToMessagesRequest();
+                const success = await flushHttp(client.paginateEventTimeline(timeline!, {
+                    backwards: direction === Direction.Backward,
+                }));
+
+                expect(success).toBeTruthy();
+                expect(timeline!.getEvents().length).toEqual(1);
+                expect(timeline!.getEvents()[0].event).toEqual(THREAD_ROOT);
+                expect(timeline!.getPaginationToken(direction)).toEqual(`${direction}${RANDOM_TOKEN}2`);
+            }
+
+            it("should allow you to paginate all threads", async function() {
+                // @ts-ignore
+                client.clientOpts.experimentalThreadSupport = true;
+                Thread.setServerSideSupport(FeatureSupport.Experimental);
+                Thread.setServerSideListSupport(FeatureSupport.None);
+
+                const room = client.getRoom(roomId);
+
+                httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+                httpBackend.when("GET", "/sync").respond(200, INITIAL_SYNC_DATA);
+                httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+                httpBackend.when("GET", "/sync").respond(200, INITIAL_SYNC_DATA);
+
+                const timelineSetsPromise = room?.createThreadsTimelineSets();
+                expect(timelineSetsPromise).not.toBeNull();
+                const timelineSets = await flushHttp(timelineSetsPromise!);
+                expect(timelineSets).not.toBeNull();
+                const [allThreads, myThreads] = timelineSets!;
+
+                await testPagination(allThreads, Direction.Backward);
+                await testPagination(myThreads, Direction.Backward);
+            });
+        });
+    });
+
     describe("event timeline for sent events", function() {
         const TXN_ID = "txn1";
         const event = utils.mkMessage({