test(session): cover pagination behaviors

Author: CasualDeveloper

packages/opencode/test/cli/tui/pagination-helpers.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test"
+import { evictFromEnd, evictFromStart, windowNewest, windowOldest } from "../../../src/cli/cmd/tui/util/pagination"
+import type { Message } from "@opencode-ai/sdk/v2"
+
+const make = (ids: string[]) =>
+  ids.map(
+    (id) =>
+      ({
+        id,
+        sessionID: "ses_test",
+        role: "user",
+        agent: "default",
+        model: { providerID: "test", modelID: "test" },
+        time: { created: Date.now() },
+      }) as Message,
+  )
+
+describe("tui pagination helpers", () => {
+  test("window bounds skip pinned message", () => {
+    const messages = make(["m1", "m2", "m3", "m4"])
+    expect(windowOldest(messages, "m1")).toBe("m2")
+    expect(windowNewest(messages, "m4")).toBe("m3")
+  })
+
+  test("evictFromStart skips pinned messages", () => {
+    const messages = make(["m1", "m2", "m3", "m4", "m5"])
+    const evicted = evictFromStart(messages, 2, "m2")
+    expect(evicted.map((m) => m.id)).toEqual(["m1", "m3"])
+    expect(messages.map((m) => m.id)).toEqual(["m2", "m4", "m5"])
+  })
+
+  test("evictFromEnd skips pinned messages", () => {
+    const messages = make(["m1", "m2", "m3", "m4", "m5"])
+    const evicted = evictFromEnd(messages, 2, "m4")
+    expect(evicted.map((m) => m.id)).toEqual(["m5", "m3"])
+    expect(messages.map((m) => m.id)).toEqual(["m1", "m2", "m4"])
+  })
+})

packages/opencode/test/server/session-messages.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { Session } from "../../src/session"
+import { Identifier } from "../../src/id/id"
+import { Log } from "../../src/util/log"
+
+const projectRoot = path.join(__dirname, "../..")
+Log.init({ print: false })
+
+const TEST_TIMEOUT_MS = 30_000
+
+describe("session.messages API", () => {
+  test(
+    "returns 400 when both before and after specified",
+    async () => {
+      await Instance.provide({
+        directory: projectRoot,
+        fn: async () => {
+          const app = Server.App()
+          const session = await Session.create({})
+
+          const response = await app.request(`/session/${session.id}/message?before=msg_01ABC&after=msg_01XYZ`)
+
+          expect(response.status).toBe(400)
+          const body = (await response.json()) as { error: string }
+          expect(body.error).toContain("Cannot specify both")
+        },
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test("includes Link header with rel=prev when more pages exist (before cursor)", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const app = Server.App()
+        const session = await Session.create({})
+
+        // Create 5 messages
+        for (let i = 0; i < 5; i++) {
+          await Session.updateMessage({
+            id: Identifier.ascending("message"),
+            role: "user",
+            sessionID: session.id,
+            agent: "default",
+            model: { providerID: "test", modelID: "test" },
+            time: { created: Date.now() },
+          })
+        }
+
+        // Request with limit=2 (should have more)
+        const response = await app.request(`/session/${session.id}/message?limit=2`)
+
+        expect(response.status).toBe(200)
+        const link = response.headers.get("Link")
+        expect(link).toContain('rel="prev"')
+        expect(link).toContain("before=")
+      },
+    })
+  })
+
+  test("includes Link header with rel=next when using after cursor with more pages", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const app = Server.App()
+        const session = await Session.create({})
+
+        // Create 5 messages
+        const ids: string[] = []
+        for (let i = 0; i < 5; i++) {
+          const msg = await Session.updateMessage({
+            id: Identifier.ascending("message"),
+            role: "user",
+            sessionID: session.id,
+            agent: "default",
+            model: { providerID: "test", modelID: "test" },
+            time: { created: Date.now() },
+          })
+          ids.push(msg.id)
+        }
+
+        // Request after first message with limit=2
+        const response = await app.request(`/session/${session.id}/message?after=${ids[0]}&limit=2`)
+
+        expect(response.status).toBe(200)
+        const link = response.headers.get("Link")
+        expect(link).toContain('rel="next"')
+        expect(link).toContain("after=")
+      },
+    })
+  })
+
+  test("omits Link header when no more pages", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const app = Server.App()
+        const session = await Session.create({})
+
+        // Create 2 messages
+        for (let i = 0; i < 2; i++) {
+          await Session.updateMessage({
+            id: Identifier.ascending("message"),
+            role: "user",
+            sessionID: session.id,
+            agent: "default",
+            model: { providerID: "test", modelID: "test" },
+            time: { created: Date.now() },
+          })
+        }
+
+        // Request with limit=10 (more than available)
+        const response = await app.request(`/session/${session.id}/message?limit=10`)
+
+        expect(response.status).toBe(200)
+        const link = response.headers.get("Link")
+        expect(link).toBeNull()
+      },
+    })
+  })
+
+  test("returns 400 when oldest used with before or after", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const app = Server.App()
+        const session = await Session.create({})
+
+        const response1 = await app.request(`/session/${session.id}/message?oldest=true&before=msg_01ABC`)
+        expect(response1.status).toBe(400)
+        const body1 = (await response1.json()) as { error: string }
+        expect(body1.error).toContain("Cannot use 'oldest' with")
+
+        const response2 = await app.request(`/session/${session.id}/message?oldest=true&after=msg_01XYZ`)
+        expect(response2.status).toBe(400)
+        const body2 = (await response2.json()) as { error: string }
+        expect(body2.error).toContain("Cannot use 'oldest' with")
+      },
+    })
+  })
+
+  test("oldest=true returns messages in ascending order with rel=next Link", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const app = Server.App()
+        const session = await Session.create({})
+
+        // Create 5 messages with small delay to ensure ordering
+        const ids: string[] = []
+        for (let i = 0; i < 5; i++) {
+          const msg = await Session.updateMessage({
+            id: Identifier.ascending("message"),
+            role: "user",
+            sessionID: session.id,
+            agent: "default",
+            model: { providerID: "test", modelID: "test" },
+            time: { created: Date.now() },
+          })
+          ids.push(msg.id)
+        }
+
+        // Request oldest with limit=2 (should have more pages)
+        const response = await app.request(`/session/${session.id}/message?oldest=true&limit=2`)
+
+        expect(response.status).toBe(200)
+        const messages = (await response.json()) as Array<{ info: { id: string } }>
+        expect(messages.length).toBe(2)
+        // Oldest messages should be first (ascending order)
+        expect(messages[0].info.id).toBe(ids[0])
+        expect(messages[1].info.id).toBe(ids[1])
+
+        const link = response.headers.get("Link")
+        expect(link).toContain('rel="next"')
+        expect(link).toContain("after=")
+        expect(link).not.toContain("oldest=") // oldest param stripped on subsequent pages
+      },
+    })
+  })
+})