@bongos/core 1.19.715 → 1.19.725

package/tests/task_field_bounds_match_db.mjs

@@ -0,0 +1,140 @@
+// tests/task_field_bounds_match_db.mjs
+//
+// task 1002845 — a value the route validator accepts must be one the INSERT
+// accepts. When those two disagree the caller gets an opaque 500 from deep inside
+// the DB, with nothing naming the field.
+//
+// THE DEFECT, measured against the live API before the fix:
+//   POST /tasks {manual_degree: 0}  →  500 {"code":"create_failed","message":"internal error"}
+// TASK_FIELD_BOUNDS said min 0; migrations/003_pms.sql says
+// `manual_degree integer CHECK (manual_degree BETWEEN 1 AND 5)`. The route let 0
+// through, the INSERT raised SQLSTATE 23514, and the generic catch answered
+// "internal error". Idea 1000456 records roughly four blind retries spent on this.
+//
+// This is the SECOND time: task 1233 fixed the identical defect on `priority`
+// (a laxer 0-100 range) and left a comment saying so, and `manual_degree` sat
+// beside it unfixed. So the guard here is not "is manual_degree 1..5" — it is
+// "does EVERY bound in TASK_FIELD_BOUNDS match the DB CHECK it mirrors", derived
+// from the migration rather than hand-copied, so the third instance fails loudly.
+//
+// Run:  node tests/task_field_bounds_match_db.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { TASK_FIELD_BOUNDS } = require(path.join(ROOT, 'modules', 'lifecycle', 'task-classifier.js'));
+const { describeCheckViolation, CHECK_VIOLATION } = require(path.join(ROOT, 'modules', 'lifecycle', 'pg-constraint-fail.js'));
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// Read the DB's own CHECK bounds out of the migrations, newest definition wins.
+// Derived, not hand-copied: a migration that later widens or narrows a CHECK must
+// move this test's expectation with it, which is the whole point.
+function dbCheckBounds(column) {
+  const dir = path.join(ROOT, 'migrations');
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.sql')).sort();
+  assert.ok(files.length > 10, `only ${files.length} migrations read — the sweep is not finding the migrations dir`);
+  const re = new RegExp(`${column}\\s+integer[^,]*?CHECK\\s*\\(\\s*${column}\\s+BETWEEN\\s+(\\d+)\\s+AND\\s+(\\d+)\\s*\\)`, 'i');
+  const alterRe = new RegExp(`ALTER\\s+TABLE[^;]*?${column}[^;]*?BETWEEN\\s+(\\d+)\\s+AND\\s+(\\d+)`, 'is');
+  let found = null;
+  for (const f of files) {
+    const sql = fs.readFileSync(path.join(dir, f), 'utf8');
+    const m = sql.match(re) || sql.match(alterRe);
+    if (m) found = { min: Number(m[1]), max: Number(m[2]), file: f };
+  }
+  return found;
+}
+
+t('the migrations really do declare a CHECK for every bounded field (the scan works)', () => {
+  for (const column of Object.keys(TASK_FIELD_BOUNDS)) {
+    const db = dbCheckBounds(column);
+    assert.ok(db, `no CHECK found for ${column} — either the column lost its constraint or this scan has drifted off the SQL shape`);
+  }
+});
+
+t('every TASK_FIELD_BOUNDS range matches the DB CHECK it mirrors', () => {
+  for (const [column, bounds] of Object.entries(TASK_FIELD_BOUNDS)) {
+    const db = dbCheckBounds(column);
+    assert.equal(bounds.min, db.min,
+      `${column}: validator accepts from ${bounds.min} but the DB CHECK in ${db.file} starts at ${db.min} — a value in between passes the route and dies in the INSERT as an opaque 500`);
+    assert.equal(bounds.max, db.max,
+      `${column}: validator accepts up to ${bounds.max} but the DB CHECK in ${db.file} stops at ${db.max}`);
+  }
+});
+
+t('manual_degree specifically — the regression this task fixed', () => {
+  assert.equal(TASK_FIELD_BOUNDS.manual_degree.min, 1,
+    'min 0 is what let POST /tasks {manual_degree:0} reach the INSERT and 500');
+  assert.equal(TASK_FIELD_BOUNDS.manual_degree.max, 5);
+});
+
+// --- the backstop: when a mismatch DOES slip through, say which constraint ----
+
+t('describeCheckViolation names the constraint on a 23514', () => {
+  const out = describeCheckViolation({ code: CHECK_VIOLATION, constraint: 'tasks_manual_degree_check' });
+  assert.equal(out.status, 400, 'a client-correctable value must not answer 500');
+  assert.equal(out.code, 'constraint_violation');
+  assert.match(out.message, /tasks_manual_degree_check/);
+  assert.equal(out.details.constraint, 'tasks_manual_degree_check');
+});
+
+t('describeCheckViolation NEVER echoes err.detail — it carries the failing row', () => {
+  const out = describeCheckViolation({
+    code: CHECK_VIOLATION,
+    constraint: 'tasks_manual_degree_check',
+    detail: 'Failing row contains (1, a-private-title, sk-live-abc123, 0).',
+    where: 'PL/pgSQL function some_trigger()',
+  });
+  const rendered = JSON.stringify(out);
+  assert.ok(!rendered.includes('Failing row'), 'the row dump must never reach the response body');
+  assert.ok(!rendered.includes('a-private-title'), 'row VALUES must never reach the response body');
+  assert.ok(!rendered.includes('sk-live-abc123'), 'a secret sitting in an adjacent column must never be echoed');
+  assert.ok(!rendered.includes('PL/pgSQL'), 'internal execution context is not the caller\'s business');
+});
+
+t('describeCheckViolation returns null for anything that is not a CHECK violation', () => {
+  assert.equal(describeCheckViolation(null), null);
+  assert.equal(describeCheckViolation(undefined), null);
+  assert.equal(describeCheckViolation({}), null);
+  assert.equal(describeCheckViolation(new Error('boom')), null, 'a plain error must fall through to the generic 500');
+  assert.equal(describeCheckViolation({ code: '23505', constraint: 'x_key' }), null,
+    'a UNIQUE violation is a different problem and must not be relabelled as a bad value');
+  assert.equal(describeCheckViolation({ code: '23503' }), null, 'nor a foreign-key violation');
+});
+
+t('describeCheckViolation still answers 400 when the driver gives no constraint name', () => {
+  const out = describeCheckViolation({ code: CHECK_VIOLATION });
+  assert.equal(out.status, 400);
+  assert.equal(out.details.constraint, null);
+  assert.ok(out.message.length > 0, 'a nameless violation still beats "internal error"');
+});
+
+t('constraint_violation is registered so its CATEGORY agrees with its status', () => {
+  const { categoryForCode, isRetriable } = require(path.join(ROOT, 'src', 'bongos', 'api-errors.js'));
+  assert.equal(categoryForCode('constraint_violation'), 'bad_request',
+    'unregistered it would classify as `internal` — a 400 body labelled a server fault, which tells a retrying client exactly the wrong thing');
+  assert.equal(isRetriable('constraint_violation'), false, 'retrying the same bad value cannot help');
+});
+
+t('the POST /tasks catch actually calls the backstop', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'task-write-routes.js'), 'utf8');
+  const i = src.indexOf("log.error('[gds] POST /tasks'");
+  assert.ok(i !== -1, 'could not find the POST /tasks catch — this guard is reading the wrong shape');
+  const tail = src.slice(i, i + 800);
+  assert.match(tail, /describeCheckViolation\s*\(/, 'the catch must consult the backstop before answering create_failed');
+  assert.ok(tail.indexOf('describeCheckViolation') < tail.indexOf("res.fail('create_failed'"),
+    'the backstop must run BEFORE the generic 500, or it can never fire');
+});
+
+console.log(`\ntask_field_bounds_match_db: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);