@bongos/core 1.19.261 → 1.19.263

package/tests/task_lib.mjs

@@ -0,0 +1,115 @@
+// tests/task_lib.mjs
+//
+// task 1002463 — the shared task-domain helpers extracted out of work.js and
+// goals-page.js into modules/hall-ui/public/task-lib.js.
+//
+// WHY THIS FILE EXISTS. The extraction was verified by an equivalence pass against
+// the pristine pre-refactor sources — and that pass MISSED two real regressions,
+// because every input it fed deHashRefs was a string or null. A grader caught them:
+// the digit bound had been "tidied" from \d{1,5} to \d+, and the null guard from
+// (text == null ? '' : text) to (text || ''). Both are behaviour changes hiding in
+// a refactor. The lesson is that equivalence proofs are only as good as their input
+// domain, so the boundaries now have named, checked-in cases.
+//
+// Run:  node tests/task_lib.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const T = require(join(ROOT, 'modules/hall-ui/public/task-lib.js'));
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// ---- deHashRefs: the two regressions, pinned ------------------------------
+t('deHashRefs rewrites a 1-5 digit ref (GitHub would autolink it to an issue)', () => {
+  assert.equal(T.deHashRefs('see #123'), 'see task 123');
+  assert.equal(T.deHashRefs('#1'), 'task 1');
+  assert.equal(T.deHashRefs('#12345'), 'task 12345');
+});
+
+t('deHashRefs LEAVES a 6+ digit run alone — \\d{1,5} is load-bearing by omission', () => {
+  // \d{1,5} followed by \b cannot match inside a longer digit run: after 5 digits
+  // the next char is still a word char, so there is no boundary and no match at
+  // all. Widening to \d+ silently changed this. Pinned so it cannot drift back.
+  assert.equal(T.deHashRefs('#123456'), '#123456');
+  assert.equal(T.deHashRefs('#1002463'), '#1002463');
+  assert.equal(T.deHashRefs('#12345 and #123456'), 'task 12345 and #123456');
+});
+
+t('deHashRefs keeps falsy-but-real input — (text == null) not (!text)', () => {
+  // `text || ''` would swallow these into the empty string.
+  assert.equal(T.deHashRefs(0), '0');
+  assert.equal(T.deHashRefs(false), 'false');
+  assert.equal(T.deHashRefs(NaN), 'NaN');
+  // ...while genuinely absent input is still the empty string.
+  assert.equal(T.deHashRefs(null), '');
+  assert.equal(T.deHashRefs(undefined), '');
+});
+
+// ---- touchesConflict: the parallel-safety predicate -----------------------
+t('touchesConflict: a path collides with itself, its parents and its children', () => {
+  assert.equal(T.touchesConflict(['src'], ['src']), true);
+  assert.equal(T.touchesConflict(['src'], ['src/gds/db.js']), true);
+  assert.equal(T.touchesConflict(['src/gds/db.js'], ['src']), true);
+  assert.equal(T.touchesConflict(['src'], ['srcery']), false, 'prefix must not count as a parent');
+  assert.equal(T.touchesConflict(['a'], ['b']), false);
+});
+
+t('touchesConflict: trailing slashes normalise, non-arrays are inert', () => {
+  assert.equal(T.touchesConflict(['src/'], ['src']), true);
+  assert.equal(T.touchesConflict(null, ['src']), false);
+  assert.equal(T.touchesConflict('src', ['src']), false, 'a bare string is not a list');
+});
+
+// ---- priorityRank / creditsPerMinute: sort keys ---------------------------
+t('priorityRank: unparseable or absent sorts LAST, not first', () => {
+  assert.equal(T.priorityRank('P1'), 1);
+  assert.equal(T.priorityRank('P5'), 5);
+  assert.equal(T.priorityRank(null), 99);
+  assert.equal(T.priorityRank('nonsense'), 99);
+});
+
+t('creditsPerMinute: unpriced/unestimated sinks below a genuine zero ratio', () => {
+  assert.equal(T.creditsPerMinute({ credits_reward: 10, est_minutes: 5 }), 2);
+  assert.equal(T.creditsPerMinute({ credits_reward: 0, est_minutes: 5 }), -Infinity);
+  assert.equal(T.creditsPerMinute({ credits_reward: 10, est_minutes: 0 }), -Infinity);
+  assert.equal(T.creditsPerMinute({}), -Infinity);
+});
+
+// ---- friendlyBatchReason: the bug this extraction fixed -------------------
+t('friendlyBatchReason explains MODULE_CONFLICT — the case goals-page.js had lost', () => {
+  assert.match(
+    T.friendlyBatchReason({ reason: 'MODULE_CONFLICT', module_key: 'ideas', conflictsWithTaskId: 7 }),
+    /shares module "ideas" with task #7/
+  );
+  assert.match(
+    T.friendlyBatchReason({ reason: 'MODULE_CONFLICT', module_key: 'ideas' }),
+    /shares module "ideas" with an active claim/
+  );
+});
+
+t('friendlyBatchReason falls through to the raw code for an unmapped reason', () => {
+  // The failure mode this guards: a new server-side refusal code degrades to the
+  // machine string in the UI rather than throwing. Loud enough to notice, safe.
+  assert.equal(T.friendlyBatchReason({ reason: 'SOME_NEW_CODE' }), 'SOME_NEW_CODE');
+  assert.equal(T.friendlyBatchReason(null), 'not claimable');
+});
+
+// ---- rankTagHtml: escaping ------------------------------------------------
+t('rankTagHtml escapes its label and treats xenos as "no floor"', () => {
+  assert.match(T.rankTagHtml('xenos'), /Any rank/);
+  assert.match(T.rankTagHtml('metic'), /Metic\+/);
+  assert.match(T.rankTagHtml('archon'), /Archon</, 'archon takes no + suffix');
+  assert.doesNotMatch(T.rankTagHtml('<img src=x onerror=1>'), /<img/);
+});
+
+console.log(`\ntask-lib tests: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);