Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

11.1 KB
Raw Blame
import { StrictMode, useCallback } from "react";
import { act, render, screen, waitFor } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import {
  ChatStateAdapterProvider,
  useChatStateAdapter,
} from "@/features/chat/ChatStateAdapter";
import { useMasteryStudySession } from "@/hooks/useMasteryStudySession";
import { useMasteryOpening } from "@/hooks/useMasteryOpening";
import { isMasteryDraftSendReady } from "@/lib/mastery-study-route";
import { setPendingPrompt } from "@/lib/pending-prompt";
import { MASTERY_OPENING_SCOPE } from "@/lib/mastery-mode";
import { initI18n } from "@/i18n/init";

initI18n("en");
const mocks = vi.hoisted(() => ({
  refresh: vi.fn(),
  revision: 0,
  topic: vi.fn(),
  sessions: vi.fn(),
  getSession: vi.fn(),
  replace: vi.fn(),
  requests: [] as Record<string, unknown>[],
  emit: undefined as
    undefined | ((event: Record<string, unknown>) => void),
}));
vi.mock("next/navigation", () => ({ useRouter: () => router }));
const router = { replace: mocks.replace };
vi.mock("@/lib/learning-api", () => ({
  fetchMasteryTopic: mocks.topic,
  fetchMasteryTopicSessions: mocks.sessions,
}));
vi.mock("@/lib/session-api", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@/lib/session-api")>()),
  getSession: mocks.getSession,
}));
vi.mock("@/hooks/useMasteryPathActivity", () => ({
  useMasteryPathActivity: () => ({
    revision: mocks.revision,
    refresh: mocks.refresh,
  }),
}));
vi.mock("@/features/chat/transport/UnifiedTurnClient", () => ({
  UnifiedTurnClient: class {
    connected = true;
    constructor(emit: typeof mocks.emit) {
      mocks.emit = emit;
    }
    connect() {}
    disconnect() {}
    setResumeState() {}
    send(message: Record<string, unknown>) {
      mocks.requests.push(message);
    }
    sendAwaitingAck(message: Record<string, unknown>) {
      mocks.requests.push(message);
      return Promise.resolve(true);
    }
  },
}));
function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason: Error) => void;
  const promise = new Promise<T>((yes, no) => {
    resolve = yes;
    reject = no;
  });
  return { promise, resolve, reject };
}
const topic = (pathId: string) => ({
  path_id: pathId,
  sources: [],
  map: {
    modules: [],
    counts: { mastered: 0, learning: 0, new: 0, total: 0 },
  },
});
function Harness({
  pathId,
  sessionId,
}: {
  pathId: string;
  sessionId?: string;
}) {
  const { state, sendMessage } = useChatStateAdapter();
  const session = useMasteryStudySession(
    pathId,
    sessionId,
    "outline",
  );
  const submit = useCallback(
    (content: string) => {
      if (
        session.sessionLoading ||
        session.sessionError ||
        state.isStreaming
      )
        return false;
      sendMessage(content);
      return true;
    },
    [
      sendMessage,
      session.sessionLoading,
      session.sessionError,
      state.isStreaming,
    ],
  );
  useMasteryOpening({
    pathId,
    topicReady: Boolean(session.topic),
    hasMessages: state.messages.length > 0,
    sessionLoading: session.sessionLoading,
    sessionError: session.sessionError,
    sessionMode: session.sessionMode,
    isStreaming: state.isStreaming,
    submit,
  });
  return (
    <>
      <span data-testid="loading">
        {String(session.sessionLoading)}
      </span>
      <span data-testid="error">{session.sessionError}</span>
      <span data-testid="server-id">{state.sessionId ?? "none"}</span>
    </>
  );
}
const view = (pathId: string, sessionId?: string) => (
  <StrictMode>
    <ChatStateAdapterProvider>
      <Harness pathId={pathId} sessionId={sessionId} />
    </ChatStateAdapterProvider>
  </StrictMode>
);
const starts = () =>
  mocks.requests.filter((r) => r.type === "start_turn");
