@bongos/core 1.19.588 → 1.19.590

package/tests/goal_archive_route_e2e.mjs

@@ -0,0 +1,135 @@
+// tests/goal_archive_route_e2e.mjs — the archive two-step over real HTTP
+// (BV1.R14, task 1003601, goal 1000086, ADR 0250 D3).
+//
+// WHY A SECOND FILE. goal_archive_disposition.mjs pins the two halves in
+// isolation — the pure planner's truth table, and the writer's transaction shape
+// against a fake pool. Neither exercises the WIRING: that the route reads the
+// body it declares, calls the planner with the right arguments, renders its
+// verdict verbatim, resolves move targets BEFORE writing, and hands the writer a
+// plan. Every one of those is a place a correct planner and a correct writer can
+// still add up to a broken endpoint, and each was a real risk on this change
+// (the route previously read no body at all).
+//
+// So this drives the REAL router over a real socket, with the db layer stubbed at
+// the module boundary the way task_visual_route_gate.mjs does — the router under
+// test is the shipped one, not a re-assembly of it.
+//
+// THE CASE WORTH THE FILE ON ITS OWN is #6: a typo'd `disposition` (singular).
+// Without the ADR 0118 schema the handler reads `req.body.dispositions` as
+// undefined and takes the REFUSAL branch — so a caller who wrote a complete map
+// under a misspelled key is told the goal holds open work, which is true,
+// unhelpful, and indistinguishable from having sent nothing. That is the failure
+// shape that teaches an agent to retry with a different map instead of fixing the
+// key.
+//
+// Run:  node tests/goal_archive_route_e2e.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+process.env.NODE_ENV = 'test';
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const db = require('../modules/lifecycle/db.js');
+
+api.requireBuilder = (req, _res, next) => { req.builder = { id: '3', rank: 'archon' }; next(); };
+api.requirePermission = () => (req, _res, next) => next();
+
+let GOALS = {
+  7:  { id: 7, status: 'open', title: 'cut me', version_id: 'BONGOS-V1' },
+  42: { id: 42, status: 'open', title: 'survivor', version_id: 'BONGOS-V1' },
+  99: { id: 99, status: 'archived', title: 'closed', version_id: 'BONGOS-V1' },
+};
+let OPEN = [{ id: '1', title: 'one', status: 'ready' }, { id: '2', title: 'two', status: 'active' }];
+let applied = null;
+db.getGoal = async (id) => GOALS[Number(id)] ?? null;
+db.isGoalMember = async () => true;
+db.openTasksInGoal = async () => ({ total: OPEN.length, tasks: OPEN });
+db.setGoalStatus = async ({ goalId }) => ({ ...GOALS[goalId], status: 'archived' });
+db.archiveGoalWithDispositions = async ({ goalId, plan, reason }) => {
+  applied = { goalId, plan, reason };
+  return { goal: { ...GOALS[goalId], status: 'archived' }, applied: plan.map(p => ({ task_id: String(p.taskId), verb: p.verb, result: p.verb === 'abandon' ? 'abandoned' : 'moved' })) };
+};
+
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, statusOrOpts, details) => {
+    const o = typeof statusOrOpts === 'number' ? { status: statusOrOpts } : (statusOrOpts || {});
+    return res.status(o.status || 400).json({ error: code, message: o.message, details: o.details ?? details });
+  };
+  next();
+});
+app.use('/api/gds', require('../modules/lifecycle/routes/goals.js')());
+const server = app.listen(0);
+await new Promise(r => server.once('listening', r));
+const base = `http://127.0.0.1:${server.address().port}/api/gds`;
+const post = async (p, body) => {
+  const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+  return { status: r.status, body: await r.json().catch(() => null) };
+};
+
+let n = 0; const ok = (m) => { n++; console.log('  ✓', m); };
+
+// 1. bare archive of a goal holding work → the R10 refusal, WITH the tasks
+let r = await post('/goals/7/archive');
+assert.equal(r.status, 409); assert.equal(r.body.error, 'goal_holds_open_tasks');
+assert.equal(r.body.details.tasks.length, 2);
+ok('bare archive refuses 409 goal_holds_open_tasks and returns both tasks');
+
+// 2. a partial map → refused, names the undecided task
+r = await post('/goals/7/archive', { reason: 'cut', dispositions: { 1: { verb: 'abandon' } } });
+assert.equal(r.status, 400); assert.equal(r.body.error, 'disposition_incomplete');
+assert.deepEqual(r.body.details.tasks.map(t => t.id), ['2']);
+ok('partial map refuses 400 disposition_incomplete, naming task 2');
+
+// 3. complete map with no reason → refused
+r = await post('/goals/7/archive', { dispositions: { 1: { verb: 'abandon' }, 2: { verb: 'abandon' } } });
+assert.equal(r.status, 400); assert.equal(r.body.error, 'archive_reason_required');
+ok('an abandon with no reason refuses 400 archive_reason_required');
+
+// 4. move into a CLOSED goal → refused before any write
+applied = null;
+r = await post('/goals/7/archive', { reason: 'cut', dispositions: { 1: { verb: 'move', goal_id: 99 }, 2: { verb: 'abandon' } } });
+assert.equal(r.status, 409); assert.equal(r.body.error, 'bad_disposition');
+assert.equal(applied, null, 'nothing was written');
+ok('move into an archived goal refuses 409 bad_disposition, writing nothing');
+
+// 5. move into the goal being archived → refused
+r = await post('/goals/7/archive', { reason: 'cut', dispositions: { 1: { verb: 'move', goal_id: 7 }, 2: { verb: 'abandon' } } });
+assert.equal(r.status, 400); assert.equal(r.body.error, 'bad_disposition');
+ok('move into the goal being archived refuses 400 bad_disposition');
+
+// 6. unknown body field → rejected by the ADR 0118 schema
+r = await post('/goals/7/archive', { reason: 'cut', disposition: { 1: { verb: 'abandon' } } });
+assert.equal(r.status, 400);
+assert.equal(r.body.error?.code ?? r.body.error, 'validation_failed');
+ok('a typo\'d `disposition` (singular) is rejected as validation_failed, not read as "none given"');
+
+// 7. THE HAPPY PATH — complete map, one abandon + one move
+applied = null;
+r = await post('/goals/7/archive', { reason: 'cut in the ten-areas review', dispositions: { 1: { verb: 'abandon' }, 2: { verb: 'move', goal_id: 42 } } });
+assert.equal(r.status, 200, JSON.stringify(r.body));
+assert.equal(r.body.goal.status, 'archived');
+assert.deepEqual(r.body.applied, [
+  { task_id: '1', verb: 'abandon', result: 'abandoned' },
+  { task_id: '2', verb: 'move', result: 'moved' },
+]);
+assert.deepEqual(applied.plan, [
+  { taskId: 1, verb: 'abandon', toGoalId: null },
+  { taskId: 2, verb: 'move', toGoalId: 42 },
+]);
+assert.equal(applied.reason, 'cut in the ten-areas review');
+ok('a complete map archives the goal and reports what happened to each task');
+
+// 8. a goal holding nothing is still ONE call, no reason needed
+OPEN = [];
+r = await post('/goals/7/archive');
+assert.equal(r.status, 200); assert.equal(r.body.goal.status, 'archived');
+assert.deepEqual(r.body.applied, []);
+ok('a goal holding nothing archives in one call with no reason');
+
+assert.equal(n, 8, 'every check must run — an early return would pass silently');
+console.log(`\n${n}/8 end-to-end checks passed against the real router.`);
+server.close();