@bongos/core 1.20.81 → 1.20.82

package/tests/profile_earnings.mjs

@@ -0,0 +1,237 @@
+// tests/profile_earnings.mjs — everyone gets an earnings chart, labelled by kind
+// of credit (task 1004436 / WA6.RP06, goal 1000095, criterion
+// wa6-roles-read-true-in-public).
+//
+// The done-when: "an artist and an ideator fixture with credits and zero shipped
+// tasks both get a labelled earnings chart". Run for real, end to end:
+//
+//   1. THE KINDS. Which kind each ledger reason is, as the read's own SQL says it,
+//      and the one kind the reason cannot tell apart (a descent hop shares stream
+//      1's key) held against the WRITER's own description text.
+//   2. THE FOLD. Every kind named, zero days dropped, the parts summing to the
+//      whole.
+//   3. THE ROUTE. Signed in only, a bad id refused, an unknown builder a 404, and
+//      the read scoped to that one builder.
+//   4. THE PAGE. The REAL profile-charts.js on the REAL kit, fed the harness's
+//      artist and ideator fixtures (credits, no shipped task): a figure, its
+//      lede, and "where it came from" in the mock's words.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const { test, summary } = makeRunner();
+
+const earnings = require('../modules/economy/earnings.js');
+const credits = require('../modules/economy/credits.js');
+const fixture = (name) => JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures', `${name}.json`), 'utf8'));
+
+// ---- 1. the kinds -------------------------------------------------------------
+
+await test('every kind the SQL can name is a kind the page has words for', () => {
+  const named = [...earnings.EARNINGS_SQL.matchAll(/THEN '([a-z-]+)'/g)].map((m) => m[1]);
+  named.push('other'); // the ELSE
+  assert.deepEqual([...new Set(named)].sort(), [...earnings.KINDS].sort(), 'the SQL and KINDS name the same set');
+  const page = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-charts.js'), 'utf8');
+  for (const k of earnings.KINDS) assert.ok(page.includes(`${k.includes('-') ? `'${k}'` : k}: '`), `the page has words for ${k}`);
+});
+
+await test('a descent hop is told from a direct payout by the WRITER\'s own words', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/economy/credits.js'), 'utf8');
+  // the descent writer and the direct writer, by their own describe() lines
+  const descent = src.match(/describe: \(p\) => `Task #\$\{taskId\} shipped \$\{depth\} hop[^\n]*/);
+  const direct = src.match(/describe: \(p\) => `Task #\$\{taskId\} shipped under idea[^\n]*/);
+  assert.ok(descent && direct, 'both writers are where this test reads them');
+  assert.ok(descent[0].includes(earnings.DESCENT_MARK.trim()), 'the descent writer says DESCENT_MARK');
+  assert.ok(!direct[0].includes(earnings.DESCENT_MARK.trim()), 'and the direct one does not, or every idea payout would read as descent');
+  // the descent case is checked BEFORE the plain stream-1 case, or it never matches
+  const sql = earnings.EARNINGS_SQL;
+  assert.ok(sql.indexOf("'idea-descent'") < sql.indexOf("'idea-ship'"), 'descent first');
+});
+
+await test('the LIKE patterns are the economy\'s own prefixes, escaped', async () => {
+  let seen = null;
+  await earnings.readEarnings('7', { client: { query: async (sql, params) => { seen = { sql, params }; return { rows: [] }; } } });
+  assert.equal(seen.params[0], '7', 'scoped to the one builder');
+  assert.equal(seen.params[1], credits.ARTIST_PAGE_REASON_PREFIX.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[2], credits.IDEA_STREAM_REASON_PREFIXES.task_ship.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[3], credits.IDEA_STREAM_REASON_PREFIXES.full_pass.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[4], credits.IDEA_STREAM_REASON_PREFIXES.governance_pass.replace(/_/g, '\\_') + '%');
+  assert.equal(seen.params[5], `%${earnings.DESCENT_MARK}%`);
+  assert.match(seen.sql, /WHERE builder_id = \$1\b/, 'never the whole ledger');
+  assert.doesNotMatch(seen.sql.split('FROM')[0].replace(/COALESCE\(description[^)]*\)/, ''), /description|task_id|session_id/, 'no itemisation leaves the read');
+});
+
+// ---- 2. the fold --------------------------------------------------------------
+
+await test('the fold names every kind, drops zero days, sums to the whole and sorts by day', () => {
+  const out = earnings.foldEarnings([
+    { day: '2026-09-02', kind: 'page', credits: 30 },
+    { day: '2026-09-01', kind: 'idea-ship', credits: 12.4 },
+    { day: '2026-09-01', kind: 'session', credits: 0 },
+    { day: '2026-09-03', kind: 'something-new', credits: 5 },
+  ]);
+  assert.deepEqual(Object.keys(out.totals).sort(), [...earnings.KINDS].sort(), 'every kind, zero where nothing was earned');
+  assert.equal(out.totals.page, 30);
+  assert.equal(out.totals['idea-ship'], 12);
+  assert.equal(out.totals.other, 5, 'a kind the table does not know is still counted');
+  assert.equal(out.total, 47);
+  assert.deepEqual(out.days.map((d) => d.day), ['2026-09-01', '2026-09-02', '2026-09-03'], 'the zero day is gone');
+});
+
+// ---- 3. the route -------------------------------------------------------------
+
+await test('the route: signed in only, a bad id refused, an unknown builder a 404', async () => {
+  const api = require('../src/module-api.js');
+  // The read itself is proven above through its `client` seam, against its own
+  // SQL; here it is swapped before the route loads (the route takes it at
+  // require time), so the test never opens a database pool.
+  const realRead = earnings.readEarnings;
+  const realGet = api.getBuilderById;
+  const realRequire = api.requireBuilder;
+  const asked = [];
+  earnings.readEarnings = async (id) => { asked.push([id]); return earnings.foldEarnings([{ day: '2026-09-01', kind: 'page', credits: 30 }]); };
+  api.getBuilderById = async (id) => (String(id) === '2001' ? { id: 2001 } : null);
+  let signedIn = true;
+  api.requireBuilder = (req, res, next) => (signedIn ? next() : res.status(401).json({ error: 'unauthorized' }));
+  const express = require('express');
+  const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+  const app = express();
+  app.use(attachFail);
+  app.use(require('../modules/economy/routes/earnings.js')());
+  const server = await new Promise((r) => { const s = app.listen(0, '127.0.0.1', () => r(s)); });
+  const get = async (p) => { const r = await fetch(`http://127.0.0.1:${server.address().port}${p}`); return { status: r.status, body: await r.json() }; };
+  try {
+    const ok = await get('/builders/2001/earnings');
+    assert.equal(ok.status, 200);
+    assert.equal(ok.body.total, 30);
+    assert.deepEqual(ok.body.days, [{ day: '2026-09-01', kind: 'page', credits: 30 }]);
+    assert.equal(String(asked.at(-1)[0]), '2001', 'the read is that builder\'s rows');
+    assert.equal((await get('/builders/abc/earnings')).status, 400);
+    assert.equal((await get('/builders/9999/earnings')).status, 404);
+    signedIn = false;
+    assert.equal((await get('/builders/2001/earnings')).status, 401, 'owner decision (a): earnings need a sign-in');
+  } finally {
+    earnings.readEarnings = realRead;
+    api.getBuilderById = realGet;
+    api.requireBuilder = realRequire;
+    server.closeAllConnections();
+    await new Promise((r) => server.close(r));
+    // Let the closed sockets' handles finish closing before the runner's
+    // process.exit, or Windows' libuv aborts on a handle still mid-close.
+    await new Promise((r) => setTimeout(r, 50));
+  }
+});
+
+await test('the economy module mounts the route', () => {
+  const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/economy/module.json'), 'utf8'));
+  assert.ok(manifest.contributes.routes.includes('earnings'));
+});
+
+// ---- 4. the page --------------------------------------------------------------
+
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const NOW = Date.parse('2026-10-01T12:00:00Z');
+
+function bootCharts(route) {
+  const requests = [];
+  const mount = { innerHTML: '', querySelector: () => null };
+  const controls = { innerHTML: '', addEventListener() {}, querySelectorAll: () => [] };
+  const api = {
+    request: async (method, url) => {
+      requests.push(url);
+      const hit = route(url);
+      return hit ? { status: 200, ok: true, data: hit } : { status: 404, ok: false, data: null };
+    },
+  };
+  const sandbox = {
+    window: {
+      __BRANDING__: { currency: { label: 'credits' } },
+      localStorage: { getItem: () => null, setItem() {} },
+      OTB: {
+        roleAxisLabel: () => 'Role',
+        roleLabel: (d) => d,
+        escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+        $: (sel) => (sel === '#charts-grid' ? mount : sel === '#charts-controls' ? controls : null),
+        fmtNum: (n) => String(n ?? 0),
+        fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      },
+    },
+    console, Date, Map, Set, Math, Number, String, Array, Object, Infinity, URLSearchParams, Promise,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['hall-kit.js', 'profile-charts.js']) {
+    vm.runInContext(fs.readFileSync(path.join(HALL, f), 'utf8'), sandbox, { filename: f });
+  }
+  return { C: sandbox.window.OTBProfileCharts, api, requests, mount };
+}
+
+// the harness's own fixtures: an artist and an ideator who never shipped a task
+const PEOPLE = [
+  {
+    who: 'artist', id: 2001, name: 'Builder 7',
+    lede: 'Builder 7 has never shipped a task. Every credit here came from approved pages and ideas.',
+    kinds: [['Pages approved', '370'], ['Ideas that became shipped work', '42']],
+    end: '412 credits',
+  },
+  {
+    who: 'ideator', id: 2002, name: 'Builder 9',
+    lede: 'Builder 9 has never shipped a task. Every credit here came from ideas.',
+    kinds: [['Ideas that became shipped work', '96'], ['Work split from their ideas', '38'], ['Ratified by the board', '30'], ['Full Ideas passed', '22']],
+    end: '186 credits',
+  },
+];
+
+for (const P of PEOPLE) {
+  await test(`the ${P.who} fixture, with credits and no shipped task, gets a labelled earnings chart`, async () => {
+    const activity = fixture(`builders__${P.id}__activity`);
+    const earned = fixture(`builders__${P.id}__earnings`);
+    assert.equal(activity.rows.length, 0, 'the fixture really has no shipped task');
+    const b = bootCharts((url) => (url.includes('/activity') ? activity : url.includes('/earnings') ? earned : null));
+    await b.C.render({ api: b.api, API: '/api/bongos', builderId: P.id, selfId: 1, signedIn: true, name: P.name, now: NOW });
+    const out = b.mount.innerHTML;
+    assert.ok(out.includes('id="chart-drachmae"'), 'the earnings figure drew');
+    assert.ok(out.includes('Earnings over time'));
+    assert.ok(out.includes(P.lede), 'the lede says who never shipped, and where the credits came from');
+    assert.ok(out.includes(`>${P.end}</text>`), 'the line ends at the balance');
+    assert.ok(out.includes('where it came from'));
+    // "where it came from", in order, with its numbers
+    const rows = [...out.matchAll(/<span class="kit-bars__label">([^<]+)<\/span>[\s\S]*?<span class="kit-bars__val">([^<]+)<\/span>/g)].map((m) => [m[1], m[2]]);
+    assert.deepEqual(rows, P.kinds, 'every kind that earned, largest first, in the mock\'s words');
+    assert.ok(out.includes('No works shipped yet'), 'the works charts say "none yet" on their own');
+    assert.ok(!out.includes('id="chart-works"'), 'and draw no empty card');
+    assert.ok(!b.requests.some((u) => u.includes('/credits')), 'the itemised ledger is never read');
+  });
+}
+
+await test('the kinds follow the lookback window; the line still ends at the all-time total', () => {
+  const b = bootCharts(() => null);
+  const days = [{ day: '2026-06-01', kind: 'page', credits: 100 }, { day: '2026-09-25', kind: 'idea-ship', credits: 5 }];
+  assert.deepEqual(JSON.parse(JSON.stringify(b.C.earningsKinds(days))).map((k) => k.kind), ['page', 'idea-ship']);
+  assert.deepEqual(JSON.parse(JSON.stringify(b.C.earningsKinds(days.slice(1)))).map((k) => k.kind), ['idea-ship'], 'a 30-day window drops June');
+});
+
+await test('the lede: your own profile says "you"; someone who ships gets the plain sentence', () => {
+  const { C } = bootCharts(() => null);
+  const kinds = [{ kind: 'idea-ship', credits: 5 }];
+  assert.equal(C.earningsLede({ isOwn: true, shipped: false, kinds }), 'You have never shipped a task. Every credit here came from ideas.');
+  assert.equal(C.earningsLede({ name: 'Mara', isOwn: false, shipped: true, kinds }), 'Every credit Mara has earned, by the kind of work that earned it.');
+  assert.equal(C.earningsLede({ isOwn: true, shipped: true, kinds }), 'Every credit you have earned, by the kind of work that earned it.');
+});
+
+await test('signed out, nothing is asked for and the line says why', async () => {
+  const b = bootCharts(() => ({}));
+  await b.C.render({ api: b.api, API: '/api/bongos', builderId: 2002, selfId: null, signedIn: false, now: NOW });
+  assert.equal(b.requests.length, 0);
+  assert.match(b.mount.innerHTML, /Earnings and shipped work are visible to signed-in builders/);
+});
+
+summary();