beforeEach(() => {
  mocks.revision = 0;
  mocks.requests.length = 0;
  mocks.emit = undefined;
  mocks.topic.mockReset();
  mocks.sessions.mockReset();
  mocks.getSession.mockReset();
  mocks.replace.mockClear();
});

describe("mastery opening binding", () => {
  it("waits for an empty topic's draft and sends exactly once with its path", async () => {
    const pending = deferred<ReturnType<typeof topic>>();
    mocks.topic.mockReturnValue(pending.promise);
    setPendingPrompt("Design my outline", MASTERY_OPENING_SCOPE);
    render(view("topic_created"));
    expect(starts()).toHaveLength(0);
    expect(screen.getByTestId("loading")).toHaveTextContent("true");
    await act(async () => pending.resolve(topic("topic_created")));
    await waitFor(() => expect(starts()).toHaveLength(1));
    expect(starts()[0]).toMatchObject({
      workspace_mode: "mastery_path",
      mastery_path_id: "topic_created",
      mastery_session_mode: "outline",
      content: "Design my outline",
    });
    expect(screen.getByTestId("server-id")).toHaveTextContent("none");
    await act(async () =>
      mocks.emit?.({
        type: "session",
        metadata: { session_id: "unified_bound" },
      }),
    );
    await waitFor(() =>
      expect(mocks.replace).toHaveBeenCalledWith(
        "/learning/mastery/topic_created/sessions/unified_bound",
        {
          scroll: false,
        },
      ),
    );
    expect(starts()).toHaveLength(1);
  });

  it("ignores a delayed topic after switching paths", async () => {
    const old = deferred<ReturnType<typeof topic>>();
    const next = deferred<ReturnType<typeof topic>>();
    mocks.topic.mockImplementation((id: string) =>
      id === "topic_old" ? old.promise : next.promise,
    );
    const rendered = render(view("topic_old"));
    rendered.rerender(view("topic_next"));
    await act(async () => old.resolve(topic("topic_old")));
    expect(starts()).toHaveLength(0);
    await act(async () => next.resolve(topic("topic_next")));
    await waitFor(() => expect(starts()).toHaveLength(1));
    expect(starts()[0]).toMatchObject({
      mastery_path_id: "topic_next",
    });
  });

  it("does not send when existing-session membership fails", async () => {
    mocks.topic.mockResolvedValue(topic("topic_created"));
    mocks.sessions.mockResolvedValue([]);
    render(view("topic_created", "other_session"));
    await waitFor(() =>
      expect(screen.getByTestId("error").textContent).toContain(
        "different topic",
      ),
    );
    expect(starts()).toHaveLength(0);
  });

  it("blocks opening while an existing session loads and after failure", async () => {
    const pending = deferred<never>();
    mocks.topic.mockResolvedValue(topic("topic_created"));
    mocks.sessions.mockResolvedValue([{ session_id: "session_saved" }]);
    mocks.getSession.mockReturnValue(pending.promise);
    render(view("topic_created", "session_saved"));
    await waitFor(() => expect(mocks.getSession).toHaveBeenCalled());
    expect(starts()).toHaveLength(0);
    await act(async () =>
      pending.reject(new Error("Session unavailable")),
    );
    await waitFor(() =>
      expect(screen.getByTestId("error")).toHaveTextContent(
        "Session unavailable",
      ),
    );
    expect(starts()).toHaveLength(0);
  });

  it("preserves an existing session's stored study mode", async () => {
    mocks.topic.mockResolvedValue(topic("topic_created"));
    mocks.sessions.mockResolvedValue([{ session_id: "session_saved" }]);
    mocks.getSession.mockResolvedValue({
      session_id: "session_saved",
      messages: [],
      preferences: {
        workspace_mode: "mastery_path",
        mastery_path_id: "topic_created",
        mastery_session_mode: "study",
      },
    });
    render(view("topic_created", "session_saved"));
    await waitFor(() =>
      expect(screen.getByTestId("loading")).toHaveTextContent("false"),
    );
    expect(screen.getByTestId("server-id")).toHaveTextContent(
      "session_saved",
    );
    expect(starts()).toHaveLength(0);
  });

  it("refreshes the learning map without reloading an existing conversation", async () => {
    mocks.topic.mockResolvedValue(topic("topic_created"));
    mocks.sessions.mockResolvedValue([{ session_id: "session_saved" }]);
    mocks.getSession.mockResolvedValue({
      session_id: "session_saved",
      messages: [],
      preferences: {
        workspace_mode: "mastery_path",
        mastery_path_id: "topic_created",
        mastery_session_mode: "study",
      },
    });
    const rendered = render(view("topic_created", "session_saved"));
    await waitFor(() =>
      expect(screen.getByTestId("loading")).toHaveTextContent("false"),
    );
    const loads = mocks.getSession.mock.calls.length;
    const topics = mocks.topic.mock.calls.length;
    mocks.revision++;
    rendered.rerender(view("topic_created", "session_saved"));
    await waitFor(() =>
      expect(mocks.topic.mock.calls.length).toBeGreaterThan(topics),
    );
    expect(mocks.getSession).toHaveBeenCalledTimes(loads);
    expect(screen.getByTestId("loading")).toHaveTextContent("false");
  });

  it("discards an in-flight session snapshot after switching paths", async () => {
    const pending = deferred<Record<string, unknown>>();
    mocks.topic.mockImplementation((id: string) =>
      Promise.resolve(topic(id)),
    );
    mocks.sessions.mockResolvedValue([{ session_id: "session_old" }]);
    mocks.getSession.mockReturnValue(pending.promise);
    const rendered = render(view("topic_old", "session_old"));
    await waitFor(() => expect(mocks.getSession).toHaveBeenCalled());
    const signal = mocks.getSession.mock.calls[0][1] as AbortSignal;
    rendered.rerender(view("topic_next"));
    await waitFor(() => expect(starts()).toHaveLength(1));
    expect(signal.aborted).toBe(true);
    await act(async () =>
      pending.resolve({ session_id: "session_old", messages: [] }),
    );
    expect(screen.getByTestId("server-id")).toHaveTextContent("none");
    expect(starts()).toHaveLength(1);
  });

  it("ignores an old membership response after navigating to a new draft", async () => {
    const membership = deferred<unknown[]>();
    mocks.topic.mockImplementation((id: string) =>
      Promise.resolve(topic(id)),
    );
    mocks.sessions.mockReturnValue(membership.promise);
    const rendered = render(view("topic_old", "old_session"));
    await waitFor(() => expect(mocks.sessions).toHaveBeenCalled());
    rendered.rerender(view("topic_next"));
    await waitFor(() => expect(starts()).toHaveLength(1));
    await act(async () =>
      membership.resolve([{ session_id: "old_session" }]),
    );
    expect(starts()).toHaveLength(1);
    expect(screen.getByTestId("error")).toBeEmptyDOMElement();
  });
});

it("only admits the exact committed draft and configuration", () => {
  const ready = {
    binding: { routeKey: "topic:new", draftKey: "draft-new" },
    routeKey: "topic:new",
    sessionKey: "draft-new",
    workspaceMode: "mastery_path",
    masteryPathId: "topic",
    pathId: "topic",
    masterySessionMode: "outline",
    requestedMode: "outline",
  };
  expect(isMasteryDraftSendReady(ready)).toBe(true);
  for (const override of [
    { binding: null },
    { sessionKey: "old-session" },
    { sessionKey: "draft-old" },
    { routeKey: "other:new" },
    { workspaceMode: "chat" },
    { masteryPathId: "other" },
    { masterySessionMode: "study" },
  ])
    expect(isMasteryDraftSendReady({ ...ready, ...override })).toBe(
      false,
    );
});