Skip to content
Python
12.1 KB
Raw Blame
// @vitest-environment jsdom
import type {
  ModelProbeResult,
  ModelProfile,
  ModelProfileInput,
} from "@one-memory/contracts";
import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import * as api from "./api";
import { useModelProfiles } from "./use-model-profiles";

vi.mock("./api", () => ({
  getModelProfiles: vi.fn(),
  getModelCreationOperation: vi.fn(),
  createModelProfile: vi.fn(),
  updateModelProfile: vi.fn(),
  activateModelProfile: vi.fn(),
  deleteModelProfile: vi.fn(),
  probeModelProfile: vi.fn(),
  apiErrorCode: vi.fn(() => null),
}));

const profile: ModelProfile = {
  profile_id: "saved-1",
  name: "Saved model",
  provider_kind: "openai_compatible",
  base_url: "https://models.example/v1",
  model: "model-1",
  embedding_model: null,
  embedding_provider_kind: null,
  embedding_base_url: null,
  embedding_dimensions: null,
  context_window: null,
  disable_thinking: false,
  has_api_key: true,
  timeout_seconds: 60,
  max_concurrency: 1,
  revision: 1,
  is_active: false,
  created_at: "2026-09-14T00:00:00Z",
  updated_at: "2026-09-14T00:00:00Z",
  capabilities: {
    endpoint_reachable: false,
    model_available: false,
    embedding_available: false,
    structured_output: false,
  },
};
const input: ModelProfileInput = {
  name: profile.name,
  provider_kind: "openai_compatible",
  model: profile.model,
  base_url: profile.base_url,
  api_key: "synthetic-secret",
};
function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((done) => {
    resolve = done;
  });
  return { promise, resolve };
}
beforeEach(() => {
  vi.resetAllMocks();
  window.localStorage.clear();
  vi.mocked(api.getModelProfiles).mockResolvedValue([]);
  vi.mocked(api.createModelProfile).mockResolvedValue(profile);
  vi.mocked(api.getModelCreationOperation).mockImplementation(
    async (operationId) => ({
      operation_id: operationId,
      state: "committed",
      profile_id: profile.profile_id,
      created_revision: 1,
    }),
  );
});
afterEach(cleanup);

it("returns and retains the authoritative created profile when list refresh fails", async () => {
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(api.getModelProfiles).toHaveBeenCalledTimes(1));
  vi.mocked(api.getModelProfiles).mockRejectedValueOnce(new Error("offline"));
  let saved: ModelProfile | null | undefined;
  await act(async () => {
    saved = await result.current.create(input);
  });
  expect(saved).toEqual(profile);
  expect(result.current.profiles).toEqual([profile]);
  expect(result.current.error).toBeNull();
  expect(result.current.refreshError).toContain("已完成");
  expect(api.createModelProfile).toHaveBeenCalledTimes(1);
  vi.mocked(api.getModelProfiles).mockResolvedValue([profile]);
  await act(async () => {
    await result.current.refreshProfiles();
  });
  expect(result.current.refreshError).toBeNull();
  expect(api.createModelProfile).toHaveBeenCalledTimes(1);
});

it("publishes the saved profile while its refresh is still pending and merges duplicate create calls", async () => {
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(api.getModelProfiles).toHaveBeenCalledTimes(1));
  const refresh = deferred<ModelProfile[]>();
  vi.mocked(api.getModelProfiles).mockReturnValueOnce(refresh.promise);
  let first!: Promise<ModelProfile | null | undefined>;
  let second!: Promise<ModelProfile | null | undefined>;
  await act(async () => {
    first = result.current.create(input);
    second = result.current.create(input);
  });
  expect(result.current.profiles).toEqual([profile]);
  expect(api.createModelProfile).toHaveBeenCalledTimes(1);
  await act(async () => {
    refresh.resolve([profile]);
    await Promise.all([first, second]);
  });
  expect(await first).toEqual(profile);
  expect(await second).toEqual(profile);
});

