@bongos/core 1.21.165 → 1.21.166

package/tests/hall_board_world.mjs

@@ -244,12 +244,15 @@ const hallRenderJs = read('hall-render.js');
 const buildersJs = read('builders.js');
 const goalInboxJs = read('goal-inbox.js');
 
-test('the greeting IS the page\'s one h1, in the board\'s label voice, with a sub-line beside it', () => {
+test('the greeting IS the page\'s one h1, in the board\'s label voice, with no sub-line under it', () => {
   const h1s = indexHtml.match(/<h1\b/g) || [];
   assert.equal(h1s.length, 1, 'one-header-main-h1: the greeting must BECOME the h1, never add a second');
-  assert.match(indexHtml, /<div class="page-head page-head--board page-head--hall">\s*<h1 id="hall-h1" class="page-head__h">Builders' Hall<\/h1>\s*<p id="hall-sub" class="page-head__sub" hidden><\/p>/,
-    'the h1 is visible (no sr-only), keeps the id brand-apply.js writes into, and the sub-line ships hidden');
+  assert.match(indexHtml, /<div class="page-head page-head--board page-head--hall">\s*<h1 id="hall-h1" class="page-head__h">Builders' Hall<\/h1>/,
+    'the h1 is visible (no sr-only) and keeps the id brand-apply.js writes into');
   assert.doesNotMatch(indexHtml, /id="hall-h1" class="sr-only"/, 'the sr-only h1 is gone');
+  // task 1004780 (owner): the status sentence repeated the version tab and Next up, so it went.
+  assert.doesNotMatch(indexHtml, /id="hall-sub"/, 'no status line under the greeting');
+  assert.doesNotMatch(hallRenderJs, /hall-sub|claimable right now/, 'and nothing renders one');
 });
 
 test('the band ends level: no align-items on the grid, so the two cards stretch', () => {
@@ -300,28 +303,18 @@ test('the system notices are inbox LINES, first in the card, and counted by its
   }
 });
 
-test('the greeting reads /me, the public progress and the claimable feed, and builders.js feeds all three', () => {
+test('the greeting reads /me and the public progress (for the version tab), and builders.js feeds both', () => {
   assert.match(buildersJs, /getJSON\(`\$\{API\}\/public\/progress`\)/, 'Home fetches the public progress once');
-  // The count comes off the SAME Next-up response — one request, not a second
-  // fetch. It reads `claimable_total` rather than the length of the returned array,
-  // because that request is now bounded (?limit=2, task 1003545): the array holds two
-  // rows and the total holds the whole rank-scoped queue. Asserting the derivation
-  // rather than one literal expression is deliberate — the previous version pinned
-  // `resp.claimable.length`, which read as a requirement to download the feed.
-  assert.match(buildersJs, /lastClaimableCount = Number\.isFinite\(claimableTotal\)/,
-    'the claimable feed Home already fetches for Next-up answers the count');
-  assert.match(buildersJs, /const claimableTotal = Number\(resp && resp\.claimable_total\);/,
-    'and it takes the count from the response total, so a bounded read still knows it');
   assert.doesNotMatch(buildersJs, /getJSON\(`\$\{API\}\/tasks\/claimable`/,
-    'no unbounded claimable fetch on Home — the count must never cost the whole queue');
+    'no unbounded claimable fetch on Home');
   assert.match(buildersJs, /get lastProgressState\(\)/, 'the renderer reads progress through a getter, so it cannot freeze at boot');
-  assert.match(buildersJs, /get lastClaimableCount\(\)/, 'and the count the same way');
-  assert.equal((buildersJs.match(/renderGreeting\(\)/g) || []).length, 3, 'rendered after /me, after progress and after the claimable feed — each half as it lands');
+  assert.doesNotMatch(buildersJs, /lastClaimableCount/, 'the greeting no longer needs the claimable count (task 1004780)');
+  assert.equal((buildersJs.match(/renderGreeting\(\)/g) || []).length, 2, 'rendered after /me and after progress — each as it lands');
 });
 
 // Boot hall-render.js against a stub DOM and a ctx of getters (the way
 // builders.js builds it) and read what the greeting and the card actually say.
-function bootHallRender({ me, progress = null, claimable = null, leaderboard = [] }) {
+function bootHallRender({ me, progress = null, leaderboard = [] }) {
   const els = new Map();
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', hidden: false, _html: '', innerHTML: '',
@@ -359,7 +352,7 @@ function bootHallRender({ me, progress = null, claimable = null, leaderboard = [
     instanceRepo: null, newcomerGated: false,
     get lastMeState() { return me; }, get lastCostState() { return me.cost || null; }, get lastKarmaState() { return me.karma || null; },
     get lastNeedsState() { return me.needs || null; }, get lastRebaseState() { return me.needs_rebase_tasks || null; },
-    get lastProgressState() { return progress; }, get lastClaimableCount() { return claimable; },
+    get lastProgressState() { return progress; },
   };
   const api = windowObj.OTBHallRender(ctx);
   api.lbState.rows = leaderboard;
@@ -375,30 +368,16 @@ const ME = {
 const LEADERBOARD = [{ github_login: 'a', total_credits: 20000 }, { github_login: 'percy', total_credits: 14441 }, { github_login: 'b', total_credits: 3 }, { github_login: 'c', total_credits: 1 }];
 const PROGRESS = { progress: [{ version_id: 'BONGOS-V1', status: 'building', total_count: 605, percent_complete: 75 }, { version_id: 'V2', status: 'planning', total_count: 9000, percent_complete: 0 }] };
 
-test('RUN: the greeting names the builder, and the sub-line says how far the version is and what is claimable', () => {
-  const { api, el } = bootHallRender({ me: ME, progress: PROGRESS, claimable: 5 });
+test('RUN: the greeting names the builder, and the version tab carries how far the version is', () => {
+  const { api, el } = bootHallRender({ me: ME, progress: PROGRESS });
   api.renderGreeting();
   assert.match(el('hall-h1').textContent, /^Good (morning|afternoon|evening), Percy Jackson$/);
-  assert.equal(el('hall-sub').textContent, 'BONGOS-V1 is 75 percent complete. Five tasks are claimable right now.');
-  assert.equal(el('hall-sub').hidden, false);
-});
-
-test('RUN: each half of the sentence renders as its data lands, and the line hides with neither', () => {
+  assert.equal(el('home-version-name').textContent, 'BONGOS-V1', 'the building version, not the bigger planning one');
+  assert.equal(el('home-version-pct').textContent, '75% complete');
+  assert.equal(el('home-version').hidden, false);
   const none = bootHallRender({ me: ME });
   none.api.renderGreeting();
-  assert.equal(none.el('hall-sub').hidden, true, 'nothing to say yet');
-  const onlyProgress = bootHallRender({ me: ME, progress: PROGRESS });
-  onlyProgress.api.renderGreeting();
-  assert.equal(onlyProgress.el('hall-sub').textContent, 'BONGOS-V1 is 75 percent complete.');
-  const zero = bootHallRender({ me: ME, progress: PROGRESS, claimable: 0 });
-  zero.api.renderGreeting();
-  assert.match(zero.el('hall-sub').textContent, /Nothing is claimable right now\.$/);
-  const one = bootHallRender({ me: ME, claimable: 1 });
-  one.api.renderGreeting();
-  assert.equal(one.el('hall-sub').textContent, 'One task is claimable right now.');
-  const many = bootHallRender({ me: ME, claimable: 63 });
-  many.api.renderGreeting();
-  assert.equal(many.el('hall-sub').textContent, '63 tasks are claimable right now.');
+  assert.equal(none.el('home-version').hidden, true, 'no progress yet: no tab');
 });
 
 test('RUN: the Standing card carries the three facts, the place as "2nd of 4", and no banner', () => {

package/tests/home_attention_cards.mjs

@@ -97,8 +97,12 @@ test('closing natively (Escape) also returns the slice, so a reopen still finds
   const { ctx, page } = await bootInbox();
   await page.click('[data-attn-open="attention-blockers"]');
   await page.keyboard.press('Escape');
-  await page.waitForFunction(() => !document.getElementById('attention-dialog').open);
-  const back = await page.evaluate(() => !!document.querySelector('#attention-slices > #attention-blockers'));
+  // `open` turns false at once, but the dialog's `close` EVENT (which moves the slice home) is
+  // queued after it, so wait for the slice itself rather than for `open` (task 1004780 — reading
+  // straight after `open` flipped raced the event and failed CI about half the time).
+  const back = await page.waitForFunction(
+    () => !document.getElementById('attention-dialog').open && !!document.querySelector('#attention-slices > #attention-blockers'),
+    null, { timeout: 3000 }).then(() => true, () => false);
   assert.equal(back, true, 'the dialog close event moves the slice home');
   await page.click('[data-attn-open="attention-blockers"]');
   const rows = await page.evaluate(() => document.querySelectorAll('#attention-dialog-body .ginbox__item').length);

package/tests/settings_art_key_absent.mjs

@@ -0,0 +1,137 @@
+// tests/settings_art_key_absent.mjs — the image-generation key card on a project
+// with no art pipeline (task 1004786).
+//
+// The key routes (/me/art-key/*) left the core with the art-pipeline module, but
+// the Settings card and the art_key need stayed. On cloudbongos.com — which has
+// no art pipeline — every builder past Xenos was told "your free art coverage has
+// ended, add your key", and the card the nudge pointed at could never load, so
+// there was nowhere to add one. Two halves, both pinned here:
+//
+//   - builder-needs: with the art pipeline absent (ctx.artPipeline === false) the
+//     art_key need is not raised at all — nothing to nag about, nothing to add;
+//   - settings.js: a 404 from GET /me/art-key/own means the routes are not
+//     installed, so the section stays hidden instead of showing a reload error.
+//     A real failure (500) still shows the error.
+//
+// Pure vm + file-read (no DB/network) — runs in the DB-free unit gate.
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings.js'), 'utf8');
+const ME = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/me.js'), 'utf8');
+const needs = createRequire(import.meta.url)('../modules/builder-settings/builder-needs.js');
+
+let passed = 0, failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+function makeEl() {
+  return {
+    hidden: false, textContent: '', value: '', disabled: false, href: '', className: '',
+    dataset: {}, style: {}, children: [], _html: '',
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    addEventListener() {}, appendChild(c) { return c; },
+    append() {}, prepend() {}, remove() {}, setAttribute() {}, removeAttribute() {}, getAttribute() { return null; },
+    querySelector() { return null; }, querySelectorAll() { return []; }, closest() { return null; },
+    classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
+    focus() {},
+  };
+}
+
+// Boot the real settings.js; GET /me/art-key/own answers with `artKeyStatus`.
+async function boot(artKeyStatus) {
+  const els = new Map();
+  const $ = (sel) => { if (!els.has(sel)) els.set(sel, makeEl()); return els.get(sel); };
+  // The markup ships both hidden (settings.html), so the stub starts them hidden.
+  $('#art-key').hidden = true;
+  $('#artkey-banner').hidden = true;
+  const builder = { id: 4, github_login: 'b4', rank: 'thetes', preferred_disciplines: ['engineer'] };
+  const me = { builder, needs: { items: [needs.artKeyNeed({ rank: 'thetes' })] } };
+  const api = {
+    async request(method, url) {
+      if (method === 'GET' && url === '/api/bongos/me') return { status: 200, ok: true, data: me };
+      if (method === 'GET' && url === '/api/bongos/me/art-key/own') {
+        return artKeyStatus === 200
+          ? { status: 200, ok: true, data: { set: false, storage_configured: true } }
+          : { status: artKeyStatus, ok: false, data: null };
+      }
+      return { status: 404, ok: false, data: null };
+    },
+  };
+  const escapeHtml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  const document = {
+    getElementById: (id) => $(`#${id}`), createElement: () => makeEl(),
+    dispatchEvent() {}, addEventListener() {}, querySelector: () => null, querySelectorAll: () => [],
+  };
+  const window = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => api },
+    OTB: {
+      $, escapeHtml, toast() {}, disciplines: () => ['engineer'], roleLabel: (d) => d,
+      hubOrigin: () => null, settingsPanels: () => [],
+    },
+    OTBKit: { emptyStateHtml: (m) => m, makeSectionRail: () => ({ refresh() {}, activate() {} }) },
+    location: { hash: '', pathname: '/settings', search: '', assign() {} },
+    scrollTo() {}, confirm: () => false, addEventListener() {},
+  };
+  const sandbox = {
+    window, document, console: { log() {}, warn() {}, error() {}, info() {} },
+    history: { replaceState() {} }, URLSearchParams, setTimeout, clearTimeout,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'settings.js' });
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r));
+  return $;
+}
+
+console.log('\nthe art_key need without an art pipeline:');
+
+await t('artPipeline: false raises no art_key need at any rank', () => {
+  for (const rank of ['xenos', 'thetes', 'metic', 'archon']) {
+    assert.equal(needs.artKeyNeed({ rank, artPipeline: false }), null, rank);
+    const r = needs.computeNeeds({ rank, artPipeline: false });
+    assert.ok(!r.items.some((n) => n.id === 'art_key'), rank);
+  }
+});
+
+await t('with the pipeline present (or unstated) the need is unchanged', () => {
+  assert.equal(needs.artKeyNeed({ rank: 'thetes', artPipeline: true }).state, 'action_needed');
+  assert.equal(needs.artKeyNeed({ rank: 'thetes' }).state, 'action_needed');
+});
+
+await t('/me tells computeNeeds whether the art pipeline is installed', () => {
+  const call = ME.slice(ME.indexOf('settings.computeNeeds({'), ME.indexOf('isFoundingOwner'));
+  assert.match(call, /artPipeline:/);
+});
+
+console.log('\nthe Settings card:');
+
+await t('routes not installed (404) → the section stays hidden, no reload error', async () => {
+  const $ = await boot(404);
+  assert.equal($('#art-key').hidden, true);
+  assert.equal($('#artkey-banner').hidden, true);
+  assert.doesNotMatch($('#artkey-card').innerHTML, /could not be loaded/);
+});
+
+await t('a real failure (500) still shows the error', async () => {
+  const $ = await boot(500);
+  assert.equal($('#art-key').hidden, false);
+  assert.match($('#artkey-card').innerHTML, /could not be loaded/);
+});
+
+await t('routes present → the key box renders', async () => {
+  const $ = await boot(200);
+  assert.equal($('#art-key').hidden, false);
+  assert.match($('#artkey-card').innerHTML, /id="artkey-input"/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);