@bongos/core 1.20.9 → 1.20.11

package/tests/speciality_offer_ui.mjs

@@ -0,0 +1,185 @@
+// tests/speciality_offer_ui.mjs — a speciality's OWNER chooses what it offers,
+// from the hall (task 1004404; ADR 0310 §1).
+//
+// Before this only the API could set a speciality's offered skills, so nothing
+// made in the hall offered any and the adoption walkthrough never appeared. These
+// pin that the owner can choose on create AND afterwards, that each choice shows
+// the skill's plain description, that only installed skills are choices, and that
+// a skill removed since is named rather than silently kept.
+//
+// Like tests/speciality_walkthrough_ui.mjs this EXECUTES the real
+// modules/hall-ui/public/settings-specialities.js in a vm under a minimal DOM
+// stub against a fake API, and drives the delegated handlers the page wires.
+//
+// Run:  node tests/speciality_offer_ui.mjs
+import assert from 'node:assert/strict';
+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';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings-specialities.js'), 'utf8');
+const HTML = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings.html'), 'utf8');
+const { test, summary } = makeRunner();
+
+const INSTALLED = [
+  { name: 'builder-cost', does: 'Records money spent on the project.', cost: 'Free. It only adds an entry.' },
+  { name: 'recall', does: 'Searches everything the project already knows.', cost: 'Free, and it changes nothing.' },
+  { name: 'status', does: 'Shows how far along a version is.', cost: 'Free, and it changes nothing.' },
+];
+
+const mine = (over = {}) => ({ id: 12, name: 'Pricing', discipline: 'engineer', summary: '', contract_md: '', visibility: 'private', adoptable: true, mine: true, skills: ['recall', 'retired-skill'], ...over });
+const theirs = (over = {}) => ({ id: 9, name: 'Economics', discipline: 'ideator', summary: '', contract_md: '', visibility: 'public', adoptable: true, mine: false, skills: ['recall'], ...over });
+
+// The checked boxes a form would submit, read off the rendered markup.
+const checkedIn = (html) => [...html.matchAll(/<input type="checkbox" name="skill" value="([^"]+)" checked/g)].map((m) => m[1]);
+const fakeForm = (dataset, values) => ({
+  dataset,
+  querySelectorAll: (sel) => (sel === 'input[name="skill"]:checked' ? values.map((value) => ({ value })) : []),
+});
+
+async function boot({ catalog = [mine(), theirs()] } = {}) {
+  const requests = [];
+  const toasts = [];
+  const els = new Map();
+  const handlers = new Map();
+  const makeEl = (id) => ({
+    id, hidden: id === 'specialities-scroll', innerHTML: '', textContent: '', elements: {}, dataset: {}, open: false,
+    addEventListener(type, fn) { handlers.set(`${id}:${type}`, fn); },
+  });
+  for (const id of ['specialities-scroll', 'specialities-rows', 'speciality-suggestions', 'specialities-status', 'speciality-create', 'speciality-create-offer', 'speciality-create-skills']) els.set(id, makeEl(id));
+  // The create form's fields, as settings.html declares them.
+  const create = els.get('speciality-create');
+  const field = (value) => ({ value, addEventListener() {} });
+  create.elements = { name: field(''), discipline: field(''), summary: field(''), contract_md: field(''), visibility: field('private'), sellable: { checked: false, disabled: false, addEventListener() {} } };
+  create.reset = () => { create.elements.name.value = ''; };
+  create.querySelectorAll = () => [];
+
+  const fetch = async (url, opts = {}) => {
+    const method = opts.method || 'GET';
+    const p = url.replace('/api/bongos', '');
+    requests.push({ method, path: p, body: opts.body ? JSON.parse(opts.body) : undefined });
+    let body = {};
+    if (method === 'GET' && p === '/specialities') body = { specialities: catalog };
+    else if (method === 'GET' && p === '/me/specialities') body = { adoptions: [] };
+    else if (method === 'GET' && p === '/specialities/offered') body = { suggestions: [] };
+    else if (method === 'GET' && p === '/specialities/installed-skills') body = { skills: INSTALLED };
+    else if (method === 'PATCH') body = { speciality: { id: 12 } };
+    else if (method === 'POST' && p === '/specialities') body = { speciality: { id: 13 } };
+    return { ok: true, status: 200, json: async () => body };
+  };
+
+  const document = { readyState: 'complete', getElementById: (id) => els.get(id) || null, addEventListener() {}, querySelector: () => null };
+  const window = {
+    OTB: {
+      escapeHtml: (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+      $: () => null, toast: (m) => toasts.push(m), roleAxisLabel: () => 'Role',
+    },
+    location: { assign() {} },
+  };
+  vm.runInNewContext(SRC, { window, document, fetch, JSON, Promise, Map, Set, String, Number, Array, Object, Math, RegExp, console });
+  const settle = async () => { for (let i = 0; i < 8; i++) await new Promise((r) => setTimeout(r, 0)); };
+  await settle();
+
+  const rows = els.get('specialities-rows');
+  async function click(act, id) {
+    const btn = { dataset: { act, id: String(id) } };
+    handlers.get('specialities-rows:click')({ target: { closest: (sel) => (sel === 'button[data-act]' ? btn : null) } });
+    await settle();
+  }
+  async function submitOffer(id, values) {
+    const form = fakeForm({ id: String(id) }, values);
+    handlers.get('specialities-rows:submit')({ target: { closest: (sel) => (sel === 'form.speciality-offer' ? form : null) }, preventDefault() {} });
+    await settle();
+  }
+  return { els, rows, requests, toasts, click, submitOffer, handlers, create, settle };
+}
+
+const writes = (h) => h.requests.filter((r) => r.method !== 'GET');
+const installedReads = (h) => h.requests.filter((r) => r.path === '/specialities/installed-skills').length;
+
+await test('only a speciality you own has an "Offered skills" control', async () => {
+  const h = await boot();
+  const buttons = [...h.rows.innerHTML.matchAll(/data-act="offer" data-id="(\d+)"/g)].map((m) => m[1]);
+  assert.deepEqual(buttons, ['12']);
+});
+
+await test('opening it lists every installed skill with its plain description and cost, the current offer ticked', async () => {
+  const h = await boot();
+  assert.equal(installedReads(h), 0, 'nothing is fetched until the owner asks');
+  await h.click('offer', 12);
+  assert.equal(installedReads(h), 1);
+  const html = h.rows.innerHTML;
+  for (const k of INSTALLED) {
+    assert.ok(html.includes(`value="${k.name}"`), `${k.name} is a choice`);
+    assert.ok(html.includes(k.does), `${k.name} shows what it does`);
+    assert.ok(html.includes(k.cost), `${k.name} shows what it costs`);
+  }
+  assert.deepEqual(checkedIn(html), ['recall'], 'what it offers today is ticked');
+  assert.match(html, /Offering a skill turns nothing on/);
+});
+
+await test('a skill it offers that the instance no longer has is named, not offered as a choice', async () => {
+  const h = await boot();
+  await h.click('offer', 12);
+  assert.ok(!h.rows.innerHTML.includes('value="retired-skill"'), 'not a checkbox');
+  assert.match(h.rows.innerHTML, /No longer on this project, so saving drops it from the offer: <code>retired-skill<\/code>/);
+});
+
+await test('saving sends exactly the ticked skills as one PATCH, and nothing is written before', async () => {
+  const h = await boot();
+  await h.click('offer', 12);
+  assert.equal(writes(h).length, 0);
+  await h.submitOffer(12, ['recall', 'status']);
+  const w = writes(h);
+  assert.equal(w.length, 1);
+  assert.equal(w[0].method, 'PATCH');
+  assert.equal(w[0].path, '/specialities/12');
+  assert.deepEqual(w[0].body, { skills: ['recall', 'status'] });
+  assert.ok(h.toasts.some((m) => /offers 2 skills/.test(m)));
+  assert.ok(!/class="speciality-offer"/.test(h.rows.innerHTML), 'the editor closes on save');
+});
+
+await test('offering nothing is a choice too', async () => {
+  const h = await boot();
+  await h.click('offer', 12);
+  await h.submitOffer(12, []);
+  assert.deepEqual(writes(h)[0].body, { skills: [] });
+});
+
+await test('the installed list is read once per page, however often the editor opens', async () => {
+  const h = await boot();
+  await h.click('offer', 12);
+  await h.click('offer', 12); // close
+  await h.click('offer', 12); // open again
+  assert.equal(installedReads(h), 1);
+});
+
+await test('the create form offers the same choices, filled on first open, and sends them with the new speciality', async () => {
+  const h = await boot();
+  const box = h.els.get('speciality-create-offer');
+  const host = h.els.get('speciality-create-skills');
+  box.open = true;
+  h.handlers.get('speciality-create-offer:toggle')();
+  await h.settle();
+  for (const k of INSTALLED) assert.ok(host.innerHTML.includes(`value="${k.name}"`) && host.innerHTML.includes(k.does));
+  assert.deepEqual(checkedIn(host.innerHTML), [], 'a new speciality starts offering nothing');
+  h.create.elements.name.value = 'New one';
+  h.create.elements.discipline.value = 'engineer';
+  h.create.querySelectorAll = (sel) => (sel === 'input[name="skill"]:checked' ? [{ value: 'status' }] : []);
+  h.handlers.get('speciality-create:submit')({ preventDefault() {} });
+  await h.settle();
+  const post = writes(h).find((r) => r.method === 'POST' && r.path === '/specialities');
+  assert.ok(post, 'created');
+  assert.deepEqual(post.body.skills, ['status']);
+});
+
+await test('settings.html carries the create form\'s picker inside the form it submits with', () => {
+  const form = HTML.slice(HTML.indexOf('<form id="speciality-create"'), HTML.indexOf('</form>', HTML.indexOf('<form id="speciality-create"')));
+  assert.match(form, /<details id="speciality-create-offer"/);
+  assert.match(form, /id="speciality-create-skills"/);
+});
+
+summary();

package/tests/speciality_skills.mjs

@@ -73,6 +73,48 @@ await test('every skill in the real tree reads a real description — none is a
   assert.deepEqual(bad, [], `these would teach nothing in the walkthrough: ${bad.join(', ')}`);
 });
 
