@bongos/core 1.19.646 → 1.19.648

package/tests/patch_value_summary_e2e.mjs

@@ -0,0 +1,142 @@
+// tests/patch_value_summary_e2e.mjs — PATCH /tasks/:id value_summary over real
+// HTTP (task 1003817).
+//
+// WHY A SECOND FILE. migration_allocation.mjs pins the two halves in isolation:
+// the route's schema/gate/write as SOURCE TEXT, and db.updateTaskValueSummary
+// driven against a stubbed pool so the real `SET value_summary =` SQL is proven.
+// Neither exercises the WIRING, and the wiring is where this class of change
+// fails — the whole defect being fixed is a value that reached three consumers
+// and never reached the row. Specifically, source text cannot see that the
+// route's STRICT validator (ADR 0118) actually admits the new field: before this
+// task, `value_summary` on this route was a hard 400 `unknown_field`, and a
+// schema entry that is subtly wrong (mis-typed, mis-named, declared on the
+// create schema instead) fails exactly the same way while every text assertion
+// still passes.
+//
+// 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 and
+// goal_archive_route_e2e.mjs do — the router under test is the shipped one.
+//
+// THE CASES WORTH THE FILE: (2) proves acceptance 1 end to end — a corrected
+// summary reaches the write. (4) and (5) prove acceptance 2 from the other side:
+// an OMITTED field must not touch the row at all, and a whitespace-only one must
+// be refused rather than trimmed into a blank record. `value_summary` is the
+// public shipped-value sentence, so blanking it is the one failure mode that is
+// worse than the bug.
+//
+// Run:  node tests/patch_value_summary_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();
+
+const TASK = { id: 5150, title: 'a task', status: 'completed', version_id: 'BONGOS-V2', value_summary: 'the FIRST ship sentence' };
+
+// Every write the handler can reach, recorded rather than performed — so a test
+// can assert not only what WAS written but that nothing else was.
+let writes = [];
+db.getTask = async () => ({ ...TASK });
+db.updateTaskValueSummary = async (id, v) => { writes.push({ fn: 'value_summary', id, v }); return { ...TASK, value_summary: v }; };
+db.updateTaskTitle = async (id, v) => { writes.push({ fn: 'title', id, v }); return { ...TASK, title: v }; };
+db.updateTaskKind = async (id, v) => { writes.push({ fn: 'kind', id, v }); return { ...TASK, kind: v }; };
+
+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/tasks.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 patch = async (body) => {
+  writes = [];
+  const r = await fetch(`${base}/tasks/${TASK.id}`, {
+    method: 'PATCH',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: r.status, body: await r.json().catch(() => null), writes };
+};
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+console.log('PATCH /tasks/:id value_summary (task 1003817):');
+
+// 1. The regression guard: this is what the route used to do with the field.
+await t('the field is no longer rejected as an unknown field', async () => {
+  const r = await patch({ value_summary: 'anything' });
+  assert.notEqual(r.body && r.body.error, 'unknown_field',
+    'the strict validator must ADMIT value_summary — a missing schema entry looks exactly like the original bug');
+  assert.notEqual(r.body && r.body.error, 'no_supported_fields',
+    'and the supported-fields guard must count it, or a value_summary-only PATCH is refused');
+});
+
+// 2. ACCEPTANCE 1, end to end.
+await t('a corrected summary reaches the write, trimmed', async () => {
+  const r = await patch({ value_summary: '  the CORRECTED sentence  ' });
+  assert.equal(r.status, 200, `expected 200, got ${r.status} ${JSON.stringify(r.body)}`);
+  assert.deepEqual(r.writes, [{ fn: 'value_summary', id: TASK.id, v: 'the CORRECTED sentence' }]);
+});
+
+// 3. It composes with the other planning fields rather than replacing them.
+await t('it can travel with another field in one body', async () => {
+  const r = await patch({ value_summary: 'both', title: 'new title' });
+  assert.equal(r.status, 200);
+  const fns = r.writes.map((w) => w.fn).sort();
+  assert.deepEqual(fns, ['title', 'value_summary']);
+});
+
+// 4. ACCEPTANCE 2, from the route's side.
+await t('ACCEPTANCE 2: an omitted value_summary writes nothing at all', async () => {
+  const r = await patch({ title: 'only the title' });
+  assert.equal(r.status, 200);
+  assert.deepEqual(r.writes.filter((w) => w.fn === 'value_summary'), [],
+    'an omitted field must not reach the column — not even to write back what was there');
+});
+
+// 5. The failure mode worse than the bug.
+await t('a blank or whitespace-only summary is REFUSED, never written', async () => {
+  for (const bad of ['', '   ', '\t\n ']) {
+    const r = await patch({ value_summary: bad });
+    assert.equal(r.status, 400, `${JSON.stringify(bad)} must be refused, got ${r.status}`);
+    assert.deepEqual(r.writes, [], `${JSON.stringify(bad)} must not reach the column`);
+  }
+});
+
+// 6. And the refusal has to be diagnosable, since the caller is usually a script.
+await t('the refusal names the field and says omission is how you leave it alone', async () => {
+  const r = await patch({ value_summary: '   ' });
+  assert.equal(r.body.error, 'bad_value_summary');
+  assert.match(r.body.message, /never blanked/i);
+  assert.match(r.body.message, /omit/i);
+});
+
+// 7. The cap is the shared one, not a number re-typed on this route.
+await t('an over-long summary is refused by the shared LIMITS cap', async () => {
+  const r = await patch({ value_summary: 'x'.repeat(api.LIMITS.VALUE_SUMMARY + 1) });
+  assert.equal(r.status, 400);
+  assert.deepEqual(r.writes, []);
+});
+
+server.close();
+console.log(`\npatch_value_summary_e2e: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/ship_cannot_lie.mjs

@@ -242,15 +242,16 @@ test('the refusal is wired into the regrade path, before any grade spend', () =>
     .replace(/\/\/[^\n]*/g, '')), 'usage does not offer --notes');
 });
 
-test('ACCEPTANCE 3: --summary reaches the GRADER on a re-grade but never the task row', () => {
+test('ACCEPTANCE 3: --summary reaches the grader AND the task row on a re-grade', () => {
   // Task 1003702's third acceptance asked whether --summary reaches the stored
-  // value_summary on a re-grade. It does NOT, and that is a separate defect
-  // filed as task 1003817 (it needs a server route change; this task's fix is
-  // CLI-only). Pinned here rather than left in prose for the reason this whole
-  // file exists: the panel reads the DIFF, so an answer that lives only in ship
-  // notes is an answer nobody can check — which is the very bug task 1003702 is.
+  // value_summary on a re-grade. It did NOT — a separate defect, filed and fixed
+  // as task 1003817, which added value_summary to the PATCH /tasks/:id schema and
+  // the persistRegradeSummary call below. This test used to pin the ABSENCE of a
+  // writer; it now pins its PRESENCE, for the reason this whole file exists: the
+  // panel reads the DIFF, so an answer that lives only in ship notes is an answer
+  // nobody can check — which is the very bug task 1003702 was.
   const src = readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
-  const regrade = src.slice(src.indexOf('async function regradeMain'));
+  const regrade = src.slice(src.indexOf('async function persistRegradeSummary'));
   const code = regrade.replace(/\/\/[^\n]*/g, ''); // comments describe, they do not write
 
   // Half one — the threading is intact, so nothing regressed: --summary still
@@ -261,10 +262,38 @@ test('ACCEPTANCE 3: --summary reaches the GRADER on a re-grade but never the tas
     'the summary still reaches the grader prompt');
   assert.match(code, /valueSummary: summary/, 'and the completion card');
 
-  // Half two — and there is no writer. A `value_summary:` KEY would be a request
-  // payload; the legitimate read is `task.value_summary`, dot-access. If someone
-  // later adds the write (task 1003817), this assertion is what tells them to
-  // update the comment above `const summary` rather than leave it lying.
-  assert.ok(!/[^.]\bvalue_summary\s*:/.test(code),
-    'regradeMain writes value_summary nowhere — see task 1003817');
+  // Half two — and now there IS a writer, wired into the path (the (1) lesson:
+  // a helper nothing calls is not a fix).
+  assert.match(code, /patchTasksId\(\{[\s\S]{0,80}?body: \{ value_summary: next \}/,
+    'persistRegradeSummary PATCHes value_summary onto the task row');
+  assert.match(code, /await persistRegradeSummary\(\{ taskId, summaryArg, task \}\)/,
+    'and regradeMain actually calls it');
+});
+
+test('a re-grade that omits --summary leaves the stored value_summary alone', () => {
+  // ACCEPTANCE 2. The row must survive an omitted flag: `summary` falls back to
+  // task.value_summary, so writing that fallback back would be a no-op at best
+  // and, on any future refactor of the fallback, a way to overwrite the record
+  // with something derived. persistRegradeSummary keys on summaryArg — the RAW
+  // flag — not on the resolved `summary`, and returns before the PATCH when it
+  // is absent. Pinned as source structure because the alternative (a live
+  // re-grade) costs a 4-worker panel run.
+  const src = readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
+  const start = src.indexOf('async function persistRegradeSummary');
+  const fn = src.slice(start, src.indexOf('async function regradeMain', start));
+  const code = fn.replace(/\/\/[^\n]*/g, '');
+
+  // It reads the raw flag, never the resolved fallback.
+  assert.match(code, /const next = \(summaryArg \|\| ''\)\.trim\(\)/,
+    'the guard keys on the raw --summary, not the stored-value fallback');
+
+  // Both early returns precede the only PATCH in the function.
+  const omitted = code.indexOf("reason: 'omitted'");
+  const unchanged = code.indexOf("reason: 'unchanged'");
+  const patch = code.indexOf('patchTasksId');
+  assert.ok(omitted !== -1 && omitted < patch, 'an omitted --summary returns before the write');
+  assert.ok(unchanged !== -1 && unchanged < patch, 'an unchanged --summary returns before the write too');
+
+  // And a failed write never aborts the re-grade — no process.exit, no throw.
+  assert.ok(!/process\.exit/.test(code), 'a summary that will not persist must not kill the re-grade');
 });