@bongos/core 1.21.45 → 1.21.46

package/tests/wizard_github_feedback.mjs

@@ -0,0 +1,239 @@
+// tests/wizard_github_feedback.mjs — the setup checklist tells the founder the truth
+// at every GitHub sign-in stage (task 1004572).
+//
+// WHY. Live on 2026-10-04, a founder setting up mercury was told, in turn:
+//   • "Waiting for your approval on GitHub…" while the platform was already placing
+//     the credentials ('converting' fell through to the pending branch);
+//   • "GitHub setup didn't start. Nothing was changed on GitHub" after GitHub HAD made
+//     an app on their account — so they made another, and another;
+//   • and, once a setup link lapsed, nothing at all: no button, forever, because a
+//     lapsed 'pending' row was never read as expired and the "start again" offer was
+//     timed from a click that a reload forgets;
+//   • and on the project itself, a bare "auth not configured".
+//
+// Four layers, all DB-free and network-free:
+//   1. manifest-truth.js — the effective status and how far a failure got (PURE).
+//   2. renderStepOauthApp, EXECUTED by the vm-slice idiom: the words for each stage.
+//   3. the reload path, EXECUTED: the seed from the instance read and the wait timer.
+//   4. the project's own sign-in door with nothing configured: a page in words.
+//
+// Run:  node --test tests/wizard_github_feedback.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+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 require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
+
+const truth = require(path.join(ROOT, 'modules', 'provisioning', 'manifest-truth.js'));
+
+// ── 1. manifest-truth.js ────────────────────────────────────────────────────
+
+const NOW = Date.parse('2026-10-04T20:30:00Z');
+const LATER = '2026-10-04T20:45:00Z';
+const EARLIER = '2026-10-04T20:15:00Z';
+
+test('a pending link past its expiry reads EXPIRED; one still live stays pending', () => {
+  assert.equal(truth.effectiveManifestStatus({ status: 'pending', expires_at: EARLIER }, NOW), 'expired');
+  assert.equal(truth.effectiveManifestStatus({ status: 'pending', expires_at: LATER }, NOW), 'pending');
+  // only 'pending' decays — a finished or failed attempt keeps its word
+  for (const s of ['code_received', 'converting', 'done', 'error']) {
+    assert.equal(truth.effectiveManifestStatus({ status: s, expires_at: EARLIER }, NOW), s, s);
+  }
+});
+
+test('how far a failure got is read from the row\'s shape, never from error text', () => {
+  assert.equal(truth.manifestFailure({ attempts: 0 }), 'not_approved');
+  assert.equal(truth.manifestFailure({ attempts: 1, app_slug: 'mercury-cloudbongos-com' }), 'sign_in_unconfirmed');
+  assert.equal(truth.manifestFailure({ attempts: 1, app_slug: null, last_error: 'did not report sign-in ready' }), 'finish_failed',
+    'an error message alone claims nothing — only a recorded App does');
+  assert.deepEqual([...truth.MANIFEST_FAILURES].sort(), ['finish_failed', 'not_approved', 'sign_in_unconfirmed']);
+});
+
+test('publicGithubApp: effective status, failure only on error, started_at, and nothing else', () => {
+  const row = { status: 'pending', expires_at: EARLIER, created_at: '2026-10-04T19:57:35.018Z', github_code: 'SECRET', state: 'SECRET', last_error: 'SECRET' };
+  const pub = truth.publicGithubApp(row, NOW);
+  assert.deepEqual(pub, { status: 'expired', app_slug: null, failure: null, started_at: '2026-10-04T19:57:35.018Z' });
+  assert.doesNotMatch(JSON.stringify(pub), /SECRET/);
+  assert.equal(truth.publicGithubApp({ status: 'error', attempts: 1, app_slug: 'a' }, NOW).failure, 'sign_in_unconfirmed');
+  assert.equal(truth.publicGithubApp(null), null);
+});
+
+// ── 2. the words for each stage ─────────────────────────────────────────────
+
+const RS = SCRIPT.indexOf('    /* oauth-app — the ADR 0133 one-click GitHub-App manifest flow');
+const RE = SCRIPT.indexOf('    /* device-flow', RS);
+const RENDER = SCRIPT.slice(RS, RE);
+
+test('the GitHub step region is still findable (a rename must fail loudly)', () => {
+  assert.ok(RS > 0 && RE > RS, 'both slice boundaries found');
+  assert.match(RENDER, /function renderStepOauthApp\(\)/);
+});
+
+function stage(live, { stale = false } = {}) {
+  const sandbox = {
+    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, instStatus: 'active', addrReady: true, ...live },
+    manifestStale: stale,
+    autoOpenArmed: false,
+    resolvedDomain: () => 'mercury.example.com',
+    apexBase: () => 'example.com',
+    esc: (x) => String(x).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])),
+    GH_ICON: '',
+    manualOauthDetails: () => '<details>manual</details>',
+    projectPageLink: (t) => '<a>' + t + '</a>',
+    autoOpenTick: () => '<label>auto</label>',
+    progressMarkup: (now, done, note, cls) => `<prog now=${now} done=${done} cls="${cls}">${note}</prog>`,
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(`${RENDER}\nvar out = renderStepOauthApp();`, sandbox);
+  return sandbox.out;
+}
+const startButton = /data-action="manifest-start"/;
+
+test('pending: waiting for approval, and says where a missing GitHub tab went', () => {
+  const html = stage({ manifest: 'pending' });
+  assert.match(html, /Waiting for your approval on GitHub/);
+  assert.match(html, /No GitHub tab\? It may have opened behind this window or in another one/);
+  assert.doesNotMatch(html, startButton, 'no restart offer while the wait is young');
+  assert.match(stage({ manifest: 'pending' }, { stale: true }), /Start the setup again/, 'offered once the wait has gone wrong');
+});
+
+test('converting is the SAME stage as code_received — approved, placing credentials — never "waiting for approval"', () => {
+  for (const m of ['code_received', 'converting']) {
+    const html = stage({ manifest: m });
+    assert.match(html, /GitHub’s part is done/, m);
+    assert.match(html, /<prog now=1 done=1/, `${m}: the strip is past the approval stage`);
+    assert.doesNotMatch(html, /Waiting for your approval/, m);
+  }
+});
+
+test('a failure AFTER approval says an app now exists, names it, and does not push a second one', () => {
+  const html = stage({ manifest: 'error', manifestFailure: 'sign_in_unconfirmed', appSlug: 'mercury-cloudbongos-com' });
+  assert.match(html, /GitHub approved the app and the platform placed its credentials/);
+  assert.match(html, /href="https:\/\/github\.com\/settings\/apps\/mercury-cloudbongos-com"/);
+  assert.match(html, /would make a second app/);
+  assert.match(html, /href="\/contact"/);
+  assert.match(html, /cls="isErr"/, 'the strip shows where it stopped');
+  assert.doesNotMatch(html, /Nothing was changed on GitHub/, 'the old claim was false here');
+  assert.doesNotMatch(html, /class="ghbtn"/, 'no big primary "set up" button inviting a second app');
+  assert.match(html, /Try again anyway/, '…but the founder is never left with no way forward');
+});
+
+test('approved but never finished: delete the app GitHub made first, then try again', () => {
+  const html = stage({ manifest: 'error', manifestFailure: 'finish_failed' });
+  assert.match(html, /GitHub approved the app, but the platform couldn’t finish/);
+  assert.match(html, /delete it first/);
+  assert.doesNotMatch(html, /Nothing was changed on GitHub/);
+  assert.match(html, startButton);
+});
+
+test('a failure before GitHub (or a refused start) keeps the honest "nothing changed" line', () => {
+  assert.match(stage({ manifest: 'error', manifestFailure: 'not_approved' }), /Nothing was changed on GitHub/);
+  const refused = stage({ manifest: 'error', manifestMsg: 'HTTP 500' });
+  assert.match(refused, /Nothing was changed on GitHub/);
+  assert.match(refused, /Technical details/);
+  assert.match(refused, startButton);
+});
+
+test('an expired link offers a fresh one', () => {
+  const html = stage({ manifest: 'expired' });
+  assert.match(html, /That setup link expired/);
+  assert.match(html, startButton);
+});
+
+// ── 3. the reload path ──────────────────────────────────────────────────────
+
+const WS = SCRIPT.indexOf('    function manifestInFlight() {');
+const WE = SCRIPT.indexOf('    function pollManifest(stateToken) {', WS);
+const WAIT = SCRIPT.slice(WS, WE);
+const SS = SCRIPT.indexOf('            var ga = data.github_app;');
+const SE = SCRIPT.indexOf('            /* the checklist reflects live state (task 1002694)', SS);
+const SEED = SCRIPT.slice(SS, SE);
+
+test('the reload regions are still findable (a rename must fail loudly)', () => {
+  assert.ok(WS > 0 && WE > WS, 'wait-timer boundaries found');
+  assert.ok(SS > 0 && SE > SS, 'instance-read seed boundaries found');
+  assert.match(SCRIPT, /if \(!terminal \|\| manifestInFlight\(\)\) pollTimer = setTimeout\(tick, 5000\);/,
+    'a GitHub leg in flight keeps the instance read alive once the project is up — after a reload it is the only watcher');
+});
+
+// A page that RELOADED: no click in this tab, no manifest poll, just the instance read.
+function reloaded(githubApp, now) {
+  const renders = [];
+  const sandbox = {
+    data: { github_app: githubApp },
+    live: { manifest: null, manifestFailure: null, appSlug: null },
+    manifestPollTimer: null, manifestStartedAt: 0, manifestStale: false,
+    rememberManifest: () => {}, renderSteps: () => renders.push(1),
+    Date: { now: () => now, parse: Date.parse },
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(`${WAIT}\n${SEED}`, sandbox);
+  return { sandbox, renders, tick: () => vm.runInContext(SEED, sandbox) };
+}
+
+test('a reloaded page times the wait from when the link was minted, and still reaches "start again"', () => {
+  const minted = '2026-10-04T20:20:00Z';
+  const young = reloaded({ status: 'pending', app_slug: null, failure: null, started_at: minted }, Date.parse(minted) + 30000);
+  assert.equal(young.sandbox.live.manifest, 'pending');
+  assert.equal(young.sandbox.manifestStartedAt, Date.parse(minted), 'seeded from the server');
+  assert.equal(young.sandbox.manifestStale, false);
+
+  const old = reloaded({ status: 'pending', app_slug: null, failure: null, started_at: minted }, Date.parse(minted) + 120000);
+  old.tick();   // the next 5s read: same status, so the wait timer decides
+  assert.equal(old.sandbox.manifestStale, true, 'the offer appears — it used to be never after a reload');
+  assert.equal(vm.runInContext('manifestInFlight()', old.sandbox), true);
+});
+
+test('a reloaded page learns HOW a failure happened, not just that it did', () => {
+  const r = reloaded({ status: 'error', app_slug: 'mercury-cloudbongos-com', failure: 'sign_in_unconfirmed', started_at: null }, NOW);
+  assert.equal(r.sandbox.live.manifest, 'error');
+  assert.equal(r.sandbox.live.manifestFailure, 'sign_in_unconfirmed');
+  assert.equal(r.sandbox.live.appSlug, 'mercury-cloudbongos-com');
+  assert.equal(vm.runInContext('manifestInFlight()', r.sandbox), false, 'a finished attempt stops the watch');
+});
+
+test('the reset literal and the initial literal still agree, failure field included', () => {
+  const lits = SCRIPT.match(/live = \{ instStatus: null[^}]*\}/g) || [];
+  assert.equal(lits.length, 2);
+  assert.equal(lits[0].replace(/^var /, ''), lits[1]);
+  assert.match(lits[0], /manifestFailure: null/);
+});
+
+// ── 4. the project's own door with nothing configured ───────────────────────
+
+test('a project with no sign-in configured answers a page in words, not a bare "auth not configured"', async () => {
+  const auth = require(path.join(ROOT, 'src', 'bongos', 'auth.js'));
+  const prev = { a: auth.authConfigured, i: auth.idpConfigured };
+  auth.authConfigured = () => false;
+  auth.idpConfigured = () => false;
+  const express = require('express');
+  const buildAuthRouter = require(path.join(ROOT, 'src', 'bongos', 'routes', 'auth.js'));
+  const app = express();
+  app.use('/api/bongos', buildAuthRouter());
+  const server = app.listen(0);
+  try {
+    await new Promise((r) => server.once('listening', r));
+    const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+    for (const p of ['/auth/web/start', '/auth/web/callback']) {
+      const res = await fetch(base + p);
+      const html = await res.text();
+      assert.equal(res.status, 503, p);
+      assert.match(res.headers.get('content-type') || '', /text\/html/, p);
+      assert.match(html, /Sign-in isn&#39;t set up on this project yet|Sign-in isn't set up on this project yet/, p);
+      assert.match(html, /Wire GitHub sign-in/, `${p}: points the owner at the step that fixes it`);
+      assert.doesNotMatch(html, /^auth not configured$/, p);
+    }
+  } finally {
+    server.close();
+    auth.authConfigured = prev.a; auth.idpConfigured = prev.i;
+  }
+});