@bongos/core 1.19.1059 → 1.19.1061

package/tests/fixtures/page-ledger.mjs

@@ -0,0 +1,206 @@
+// tests/fixtures/page-ledger.mjs — a STATEFUL fake pool for Tweak Mode's
+// whole-path tests: a small in-memory tasks / claims / builders /
+// copy_desk_flags ledger that answers the SQL the real copy-desk routes and the
+// real lifecycle port send (the page claim, task 1004317 / TW06; the page reads
+// and the recommendation, task 1004318 / TW07).
+//
+// The page's advisory lock is modelled as a real mutex, so a "two artists at
+// once" case is a race the lock has to win, not two calls in a row. Every
+// statement yields first, so concurrent requests really interleave.
+//
+// An unknown statement THROWS: a route that sends SQL this ledger does not
+// model fails loudly instead of reading an empty answer.
+//
+// Shared by tests/copy_desk_page_claim.mjs, tests/copy_desk_page_next.mjs and
+// tests/copy_desk_page_submit.mjs
+// (a fixture, not a test: the runner discovers tests/*.mjs only).
+
+import { strict as assert } from 'node:assert';
+
+const flat = (sql) => String(sql).replace(/\s+/g, ' ').trim();
+
+export function installPageLedger(api, { builders }) {
+  const db = {
+    builders: new Map(builders.map((b) => [String(b.id), { status: 'active', ...b, id: String(b.id) }])),
+    tasks: [],
+    claims: [],
+    flags: [],
+    grades: new Map(),
+    seq: { task: 5000, claim: 9000, flag: 100 },
+    building: true,
+  };
+  const seen = [];
+
+  // The advisory lock, as a mutex per key: a second locker waits until the
+  // first commits or rolls back.
+  const locks = new Map();
+  async function lock(key, owner) {
+    while (locks.has(key)) await locks.get(key).done;
+    let release;
+    const done = new Promise((r) => { release = r; });
+    locks.set(key, { owner, done, release });
+  }
+  function unlockAll(owner) {
+    for (const [k, v] of [...locks]) if (v.owner === owner) { locks.delete(k); v.release(); }
+  }
+
+  const activeClaim = (taskId) => db.claims.find((x) => String(x.task_id) === String(taskId) && x.released_at == null) || null;
+  const isWeb = (c) => c.worktree_name == null && c.creator_session_id == null;
+
+  // listPageTweakTasks' row, column for column (modules/lifecycle/page-tweak-reads.js).
+  function pageTweakRow(t) {
+    const ac = activeClaim(t.id);
+    const web = db.claims.filter((c) => String(c.task_id) === String(t.id) && isWeb(c)).slice(-1)[0] || null;
+    const hb = ac ? db.builders.get(String(ac.builder_id)) : null;
+    const ab = web ? db.builders.get(String(web.builder_id)) : null;
+    return {
+      id: t.id, status: t.status, title: t.title, description: t.description, source_ref: t.source_ref, touches: t.touches,
+      shipped_at: t.shipped_at || null, created_at: t.created_at || null, updated_at: t.updated_at || null,
+      grade_passed: db.grades.has(String(t.id)) ? db.grades.get(String(t.id)) : null,
+      holder_id: ac ? ac.builder_id : null, holder_login: hb ? hb.github_login : null,
+      holder_worktree: ac ? ac.worktree_name != null : null,
+      artist_id: web ? web.builder_id : null, artist_login: ab ? ab.github_login : null,
+    };
+  }
+
+  async function answer(q, p, owner) {
+    seen.push(q);
+    await new Promise((r) => setImmediate(r));
+    if (/^(BEGIN|COMMIT|ROLLBACK)$/.test(q)) {
+      if (q !== 'BEGIN') unlockAll(owner);
+      return { rows: [] };
+    }
+    if (/pg_advisory_xact_lock\(hashtext\(\$1\)\)/.test(q)) {
+      assert.ok(owner, 'the page lock must be taken on the transaction client');
+      await lock(p[0], owner);
+      return { rows: [] };
+    }
+    if (/^SELECT id, status, github_login, display_name FROM builders WHERE id = \$1/.test(q)) {
+      const b = db.builders.get(String(p[0]));
+      return { rows: b ? [b] : [] };
+    }
+    if (/^SELECT preferred_disciplines FROM builders WHERE id = \$1/.test(q)) {
+      const b = db.builders.get(String(p[0]));
+      return { rows: b ? [{ preferred_disciplines: b.preferred_disciplines }] : [] };
+    }
+    if (/FROM tasks WHERE source = \$1 AND left\(source_ref, length\(\$2\)\) = \$2 ORDER BY id ASC FOR UPDATE/.test(q)) {
+      return { rows: db.tasks.filter((t) => t.source === p[0] && String(t.source_ref).startsWith(p[1])).map((t) => ({ ...t })) };
+    }
+    if (/FROM claims c JOIN builders b ON b\.id = c\.builder_id WHERE c\.task_id = \$1 AND c\.released_at IS NULL/.test(q)) {
+      const c = activeClaim(p[0]);
+      if (!c) return { rows: [] };
+      const b = db.builders.get(String(c.builder_id));
+      return { rows: [{ ...c, github_login: b.github_login, display_name: b.display_name }] };
+    }
+    if (/^INSERT INTO claims \(task_id, builder_id, worktree_name, requested_worktree_name, head_sha, creator_session_id\) VALUES \(\$1, \$2, NULL, NULL, NULL, NULL\)/.test(q)) {
+      if (activeClaim(p[0])) {
+        throw Object.assign(new Error('duplicate key'), { code: '23505', constraint: 'uniq_active_claim_per_task' });
+      }
+      const c = { id: String(++db.seq.claim), task_id: String(p[0]), builder_id: String(p[1]), worktree_name: null, creator_session_id: null, claimed_at: new Date().toISOString(), released_at: null };
+      db.claims.push(c);
+      return { rows: [{ ...c }] };
+    }
+    if (/^UPDATE tasks SET status = 'active', updated_at = now\(\) WHERE id = \$1/.test(q)) {
+      db.tasks.find((t) => String(t.id) === String(p[0])).status = 'active';
+      return { rows: [] };
+    }
+    // createTask's reads: the catch-all goal of the version, and its scope.
+    if (/FROM goals g JOIN versions v ON v\.id = g\.version_id WHERE g\.version_id = \$1 AND g\.title = \$2/.test(q)) {
+      return { rows: [{ id: '77', version_status: 'building' }] };
+    }
+    if (/^SELECT scope_modules FROM goals WHERE id = \$1/.test(q)) return { rows: [{ scope_modules: [] }] };
+    if (/^INSERT INTO tasks \(version_id, title, description, status, touches,/.test(q)) {
+      assert.ok(owner, 'the round must be created inside the claim transaction');
+      const t = {
+        id: String(++db.seq.task), version_id: p[0], title: p[1], description: p[2], status: p[3], touches: p[4],
+        credits_reward: p[10], source: p[11], source_ref: p[12], kind: p[14], discipline: p[15], requires_rank: p[20], goal_id: p[22], created_by: p[23],
+      };
+      db.tasks.push(t);
+      return { rows: [{ ...t }] };
+    }
+    if (/^SELECT id, name, status, scope_doc_path, started_at, shipped_at, done_when FROM versions/.test(q)) {
+      return { rows: db.building ? [{ id: 'V9', name: 'V9', status: 'building' }] : [{ id: 'V8', name: 'V8', status: 'shipped' }] };
+    }
+    // The draft save and the submit (task 1004319 / TW08,
+    // modules/lifecycle/page-tweak-write.js). The task row lock is a real
+    // mutex too, so a raced second submit waits for the first to commit.
+    if (/^SELECT id, status, title, description, source, source_ref, version_id, goal_id, touches FROM tasks WHERE id = \$1 FOR UPDATE$/.test(q)) {
+      assert.ok(owner, 'the task row must be locked on the transaction client');
+      await lock(`task:${p[0]}`, owner);
+      const t = db.tasks.find((x) => String(x.id) === String(p[0]));
+      return { rows: t ? [{ ...t }] : [] };
+    }
+    if (/^UPDATE tasks SET description = \$2, (status = 'ready', )?updated_at = now\(\) WHERE id = \$1 RETURNING id, status, description, source_ref, updated_at$/.test(q)) {
+      assert.ok(owner, 'a description write runs inside the transaction');
+      const t = db.tasks.find((x) => String(x.id) === String(p[0]));
+      t.description = p[1];
+      if (/status = 'ready'/.test(q)) t.status = 'ready';
+      t.updated_at = new Date().toISOString();
+      db.writes = (db.writes || 0) + 1;
+      return { rows: [{ id: t.id, status: t.status, description: t.description, source_ref: t.source_ref, updated_at: t.updated_at }] };
+    }
+    if (/^SELECT id, source_ref FROM tasks WHERE source = \$1 AND source_ref = ANY\(\$2::text\[\]\)$/.test(q)) {
+      return { rows: db.tasks.filter((t) => t.source === p[0] && p[1].includes(t.source_ref)).map((t) => ({ id: t.id, source_ref: t.source_ref })) };
+    }
+    if (/^UPDATE claims SET released_at = now\(\), outcome = \$2 WHERE id = \$1 AND released_at IS NULL$/.test(q)) {
+      const c = db.claims.find((x) => String(x.id) === String(p[0]) && x.released_at == null);
+      if (c) Object.assign(c, { released_at: new Date().toISOString(), outcome: p[1] });
+      return { rows: [] };
+    }
+    // The page reads (listPageTweakTasks), computed from the ledger's state.
+    if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) {
+      assert.match(q, /WHERE t\.source = 'page-tweak'/);
+      // The optional page scope (task 1004319): $1 is the round-ref prefix or null.
+      assert.match(q, /left\(t\.source_ref, length\(\$1::text\)\) = \$1::text/);
+      const prefix = p[0] == null ? null : String(p[0]);
+      (db.pageScopes = db.pageScopes || []).push(prefix);
+      return { rows: db.tasks.filter((t) => t.source === 'page-tweak' && (prefix == null || String(t.source_ref).startsWith(prefix))).map(pageTweakRow) };
+    }
+    // The flag SQL (the page ask).
+    if (/FROM copy_desk_flags f WHERE f\.scope = 'page' AND f\.page_id = \$1 AND f\.flagged_by = \$2 AND f\.status = 'open'/.test(q)) {
+      return { rows: db.flags.filter((x) => x.scope === 'page' && x.page_id === p[0] && String(x.flagged_by) === String(p[1]) && x.status === 'open').slice(0, 1) };
+    }
+    if (/^INSERT INTO copy_desk_flags/.test(q)) {
+      const [scope, surface, stringId, reason, kind, , , , , by, pageId] = p;
+      // The CHECKs of copy_desk_002, so the fake refuses what Postgres would.
+      assert.equal((scope === 'page'), (pageId != null), 'copy_desk_flags_target_chk');
+      if (scope === 'page') assert.equal(surface, pageId, 'copy_desk_flags_page_surface_chk');
+      const dup = db.flags.find((x) => x.status === 'open' && String(x.flagged_by) === String(by) && x.surface === surface && (x.string_id || '') === (stringId || ''));
+      if (dup) throw Object.assign(new Error('dup'), { code: '23505' });
+      const row = { id: String(++db.seq.flag), scope, surface, string_id: stringId, page_id: pageId, reason, kind, flagged_by: String(by), flagged_at: new Date().toISOString(), status: 'open' };
+      db.flags.push(row);
+      return { rows: [{ ...row }] };
+    }
+    if (/COUNT\(DISTINCT flagged_by\)::int AS askers FROM copy_desk_flags WHERE scope = 'page' AND page_id = \$1 AND status = 'open'/.test(q)) {
+      return { rows: [{ askers: new Set(db.flags.filter((x) => x.scope === 'page' && x.page_id === p[0] && x.status === 'open').map((x) => x.flagged_by)).size }] };
+    }
+    // flags.pageAskSummary: open asks grouped by page.
+    if (/^SELECT page_id, COUNT\(DISTINCT flagged_by\)::int AS askers, MIN\(flagged_at\) AS oldest_ask_at FROM copy_desk_flags WHERE scope = 'page' AND status = 'open' GROUP BY page_id$/.test(q)) {
+      const by = new Map();
+      for (const x of db.flags) {
+        if (x.scope !== 'page' || x.status !== 'open') continue;
+        const g = by.get(x.page_id) || { page_id: x.page_id, who: new Set(), oldest: null };
+        g.who.add(String(x.flagged_by));
+        if (!g.oldest || new Date(x.flagged_at) < new Date(g.oldest)) g.oldest = x.flagged_at;
+        by.set(x.page_id, g);
+      }
+      return { rows: [...by.values()].map((g) => ({ page_id: g.page_id, askers: g.who.size, oldest_ask_at: g.oldest })) };
+    }
+    if (/^UPDATE copy_desk_flags SET status = 'resolved', resolved_task_id = \$2, resolved_by = \$3/.test(q)) {
+      const hit = db.flags.filter((x) => x.scope === 'page' && x.page_id === p[0] && x.status === 'open' && new Date(x.flagged_at) <= new Date(p[3]));
+      for (const x of hit) Object.assign(x, { status: 'resolved', resolved_task_id: String(p[1]), resolved_by: String(p[2]), resolution_note: p[4] });
+      return { rows: hit.map((x) => ({ id: x.id })) };
+    }
+    throw new Error(`unexpected SQL: ${q.slice(0, 160)}`);
+  }
+
+  let clientSeq = 0;
+  api.pool = {
+    query: (sql, params = []) => answer(flat(sql), params, null),
+    async connect() {
+      const owner = ++clientSeq;
+      return { query: (sql, params = []) => answer(flat(sql), params, owner), release() { unlockAll(owner); } };
+    },
+  };
+  return { db, seen };
+}