wehub-resource-sync
120 lines
4.5 KiB
JavaScript
120 lines
4.5 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* Over-limit gate smoke test — the premise the self-learning "teach a workflow"
|
|
* loop rests on.
|
|
*
|
|
* The narrated teach loop has the agent recall a saved procedure and apply it to
|
|
* a *different* over-limit charge. That only clears the charge if the gate is
|
|
* lifted *exclusively* by a finalized exception filed under a JUSTIFYING code
|
|
* (see src/lib/store.ts `hasApprovedException` +
|
|
* src/app/api/v1/policy-exception-codes.ts `isJustifying`). The Save card echoes
|
|
* the demonstrated justifying code (EXC-BOARD-APPROVED) back to the agent as the
|
|
* canonical procedure; if a non-justifying code also cleared the gate, or a
|
|
* justifying one didn't, that procedure would be wrong. This guards that premise.
|
|
*
|
|
* Proves, against the running demo server, on one over-limit transaction:
|
|
* 1. approve with NO exception → 422 OVER_POLICY_LIMIT (precondition)
|
|
* 2. approve after a NON-justifying exception → 422 OVER_POLICY_LIMIT (does not unlock)
|
|
* 3. approve after a JUSTIFYING exception → 201 (unlocks)
|
|
*
|
|
* The in-memory store mutates (step 3 approves the txn), so run this against a
|
|
* freshly-started server, and restart the server before a live demo.
|
|
*
|
|
* Usage:
|
|
* node scripts/over-limit-gate-smoke.mjs
|
|
* Env (optional):
|
|
* DEMO_URL default http://localhost:3000
|
|
* GATE_TXN_ID default t-3 (an over-limit pending seed txn NOT used in the demo beats)
|
|
*/
|
|
|
|
const DEMO_URL = process.env.DEMO_URL ?? "http://localhost:3000";
|
|
const TXN_ID = process.env.GATE_TXN_ID ?? "t-3";
|
|
|
|
// EXC-BOARD-APPROVED must stay in sync with the justifying code the Save card's
|
|
// CANONICAL_PROCEDURE echoes to the agent (src/app/page.tsx).
|
|
const JUSTIFYING_CODE = "EXC-BOARD-APPROVED";
|
|
const NON_JUSTIFYING_CODE = "EXC-WILL-REIMBURSE";
|
|
|
|
const results = [];
|
|
function check(name, ok, detail) {
|
|
results.push({ name, ok });
|
|
console.log(`${ok ? "✓" : "✗"} ${name}${detail ? ` — ${detail}` : ""}`);
|
|
return ok;
|
|
}
|
|
|
|
async function approve(id) {
|
|
const res = await fetch(`${DEMO_URL}/api/v1/transactions/${id}`, {
|
|
method: "PUT",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ status: "approved" }),
|
|
});
|
|
const body = await res.json().catch(() => null);
|
|
return { status: res.status, body };
|
|
}
|
|
|
|
async function openException(transactionId, code) {
|
|
const res = await fetch(`${DEMO_URL}/api/v1/exceptions`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ transactionId, code }),
|
|
});
|
|
const body = await res.json().catch(() => null);
|
|
if (!res.ok) throw new Error(`open ${code}: HTTP ${res.status}`);
|
|
return body.id;
|
|
}
|
|
|
|
async function finalize(exceptionId) {
|
|
const res = await fetch(
|
|
`${DEMO_URL}/api/v1/exceptions/${exceptionId}/finalize`,
|
|
{ method: "POST", headers: { "Content-Type": "application/json" } },
|
|
);
|
|
if (!res.ok) throw new Error(`finalize ${exceptionId}: HTTP ${res.status}`);
|
|
}
|
|
|
|
console.log(`over-limit gate smoke — ${DEMO_URL}, txn ${TXN_ID}\n`);
|
|
|
|
try {
|
|
// 1. Precondition: the seed txn is over its policy limit and unapproved.
|
|
const pre = await approve(TXN_ID);
|
|
check(
|
|
"1. approve with no exception is rejected",
|
|
pre.status === 422 && pre.body?.error === "OVER_POLICY_LIMIT",
|
|
`HTTP ${pre.status} ${pre.body?.error ?? ""}`,
|
|
);
|
|
|
|
// 2. A non-justifying exception files but does NOT lift the gate.
|
|
const nonJustId = await openException(TXN_ID, NON_JUSTIFYING_CODE);
|
|
await finalize(nonJustId);
|
|
const afterNonJust = await approve(TXN_ID);
|
|
check(
|
|
"2. non-justifying exception does not unlock approval",
|
|
afterNonJust.status === 422 &&
|
|
afterNonJust.body?.error === "OVER_POLICY_LIMIT",
|
|
`HTTP ${afterNonJust.status} ${afterNonJust.body?.error ?? ""}`,
|
|
);
|
|
|
|
// 3. A justifying exception lifts the gate — approval now succeeds.
|
|
const justId = await openException(TXN_ID, JUSTIFYING_CODE);
|
|
await finalize(justId);
|
|
const afterJust = await approve(TXN_ID);
|
|
check(
|
|
"3. justifying exception unlocks approval",
|
|
afterJust.status === 201,
|
|
`HTTP ${afterJust.status}`,
|
|
);
|
|
} catch (error) {
|
|
check("gate smoke", false, String(error).slice(0, 200));
|
|
}
|
|
|
|
const failed = results.filter((r) => !r.ok);
|
|
console.log(
|
|
`\n${failed.length === 0 ? "PASS" : "FAIL"} — ${results.length - failed.length}/${results.length} checks passed`,
|
|
);
|
|
if (failed.length > 0) {
|
|
console.log(
|
|
"hint: run against a FRESHLY-started server (the in-memory store mutates; " +
|
|
"a prior run leaves the txn approved). Confirm the seed txn is over-limit.",
|
|
);
|
|
}
|
|
process.exit(failed.length === 0 ? 0 : 1);
|