Skip to content

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

18.8 KB
Raw Blame
import React, { useEffect, useState } from "react";
import {
  act,
  fireEvent,
  render,
  screen,
  waitFor,
} from "@testing-library/react";
import { beforeEach, expect, it, vi } from "vitest";
import {
  SettingsProvider,
  defaultCatalog,
  useSettings,
} from "@/features/settings/store/SettingsStore";
import { useStagedSettings } from "@/features/settings/store/useStagedSettings";
import { SettingsToolbar } from "@/components/settings/SettingsToolbar";
import DocumentParsing from "@/features/settings/sections/DocumentParsingSettingsSection";
import { MinerUEngineSettings } from "@/components/settings/MinerUEngineSettings";
import Appearance from "@/features/settings/sections/AppearanceSettingsSection";
import { UiSettingsProvider } from "@/features/settings/store/UiSettingsProvider";
import { stageRegistryAction } from "@/lib/provider-registry";

const mocks = vi.hoisted(() => ({ fetch: vi.fn(), theme: vi.fn() }));
vi.mock("@/lib/api", () => ({
  apiUrl: (s: string) => s,
  apiFetch: (...args: unknown[]) => mocks.fetch(...args),
}));
vi.mock("next/navigation", () => ({ useRouter: () => ({ push: vi.fn() }) }));
const t = (key: string, values?: Record<string, unknown>) => key.replace(/{{(.*?)}}/g, (_, name) => String(values?.[name] ?? name));
vi.mock("react-i18next", () => ({
  useTranslation: () => ({ t, i18n: { language: "en" } }),
}));
vi.mock("@/lib/theme", () => ({
  setTheme: (...args: unknown[]) => mocks.theme(...args),
}));
vi.mock("@/context/AppShellContext", () => ({
  useAppShell: () => ({
    codeBlockTheme: "github",
    codeBlockShowLineNumbers: false,
    codeBlockWrapLongLines: false,
  }),
}));
vi.mock("@/lib/llm-options", () => ({
  invalidateLLMOptionsCache: vi.fn(),
  listLLMOptions: vi.fn(async () => ({ active: null, options: [] })),
}));
let settings: ReturnType<typeof useSettings>;
let live: ReturnType<typeof defaultCatalog>;
let stored: any;
let resources: Record<string, any>;
const reply = (value: unknown, ok = true) => ({
  ok,
  status: ok ? 200 : 422,
  json: async () => value,
});
beforeEach(() => {
  live = defaultCatalog();
  stored = null;
  resources = {
    workspace: { path: "/original" },
    "video-learning": { provider: "youtube" },
  };
  mocks.fetch.mockImplementation(async (url: string, init?: RequestInit) => {
    const method = init?.method ?? "GET";
    if (url === "/api/settings")
      return reply({
        catalog: live,
        ui: { theme: "snow", language: "en", response_language: "en" },
      });
    if (url === "/api/settings/draft") {
      if (method === "PUT") stored = JSON.parse(String(init?.body));
      if (method === "DELETE") stored = null;
      return reply({ draft: stored });
    }
    if (url === "/api/settings/apply") {
      live = stored.catalog;
      stored = null;
      return reply({ catalog: live });
    }
    const key = url.split("/").pop()!;
    if (method === "PUT") resources[key] = JSON.parse(String(init?.body));
    return reply(resources[key] ?? {});
  });
});
function Capture() {
  const value = useSettings();
  useEffect(() => {
    settings = value;
  }, [value]);
  return null;
}
function Editor({ name }: { name: string }) {
  const [liveValue, setLiveValue] = useState(resources[name]);
  const [draft, edit] = useStagedSettings(name, liveValue, setLiveValue);
  const isSubagent = name.startsWith("subagent:");
  return (
    <input
      aria-label={name}
      value={isSubagent ? draft.model ?? "" : draft.path ?? draft.provider}
      onChange={(e) =>
        edit(
          isSubagent
            ? { model: e.target.value }
            : name === "workspace"
            ? { path: e.target.value }
            : { provider: e.target.value },
        )
      }
    />
  );
}
function App({ page = "workspace" }: { page?: string }) {
  return (
    <SettingsProvider>
      <UiSettingsProvider>
        <Capture />
        <SettingsToolbar />
        {page === "appearance" ? (
          <Appearance />
        ) : page === "document-parsing" ? (
          <DocumentParsing />
        ) : page === "mineru" ? (
          <MinerUEngineSettings />
        ) : page ? (
          <Editor key={page} name={page} />
        ) : null}
      </UiSettingsProvider>
    </SettingsProvider>
  );
}
async function ready() {
  await waitFor(() => expect(settings.settingsLoading).toBe(false));
}
const writes = (endpoint: string) =>
  mocks.fetch.mock.calls.filter(
    ([url, init]) => url === endpoint && init?.method === "PUT",
  );