+// task 1004403: every skill a speciality could offer — every core skill and
+// every module's, enabled here or not — carries its own people-facing lines, so
+// the walkthrough never has to derive them and a new skill cannot arrive without.
+const { JARGON_TERMS } = require('../modules/sessions/accessibility.js');
+// The words task 1004403 named as the ones the derived text leaked, plus the
+// repo nouns a newcomer would not know.
+const SKILL_JARGON = ['DB', 'grep', 'grepping', 'rank-scoped', 'status=', 'residue', 'criterion', 'criteria', 'touches[]', 'branch', 'commit', 'diff', 'SHA', 'CI', 'repo', 'PR'];
+const everySkill = () => skills.installedSkills({ coreRoot: ROOT, isModuleEnabled: () => true });
+
+await test('every installable skill carries plain, reach-for and cost — none is derived', () => {
+  const all = [...everySkill().values()];
+  assert.ok(all.length >= 60, `the whole tree was read (${all.length})`);
+  const missing = all.flatMap((s) => ['plain', 'reachFor', 'cost'].filter((k) => !s[k] || s[k].length < 15).map((k) => `${s.name}.${k}`));
+  assert.deepEqual(missing, [], 'add plain: / reach-for: / cost: to the SKILL.md frontmatter, written for someone with no engineering background');
+  const derived = all.filter((s) => { const d = skills.explainSkill(s).derived; return d.does || d.reachFor || d.cost; }).map((s) => s.name);
+  assert.deepEqual(derived, [], 'the walkthrough shows the author\'s own words for every skill');
+});
+
+await test('the people-facing lines stay out of the vocabulary they exist to translate', () => {
+  const banned = [...JARGON_TERMS, ...SKILL_JARGON];
+  const hits = [];
+  for (const s of everySkill().values()) {
+    for (const k of ['plain', 'reachFor', 'cost']) {
+      for (const term of banned) {
+        const re = new RegExp(`(^|[^A-Za-z])${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^A-Za-z]|$)`, /^[A-Z+-]+$/.test(term) ? '' : 'i');
+        if (re.test(s[k] || '')) hits.push(`${s.name}.${k}: "${term}"`);
+      }
+    }
+  }
+  assert.deepEqual(hits, []);
+});
+
+await test('a skill with a paid step says so in its cost line', () => {
+  // The ones whose run spends money: every hand-in pays for a quality review,
+  // and image generation is billed per image. Named, so dropping the word from
+  // one of them is caught rather than trusted.
+  const paid = ['builder-ship', 'fix-task', 'builder-sequence', 'grade-recover', 'tweak', 'otb-tile-generate', 'imagegen-frontend-web', 'imagegen-frontend-mobile'];
+  const all = everySkill();
+  const quiet = paid.filter((n) => !/\bpaid\b|costs money/i.test((all.get(n) || {}).cost || ''));
+  assert.deepEqual(quiet, []);
+});
+
 await test('explainSkill splits a model-facing description into what it does, when, and what it costs', () => {
   const e = skills.explainSkill({
     name: 'goal-review', source: 'core',
@@ -262,6 +304,15 @@ try {
     store.speciality = saved;
   });
 
+  await test('GET /specialities/installed-skills lists every installed skill, explained, for the owner\'s picker (task 1004404)', async () => {
+    const r = await call('GET', '/specialities/installed-skills');
+    assert.equal(r.status, 200, `not captured by /specialities/:id: ${JSON.stringify(r.body)}`);
+    assert.deepEqual(r.body.skills.map((s) => s.name), ['costing', 'recall', 'status'], 'every installed skill, by name — the choices are what the instance has');
+    const recall = r.body.skills.find((s) => s.name === 'recall');
+    assert.equal(recall.does, 'Search what the project knows. Read-only.', 'the same explanation the walkthrough shows');
+    assert.match(recall.cost, /^Read-only/);
+  });
+
   await test('PUT /specialities/:id/skills needs an active adoption', async () => {
     store.adoption = null;
     const r = await call('PUT', '/specialities/9/skills', { enabled_skills: ['recall'] });