it("ignores an initial list arriving after a newer save", async () => {
  const initial = deferred<ModelProfile[]>();
  vi.mocked(api.getModelProfiles)
    .mockReturnValueOnce(initial.promise)
    .mockResolvedValue([profile]);
  const { result } = renderHook(useModelProfiles);
  await act(async () => {
    await result.current.create(input);
  });
  await act(async () => {
    initial.resolve([]);
  });
  expect(result.current.profiles).toEqual([profile]);
});

it("retains failed create for reconciliation without resending or exposing the key", async () => {
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(api.getModelProfiles).toHaveBeenCalledTimes(1));
  vi.mocked(api.createModelProfile).mockRejectedValueOnce(
    new Error("failed synthetic-secret"),
  );
  await act(async () => {
    expect(await result.current.create(input)).toBeUndefined();
  });
  expect(result.current.profiles).toEqual([]);
  expect(result.current.error).not.toContain("synthetic-secret");
  expect(result.current.error).toBeTruthy();
  expect(result.current.pendingCreation).toBeTruthy();
  await act(async () => {
    await result.current.create(input);
  });
  expect(api.createModelProfile).toHaveBeenCalledTimes(1);
  expect(api.getModelCreationOperation).not.toHaveBeenCalled();
});

it("does not refresh or leak a late operation into a new mounted hook", async () => {
  const operation = deferred<ModelProfile>();
  vi.mocked(api.createModelProfile).mockReturnValueOnce(operation.promise);
  const first = renderHook(useModelProfiles);
  await waitFor(() => expect(api.getModelProfiles).toHaveBeenCalledTimes(1));
  let saved!: Promise<ModelProfile | null | undefined>;
  act(() => {
    saved = first.result.current.create(input);
  });
  first.unmount();
  const next = renderHook(useModelProfiles);
  await act(async () => {
    operation.resolve(profile);
    await saved;
  });
  expect(next.result.current.profiles).toEqual([]);
  expect(api.getModelProfiles).toHaveBeenCalledTimes(2);
});

it("does not let an older refresh overwrite a later activation", async () => {
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(api.getModelProfiles).toHaveBeenCalledTimes(1));
  const old = deferred<ModelProfile[]>();
  const active = { ...profile, is_active: true, revision: 2 };
  vi.mocked(api.getModelProfiles)
    .mockReturnValueOnce(old.promise)
    .mockResolvedValueOnce([active]);
  vi.mocked(api.activateModelProfile).mockResolvedValueOnce(active);
  await act(async () => {
    await result.current.create(input);
  });
  await act(async () => {
    await result.current.activate(profile.profile_id);
  });
  await act(async () => {
    old.resolve([profile]);
  });
  expect(result.current.profiles).toEqual([active]);
});

it("keeps update and delete receipts when their follow-up reads fail", async () => {
  vi.mocked(api.getModelProfiles)
    .mockResolvedValueOnce([profile])
    .mockRejectedValue(new Error("offline"));
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(result.current.profiles).toEqual([profile]));
  const updated = { ...profile, revision: 2, name: "Updated" };
  vi.mocked(api.updateModelProfile).mockResolvedValueOnce(updated);
  await act(async () => {
    expect(
      await result.current.update(profile.profile_id, {
        expected_revision: 1,
        name: "Updated",
      }),
    ).toEqual(updated);
  });
  expect(result.current.profiles).toEqual([updated]);
  await act(async () => {
    await result.current.remove(profile.profile_id);
  });
  expect(result.current.profiles).toEqual([]);
  expect(result.current.refreshError).toBeTruthy();
});

it("blocks other writes and retains pending after a synchronous create failure", async () => {
  const { result } = renderHook(useModelProfiles);
  const operation = deferred<ModelProfile>();
  vi.mocked(api.createModelProfile).mockReturnValueOnce(operation.promise);
  let saved!: Promise<ModelProfile | null | undefined>;
  await act(async () => {
    saved = result.current.create(input);
    expect(await result.current.activate(profile.profile_id)).toBeUndefined();
  });
  expect(api.activateModelProfile).not.toHaveBeenCalled();
  await act(async () => {
    operation.resolve(profile);
    await saved;
  });
  vi.mocked(api.createModelProfile).mockImplementationOnce(() => {
    throw new Error("offline");
  });
  await act(async () => {
    await result.current.create(input);
  });
  expect(result.current.busy).toBeNull();
  await act(async () => {
    await result.current.create(input);
  });
  expect(api.createModelProfile).toHaveBeenCalledTimes(2);
  expect(result.current.pendingCreation).toBeTruthy();
});