it("keeps edits across pages, saves a real draft, and applies every page from one toolbar", async () => {
  const view = render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/draft" },
  });
  expect(writes("/api/settings/workspace")).toHaveLength(0);
  view.rerender(<App page="video-learning" />);
  fireEvent.change(screen.getByLabelText("video-learning"), {
    target: { value: "invidious" },
  });
  fireEvent.click(screen.getByText("Save draft"));
  await waitFor(() => expect(settings.draftState).toBe("saved"));
  expect(stored.extensions.workspace.path).toBe("/draft");
  expect(resources.workspace.path).toBe("/original");
  view.rerender(<App />);
  expect(screen.getByLabelText("workspace")).toHaveValue("/draft");
  fireEvent.click(screen.getByText("Apply changes"));
  await waitFor(() => expect(settings.draftState).toBe("clean"));
  expect(resources.workspace.path).toBe("/draft");
  expect(resources["video-learning"].provider).toBe("invidious");
  expect(stored).toBeNull();
});

it("restores a stored draft on remount, and Discard restores the live value without a write", async () => {
  const view = render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/draft" },
  });
  await act(() => settings.saveDraft());
  view.unmount();
  render(<App />);
  await ready();
  await waitFor(() =>
    expect(screen.getByLabelText("workspace")).toHaveValue("/draft"),
  );
  await act(() => settings.discardDraft());
  expect(screen.getByLabelText("workspace")).toHaveValue("/original");
  expect(writes("/api/settings/workspace")).toHaveLength(0);
});

it("keeps failed changes pending and allows retry", async () => {
  render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/invalid" },
  });
  const implementation = mocks.fetch.getMockImplementation()!;
  mocks.fetch.mockImplementation((url, init) =>
    url === "/api/settings/workspace"
      ? reply({ detail: "Invalid folder" }, false)
      : implementation(url, init),
  );
  await act(() => settings.applyCatalog());
  expect(settings.draftState).toBe("unsaved");
  expect(screen.getByLabelText("workspace")).toHaveValue("/invalid");
  expect(settings.toast).toContain("Could not apply");
  mocks.fetch.mockImplementation(implementation);
  await act(() => settings.applyCatalog());
  expect(settings.draftState).toBe("clean");
});

it.each(["/api/settings/draft", "/api/settings/apply"])("shows a denied %s write without losing the editable draft", async endpoint => {
  live.services.llm.profiles.push({ id: "saved", name: "Saved profile", binding: "custom", base_url: "", api_key: "", api_version: "", models: [] });
  render(<App page="" />);
  await ready();
  await act(async () => settings.mutateCatalog(next => {
    next.services.llm.profiles[0].name = "Retained draft";
  }));
  const original = mocks.fetch.getMockImplementation()!;
  mocks.fetch.mockImplementation((url, init) => url === endpoint && init?.method !== "GET"
    ? { ...reply({ detail: "Check the service account write permissions; your draft was retained." }, false), status: 503 }
    : original(url, init));
  await act(() => settings.applyCatalog());
  expect(settings.toast).toContain("service account write permissions");
  expect(settings.draft.services.llm.profiles[0].name).toBe("Retained draft");
  expect(live.services.llm.profiles[0].name).not.toBe("Retained draft");
  mocks.fetch.mockImplementation(original);
  await act(() => settings.applyCatalog());
  expect(settings.draftState).toBe("clean");
  expect(live.services.llm.profiles[0].name).toBe("Retained draft");
});

it("stages language and appearance without changing browser preferences until Apply", async () => {
  render(<App page="appearance" />);
  await ready();
  await act(async () => {
    await settings.updateTheme("dark");
    await settings.updateLanguage("zh");
    await settings.updateCodeBlockShowLineNumbers(true);
  });
  expect(settings.theme).toBe("dark");
  expect(settings.language).toBe("zh");
  expect(settings.codeBlockShowLineNumbers).toBe(true);
  expect(mocks.theme).not.toHaveBeenCalled();
  expect(writes("/api/settings/ui")).toHaveLength(0);
  await act(() => settings.discardDraft());
  expect(settings.theme).toBe("snow");
  await act(() => settings.updateTheme("dark"));
  await act(() => settings.applyCatalog());
  expect(mocks.theme).toHaveBeenCalledWith("dark");
  expect(resources.ui.theme).toBe("dark");
});

it("removes pending state when an edit is reverted", async () => {
  render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/draft" },
  });
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/original" },
  });
  expect(settings.draftState).toBe("clean");
});

