Skip to content

Your lightweight open-source personal agent.

12.7 KB
Raw Blame
import { act, render, renderHook, screen, waitFor, within } from "@testing-library/react";
import { createRef, type ReactNode } from "react";
import { beforeEach, expect, it, vi } from "vitest";
import { usePromptHistory } from "@/hooks/usePromptHistory";
import * as api from "@/lib/api";
import { NanobotClient } from "@/lib/nanobot-client";
import { ClientProvider } from "@/providers/ClientProvider";
import type { UIMessage, WebuiThreadPersistedPayload } from "@/lib/types";
import { ThreadViewport, type ThreadViewportHandle } from "@/components/thread/ThreadViewport";

vi.mock("@/lib/api", async (original) => ({ ...await original<typeof api>(), fetchPromptIndex: vi.fn(), fetchWebuiThread: vi.fn() }));
const index = Array.from({ length: 2000 }, (_, index) => ({ id: `u${index}`, preview: `question ${index}`,
  answerPreview: "answer", createdAt: index + 1, cursor: String(index), turnId: `turn${index}` }));
const latest: UIMessage[] = [{ id: "u1999", content: "question 1999", role: "user", createdAt: 2000 }];
function page(start: number): WebuiThreadPersistedPayload {
  return { schemaVersion: 3, projection: "events", events: [
    { event: "user_message", chat_id: "a", projection_id: `u${start}`, text: `question ${start}`, starts_turn: true },
    { event: "message", chat_id: "a", projection_id: `a${start}`, text: "answer" },
  ], page: { before_cursor: String(start), after_cursor: String(start + 1), user_message_offset: start,
    has_more_before: start > 0, has_more_after: start < 1999 } };
}
function wrapper(enabled = true) {
  const client = new NanobotClient({ url: "ws://localhost:8765", reconnect: false });
  return ({ children }: { children: ReactNode }) => <ClientProvider client={client} token="test"
    webuiCapabilities={enabled ? ["webui.prompt-navigation.v1"] : []}>{children}</ClientProvider>;
}
beforeEach(() => {
  vi.mocked(api.fetchPromptIndex).mockReset().mockResolvedValue({ prompts: index, revision: "first" });
  vi.mocked(api.fetchWebuiThread).mockReset().mockImplementation(async (_token, _key, options) => {
    if (typeof options === "string") throw new Error("expected page options");
    return page(Number(options?.after ?? Number(options?.before) - 1));
  });
});

it("loads the complete index without bodies, reads bounded windows and leaves live history alone", async () => {
  const { result, rerender } = renderHook(({ messages }) => usePromptHistory("a", 1, messages), {
    wrapper: wrapper(), initialProps: { messages: latest },
  });
  await waitFor(() => expect(result.current.prompts).toHaveLength(2000));
  expect(api.fetchWebuiThread).not.toHaveBeenCalled();
  await act(async () => result.current.jump("u500"));
  expect(result.current.window?.userMessageOffset).toBe(500);
  expect(result.current.target?.id).toBe("u500");
  rerender({ messages: [...latest, { id: "live", role: "assistant", content: "new output", createdAt: 2001 }] });
  expect(result.current.window?.messages).toHaveLength(2);
  for (let i = 0; i < 8; i++) await act(async () => result.current.newer());
  expect(result.current.window?.messages).toHaveLength(6);
  expect(result.current.window?.userMessageOffset).toBe(506);
  await act(async () => result.current.older());
  expect(result.current.window?.userMessageOffset).toBe(505);
  expect(result.current.window?.messages).toHaveLength(6);
  expect(api.fetchWebuiThread).toHaveBeenLastCalledWith("test", "a", expect.objectContaining({ before: "506", limit: 24 }));
  act(() => result.current.latest());
  expect(result.current.window).toBeNull();
  expect(latest).toHaveLength(1);
});

it.each(["older", "newer"] as const)("keeps one pending %s page when boundary inputs arrive before the next render", async (operation) => {
  const { result } = renderHook(() => usePromptHistory("a", 1, latest), { wrapper: wrapper() });
  await waitFor(() => expect(result.current.prompts).toHaveLength(2000));
  await act(async () => result.current.jump("u10"));
  let finish!: (body: WebuiThreadPersistedPayload) => void;
  vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
  const load = result.current[operation];
  act(() => {
    load();
    load();
  });
  expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2);
  const options = vi.mocked(api.fetchWebuiThread).mock.lastCall?.[2];
  if (typeof options !== "object") throw new Error("expected page options");
  expect(options.signal?.aborted).toBe(false);
  expect(result.current.loading).toBe(true);
  await act(async () => finish(page(operation === "older" ? 9 : 11)));
  expect(result.current.loading).toBe(false);
  expect(result.current.window?.messages).toHaveLength(4);
});

