forked from longtao.wu/droboticflow
208 lines
6.6 KiB
JavaScript
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);
|
|
}
|
|
});
|