Skip to content
Python
11.0 KB
Raw Blame
// @vitest-environment jsdom
import type { ModelProbeOperationReceipt } from "@one-memory/contracts";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { recoverableProbe } from "./model-probe-client";
import {
  readPendingModelProbe,
  savePendingModelProbe,
} from "./pending-model-probe";

const ID = "11111111-1111-4111-8111-111111111111";
const PROFILE = "22222222-2222-4222-8222-222222222222";
const OTHER = "33333333-3333-4333-8333-333333333333";
const pending = { operationId: ID, profileId: PROFILE, inputRevision: 1 };
const KEY = "one-memory.pending-model-probe.v1";
function absent(): ModelProbeOperationReceipt {
  return {
    schema_version: 1,
    operation_id: ID,
    profile_id: null,
    expected_profile_revision: null,
    state: "not_found",
    result: null,
    code: null,
    stale: null,
  };
}
function completed(): ModelProbeOperationReceipt {
  return {
    schema_version: 1,
    operation_id: ID,
    profile_id: PROFILE,
    expected_profile_revision: 1,
    state: "completed",
    code: null,
    stale: false,
    result: {
      profile_id: PROFILE,
      input_profile_revision: 1,
      profile_revision: 2,
      stages: [{ stage: "model", ok: true, code: "ok", latency_ms: 1 }],
      capabilities: {
        endpoint_reachable: true,
        model_available: true,
        structured_output: true,
        embedding_available: true,
      },
    },
  };
}
function transport() {
  return {
    lookup: vi.fn(async (_id: string) => absent()),
    probe: vi.fn(async (_id: string, _request: unknown) => completed()),
  };
}
beforeEach(() => {
  window.localStorage.clear();
  vi.spyOn(crypto, "randomUUID").mockReturnValue(ID);
});
afterEach(() => vi.restoreAllMocks());

it("checks capability, saves/readbacks metadata before exactly one POST, clears confirmed result", async () => {
  const t = transport();
  t.probe.mockImplementation(async (id, request) => {
    expect(id).toBe(PROFILE);
    expect(request).toEqual({ operation_id: ID, expected_profile_revision: 1 });
    expect(readPendingModelProbe()).toEqual(pending);
    return completed();
  });
  expect(await recoverableProbe(PROFILE, 1, t)).toEqual(completed().result);
  expect(t.lookup).toHaveBeenCalledExactlyOnceWith(ID);
  expect(t.probe).toHaveBeenCalledOnce();
  expect(readPendingModelProbe()).toBeNull();
});

it("after lost POST response the next click only GETs the original operation", async () => {
  const t = transport();
  t.probe.mockRejectedValueOnce(Error("SECRET response body"));
  await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
    "model_probe_operation_pending",
  );
  expect(readPendingModelProbe()).toEqual(pending);
  t.lookup.mockResolvedValue(completed());
  expect(await recoverableProbe(PROFILE, 2, t)).toEqual(completed().result);
  expect(t.probe).toHaveBeenCalledOnce();
  expect(readPendingModelProbe()).toBeNull();
});

it("reopened module recovers matching profile by stored input revision", async () => {
  savePendingModelProbe(pending);
  const t = transport();
  t.lookup.mockResolvedValue(completed());
  vi.resetModules();
  const fresh = await import("./model-probe-client");
  await fresh.recoverableProbe(PROFILE, 2, t);
  expect(t.probe).not.toHaveBeenCalled();
  expect(crypto.randomUUID).not.toHaveBeenCalled();
});

it("another profile cannot overwrite pending or make any request", async () => {
  savePendingModelProbe(pending);
  const t = transport();
  await expect(recoverableProbe(OTHER, 1, t)).rejects.toThrow(
    "model_probe_other_profile_pending",
  );
  expect(t.lookup).not.toHaveBeenCalled();
  expect(t.probe).not.toHaveBeenCalled();
  expect(readPendingModelProbe()).toEqual(pending);
});

it.each(["404", "network", "invalid", "not-absent", "wrong-id"])(
  "fresh capability failure %s never saves or POSTs",
  async (kind) => {
    const t = transport();
    if (kind === "404" || kind === "network")
      t.lookup.mockRejectedValue(Error(`private ${kind}`));
    else
      t.lookup.mockResolvedValue(
        kind === "not-absent"
          ? completed()
          : kind === "wrong-id"
            ? { ...absent(), operation_id: OTHER }
            : ({} as ModelProbeOperationReceipt),
      );
    await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
      "model_probe_capability_unavailable",
    );
    expect(readPendingModelProbe()).toBeNull();
    expect(t.probe).not.toHaveBeenCalled();
  },
);

it.each(["pending", "not_found", "disconnect"])(
  "recovery %s retains pending without POST",
  async (state) => {
    savePendingModelProbe(pending);
    const t = transport();
    if (state === "disconnect") t.lookup.mockRejectedValue(Error("secret"));
    else
      t.lookup.mockResolvedValue(
        state === "not_found"
          ? absent()
          : {
              ...completed(),
              state: "pending",
              result: null,
            },
      );
    await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
      "model_probe_operation_pending",
    );
    expect(readPendingModelProbe()).toEqual(pending);
    expect(t.probe).not.toHaveBeenCalled();
  },
);

it.each(["failed", "stale"])(
  "matching terminal %s clears but does not retry",
  async (kind) => {
    savePendingModelProbe(pending);
    const t = transport();
    t.lookup.mockResolvedValue(
      kind === "stale"
        ? { ...completed(), stale: true }
        : {
            ...completed(),
            state: "failed",
            result: null,
            code: "model_probe_profile_changed",
            stale: true,
          },
    );
    await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
      kind === "stale"
        ? "model_probe_operation_stale"
        : "model_probe_operation_stale",
    );
    expect(readPendingModelProbe()).toBeNull();
    expect(t.probe).not.toHaveBeenCalled();
  },
);

