Skip to content
Python
7.3 KB
Raw Blame
// @vitest-environment jsdom
import { afterEach, expect, it, vi } from "vitest";
import {
  clearPendingModelCreation,
  readPendingModelCreation,
  savePendingModelCreation,
} from "./pending-model-creation";

const KEY = "one-memory.pending-model-creation.v1";
const ERROR = "pending_model_creation_failed";
const ID = "d306b9d7-8dd5-4894-b5aa-dfe1e5c57ab9";
const OTHER = "bdb0b477-c9f1-42b7-aabd-6d52ebc5fdce";
const encode = (operationId = ID) =>
  JSON.stringify({ schemaVersion: 1, operationId });
function storage(raw: string | null = null) {
  let value = raw;
  return {
    getItem: vi.fn((_key: string) => value),
    setItem: vi.fn((_key: string, next: string) => {
      value = next;
    }),
    removeItem: vi.fn((_key: string) => {
      value = null;
    }),
  };
}
afterEach(() => vi.restoreAllMocks());

it("returns null only when absent, without writing", () => {
  const target = storage();
  expect(readPendingModelCreation(target)).toBeNull();
  expect(target.getItem).toHaveBeenCalledExactlyOnceWith(KEY);
  expect(target.setItem).not.toHaveBeenCalled();
  expect(target.removeItem).not.toHaveBeenCalled();
});

it("persists only the version and ID across module reload with default storage mocked", async () => {
  const target = storage();
  vi.spyOn(window, "localStorage", "get").mockReturnValue(
    target as unknown as Storage,
  );
  savePendingModelCreation(ID);
  expect(target.setItem).toHaveBeenCalledExactlyOnceWith(KEY, encode());
  vi.resetModules();
  const fresh = await import("./pending-model-creation");
  expect(fresh.readPendingModelCreation()).toBe(ID);
  expect(target.setItem).toHaveBeenCalledOnce();
  fresh.clearPendingModelCreation(ID);
  expect(fresh.readPendingModelCreation()).toBeNull();
});

it.each([
  "",
  "null",
  "[]",
  "{",
  JSON.stringify({ schemaVersion: 2, operationId: ID }),
  JSON.stringify({ schemaVersion: "1", operationId: ID }),
  JSON.stringify({ operationId: ID }),
  JSON.stringify({ schemaVersion: 1 }),
  JSON.stringify({ schemaVersion: 1, operationId: ID, api_key: "DO_NOT_ECHO" }),
  JSON.stringify({
    schemaVersion: 1,
    operationId: ID,
    endpoint: "DO_NOT_ECHO",
    name: "DO_NOT_ECHO",
  }),
])(
  "refuses corrupt or extra-field data without overwriting or deleting it (%#)",
  (raw) => {
    const target = storage(raw);
    expect(() => readPendingModelCreation(target)).toThrowError(
      new Error(ERROR),
    );
    expect(() => savePendingModelCreation(ID, target)).toThrowError(
      new Error(ERROR),
    );
    expect(() => clearPendingModelCreation(ID, target)).toThrowError(
      new Error(ERROR),
    );
    expect(target.setItem).not.toHaveBeenCalled();
    expect(target.removeItem).not.toHaveBeenCalled();
    expect(target.getItem(KEY)).toBe(raw);
  },
);

it.each([
  ID.toUpperCase(),
  ID.replaceAll("-", ""),
  ` ${ID}`,
  `${ID}\n`,
  "",
  "not-a-uuid",
  123,
  null,
])("requires canonical string UUIDs on every entry point (%#)", (invalid) => {
  const target = storage();
  expect(() =>
    savePendingModelCreation(invalid as string, target),
  ).toThrowError(ERROR);
  expect(() =>
    clearPendingModelCreation(invalid as string, target),
  ).toThrowError(ERROR);
  expect(() =>
    readPendingModelCreation(
      storage(JSON.stringify({ schemaVersion: 1, operationId: invalid })),
    ),
  ).toThrowError(ERROR);
  expect(target.setItem).not.toHaveBeenCalled();
  expect(target.removeItem).not.toHaveBeenCalled();
});

