@bongos/core 1.21.1 → 1.21.3

package/tests/leaderboard_roles.mjs

@@ -0,0 +1,272 @@
+// tests/leaderboard_roles.mjs — the leaderboard, the roster and the status page
+// tell the roles apart (task 1004437 / WA6.RP07, goal 1000095, criterion
+// wa6-roles-read-true-in-public).
+//
+// The done-when: "all three lists show roles per the mock and no browser-only
+// artist shows a misleading 0". Run for real:
+//
+//   1. THE READ. readRolesForBuilders over a page of builders: the profile's own
+//      main/shown rules (chosen, else earned, else preferred), a craft shown only
+//      once it earned, two reads for the whole page and never one per row.
+//   2. THE ROUTE. GET /public/leaderboard carries each row's roles and per-craft
+//      credits (the figure a role ranks by is in the row, ADR 0255), and a roles
+//      failure costs the roles, never the board.
+//   3. THE ROSTER. The REAL roster.js over the harness's public fixture: a Roles
+//      column, the Everyone / Engineers / Artists / Ideators toggle ranking by
+//      the credits that craft earned, and a dash, not a 0, for a builder with no
+//      AI sessions.
+//   4. THE STANDING CARD and 5. THE STATUS PAGE: the real functions, run.
+
+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 seams = require('../src/module-seams.js');
+const creditsByCraftLib = require('../modules/economy/credits-by-craft.js');
+const FIX = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/public__leaderboard.json'), 'utf8'));
+const read = (f) => fs.readFileSync(path.join(ROOT, f), 'utf8').replace(/\r\n/g, '\n');
+
+// economy's own fold over hand-written grouped rows: what the ledger statement returns
+function rewardOver(grouped, calls) {
+  return {
+    craftForPreference: creditsByCraftLib.craftForPreference,
+    creditsByCraft: async (ids) => { calls.push(['credits', ids]); return creditsByCraftLib.foldCraftRows(ids, grouped); },
+  };
+}
+
+// ---- 1. the read ------------------------------------------------------------------
+
+await test('a page of builders: chosen, earned and preferred main roles, and a craft shown only once it earned', async () => {
+  const { readRolesForBuilders } = require('../src/bongos/role-stats.js');
+  const calls = [];
+  seams._reset();
+  seams.registerProvider('reward', rewardOver([
+    { builder_id: '1', discipline: 'engineer', amount: 900 },
+    { builder_id: '1', discipline: 'ideator', amount: 20 },
+    { builder_id: '2', discipline: 'artist', amount: 370 },
+    { builder_id: '2', discipline: 'ideator', amount: 42 },
+    { builder_id: '3', discipline: 'ideator', amount: 186 },
+  ], calls));
+  const choices = new Map([
+    ['2', { preferred_disciplines: ['artist', 'ideator'], main_discipline: 'artist' }],
+    ['3', { preferred_disciplines: ['ideator', 'artist'], main_discipline: null }],
+    ['4', { preferred_disciplines: ['ui'], main_discipline: null }],
+  ]);
+  const out = await readRolesForBuilders(['1', '2', 3, '4', 'x', '2'], { getRoleChoices: async (ids) => { calls.push(['choices', ids]); return choices; } });
+  assert.deepEqual([...out.keys()], ['1', '2', '3', '4'], 'every valid id once, a bad one dropped');
+  const r = (id) => JSON.parse(JSON.stringify(out.get(id)));
+  assert.deepEqual([r('1').main, r('1').main_basis, r('1').shown], ['engineer', 'earned', ['engineer', 'ideator']]);
+  assert.deepEqual([r('2').main, r('2').main_basis, r('2').shown], ['artist', 'chosen', ['artist', 'ideator']]);
+  assert.deepEqual(r('3').shown, ['ideator'], 'a preferred craft that earned nothing does not show');
+  assert.deepEqual([r('4').main, r('4').main_basis, r('4').shown], ['artist', 'preferred', ['artist']], 'ui is the artist\'s craft, as on the profile');
+  assert.equal(r('2').credits_by_craft.artist, 370);
+  assert.equal(r('2').credits_by_craft.total, 412);
+  assert.deepEqual(calls.map((c) => c[0]).sort(), ['choices', 'credits'], 'two reads for the whole page, never one per row');
+  seams._reset();
+});
+
+// ---- 2. the route -----------------------------------------------------------------
+
+async function bootPublic({ rolesThrow = false } = {}) {
+  const db = require('../src/bongos/db.js');
+  const realChoices = db.getBuilderRoleChoices;
+  db.getBuilderRoleChoices = async () => {
+    if (rolesThrow) throw new Error('db down');
+    return new Map([['2001', { preferred_disciplines: ['artist'], main_discipline: 'artist' }]]);
+  };
+  seams._reset();
+  seams.registerProvider('reward', {
+    craftForPreference: creditsByCraftLib.craftForPreference,
+    getLeaderboardWithAchievements: async () => [
+      { id: '1', github_login: 'eng', total_credits: 900, tokens_used: '5000' },
+      { id: '2001', github_login: 'art', total_credits: 370, tokens_used: '0' },
+    ],
+    creditsByCraft: async (ids) => creditsByCraftLib.foldCraftRows(ids, [
+      { builder_id: '1', discipline: 'engineer', amount: 900 },
+      { builder_id: '2001', discipline: 'artist', amount: 370 },
+    ]),
+  });
+  const express = require('express');
+  const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+  const app = express();
+  app.use(attachFail);
+  app.use(require('../src/bongos/routes/public.js')());
+  const server = await new Promise((r) => { const s = app.listen(0, '127.0.0.1', () => r(s)); });
+  const get = async (p) => { const res = await fetch(`http://127.0.0.1:${server.address().port}${p}`); return { status: res.status, body: await res.json() }; };
+  const close = async () => {
+    db.getBuilderRoleChoices = realChoices;
+    seams._reset();
+    server.closeAllConnections();
+    await new Promise((r) => server.close(r));
+    await new Promise((r) => setTimeout(r, 50));
+  };
+  return { get, close };
+}
+
+await test('GET /public/leaderboard: every row names its roles and the credits each craft earned', async () => {
+  const s = await bootPublic();
+  try {
+    const { status, body } = await s.get('/public/leaderboard');
+    assert.equal(status, 200);
+    const [eng, art] = body.leaderboard;
+    assert.deepEqual(eng.roles.shown, ['engineer']);
+    assert.deepEqual(art.roles.shown, ['artist']);
+    assert.equal(art.roles.main_basis, 'chosen');
+    assert.equal(art.roles.credits_by_craft.artist, 370, 'the figure an Artists toggle ranks by is in the row');
+  } finally { await s.close(); }
+});
+
+await test('a roles failure costs the roles, never the board', async () => {
+  const s = await bootPublic({ rolesThrow: true });
+  try {
+    const { status, body } = await s.get('/public/leaderboard');
+    assert.equal(status, 200);
+    assert.equal(body.leaderboard.length, 2, 'the rows still go out');
+    assert.ok(body.leaderboard.every((r) => r.roles === undefined), 'and simply carry no roles');
+  } finally { await s.close(); }
+});
+
+await test('the public list carries karma, so the roster can read it and keep its karma column', () => {
+  const sql = read('modules/economy/achievements.js');
+  const q = sql.slice(sql.indexOf('async function getLeaderboardWithAchievements'), sql.indexOf('async function getLeaderboardWithAchievements') + 1200);
+  assert.match(q, /\bb\.karma\b/);
+});
+
+// ---- 3. the roster ----------------------------------------------------------------
+
+function bootRoster() {
+  const els = {};
+  const el = (id) => (els[id] = els[id] || {
+    id, innerHTML: '', textContent: '', className: '', hidden: true,
+    listeners: {}, addEventListener(t, f) { this.listeners[t] = f; },
+    querySelectorAll: () => [],
+  });
+  let ledgerOpts = null;
+  let rendered = [];
+  const kit = {
+    esc: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+    makePager: () => ({ page: 1 }),
+    makeFilterBar: () => {},
+    makeLedger: (opts) => { ledgerOpts = opts; return { render: (rows) => { rendered = rows; } }; },
+  };
+  let resolveLoaded;
+  const loaded = new Promise((r) => { resolveLoaded = r; });
+  const sandbox = {
+    window: { OTBKit: kit, OTB: { fmtInt: (n) => String(Number(n) || 0), rankLabel: (r) => r } },
+    document: { getElementById: el },
+    fetch: async (url) => { sandbox.__url = url; return { ok: true, json: async () => FIX }; },
+    console, Promise, setTimeout,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(read('modules/hall-ui/public/roster.js'), sandbox, { filename: 'roster.js' });
+  setTimeout(resolveLoaded, 30);
+  return {
+    loaded, sandbox, els,
+    get opts() { return ledgerOpts; },
+    get rows() { return rendered; },
+    click(roleKey) {
+      els['roster-roles'].listeners.click({ target: { closest: () => ({ dataset: { role: roleKey } }) } });
+    },
+  };
+}
+
+await test('the roster reads the public list and draws a Roles column, main role first', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  assert.equal(r.sandbox.__url, '/api/bongos/public/leaderboard', 'the list that carries the roles');
+  const labels = JSON.parse(JSON.stringify(r.opts.columns.map((c) => (typeof c === 'string' ? c : c.label))));
+  assert.deepEqual(labels, ['Place', 'Builder', 'Roles', 'Rank', 'Credits', 'Karma', 'Tokens']);
+  const art = r.rows.find((b) => String(b.id) === '2001');
+  const html = r.opts.rowHtml(art);
+  assert.match(html, /<span class="lb-role lb-role--lead">Artist<\/span><span class="lb-role">Ideator<\/span>/);
+  assert.match(r.els['roster-roles'].innerHTML, /Everyone[\s\S]*Engineers[\s\S]*Artists[\s\S]*Ideators/);
+});
+
+await test('a builder with no AI sessions reads a dash and a sentence, never a 0 of tokens', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  const art = r.rows.find((b) => String(b.id) === '2001');
+  const cells = r.opts.rowHtml(art).split('</td>');
+  const tokensCell = cells[6];
+  assert.ok(!/>0</.test(tokensCell), 'no bare 0 in the tokens cell');
+  assert.match(tokensCell, /—/);
+  assert.match(tokensCell, /No AI sessions recorded/, 'the tooltip says why, instead of a tokens-per-credit figure');
+  const eng = r.rows.find((b) => Number(b.tokens_used) > 0);
+  assert.match(r.opts.rowHtml(eng), /tokens per credit/, 'the efficiency figure still shows where there are tokens');
+});
+
+await test('the Artists toggle shows only artists, ranked by the credits that craft earned, with its own places', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  r.click('artist');
+  const ids = r.rows.map((b) => String(b.id));
+  const artists = FIX.leaderboard.filter((b) => b.roles.shown.includes('artist'));
+  assert.deepEqual(ids.sort(), artists.map((b) => String(b.id)).sort(), 'exactly the builders shown as artists');
+  const credits = r.rows.map((b) => b.roles.credits_by_craft.artist);
+  assert.deepEqual(credits, [...credits].sort((a, b) => b - a), 'ranked by artist credits, not total credits');
+  assert.equal(String(r.rows[0].id), '2001', 'the browser-only artist leads the artists');
+  const labels = r.opts.columns.map((c) => (typeof c === 'string' ? c : c.label));
+  assert.equal(labels[4], 'Credits as artist', 'the header names the craft');
+  assert.match(r.opts.rowHtml(r.rows[0]), /ledger__place">1</, 'the place is the place among artists');
+  assert.match(r.opts.rowHtml(r.rows[0]), /<td class="ledger__num">370<\/td>/, 'and the figure is the artist credits');
+  r.click('');
+  assert.equal(r.rows.length, FIX.leaderboard.length, 'Everyone brings every builder back');
+});
+
+// ---- 4. the standing card ---------------------------------------------------------
+
+function extract(src, start, end) {
+  const a = src.indexOf(start);
+  const b = src.indexOf(end, a);
+  assert.ok(a !== -1 && b !== -1, `found ${start}`);
+  return src.slice(a, b);
+}
+
+await test('the standing card adds the place inside the builder\'s main role, only when it says something new', () => {
+  const src = read('modules/hall-ui/public/hall-render.js');
+  const code = extract(src, 'const lbState = { rows: [] };', '// task 1003459');
+  const sandbox = { rows: FIX.leaderboard };
+  vm.createContext(sandbox);
+  vm.runInContext(`${code}; lbState.rows = rows; this.place = leaderboardPlace; this.text = rolePlaceText;`, sandbox);
+  const art = sandbox.place('builder-7');
+  assert.equal(art.role.craft, 'artist');
+  assert.equal(sandbox.text(art), `#1 as an artist`);
+  const top = sandbox.place(FIX.leaderboard[0].github_login);
+  assert.equal(sandbox.text(top), '', 'the top engineer is #1 either way, so nothing is added');
+  assert.match(src, /setText\('stat-rank-sub', rollPlace \? \[`#\$\{rollPlace\.place\} on the leaderboard`, rolePlaceText\(rollPlace\)\]/);
+  assert.match(read('modules/hall-ui/public/builders.js'), /getJSON\(`\$\{API\}\/public\/leaderboard`\)/, 'the hall reads the list with the roles');
+});
+
+// ---- 5. the status page -----------------------------------------------------------
+
+await test('the status leaderboard names each builder\'s roles, main one first, as text', () => {
+  const src = read('modules/status-ui/public/status.js');
+  const code = extract(src, 'const ROLE_WORD', 'async function loadLeaderboard');
+  const made = [];
+  const node = (tag) => {
+    const n = { tag, className: '', textContent: '', children: [], attrs: {}, appendChild(c) { this.children.push(c); }, setAttribute(k, v) { this.attrs[k] = v; } };
+    made.push(n);
+    return n;
+  };
+  const sandbox = { document: { createElement: node } };
+  vm.createContext(sandbox);
+  vm.runInContext(`${code}; this.renderRoles = renderRoles;`, sandbox);
+  const row = sandbox.renderRoles({ shown: ['artist', 'ideator', 'wizard'] });
+  assert.deepEqual(row.children.map((c) => [c.className, c.textContent]), [
+    ['leader__role leader__role--lead', 'Artist'],
+    ['leader__role', 'Ideator'],
+  ], 'a word the page does not know is dropped, not printed');
+  assert.equal(sandbox.renderRoles(null), null, 'a row without roles draws nothing');
+  assert.match(src, /const roles = renderRoles\(b\.roles\);\s*if \(roles\) name\.appendChild\(roles\);/);
+});
+
+summary();