it("stages default and task model choices against newly added draft models", async () => {
  render(<App page="" />);
  await ready();
  await act(async () =>
    settings.mutateCatalog((next) => {
      next.services.llm.profiles.push({
        id: "p",
        name: "new",
        binding: "custom",
        base_url: "",
        api_key: "",
        api_version: "",
        models: [{ id: "m", name: "m", model: "m" }],
      });
      stageRegistryAction(next, {
        kind: "default",
        service: "llm",
        profile_id: "p",
        model_id: "m",
      });
      stageRegistryAction(next, {
        kind: "task_choice",
        task: {
          mode: "reference",
          selection: { profile_id: "p", model_id: "m" },
        },
      });
    }),
  );
  expect(settings.draft.services.task.mode).toBe("reference");
  expect(live.services.llm.profiles).toHaveLength(0);
  await act(() => settings.applyCatalog());
  expect(live.services.llm.active_model_id).toBe("m");
  expect(live.services.task.selection?.model_id).toBe("m");
});

it("applies a restored draft while its editor is mounted without reverting the display", async () => {
  stored = {
    catalog: live,
    extensions: { workspace: { path: "/restored" } },
  };
  render(<App />);
  await ready();
  await waitFor(() =>
    expect(screen.getByLabelText("workspace")).toHaveValue("/restored"),
  );
  await act(() => settings.applyCatalog());
  expect(settings.draftState).toBe("clean");
  expect(screen.getByLabelText("workspace")).toHaveValue("/restored");
});

it("persists a restored subagent draft before clearing it", async () => {
  const subagent = { enabled: true, model: "restored-model", effort: "high" };
  resources["subagent:opencode"] = {};
  stored = {
    catalog: live,
    extensions: { "subagent:opencode": subagent },
  };
  render(<App page="subagent:opencode" />);
  await ready();

  await waitFor(() =>
    expect(screen.getByLabelText("subagent:opencode")).toHaveValue(
      "restored-model",
    ),
  );
  await act(() => settings.applyCatalog());

  const subagentWriteIndex = mocks.fetch.mock.calls.findIndex(
    ([url, init]) =>
      url === "/api/subagents/settings" && init?.method === "PUT",
  );
  const catalogApplyIndex = mocks.fetch.mock.calls.findIndex(
    ([url, init]) => url === "/api/settings/apply" && init?.method === "POST",
  );
  expect(JSON.parse(String(mocks.fetch.mock.calls[subagentWriteIndex][1]?.body)))
    .toEqual({ backends: { opencode: subagent } });
  expect(subagentWriteIndex).toBeLessThan(catalogApplyIndex);
  expect(settings.draftState).toBe("clean");
  expect(stored).toBeNull();
});

it("keeps the toolbar available when reverting an already saved draft", async () => {
  render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/draft" },
  });
  await act(() => settings.saveDraft());
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/original" },
  });
  expect(settings.draftState).toBe("unsaved");
  await act(() => settings.discardDraft());
  expect(stored).toBeNull();
  expect(settings.draftState).toBe("clean");
});

it("stages parser URL edits immediately and keeps them when changing parser panels", async () => {
  resources["document-parsing"] = {
    engine: "docling",
    engines: {
      docling: { mode: "remote", api_base_url: "http://parser-old" },
      tika: { server_url: "http://tika-old" },
      mineru: { mode: "local" },
    },
    available_engines: [
      { id: "docling", name: "Docling", available: true },
      { id: "tika", name: "Tika", available: true },
    ],
    readiness: {},
    installable: [],
    mineru: { api_token_set: false },
  };
  const view = render(<App page="document-parsing" />);
  await ready();
  fireEvent.change(await screen.findByDisplayValue("http://parser-old"), {
    target: { value: "http://parser-draft" },
  });
  expect(settings.draftState).toBe("unsaved");
  expect(writes("/api/settings/document-parsing")).toHaveLength(0);
  expect(
    screen.queryByRole("button", { name: "Save remote server" }),
  ).toBeNull();
  view.rerender(<App page="" />);
  await act(() => settings.applyCatalog());
  expect(resources["document-parsing"].engines.docling.api_base_url).toBe(
    "http://parser-draft",
  );
  expect(resources["document-parsing"].engines).not.toHaveProperty("mineru");
});

it("stages MinerU credentials and restores them when revisiting the page", async () => {
  resources.mineru = {
    settings: { mode: "cloud", api_base_url: "http://mineru" },
    api_token_set: false,
  };
  const view = render(<App page="mineru" />);
  await ready();
  fireEvent.change(await screen.findByPlaceholderText("Paste API token"), {
    target: { value: "test-only-token" },
  });
  expect(settings.draftState).toBe("unsaved");
  expect(writes("/api/settings/mineru")).toHaveLength(0);
  view.rerender(<App page="" />);
  view.rerender(<App page="mineru" />);
  expect(await screen.findByPlaceholderText("Paste API token")).toHaveValue(
    "test-only-token",
  );
  await act(() => settings.discardDraft());
  expect(screen.getByPlaceholderText("Paste API token")).toHaveValue("");
});