it("enforces the inclusive 256 UTF-8 byte limit before JSON parsing", () => {
  const exact =
    encode() + " ".repeat(256 - new TextEncoder().encode(encode()).length);
  expect(readPendingModelCreation(storage(exact))).toBe(ID);
  expect(() => readPendingModelCreation(storage(`${exact} `))).toThrowError(
    ERROR,
  );
  const oversized = JSON.stringify({
    schemaVersion: 1,
    operationId: ID,
    raw: "界".repeat(70),
  });
  expect(oversized.length).toBeLessThan(256);
  expect(new TextEncoder().encode(oversized).length).toBeGreaterThan(256);
  expect(() => readPendingModelCreation(storage(oversized))).toThrowError(
    ERROR,
  );
});

it("same ID is idempotent and another ID cannot overwrite or clear it", () => {
  const target = storage(encode());
  savePendingModelCreation(ID, target);
  expect(target.getItem).toHaveBeenCalledTimes(2);
  expect(target.setItem).not.toHaveBeenCalled();
  expect(() => savePendingModelCreation(OTHER, target)).toThrowError(ERROR);
  expect(() => clearPendingModelCreation(OTHER, target)).toThrowError(ERROR);
  expect(target.removeItem).not.toHaveBeenCalled();
  clearPendingModelCreation(ID, target);
  clearPendingModelCreation(ID, target);
  expect(target.removeItem).toHaveBeenCalledExactlyOnceWith(KEY);
  expect(readPendingModelCreation(target)).toBeNull();
});

it.each(["getItem", "setItem", "removeItem"] as const)(
  "sanitizes %s failures",
  (method) => {
    const target = storage(method === "removeItem" ? encode() : null);
    target[method].mockImplementation(() => {
      throw new Error("DO_NOT_ECHO");
    });
    const action =
      method === "getItem"
        ? () => readPendingModelCreation(target)
        : method === "setItem"
          ? () => savePendingModelCreation(ID, target)
          : () => clearPendingModelCreation(ID, target);
    expect(action).toThrowError(new Error(ERROR));
  },
);

it("sanitizes a denied default-storage accessor for read, save and clear", () => {
  vi.spyOn(window, "localStorage", "get").mockImplementation(() => {
    throw new Error("DO_NOT_ECHO");
  });
  expect(() => readPendingModelCreation()).toThrowError(new Error(ERROR));
  expect(() => savePendingModelCreation(ID)).toThrowError(new Error(ERROR));
  expect(() => clearPendingModelCreation(ID)).toThrowError(new Error(ERROR));
});

it.each([null, encode(OTHER), "corrupt"])(
  "rejects divergent write readback without cleanup (%#)",
  (readback) => {
    const target = storage();
    target.getItem.mockReturnValueOnce(null).mockReturnValue(readback);
    expect(() => savePendingModelCreation(ID, target)).toThrowError(ERROR);
    expect(target.setItem).toHaveBeenCalledOnce();
    expect(target.removeItem).not.toHaveBeenCalled();
  },
);

it("rechecks idempotent save and absent clear without touching a competing intent", () => {
  const target = storage();
  target.getItem.mockReturnValueOnce(encode()).mockReturnValue(encode(OTHER));
  expect(() => savePendingModelCreation(ID, target)).toThrowError(ERROR);
  target.getItem.mockReturnValueOnce(null);
  expect(() => clearPendingModelCreation(ID, target)).toThrowError(ERROR);
  expect(target.setItem).not.toHaveBeenCalled();
  expect(target.removeItem).not.toHaveBeenCalled();
});

it.each([encode(), encode(OTHER), "corrupt"])(
  "rejects failed or raced deletion readback without deleting again (%#)",
  (readback) => {
    const target = storage(encode());
    target.getItem.mockReturnValueOnce(encode()).mockReturnValue(readback);
    expect(() => clearPendingModelCreation(ID, target)).toThrowError(ERROR);
    expect(target.removeItem).toHaveBeenCalledOnce();
  },
);

it.each(["save", "clear"])("sanitizes %s readback failure", (action) => {
  const target = storage();
  target.getItem
    .mockReturnValueOnce(action === "save" ? null : encode())
    .mockImplementation(() => {
      throw new Error("DO_NOT_ECHO");
    });
  expect(() =>
    action === "save"
      ? savePendingModelCreation(ID, target)
      : clearPendingModelCreation(ID, target),
  ).toThrowError(new Error(ERROR));
});