import { describe, expect, it } from "vite-plus/test";
import {
generateSpreadPinOrderKeys,
pinOrderKeyBetween,
} from "@t3tools/client-runtime/state/thread-sort";
import type { EnvironmentId } from "@t3tools/contracts";
import {
computeThreadMoveAvailability,
createThreadMovePlanner,
type OrderRow,
} from "./threadOrder";
function makeRow(id: string, environmentId: string, key: string | null, pinned: boolean): OrderRow {
return {
id: id as OrderRow["id"],
environmentId: environmentId as OrderRow["environmentId"],
pinOrderKey: pinned ? key : null,
activeOrderKey: pinned ? null : key,
createdAt: "2026-01-01T00:00:00.000Z",
unsettledAt: "2026-01-01T00:00:00.000Z",
pinnedAt: pinned ? "2026-01-01T00:00:00.000Z" : null,
};
}
function makeRng(seed: number) {
let state = seed >>> 0;
return () => {
state = (state * 1_664_525 + 1_013_904_223) >>> 0;
return state / 0x1_0000_0000;
};
}
const KEY_POOL = [
"a",
"b",
"ba",
"bb",
"c",
"d",
"ca",
"cb",
"da",
"db",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
null,
];
function referenceAvailability(
ordered: readonly OrderRow[],
allThreads: readonly OrderRow[],
writable: ReadonlySet<EnvironmentId>,
) {
const planner = createThreadMovePlanner({
ordered,
allThreads,
section: "pinned",
reorderableEnvironmentIds: writable,
});
const answers = new Map<string, { canMoveUp: boolean; canMoveDown: boolean }>();
for (const row of ordered) {
const movedId = `${row.environmentId}:${row.id}`;
answers.set(movedId, {
canMoveUp: planner(movedId, "up") !== null,
canMoveDown: planner(movedId, "down") !== null,
});
}
return answers;
}
function randomCase(rng: () => number) {
const rowCount = 1 + Math.floor(rng() * 9);
const rows: OrderRow[] = [];
for (let index = 0; index < rowCount; index += 1) {
const environment = rng() < 0.75 ? "env-w" : "env-x";
const key = KEY_POOL[Math.floor(rng() * KEY_POOL.length)] ?? null;
const id = rng() < 0.4 ? `t:${index}` : `t${index}`;
rows.push(makeRow(id, environment, key, true));
}
const hidden: OrderRow[] = [];
const hiddenCount = Math.floor(rng() * 4);
for (let index = 0; index < hiddenCount; index += 1) {
const key = KEY_POOL[Math.floor(rng() * KEY_POOL.length)] ?? null;
const id = rng() < 0.4 ? `h:${index}` : `h${index}`;
hidden.push(makeRow(id, rng() < 0.75 ? "env-w" : "env-x", key, true));
}
return { ordered: rows, allThreads: [...rows, ...hidden] };
}
const WRITABLE = new Set<EnvironmentId>(["env-w" as EnvironmentId]);
describe("computeThreadMoveAvailability matches the reference planner", () => {
it("agrees across randomized sections (keys, holes, non-writable rows, hidden keys)", () => {
for (let seed = 1; seed <= 4_000; seed += 1) {
const rng = makeRng(seed);
const { ordered, allThreads } = randomCase(rng);
const batch = computeThreadMoveAvailability({
ordered,
allThreads,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
});
const reference = referenceAvailability(ordered, allThreads, WRITABLE);
for (const [id, answer] of reference) {
expect(
batch.get(id) ?? { canMoveUp: false, canMoveDown: false },
`seed ${seed} row ${id} ordered=${ordered
.map((row) => `${row.id}:${row.pinOrderKey ?? "-"}:${row.environmentId}`)
.join(",")}`,
).toEqual(answer);
}
}
});
it("locks every row while a pending reorder is in flight", () => {
const rows = [makeRow("t0", "env-w", "a", true), makeRow("t1", "env-w", "c", true)];
const pending = {
section: "pinned" as const,
orderedIds: ["env-w:t1", "env-w:t0"],
before: new Map(),
assignments: new Map(),
confirmed: new Set<string>(),
commandsComplete: false,
};
const batch = computeThreadMoveAvailability({
ordered: rows,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
pendingOrder: pending,
});
expect(batch.size).toBe(0);
});
it("allows the fast-path walk past reserved keys and rewrites that skip matching keys (auditor cases)", () => {
const rows = [makeRow("t0", "env-w", "f", true), makeRow("t1", "env-x", "gn", true)];
const withThird = [...rows, makeRow("t2", "env-w", null, true)];
const batch = computeThreadMoveAvailability({
ordered: withThird,
allThreads: withThird,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
});
const reference = referenceAvailability(withThird, withThird, WRITABLE);
expect(Object.fromEntries(batch)).toEqual(Object.fromEntries(reference));
expect(batch.get("env-w:t0")).toEqual({ canMoveUp: false, canMoveDown: true });
});
it("keeps moves available for ids containing colons (composite-id parsing)", () => {
const rows = [makeRow("thread:1", "env", "a", true), makeRow("thread:2", "env", "c", true)];
const batch = computeThreadMoveAvailability({
ordered: rows,
section: "pinned",
reorderableEnvironmentIds: new Set<EnvironmentId>(["env" as EnvironmentId]),
});
const reference = referenceAvailability(
rows,
rows,
new Set<EnvironmentId>(["env" as EnvironmentId]),
);
expect(Object.fromEntries(batch)).toEqual(Object.fromEntries(reference));
expect(batch.get("env:thread:1")).toEqual({ canMoveUp: false, canMoveDown: true });
expect(batch.get("env:thread:2")).toEqual({ canMoveUp: true, canMoveDown: false });
});
it("answers empty and single-row sections without consulting hidden rows", () => {
const hidden = [makeRow("h0", "env-w", "b", true), makeRow("h1", "env-x", null, true)];
expect(
computeThreadMoveAvailability({
ordered: [],
allThreads: hidden,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
}).size,
).toBe(0);
for (const environment of ["env-w", "env-x"]) {
const ordered = [makeRow("t0", environment, "a", true)];
const allThreads = [...ordered, ...hidden];
const batch = computeThreadMoveAvailability({
ordered,
allThreads,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
});
expect(Object.fromEntries(batch)).toEqual({
[`${environment}:t0`]: { canMoveUp: false, canMoveDown: false },
});
expect(Object.fromEntries(batch)).toEqual(
Object.fromEntries(referenceAvailability(ordered, allThreads, WRITABLE)),
);
}
});
it("denies rows whose section has non-writable neighbours when the fast path fails", () => {
const rows = [
makeRow("t0", "env-w", null, true),
makeRow("t1", "env-x", "c", true),
makeRow("t2", "env-w", "d", true),
];
const batch = computeThreadMoveAvailability({
ordered: rows,
allThreads: rows,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
});
const reference = referenceAvailability(rows, rows, WRITABLE);
expect(Object.fromEntries(batch)).toEqual(Object.fromEntries(reference));
expect(batch.get("env-x:t1")).toEqual({ canMoveUp: false, canMoveDown: false });
});
it("agrees on a section where every adjacency midpoint is a hidden reserved key", () => {
const visibleKeys = generateSpreadPinOrderKeys(24);
const hiddenKeys = visibleKeys
.slice(0, -1)
.map((key, index) => pinOrderKeyBetween(key, visibleKeys[index + 1]!))
.filter((key): key is string => key != null);
const ordered = visibleKeys.map((key, index) => makeRow(`v${index}`, "env-w", key, true));
const hidden = hiddenKeys.map((key, index) => makeRow(`h${index}`, "env-w", key, true));
const allThreads = [...ordered, ...hidden];
const batch = computeThreadMoveAvailability({
ordered,
allThreads,
section: "pinned",
reorderableEnvironmentIds: WRITABLE,
});
const reference = referenceAvailability(ordered, allThreads, WRITABLE);
expect(Object.fromEntries(batch)).toEqual(Object.fromEntries(reference));
});
});