it("applies MinerU credentials and clears dirty state cleanly", async () => {
  resources.mineru = {
    settings: { mode: "cloud", api_base_url: "http://mineru" },
    api_token_set: false,
  };
  render(<App page="mineru" />);
  await ready();
  fireEvent.change(await screen.findByPlaceholderText("Paste API token"), {
    target: { value: "applied-token" },
  });
  expect(settings.draftState).toBe("unsaved");
  await act(() => settings.applyCatalog());
  expect(writes("/api/settings/mineru")).toHaveLength(1);
  expect(resources.mineru.api_token).toBe("applied-token");
  expect(settings.draftState).toBe("clean");
  expect(settings.hasUnsavedChanges).toBe(false);
});

it("applies MinerU credentials from within document-parsing page without leaving unsaved state", async () => {
  resources["document-parsing"] = {
    engine: "mineru",
    engines: {
      mineru: { mode: "local", api_base_url: "https://mineru.net" },
    },
    available_engines: [
      { id: "mineru", name: "MinerU", available: true },
    ],
    readiness: { mineru: { ready: true } },
    installable: [],
    mineru: { api_token_set: false },
  };
  resources.mineru = {
    settings: { mode: "local", api_base_url: "https://mineru.net" },
    api_token_set: false,
  };
  render(<App page="document-parsing" />);
  await ready();
  fireEvent.click(await screen.findByRole("button", { name: "Cloud API" }));
  fireEvent.change(await screen.findByPlaceholderText("Paste API token"), {
    target: { value: "cloud-token-123" },
  });
  expect(settings.draftState).toBe("unsaved");
  await act(() => settings.applyCatalog());
  expect(writes("/api/settings/mineru")).toHaveLength(1);
  expect(settings.draftState).toBe("clean");
  expect(settings.hasUnsavedChanges).toBe(false);
});

it("allows incomplete model drafts but blocks Apply before writing any live settings", async () => {
  render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), {
    target: { value: "/draft" },
  });
  await act(async () =>
    settings.mutateCatalog((next) => {
      next.services.llm.profiles.push({
        id: "new",
        name: "new",
        binding: "custom",
        api_key: "",
        api_version: "",
        base_url: "",
        models: [{ id: "new", name: "new", model: "" }],
      });
    }),
  );
  await act(() => settings.saveDraft());
  expect(stored.catalog.services.llm.profiles[0].models[0].model).toBe("");
  await act(() => settings.applyCatalog());
  expect(settings.draftState).toBe("saved");
  expect(writes("/api/settings/workspace")).toHaveLength(0);
  expect(live.services.llm.profiles).toHaveLength(0);
});

it("preserves the distinction between untouched and explicitly cleared MinerU tokens", async () => {
  resources.mineru = {
    settings: { mode: "cloud", api_base_url: "http://mineru" },
    api_token_set: true,
  };
  render(<App page="mineru" />);
  await ready();
  const token = await screen.findByPlaceholderText("••••••••••••");
  fireEvent.click(screen.getByRole("button", { name: "Show API token" }));
  expect(token).toHaveAttribute("type", "text");
  expect(settings.hasUnsavedChanges).toBe(false);
  fireEvent.change(token, { target: { value: "replacement" } });
  fireEvent.change(token, { target: { value: "" } });
  expect(settings.hasUnsavedChanges).toBe(true);
  await act(() => settings.applyCatalog());
  expect(JSON.parse(String(writes("/api/settings/mineru")[0][1].body))).toHaveProperty("api_token", "");
});

it("keeps edits made while Apply is pending for the next Apply", async () => {
  render(<App />);
  await ready();
  fireEvent.change(screen.getByLabelText("workspace"), { target: { value: "/first" } });
  const implementation = mocks.fetch.getMockImplementation()!;
  let release!: () => void;
  const gate = new Promise<void>((resolve) => { release = resolve; });
  mocks.fetch.mockImplementation(async (url, init) => {
    if (url === "/api/settings/workspace" && init?.method === "PUT") await gate;
    return implementation(url, init);
  });
  let applying!: Promise<void>;
  act(() => { applying = settings.applyCatalog(); });
  await waitFor(() => expect(writes("/api/settings/workspace")).toHaveLength(1));
  fireEvent.change(screen.getByLabelText("workspace"), { target: { value: "/second" } });
  await act(async () => { release(); await applying; });
  expect(resources.workspace.path).toBe("/first");
  expect(screen.getByLabelText("workspace")).toHaveValue("/second");
  expect(settings.draftState).toBe("unsaved");
  await act(() => settings.applyCatalog());
  expect(resources.workspace.path).toBe("/second");
  expect(settings.draftState).toBe("clean");
});