it("keeps the current page on failure and offers retry; superseded jumps and session reads cannot win", async () => {
  const { result, rerender } = renderHook(({ key }) => usePromptHistory(key, 1, latest), {
    wrapper: wrapper(), initialProps: { key: "a" },
  });
  await waitFor(() => expect(result.current.prompts).toHaveLength(2000));
  await act(async () => result.current.jump("u10"));
  vi.mocked(api.fetchWebuiThread).mockRejectedValueOnce(new Error("offline"));
  await act(async () => result.current.jump("u20"));
  expect(result.current.error).toBe("offline");
  expect(result.current.window?.userMessageOffset).toBe(10);
  await act(async () => result.current.retry());
  expect(result.current.window?.userMessageOffset).toBe(20);
  let resolve!: (body: WebuiThreadPersistedPayload) => void;
  vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise((done) => { resolve = done; }));
  act(() => result.current.jump("u30"));
  await act(async () => result.current.jump("u40"));
  await act(async () => resolve(page(30)));
  expect(result.current.window?.userMessageOffset).toBe(40);
  vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise((done) => { resolve = done; }));
  act(() => result.current.jump("u50"));
  rerender({ key: "b" });
  await act(async () => resolve(page(50)));
  expect(result.current.window).toBeNull();
  expect(result.current.loading).toBe(false);
});

it("does not request new endpoints from an older compatible host", () => {
  const { result } = renderHook(() => usePromptHistory("a", 1, latest), { wrapper: wrapper(false) });
  expect(result.current.prompts[0].id).toBe("u1999");
  expect(api.fetchPromptIndex).not.toHaveBeenCalled();
  expect(api.fetchWebuiThread).not.toHaveBeenCalled();
});

it.each([false, true])("a local jump supersedes a pending history read without discarding the current window (history=%s)", async (history) => {
  const viewport = createRef<ThreadViewportHandle>();
  function Conversation() {
    const navigation = usePromptHistory("a", 1, latest);
    return <ThreadViewport ref={viewport} messages={latest} navigation={navigation} isStreaming={false} />;
  }
  render(<Conversation />, { wrapper: wrapper() });
  await waitFor(() => expect(screen.getByTestId("prompt-rail-scroll")).toBeInTheDocument());
  if (history) {
    await act(async () => viewport.current?.jumpToUserPrompt("u10"));
  }
  const visible = history ? 10 : 1999;
  const body = within(screen.getByTestId("thread-message-region"));
  expect(body.getByText(`question ${visible}`)).toBeInTheDocument();
  let finish!: (body: WebuiThreadPersistedPayload) => void;
  vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
  act(() => viewport.current?.jumpToUserPrompt("u20"));
  const options = vi.mocked(api.fetchWebuiThread).mock.lastCall?.[2];
  if (typeof options !== "object") throw new Error("expected history read");
  act(() => viewport.current?.jumpToUserPrompt(`u${visible}`));
  await act(async () => finish(page(20)));
  expect(body.getByText(`question ${visible}`)).toBeInTheDocument();
  expect(body.queryByText("question 20")).not.toBeInTheDocument();
  expect(options.signal?.aborted).toBe(true);
});

it("keeps legacy backfilled and newly sent prompts navigable without a transcript cursor", async () => {
  vi.mocked(api.fetchPromptIndex).mockResolvedValue({ prompts: [] });
  const { result, rerender } = renderHook(({ messages }) => usePromptHistory("a", 1, messages), {
    wrapper: wrapper(), initialProps: { messages: latest },
  });
  await waitFor(() => expect(result.current.prompts[0]?.id).toBe("u1999"));
  rerender({ messages: [...latest, { id: "live-user", role: "user", content: "new question", createdAt: 2001 }] });
  expect(result.current.prompts.map((prompt) => prompt.id)).toEqual(["u1999", "live-user"]);
  act(() => result.current.jump("live-user"));
  expect(api.fetchWebuiThread).not.toHaveBeenCalled();
});