function probeResult(value = profile): ModelProbeResult {
  return {
    profile_id: value.profile_id,
    profile_revision: value.revision,
    capabilities: {
      ...value.capabilities,
      endpoint_reachable: true,
      model_available: true,
      embedding_available: true,
    },
    stages: [{ stage: "generation", ok: true, code: "ok", latency_ms: 2 }],
  };
}

it("attaches each probe to its own profile and revision and hides it after an edit", async () => {
  const other = {
    ...profile,
    profile_id: "other",
    base_url: "https://other.example/v1",
  };
  vi.mocked(api.getModelProfiles).mockResolvedValue([profile, other]);
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(result.current.profiles).toHaveLength(2));
  vi.mocked(api.probeModelProfile)
    .mockResolvedValueOnce(probeResult())
    .mockResolvedValueOnce(probeResult(other));
  await act(async () => {
    await result.current.probeProfile(profile.profile_id);
  });
  await act(async () => {
    await result.current.probeProfile(other.profile_id);
  });
  expect(result.current.probeFor(profile)).toEqual(probeResult());
  expect(result.current.probeFor(other)).toEqual(probeResult(other));
  const updated = { ...profile, revision: 2, model: "changed" };
  vi.mocked(api.updateModelProfile).mockResolvedValue(updated);
  vi.mocked(api.getModelProfiles).mockResolvedValue([updated, other]);
  await act(async () => {
    await result.current.update(profile.profile_id, {
      expected_revision: 1,
      model: "changed",
    });
  });
  expect(result.current.probeFor(updated)).toBeNull();
  expect(result.current.probeFor(other)).toEqual(probeResult(other));
  expect(api.createModelProfile).not.toHaveBeenCalled();
});

it("records a failed test only for the attempted revision and rejects a mismatched result", async () => {
  vi.mocked(api.getModelProfiles).mockResolvedValue([profile]);
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(result.current.profiles).toHaveLength(1));
  vi.mocked(api.probeModelProfile).mockRejectedValueOnce(
    new Error("private key leak"),
  );
  await act(async () => {
    await result.current.probeProfile(profile.profile_id);
  });
  expect(result.current.probeErrorFor(profile)).toBeTruthy();
  expect(result.current.probeErrorFor(profile)).not.toContain("private key");
  expect(result.current.error).toBeNull();
  expect(result.current.probeErrorFor({ ...profile, revision: 2 })).toBeNull();
  vi.mocked(api.probeModelProfile).mockResolvedValueOnce({
    ...probeResult(),
    profile_id: "wrong-profile",
  });
  await act(async () => {
    await result.current.probeProfile(profile.profile_id);
  });
  expect(result.current.probeFor(profile)).toBeNull();
  expect(result.current.profiles[0].capabilities).toEqual(profile.capabilities);
});

it("shows a probe-induced new revision only after the matching profile refresh", async () => {
  vi.mocked(api.getModelProfiles).mockResolvedValueOnce([profile]);
  const { result } = renderHook(useModelProfiles);
  await waitFor(() => expect(result.current.profiles).toHaveLength(1));
  const updated = { ...profile, revision: 2, embedding_dimensions: 512 };
  const delayed = deferred<ModelProfile[]>();
  vi.mocked(api.getModelProfiles).mockReturnValueOnce(delayed.promise);
  vi.mocked(api.probeModelProfile).mockResolvedValueOnce(probeResult(updated));
  await act(async () => {
    await result.current.probeProfile(profile.profile_id);
  });
  expect(result.current.probeFor(profile)).toBeNull();
  await act(async () => {
    delayed.resolve([updated]);
  });
  expect(result.current.probeFor(result.current.profiles[0])).toEqual(
    probeResult(updated),
  );
});