it.each([
  { operation_id: OTHER },
  { profile_id: OTHER },
  { expected_profile_revision: 2 },
  { schema_version: 2 },
  { code: "arbitrary secret" },
  { stale: null },
  { result: null },
  { secret: "extra" },
])("invalid receipt metadata %# retains pending", async (patch) => {
  savePendingModelProbe(pending);
  const t = transport();
  t.lookup.mockResolvedValue({
    ...completed(),
    ...patch,
  } as ModelProbeOperationReceipt);
  await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
    "model_probe_operation_unavailable",
  );
  expect(readPendingModelProbe()).toEqual(pending);
  expect(t.probe).not.toHaveBeenCalled();
});

it.each([
  { profile_id: OTHER },
  { input_profile_revision: 2 },
  { profile_revision: 3 },
  { profile_revision: 1.5 },
  { stages: [] },
  { stages: [{ stage: "unknown", ok: true, code: "ok", latency_ms: 0 }] },
  { stages: [{ stage: "model", ok: "true", code: "ok", latency_ms: 0 }] },
  { stages: [{ stage: "model", ok: true, code: "secret", latency_ms: 0 }] },
  { stages: [{ stage: "model", ok: true, code: "ok", latency_ms: -1 }] },
  { capabilities: { model_available: true } },
  { extra: "private" },
])("invalid result shape %# cannot clear pending", async (patch) => {
  savePendingModelProbe(pending);
  const t = transport();
  t.lookup.mockResolvedValue({
    ...completed(),
    result: { ...completed().result, ...patch },
  } as ModelProbeOperationReceipt);
  await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
    "model_probe_operation_unavailable",
  );
  expect(readPendingModelProbe()).toEqual(pending);
});

it("negative completed result is returned without pretending capabilities passed", async () => {
  const t = transport();
  const result = completed();
  if (!result.result) throw Error("fixture");
  result.result.capabilities.model_available = false;
  result.result.stages = [
    { stage: "model", ok: false, code: "unauthorized", latency_ms: 0 },
  ];
  t.probe.mockResolvedValue(result);
  expect(
    (await recoverableProbe(PROFILE, 1, t)).capabilities.model_available,
  ).toBe(false);
  expect(readPendingModelProbe()).toBeNull();
});

it.each(["corrupt", "unwritable", "readback"])(
  "storage %s blocks POST",
  async (kind) => {
    const t = transport();
    if (kind === "corrupt") window.localStorage.setItem(KEY, "{");
    else
      vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
        if (kind === "unwritable") throw Error("private");
      });
    await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
      "pending_model_probe_failed",
    );
    expect(t.probe).not.toHaveBeenCalled();
    if (kind === "corrupt") expect(t.lookup).not.toHaveBeenCalled();
  },
);

it("competing pending installed during capability check blocks our save/POST", async () => {
  const t = transport();
  t.lookup.mockImplementation(async () => {
    savePendingModelProbe({ ...pending, operationId: OTHER });
    return absent();
  });
  await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
    "pending_model_probe_failed",
  );
  expect(t.probe).not.toHaveBeenCalled();
  expect(readPendingModelProbe()?.operationId).toBe(OTHER);
});

it("failed clear cannot return success or delete competing pending", async () => {
  savePendingModelProbe(pending);
  const t = transport();
  t.lookup.mockImplementation(async () => {
    window.localStorage.setItem(
      KEY,
      JSON.stringify({
        schemaVersion: 1,
        value: { ...pending, operationId: OTHER },
      }),
    );
    return completed();
  });
  await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
    "pending_model_probe_failed",
  );
  expect(readPendingModelProbe()?.operationId).toBe(OTHER);
});

it("concurrent clicks cannot dispatch two fresh operations in this module", async () => {
  const t = transport();
  let release!: (value: ModelProbeOperationReceipt) => void;
  t.lookup.mockImplementation(
    () =>
      new Promise((resolve) => {
        release = resolve;
      }),
  );
  const first = recoverableProbe(PROFILE, 1, t);
  try {
    await expect(recoverableProbe(PROFILE, 1, t)).rejects.toThrow(
      "model_probe_in_flight",
    );
  } finally {
    release(absent());
    await first;
  }
  expect(t.probe).toHaveBeenCalledOnce();
});

it("accepts the native result's nullable/measured embedding dimensions", async () => {
  const t = transport();
  const result = completed();
  if (!result.result) throw Error("fixture");
  Object.assign(result.result.stages[0], { embedding_dimensions: null });
  result.result.stages.push({
    stage: "embedding",
    ok: true,
    code: "ok",
    latency_ms: 2,
    ...{ embedding_dimensions: 512 },
  });
  t.probe.mockResolvedValue(result);
  expect(await recoverableProbe(PROFILE, 1, t)).toEqual(result.result);
  expect(readPendingModelProbe()).toBeNull();
});

it.each([
  ["invalid", 1],
  [PROFILE, 0],
  [PROFILE, Number.MAX_SAFE_INTEGER + 1],
])(
  "invalid input never queries or dispatches (%#)",
  async (profileId, inputRevision) => {
    const t = transport();
    await expect(
      recoverableProbe(profileId as string, inputRevision as number, t),
    ).rejects.toThrow("model_probe_input_invalid");
    expect(t.lookup).not.toHaveBeenCalled();
    expect(t.probe).not.toHaveBeenCalled();
    expect(readPendingModelProbe()).toBeNull();
  },
);