it("reuses the full directory during token updates and conditional revalidation", async () => {
  const user: UIMessage = { id: "live", role: "user", content: "new question", createdAt: 2001 };
  const { result, rerender } = renderHook(({ version, messages }) => usePromptHistory("a", version, messages), {
    wrapper: wrapper(), initialProps: { version: 1, messages: [...latest, user] },
  });
  await waitFor(() => expect(result.current.prompts).toHaveLength(2001));
  const anchors = result.current.prompts;
  for (let chunk = 0; chunk < 100; chunk++) {
    rerender({ version: 1, messages: [...latest, user, { id: "answer", role: "assistant", content: String(chunk), createdAt: 2002 }] });
    expect(result.current.prompts).toBe(anchors);
  }
  expect(api.fetchPromptIndex).toHaveBeenCalledTimes(1);
  rerender({ version: 2, messages: [...latest, user] });
  await waitFor(() => expect(api.fetchPromptIndex).toHaveBeenCalledTimes(2));
  expect(api.fetchPromptIndex).toHaveBeenLastCalledWith("test", "a", expect.any(AbortSignal), { prompts: index, revision: "first" });
  expect(result.current.prompts).toBe(anchors);
});


it("merges a live input by transport identity without adding an anchor or reordering unknown-time prompts", async () => {
  const recovered = [
    { id: "old", preview: "older", answerPreview: "", createdAt: 1000, cursor: "0", turnId: "old-input" },
    { id: "persisted", preview: "same", answerPreview: "answer", createdAt: 0, cursor: "1", turnId: "input" },
  ];
  vi.mocked(api.fetchPromptIndex).mockResolvedValue({ prompts: recovered, revision: "recovered" });
  const users: UIMessage[] = [
    { id: "optimistic", role: "user", content: "same", createdAt: 2000, turnId: "input" },
    { id: "distinct", role: "user", content: "same", createdAt: 3000, turnId: "other-input" },
  ];
  const { result, rerender } = renderHook(({ key, version }) => usePromptHistory(key, version, users), {
    wrapper: wrapper(), initialProps: { key: "a", version: 1 },
  });
  await waitFor(() => expect(result.current.prompts.map((prompt) => prompt.id)).toEqual(["old", "persisted", "distinct"]));
  vi.mocked(api.fetchWebuiThread).mockResolvedValue({ schemaVersion: 3, projection: "events", events: [
    { event: "user_message", chat_id: "a", text: "same", starts_turn: true, projection_id: "persisted", turn_id: "input", created_at_ms: 0 },
    { event: "message", chat_id: "a", text: "answer", projection_id: "answer" },
  ] });
  await act(async () => result.current.jump("persisted"));
  expect(result.current.target?.id).toBe("persisted");
  expect(result.current.window?.messages[0].createdAt).toBe(0);
  rerender({ key: "a", version: 2 });
  await waitFor(() => expect(api.fetchPromptIndex).toHaveBeenCalledTimes(2));
  expect(result.current.prompts.map((prompt) => prompt.id)).toEqual(["old", "persisted", "distinct"]);
  rerender({ key: "b", version: 1 });
  await waitFor(() => expect(api.fetchPromptIndex).toHaveBeenCalledTimes(3));
  expect(result.current.prompts.map((prompt) => prompt.id)).toEqual(["old", "persisted", "distinct"]);
  expect(result.current.window).toBeNull();
  expect(result.current.target).toBeNull();
});


it("keeps the request operation with failures and retries", async () => {
  const { result } = renderHook(() => usePromptHistory("a", 1, latest), { wrapper: wrapper() });
  await waitFor(() => expect(result.current.prompts).toHaveLength(2000));
  let finish!: (body: WebuiThreadPersistedPayload) => void;
  vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
  act(() => result.current.jump("u10"));
  expect(result.current.operation).toBe("jump");
  expect(result.current.loading).toBe(true);
  await act(async () => finish(page(10)));
  expect(result.current.operation).toBeNull();

  for (const operation of ["older", "newer"] as const) {
    vi.mocked(api.fetchWebuiThread).mockRejectedValueOnce(new Error("offline"));
    await act(async () => result.current[operation]());
    expect(result.current.operation).toBe(operation);
    expect(result.current.error).toBe("offline");
    await act(async () => result.current.retry());
    expect(result.current.operation).toBeNull();
    expect(result.current.error).toBeNull();
  }
  act(() => result.current.cancel());
  expect(result.current.operation).toBeNull();
});