droboticflow/tests/frontend/annotation-work-mode.test.mjs

208 lines
6.6 KiB
JavaScript

import test from "node:test";
import assert from "node:assert/strict";
import {
readContinuousWorkMode,
writeContinuousWorkMode,
refillAnnotationWorkBuffer,
hasDirectedAnnotationRework,
} from "../../src/lib/annotation-work-mode.js";
test("isolated source failures do not stop normal rework allocation", () => {
const item = {
currentStageId: "annotation_combined",
reviewRound: 1,
status: "rework",
sourceValidationStatus: "failed",
};
assert.equal(hasDirectedAnnotationRework([item]), false);
assert.equal(hasDirectedAnnotationRework([{ ...item, sourceValidationStatus: "" }]), true);
});
const storage = () => {
const values = new Map();
return { getItem: (key) => values.get(key) ?? null, setItem: (key, value) => values.set(key, value) };
};
test("manual by default; explicit account choice survives reload without leaking to another account", () => {
const store = storage();
assert.equal(readContinuousWorkMode("alice", store), false);
writeContinuousWorkMode("alice", true, store);
assert.equal(readContinuousWorkMode("alice", store), true);
assert.equal(readContinuousWorkMode("bob", store), false);
writeContinuousWorkMode("alice", false, store);
assert.equal(readContinuousWorkMode("alice", store), false);
const broken = {
getItem() {
throw Error("blocked");
},
setItem() {
throw Error("blocked");
},
};
assert.equal(readContinuousWorkMode("alice", broken), false);
assert.throws(() => writeContinuousWorkMode("alice", true, broken));
});
test("manual reconciliation never claims; returned owned rework stops refill after one request", async () => {
let claims = 0;
const item = { id: "rework" };
const buffer = { enabled: true, occupied: 1, capacity: 8, items: [item] };
const options = {
readBuffer: async () => buffer,
claim: async () => {
claims++;
return { item, task: { id: "task" } };
},
shouldContinue: () => true,
onClaim: () => {},
};
await refillAnnotationWorkBuffer({ ...options, refill: false });
assert.equal(claims, 0);
await refillAnnotationWorkBuffer({ ...options, refill: true });
assert.equal(claims, 1);
});
test("fresh allocations stop at capacity and an empty response stops immediately", async () => {
let items = [],
claims = 0;
const options = {
readBuffer: async () => ({ enabled: true, occupied: items.length, capacity: 3, items: [...items] }),
claim: async () => {
claims++;
const item = { id: String(claims) };
items.push(item);
return { item, task: { id: "task" } };
},
shouldContinue: () => true,
onClaim: () => {},
refill: true,
};
const result = await refillAnnotationWorkBuffer(options);
assert.equal(claims, 3);
assert.equal(result.occupied, 3);
let empty = 0;
await refillAnnotationWorkBuffer({
...options,
readBuffer: async () => ({ enabled: true, occupied: 0, capacity: 8, items: [] }),
claim: async () => {
empty++;
return { item: null };
},
});
assert.equal(empty, 1);
});
test("off during a request keeps its confirmed allocation but prevents another request", async () => {
let enabled = true,
seen = 0,
claims = 0,
items = [];
let release;
const pending = new Promise((r) => (release = r));
const operation = refillAnnotationWorkBuffer({
refill: true,
readBuffer: async () => ({ enabled: true, occupied: items.length, capacity: 8, items: [...items] }),
shouldContinue: () => enabled,
onClaim: () => seen++,
claim: async () => {
claims++;
await pending;
const item = { id: "confirmed" };
items.push(item);
return { item, task: { id: "task" } };
},
});
await Promise.resolve();
enabled = false;
release();
await operation;
assert.equal(claims, 1);
assert.equal(seen, 1);
});
test("unchanged occupancy and pathological capacities cannot produce an unbounded loop", async () => {
let claims = 0;
await refillAnnotationWorkBuffer({
refill: true,
readBuffer: async () => ({ enabled: true, occupied: 1, capacity: 8, items: [] }),
shouldContinue: () => true,
onClaim: () => {},
claim: async () => ({ item: { id: String(++claims) }, task: {} }),
});
assert.equal(claims, 1);
});
test("known directed rework blocks every automatic refill poll until submitted", async () => {
let claims = 0;
const items = [{ id: "owned-rework", reviewRound: 1, status: "claimed", currentStageId: "annotation_combined" }];
const options = {
refill: true,
readBuffer: async () => ({ enabled: true, occupied: 1, capacity: 8, items }),
shouldContinue: () => true,
onClaim: () => {},
claim: async () => {
claims++;
return { item: items[0], task: {} };
},
};
await refillAnnotationWorkBuffer(options);
await refillAnnotationWorkBuffer(options);
assert.equal(claims, 0);
});
test("off still stops this document when browser refuses to persist the choice", () => {
const store = {
getItem: () => "on",
setItem() {
throw Error("quota");
},
};
assert.equal(readContinuousWorkMode("quota-user", store), true);
assert.throws(() => writeContinuousWorkMode("quota-user", false, store));
assert.equal(readContinuousWorkMode("quota-user", store), false);
});
test("summary buffer preserves directed rework priority without requiring task payload", async () => {
let claims = 0;
const result = await refillAnnotationWorkBuffer({
readBuffer: async () => ({
enabled: true,
capacity: 4,
occupied: 1,
summaries: [{ id: "rework", currentStageId: "annotation_combined", reviewRound: 2, status: "rework" }],
}),
claim: async () => {
claims++;
return {};
},
shouldContinue: () => true,
onClaim: () => {},
refill: true,
});
assert.equal(claims, 0);
assert.equal(result.summaries[0].id, "rework");
});
test("inherited rework leaves ordinary refill available in item and summary modes", async () => {
for (const field of ["items", "summaries"]) {
let claims = 0;
const rows = [
{
id: "inherited",
inheritedRework: true,
reviewRound: 2,
status: "claimed",
currentStageId: "annotation_combined",
},
];
const result = await refillAnnotationWorkBuffer({
refill: true,
readBuffer: async () => ({ enabled: true, occupied: rows.length, capacity: 2, [field]: [...rows] }),
shouldContinue: () => true,
onClaim: () => {},
claim: async () => {
claims++;
const item = { id: "new-task" };
rows.push(item);
return { item, task: { id: "new-task" } };
},
});
assert.equal(claims, 1);
assert.equal(result.occupied, 2);
}
});