@bongos/core 1.23.22 → 1.24.1

package/tests/goal_achievement_reward.mjs

@@ -0,0 +1,205 @@
+// tests/goal_achievement_reward.mjs — the karma a goal's contributors earn when it
+// is achieved (task 1001693 / BV1.P5.3, ADR 0101 Part 3).
+//
+// Three layers: the pure split (contribution-weighted, conserving, owner share,
+// nothing for a goal that shipped nothing); the booking against a recording client
+// (one guarded INSERT on the goal's reason key, so a re-achieve pays nothing); and
+// the lifecycle hook (only the statement that actually flipped a goal awards, once
+// per flipped goal, and a reward failure never fails the caller).
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const {
+  goalRewardSplit, awardGoalAchievementKarma,
+  GOAL_ACHIEVEMENT_KARMA_POOL, GOAL_REASON_PREFIX,
+} = require('../modules/economy/goal-reward.js');
+const seams = require('../src/module-seams.js');
+const reward = require('../modules/economy/reward.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', reward);
+const { autoSatisfyShippedCriteria } = require('../modules/lifecycle/done-when.js');
+
+const sum = (rows) => rows.reduce((t, r) => t + r.delta, 0);
+const byId = (rows) => Object.fromEntries(rows.map((r) => [String(r.builderId), r]));
+
+// ── the pure split ───────────────────────────────────────────────────────────
+
+test('the split follows shipped work and conserves the pool', () => {
+  const rows = goalRewardSplit({
+    contributions: [{ builderId: 1, shipped: 3 }, { builderId: 2, shipped: 1 }],
+    ownerId: null, pool: 8, ownerShare: 0,
+  });
+  assert.equal(sum(rows), 8);
+  assert.equal(byId(rows)['1'].delta, 6);
+  assert.equal(byId(rows)['2'].delta, 2);
+});
+
+test('rounding still conserves the pool and is deterministic', () => {
+  const contributions = [{ builderId: 3, shipped: 1 }, { builderId: 1, shipped: 1 }, { builderId: 2, shipped: 1 }];
+  const a = goalRewardSplit({ contributions, ownerId: null, pool: 10, ownerShare: 0 });
+  const b = goalRewardSplit({ contributions: [...contributions].reverse(), ownerId: null, pool: 10, ownerShare: 0 });
+  assert.equal(sum(a), 10);
+  assert.deepEqual(byId(a), byId(b));
+});
+
+test('joining a goal earns nothing: only builders who shipped are paid', () => {
+  const rows = goalRewardSplit({
+    contributions: [{ builderId: 1, shipped: 2 }, { builderId: 2, shipped: 0 }],
+    ownerId: null, ownerShare: 0,
+  });
+  assert.deepEqual(rows.map((r) => String(r.builderId)), ['1']);
+});
+
+test('the owner takes a coordination share, folded into one row when they also shipped', () => {
+  const asOwnerOnly = goalRewardSplit({ contributions: [{ builderId: 1, shipped: 1 }], ownerId: 9, pool: 10, ownerShare: 0.1 });
+  assert.equal(byId(asOwnerOnly)['9'].delta, 1);
+  assert.equal(byId(asOwnerOnly)['9'].role, 'owner');
+  assert.equal(sum(asOwnerOnly), 10);
+
+  const asBoth = goalRewardSplit({ contributions: [{ builderId: 9, shipped: 1 }, { builderId: 2, shipped: 1 }], ownerId: 9, pool: 10, ownerShare: 0.1 });
+  assert.equal(asBoth.filter((r) => String(r.builderId) === '9').length, 1, 'one row per builder');
+  assert.equal(byId(asBoth)['9'].role, 'owner_contributor');
+  assert.equal(sum(asBoth), 10);
+});
+
+test('a goal that shipped nothing earns nothing, the owner share included', () => {
+  assert.deepEqual(goalRewardSplit({ contributions: [], ownerId: 9 }), []);
+  assert.deepEqual(goalRewardSplit({ contributions: [{ builderId: 1, shipped: 0 }], ownerId: 9 }), []);
+});
+
+test('the default pool is karma-sized, not a money figure', () => {
+  assert.ok(GOAL_ACHIEVEMENT_KARMA_POOL > 0 && GOAL_ACHIEVEMENT_KARMA_POOL <= 50);
+});
+
+// ── the booking ──────────────────────────────────────────────────────────────
+
+function recordingExec({ ownerId = 9, shippers = [{ builder_id: 1, shipped: 2 }], alreadyAwarded = false,
+  insertFails = false, inTx = true } = {}) {
+  const calls = [];
+  return {
+    calls,
+    async query(sql, params) {
+      calls.push({ sql, params });
+      if (/SAVEPOINT/.test(sql)) {
+        if (!inTx) throw new Error('SAVEPOINT can only be used in transaction blocks');
+        return { rows: [] };
+      }
+      if (/^SELECT created_by FROM goals/.test(sql)) return { rows: ownerId === undefined ? [] : [{ created_by: ownerId }] };
+      if (/FROM tasks/.test(sql)) return { rows: shippers };
+      if (/INSERT INTO karma_log/.test(sql)) {
+        if (insertFails) throw new Error('karma_log is unwritable');
+        return { rowCount: alreadyAwarded ? 0 : params[0].length };
+      }
+      throw new Error(`unexpected SQL: ${sql}`);
+    },
+  };
+}
+
+test('booking writes karma, never credits, in one statement guarded on the goal reason', async () => {
+  const exec = recordingExec();
+  const r = await awardGoalAchievementKarma(exec, { goalId: 42 });
+  assert.equal(r.reason, 'awarded');
+  assert.equal(r.awarded, GOAL_ACHIEVEMENT_KARMA_POOL);
+  const inserts = exec.calls.filter((c) => /INSERT/.test(c.sql));
+  assert.equal(inserts.length, 1);
+  assert.match(inserts[0].sql, /INSERT INTO karma_log/);
+  assert.ok(!exec.calls.some((c) => /credit_log/.test(c.sql)), 'no credit is booked');
+  assert.match(inserts[0].sql.replace(/\s+/g, ' '),
+    /NOT EXISTS \(SELECT 1 FROM karma_log WHERE builder_id = ANY\(\$4::bigint\[\]\) AND reason = \$3\)/,
+    'builder-scoped so idx_karma_log_builder serves it, never a scan of all karma');
+  assert.equal(inserts[0].params[2], `${GOAL_REASON_PREFIX}42`);
+});
+
+test('the once-per-goal guard always includes the goal owner, even when they shipped nothing', async () => {
+  // Owner 9 shipped nothing; builder 1 shipped. An earlier award paid the owner,
+  // so the owner must be in the guard set for a re-achieve to be refused.
+  const exec = recordingExec({ ownerId: 9, shippers: [{ builder_id: 1, shipped: 2 }] });
+  await awardGoalAchievementKarma(exec, { goalId: 42 });
+  const insert = exec.calls.find((c) => /INSERT INTO karma_log/.test(c.sql));
+  assert.deepEqual([...insert.params[3]].sort(), ['1', '9']);
+});
+
+test('only shipped, non-smoke tasks of THIS goal count as contribution', async () => {
+  const exec = recordingExec();
+  await awardGoalAchievementKarma(exec, { goalId: 42 });
+  const read = exec.calls.find((c) => /FROM tasks/.test(c.sql));
+  assert.match(read.sql, /goal_id = \$1/);
+  assert.match(read.sql, /status = 'shipped'/);
+  assert.match(read.sql, /smoke/);
+  assert.deepEqual(read.params, [42]);
+});
+
+test('a re-achieved goal pays nothing the second time', async () => {
+  const r = await awardGoalAchievementKarma(recordingExec({ alreadyAwarded: true }), { goalId: 42 });
+  assert.equal(r.awarded, 0);
+  assert.equal(r.reason, 'already_awarded');
+});
+
+test('a goal that shipped nothing writes nothing', async () => {
+  const exec = recordingExec({ shippers: [] });
+  const r = await awardGoalAchievementKarma(exec, { goalId: 42 });
+  assert.equal(r.reason, 'nothing_shipped');
+  assert.ok(!exec.calls.some((c) => /INSERT/.test(c.sql)));
+});
+
+test('a failed karma write rolls back to its savepoint and never throws into the ship', async () => {
+  const exec = recordingExec({ insertFails: true });
+  const r = await awardGoalAchievementKarma(exec, { goalId: 42 });
+  assert.equal(r.reason, 'failed');
+  assert.equal(r.awarded, 0);
+  const sqls = exec.calls.map((c) => c.sql);
+  assert.equal(sqls[0], 'SAVEPOINT goal_achievement_karma');
+  assert.ok(sqls.includes('ROLLBACK TO SAVEPOINT goal_achievement_karma'));
+  assert.ok(!sqls.includes('RELEASE SAVEPOINT goal_achievement_karma'));
+});
+
+test('on the pool (no transaction) the booking still runs, without a savepoint', async () => {
+  const exec = recordingExec({ inTx: false });
+  const r = await awardGoalAchievementKarma(exec, { goalId: 42 });
+  assert.equal(r.reason, 'awarded');
+  assert.ok(!exec.calls.some((c) => /RELEASE|ROLLBACK/.test(c.sql)));
+});
+
+// ── the lifecycle hook ───────────────────────────────────────────────────────
+
+// Drives the REAL ship-time entry, autoSatisfyShippedCriteria scoped to a task:
+// no criterion closes, so it re-checks the shipping task's own goal through the
+// one flip statement. `flipped` is what that UPDATE ... RETURNING hands back.
+function lifecycleExec(flipped) {
+  return {
+    async query(sql) {
+      if (/^\s*UPDATE goals g/.test(sql)) return { rows: flipped.map((id) => ({ id, title: 'g', version_id: 'V', status: 'achieved' })) };
+      if (/SELECT goal_id FROM tasks WHERE id/.test(sql)) return { rows: [{ goal_id: 5 }] };
+      return { rows: [], rowCount: 0 };
+    },
+  };
+}
+const shipFlip = (exec) => autoSatisfyShippedCriteria(exec, { taskId: 77 }).then((r) => r.goals);
+
+async function withStubbedAward(fn, stub) {
+  const original = reward.awardGoalAchievementKarma;
+  reward.awardGoalAchievementKarma = stub;
+  try { return await fn(); } finally { reward.awardGoalAchievementKarma = original; }
+}
+
+test('the goal a ship flipped is rewarded once, on the ship executor', async () => {
+  const seen = [];
+  const exec = lifecycleExec([5]);
+  await withStubbedAward(() => shipFlip(exec),
+    async (e, { goalId }) => { seen.push({ same: e === exec, goalId: Number(goalId) }); return { awarded: 1 }; });
+  assert.deepEqual(seen, [{ same: true, goalId: 5 }]);
+});
+
+test('no flip, no reward: a goal still open or already achieved earns nothing here', async () => {
+  let called = 0;
+  await withStubbedAward(() => shipFlip(lifecycleExec([])), async () => { called += 1; });
+  assert.equal(called, 0);
+});
+
+test('a reward provider that throws never fails the achievement', async () => {
+  const goals = await withStubbedAward(() => shipFlip(lifecycleExec([5])),
+    async () => { throw new Error('karma write failed'); });
+  assert.deepEqual(goals.map((g) => g.id), [5]);
+});

