@bongos/core 1.19.550 → 1.19.551

package/tests/task_merge.mjs

@@ -0,0 +1,198 @@
+// tests/task_merge.mjs
+//
+// Regression guard for task 1001478 — db.mergeTask, the idea_inbox merge
+// verdict's twin for `tasks` (the /bug-triage counterpart to /idea-triage's
+// merge). See modules/lifecycle/db-ship.js's mergeTask header for the full
+// design rationale (why 'abandoned' + merged_into_task_id, not a new status).
+//
+// Contract under test:
+//   - a live task merges into an existing, unmerged target: status flips to
+//     'abandoned', merged_into_task_id/triage_note/value_summary are written,
+//     the txn COMMITs.
+//   - self-merge → MERGE_SELF, no DB read even reached.
+//   - not found → TASK_NOT_FOUND, ROLLBACK.
+//   - 'shipped' → CANNOT_MERGE_SHIPPED, ROLLBACK, no UPDATE (immutable history).
+//   - already merged into the SAME target → idempotent no-op (alreadyMerged:true).
+//   - already merged into a DIFFERENT target → ALREADY_MERGED, names the
+//     existing target (no re-merge chains).
+//   - active claim → TASK_HAS_ACTIVE_CLAIM, ROLLBACK, no UPDATE.
+//   - the shipped/already-merged guards short-circuit BEFORE the claims lookup.
+//   - target doesn't exist → MERGE_TARGET_NOT_FOUND.
+//   - target is itself merged elsewhere → MERGE_TARGET_MERGED, names where the
+//     chain ends (mirrors idea merge's target-COLUMN check, not target status).
+//   - no reason → value_summary is PRESERVED (no synthesized default;
+//     merged_into_task_id is the queryable source of truth).
+//
+// mergeTask opens its own transaction via pool.connect(); the #538 deps.pool
+// injection seam (honored ONLY when NODE_ENV==='test') drives it with a
+// SQL-aware fakeClient — no live DB — same posture as abandon_task.mjs.
+//
+// Run:  node tests/task_merge.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+const db = require('../modules/lifecycle/db.js');
+const { mergeTask } = db;
+
+const { test, summary } = makeRunner();
+
+// SQL-aware fake keyed on the two SELECTs mergeTask issues, by which id they
+// target — the source row (FOR UPDATE, taskId) and the target row (no lock,
+// intoTaskId). Distinguishing by bound param (not statement text, since both
+// are structurally different queries here) mirrors abandon_task.mjs's shape.
+function fakePool({
+  status = 'ready', notFound = false, mergedInto = null,
+  hasActiveClaim = false, targetNotFound = false, targetMergedInto = null,
+  updatedStatus = 'abandoned',
+} = {}) {
+  return makeSqlAwareClient((s, params) => {
+    if (/^SELECT id, title, status, merged_into_task_id FROM tasks WHERE id = \$1 FOR UPDATE/.test(s)) {
+      return { rows: notFound ? [] : [{ id: params[0], title: 'fixture bug', status, merged_into_task_id: mergedInto }] };
+    }
+    if (/^SELECT id FROM claims WHERE task_id = \$1 AND released_at IS NULL/.test(s)) {
+      return { rows: hasActiveClaim ? [{ id: 999 }] : [] };
+    }
+    if (/^SELECT id, merged_into_task_id FROM tasks WHERE id = \$1/.test(s)) {
+      return { rows: targetNotFound ? [] : [{ id: params[0], merged_into_task_id: targetMergedInto }] };
+    }
+    if (/^UPDATE tasks/.test(s)) {
+      return { rows: [{ id: params[0], title: 'fixture bug', status: updatedStatus }] };
+    }
+    return { rows: [] };   // BEGIN / COMMIT / ROLLBACK
+  });
+}
+
+const find = (queries, re) => queries.find((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+const all = (queries, re) => queries.filter((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+
+const TASK = 1001;
+const TARGET = 2002;
+
+// =========================================================================
+await test('merge: a ready task merges into an existing target, COMMITs', async () => {
+  const pool = fakePool({ status: 'ready' });
+  const out = await mergeTask({ taskId: TASK, intoTaskId: TARGET, reason: 'same report' }, { pool });
+
+  assert.equal(out.taskStatus, 'abandoned');
+  assert.equal(out.previousStatus, 'ready');
+  assert.equal(out.mergedIntoTaskId, TARGET);
+  assert.equal(out.alreadyMerged, false);
+  assert.ok(find(pool._client.queries, /^UPDATE tasks/), 'the tasks UPDATE must run');
+  assert.ok(find(pool._client.queries, /^COMMIT/), 'must COMMIT');
+  assert.ok(!find(pool._client.queries, /^ROLLBACK/), 'no ROLLBACK on the happy path');
+});
+
+await test('merge: writes merged_into_task_id + triage_note + reason-derived value_summary', async () => {
+  const pool = fakePool({ status: 'ready' });
+  await mergeTask({ taskId: TASK, intoTaskId: TARGET, reason: 'dup of #2002' }, { pool });
+  const upd = find(pool._client.queries, /^UPDATE tasks/);
+  assert.equal(upd.params[0], TASK);
+  assert.equal(upd.params[1], TARGET);
+  assert.equal(upd.params[2], 'dup of #2002');
+  assert.match(String(upd.sql), /merged_into_task_id = \$2/);
+  assert.match(String(upd.sql), /triage_note = NULLIF/);
+});
+
+await test('merge: no reason PRESERVES the existing value_summary (no synthesized default)', async () => {
+  // Round-2 grade finding: an earlier version fell back to a synthesized
+  // "Merged into #<N>" default, which unconditionally overwrote a
+  // completed/confirmed bug task's real value_summary. mergeTask now matches
+  // abandonTask's own COALESCE(NULLIF($n,''), value_summary) shape exactly —
+  // merged_into_task_id is the queryable source of truth for where it went.
+  const pool = fakePool({ status: 'ready' });
+  await mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool });
+  const upd = find(pool._client.queries, /^UPDATE tasks/);
+  assert.equal(upd.params[2], '', 'empty reason binds empty string');
+  assert.match(String(upd.sql), /COALESCE\(NULLIF\(\$3, ''\), value_summary\)/);
+});
+
+await test('merge: self-merge is refused before any SELECT (right after BEGIN)', async () => {
+  const pool = fakePool({ status: 'ready' });
+  await assert.rejects(
+    () => mergeTask({ taskId: TASK, intoTaskId: TASK }, { pool }),
+    (err) => err.code === 'MERGE_SELF',
+  );
+  assert.equal(all(pool._client.queries, /^SELECT/).length, 0, 'no SELECT reached — the check runs before the task row is even locked');
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('merge: a missing task throws TASK_NOT_FOUND and rolls back', async () => {
+  const pool = fakePool({ notFound: true });
+  await assert.rejects(
+    () => mergeTask({ taskId: 424242, intoTaskId: TARGET }, { pool }),
+    (err) => err.code === 'TASK_NOT_FOUND',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('merge: a shipped task is refused (immutable history) and rolls back', async () => {
+  const pool = fakePool({ status: 'shipped' });
+  await assert.rejects(
+    () => mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool }),
+    (err) => err.code === 'CANNOT_MERGE_SHIPPED',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('merge: the shipped guard short-circuits BEFORE the claims lookup', async () => {
+  const pool = fakePool({ status: 'shipped' });
+  await mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool }).catch(() => {});
+  assert.equal(all(pool._client.queries, /SELECT id FROM claims/).length, 0,
+    'a shipped task must not even query claims');
+});
+
+await test('merge: already merged into the SAME target is an idempotent no-op', async () => {
+  const pool = fakePool({ status: 'abandoned', mergedInto: TARGET });
+  const out = await mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool });
+  assert.equal(out.alreadyMerged, true);
+  assert.equal(out.mergedIntoTaskId, TARGET);
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0, 'idempotent — no second UPDATE');
+  assert.equal(all(pool._client.queries, /SELECT id FROM claims/).length, 0, 'no claims lookup needed');
+  assert.ok(find(pool._client.queries, /^COMMIT/), 'still COMMITs the (empty) txn');
+});
+
+await test('merge: already merged into a DIFFERENT target is refused, naming the existing one', async () => {
+  const pool = fakePool({ status: 'abandoned', mergedInto: 5005 });
+  const err = await mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool }).catch((e) => e);
+  assert.equal(err.code, 'ALREADY_MERGED');
+  assert.equal(err.merged_into, '5005');
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+});
+
+await test('merge: a task with an active claim is refused (release first) and rolls back', async () => {
+  const pool = fakePool({ status: 'ready', hasActiveClaim: true });
+  await assert.rejects(
+    () => mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool }),
+    (err) => err.code === 'TASK_HAS_ACTIVE_CLAIM',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('merge: a nonexistent target throws MERGE_TARGET_NOT_FOUND and rolls back', async () => {
+  const pool = fakePool({ status: 'ready', targetNotFound: true });
+  await assert.rejects(
+    () => mergeTask({ taskId: TASK, intoTaskId: 999999 }, { pool }),
+    (err) => err.code === 'MERGE_TARGET_NOT_FOUND',
+  );
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+await test('merge: a target that is itself merged elsewhere is refused, naming where the chain ends', async () => {
+  const pool = fakePool({ status: 'ready', targetMergedInto: 7007 });
+  const err = await mergeTask({ taskId: TASK, intoTaskId: TARGET }, { pool }).catch((e) => e);
+  assert.equal(err.code, 'MERGE_TARGET_MERGED');
+  assert.equal(err.merged_into, '7007');
+  assert.equal(all(pool._client.queries, /^UPDATE tasks/).length, 0);
+});
+
+// -------------------------------------------------------------------------
+summary();