package/tests/projects_hub_app_status.mjs

@@ -117,6 +117,23 @@ test('building and creating say where it is, with the stage marked', () => {
   assert.match(w.html({ app: { ...BUILDING.app, mode: 'adopt' } }), /Linked\. Waiting for your app to answer/);
 });
 
+// Task 1004502: past the time box the card stops saying "building" and sends the owner to
+// Render's deploy history, while the watch keeps asking (the app may still come up).
+test('a quiet build: no "building", the way to Render\'s deploy history, and the watch keeps going', () => {
+  const w = load();
+  const QUIET = { ok: true, app: { ...BUILDING.app, stage: 'quiet', quiet: true,
+    links: { ...LINKS, deploys: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events' } }, env_vars: [] };
+  const html = w.html(QUIET);
+  assert.doesNotMatch(html, /Render is building your app/);
+  assert.doesNotMatch(html, /appStages/, 'no progress rail claims a stage');
+  assert.match(html, /<p>Your app hasn’t answered for over 20 minutes\. Render may have stopped the deploy — its deploy history says why\.<\/p>/);
+  assert.match(html, /<a href="https:\/\/dashboard\.render\.com\/web\/srv-aaaaaaaa1111\/events" target="_blank" rel="noopener noreferrer">See its deploys on Render<\/a>/);
+  assert.match(html, /If it starts answering, this changes to Live by itself\./);
+  assert.equal(w.appTerminal(QUIET), false, 'the watch keeps asking');
+  const adopt = w.html({ ...QUIET, app: { ...QUIET.app, mode: 'adopt' } });
+  assert.match(adopt, /Your app hasn’t answered for over 20 minutes/);
+});
+
 test('a failure: the sentence, a Retry, and no promise of a retry by itself', () => {
   const w = load();
   const v = w.view(FAILED);

package/tests/provisioning_app_status.mjs

@@ -48,7 +48,8 @@ await ta('each runner state maps to the stage the owner sees', () => {
 await ta('a live app carries its address and the two Render links', () => {
   const s = appStatus({ ...HOST, state: 'live' });
   assert.equal(s.url, 'https://demo.onrender.com');
-  assert.deepEqual(s.links, { service: 'https://dashboard.render.com/web/srv-aaaaaaaa1111', env: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/env' });
+  assert.deepEqual(s.links, { service: 'https://dashboard.render.com/web/srv-aaaaaaaa1111', env: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/env',
+    deploys: 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events' });
   assert.equal(s.error, null);
   assert.equal(s.retry, null);
 });
@@ -75,6 +76,29 @@ await ta('a run still holding the lent key reads as waiting, not as something to
   assert.equal(s.retry, null);
 });
 
+// Task 1004502: Render can give up on a deploy (project 43 timed out in 15 minutes) and the
+// address check alone can never learn it, so a build that has not answered in QUIET_AFTER_MS
+// stops claiming to be building and sends the owner to Render's own deploy history.
+await ta('a build with no answer past the time box reads "quiet", not "building" (task 1004502)', () => {
+  const { QUIET_AFTER_MS } = require('../modules/provisioning/app-status.js');
+  assert.equal(QUIET_AFTER_MS, 20 * 60_000);
+  const t0 = Date.parse('2026-10-01T10:00:00Z');
+  const at = (state, ms) => appStatus({ ...HOST, state, updatedAt: new Date(t0).toISOString() }, { now: t0 + ms });
+  assert.equal(at('deploying', QUIET_AFTER_MS - 1000).quiet, false, 'still inside the time box');
+  assert.equal(at('deploying', QUIET_AFTER_MS - 1000).stage, 'building');
+  const q = at('deploying', QUIET_AFTER_MS + 1000);
+  assert.equal(q.quiet, true);
+  assert.equal(q.stage, 'quiet', 'it no longer reads as building');
+  assert.equal(q.links.deploys, 'https://dashboard.render.com/web/srv-aaaaaaaa1111/events');
+  assert.equal(q.error, null, 'not a failure: the platform cannot see Render\'s verdict');
+  assert.equal(q.retry, null);
+  assert.equal(at('linked', QUIET_AFTER_MS + 1000).stage, 'quiet', 'an adopted app waits the same way');
+  assert.equal(at('live', QUIET_AFTER_MS * 10).stage, 'live', 'a live app is never quiet');
+  assert.equal(at('creating', QUIET_AFTER_MS * 10).quiet, false, 'only a build is time-boxed');
+  assert.equal(appStatus({ ...HOST, state: 'deploying' }, { now: t0 }).quiet, false, 'no start time → no claim');
+  assert.equal(appStatus({ ...HOST, state: 'deploying', updatedAt: 'nonsense' }, { now: t0 }).quiet, false);
+});
+
 console.log('\nGET /provisioning/instances/:id/render:');
 const provisioning = require('../modules/provisioning/provisioning.js');
 const envManifest = require('../modules/provisioning/env-manifest.js');