package/tests/goal_sort_staleness.mjs

@@ -101,7 +101,8 @@ await test('the t.* views are rebuilt WITH the column — the core_190 lesson',
 });
 
 await test('createTask appends createdBy at the end of the bind list (the goals convention)', () => {
-  assert.match(DB_TASKS, /goal_id, created_by, promoted_at\)/,
+  // later columns append after it (task 1004950 added `needs`), never before
+  assert.match(DB_TASKS, /goal_id, created_by, promoted_at[,)]/,
     'new columns go on the end so pinned bind orders survive');
 });
 

package/tests/goal_tier.mjs

@@ -174,10 +174,20 @@ await test('setGoalStatus: UPDATE sets status + bumps updated_at, returns the ro
   const out = await setGoalStatus({ goalId: 7, status: 'achieved' }, { pool });
   assert.equal(out.status, 'achieved');
   const upd = find(pool.queries, /^UPDATE goals/);
-  assert.deepEqual(upd.params, [7, 'achieved']);
+  // The third bind is the optional fromStatus guard (task 1001693): null = unconditional.
+  assert.deepEqual(upd.params, [7, 'achieved', null]);
   assert.match(upd.sql, /updated_at = now\(\)/, 'must bump updated_at');
 });
 
+await test('setGoalStatus: fromStatus makes the move conditional, and a lost race returns null', async () => {
+  const pool = fakePool((s) => (/^UPDATE goals/.test(s) ? { rows: [] } : null));
+  const out = await setGoalStatus({ goalId: 7, status: 'achieved', fromStatus: 'open' }, { pool });
+  assert.equal(out, null);
+  const upd = find(pool.queries, /^UPDATE goals/);
+  assert.deepEqual(upd.params, [7, 'achieved', 'open']);
+  assert.match(upd.sql, /status = \$3::text/, 'the guard is in the WHERE, not checked afterwards');
+});
+
 await test('setGoalStatus: unknown goal returns null', async () => {
   const pool = fakePool(() => ({ rows: [] }));
   assert.equal(await setGoalStatus({ goalId: 404, status: 'archived' }, { pool }), null);

package/tests/google_fonts_nonblocking.mjs

@@ -0,0 +1,84 @@
+// tests/google_fonts_nonblocking.mjs — every served page that loads the Google Fonts
+// stylesheet warms both font origins first and asks for font-display: swap
+// (task 1004930, from the front-end load-speed audit).
+//
+// The stylesheet lives on fonts.googleapis.com and the font files on
+// fonts.gstatic.com: two extra origins, each a DNS + TLS round trip before text can
+// paint. A <link rel="preconnect"> to both starts those handshakes while the HTML is
+// still parsing, and display=swap paints text in the fallback face at once instead
+// of holding it invisible until the font arrives. A page that drops either pays the
+// whole wait on first paint, silently; this sweep makes a new page that forgets it
+// fail here rather than load slowly in production.
+//
+// The page set is discovered from git, not listed, so a page added later is covered
+// without anyone remembering to add it. Design mocks are exempt (never served).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+/** The served page sources: tracked .html/.js under modules/ and src/, minus mocks and tests. */
+function servedPageSources() {
+  const out = execFileSync('git', ['ls-files', '-z', '--', 'modules', 'src'], { cwd: ROOT, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  return out.split('\0').filter((f) => /\.(html|js)$/.test(f) && !/\/(mocks|tests)\//.test(f));
+}
+
+/** Every <link ...> tag in the text, as a map of its attributes (order-independent). */
+function linkTags(text) {
+  const tags = [];
+  for (const m of text.matchAll(/<link\b([^>]*)>/gi)) {
+    const attrs = {};
+    for (const a of m[1].matchAll(/([a-z-]+)(?:\s*=\s*"([^"]*)")?/gi)) attrs[a[1].toLowerCase()] = a[2] ?? true;
+    tags.push(attrs);
+  }
+  return tags;
+}
+
+/** The Google Fonts verdict for one page's text: null when it loads no Google Fonts stylesheet. */
+export function fontsVerdict(text) {
+  const links = linkTags(text);
+  const sheets = links.filter((l) => l.rel === 'stylesheet' && typeof l.href === 'string' && l.href.startsWith('https://fonts.googleapis.com/css'));
+  if (sheets.length === 0) return null;
+  const pre = (origin) => links.find((l) => l.rel === 'preconnect' && l.href === origin);
+  const gstatic = pre('https://fonts.gstatic.com');
+  return {
+    preconnectApi: Boolean(pre('https://fonts.googleapis.com')),
+    preconnectGstatic: Boolean(gstatic),
+    // Font files are fetched in CORS mode, so a preconnect without crossorigin opens
+    // a connection the font request cannot reuse.
+    gstaticCrossorigin: Boolean(gstatic && 'crossorigin' in gstatic),
+    swap: sheets.every((s) => /[?&]display=swap(&|$)/.test(s.href.replace(/&amp;/g, '&'))),
+  };
+}
+
+test('the verdict reads the tags, not their order or spelling', () => {
+  const good = '<link href="https://fonts.googleapis.com/css2?family=X&display=swap" rel="stylesheet">'
+    + '<link rel="preconnect" href="https://fonts.googleapis.com"><link crossorigin rel="preconnect" href="https://fonts.gstatic.com">';
+  assert.deepEqual(fontsVerdict(good), { preconnectApi: true, preconnectGstatic: true, gstaticCrossorigin: true, swap: true });
+  assert.equal(fontsVerdict('<link rel="stylesheet" href="/assets/site.css">'), null, 'a page with no Google Fonts is out of scope');
+  const bare = '<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=X">';
+  assert.deepEqual(fontsVerdict(bare), { preconnectApi: false, preconnectGstatic: false, gstaticCrossorigin: false, swap: false });
+  const noCors = good.replace('crossorigin ', '');
+  assert.equal(fontsVerdict(noCors).gstaticCrossorigin, false, 'a gstatic preconnect without crossorigin is not reusable');
+});
+
+test('every served page loading Google Fonts preconnects both origins and asks for swap', () => {
+  const pages = servedPageSources();
+  assert.ok(pages.length > 50, `found the page sources (${pages.length})`);
+  let checked = 0;
+  const bad = [];
+  for (const rel of pages) {
+    const v = fontsVerdict(fs.readFileSync(path.join(ROOT, rel), 'utf8'));
+    if (!v) continue;
+    checked++;
+    const missing = Object.entries(v).filter(([, ok]) => !ok).map(([k]) => k);
+    if (missing.length) bad.push(`${rel}: ${missing.join(', ')}`);
+  }
+  assert.ok(checked >= 12,`the sweep reached the pages that load Google Fonts (${checked})`);
+  assert.deepEqual(bad, [], 'pages loading Google Fonts without both preconnects and display=swap');
+});