@bongos/core 1.19.838 → 1.19.840

package/tests/provision_caddy_wiring.mjs

@@ -0,0 +1,148 @@
+// tests/provision_caddy_wiring.mjs — provisioning checks the base Caddyfile carries the
+// on-demand TLS ask and imports the site snippets before it reports a domain wired
+// (task 1002860, ADR 0303). Before it, a box missing either directive provisioned
+// "successfully" and the instance was simply unreachable. Hermetic: exec is a fake that
+// answers `caddy adapt` with a fixture of Caddy's resolved JSON.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const P = require('../scripts/gds/provision.js');
+const { caddyWiringGap, checkCaddyWiring } = require('../scripts/gds/provision-net.js');
+
+const DOMAIN = 'mercury.example.com';
+// What `caddy adapt` prints: 2.7 writes the ask as a string, 2.8+ as a permission module.
+const adapted = ({ onDemand, hosts = [] } = {}) => JSON.stringify({
+  apps: {
+    http: { servers: { srv0: { routes: hosts.map((h) => ({ match: [{ host: [h] }] })) } } },
+    ...(onDemand ? { tls: { automation: { on_demand: onDemand } } } : {}),
+  },
+});
+const ASK_27 = { ask: 'http://127.0.0.1:3002/api/bongos/provisioning/tls-check' };
+const ASK_28 = { permission: { module: 'http', endpoint: 'http://127.0.0.1:3002/api/gds/provisioning/tls-check' } };
+const OPTS = { domain: DOMAIN, caddyfile: '/etc/caddy/Caddyfile', snippetDir: '/etc/caddy/sites' };
+
+test('a wired config passes in both the 2.7 ask and the 2.8 permission shape', () => {
+  for (const onDemand of [ASK_27, ASK_28]) {
+    assert.equal(caddyWiringGap(adapted({ onDemand, hosts: [DOMAIN] }), { ...OPTS, requireHost: true }), null);
+  }
+});
+
+test('no on-demand ask, or one aimed elsewhere, names the directive and the file to add it to', () => {
+  for (const onDemand of [undefined, { ask: 'http://127.0.0.1:9000/some-other-check' }]) {
+    const gap = caddyWiringGap(adapted({ onDemand, hosts: [DOMAIN] }), OPTS);
+    assert.match(gap, /on_demand_tls/);
+    assert.match(gap, /\/etc\/caddy\/Caddyfile/);
+    assert.match(gap, /\/provisioning\/tls-check/);
+  }
+});
+
+test('a domain Caddy does not serve after the snippet is written names the missing import', () => {
+  const gap = caddyWiringGap(adapted({ onDemand: ASK_27, hosts: ['other.example.com'] }), { ...OPTS, requireHost: true });
+  assert.match(gap, /import \/etc\/caddy\/sites\/\*\.caddy/);
+  assert.match(gap, /mercury\.example\.com/);
+  assert.equal(caddyWiringGap(adapted({ onDemand: ASK_27 }), OPTS), null, 'the preflight asks only for the ask — no snippet exists yet');
+});
+
+test('output that is not Caddy JSON, or a failed adapt, is a gap rather than a pass or a crash', () => {
+  assert.match(caddyWiringGap('', OPTS), /caddy adapt/);
+  assert.match(caddyWiringGap('null', OPTS), /caddy adapt/);
+  const boom = () => { const e = new Error('Command failed'); e.stderr = Buffer.from('Error: adapting config: Caddyfile:3 - unrecognized directive'); throw e; };
+  assert.match(checkCaddyWiring(boom, OPTS), /unrecognized directive/);
+  const cmds = [];
+  checkCaddyWiring((c) => { cmds.push(c); return { ok: true, stdout: adapted({ onDemand: ASK_27 }) }; }, OPTS);
+  assert.deepEqual(cmds, ['caddy adapt --config /etc/caddy/Caddyfile --adapter caddyfile'], 'unprivileged and read-only');
+});
+
+// -- the runner legs --------------------------------------------------------
+
+const coTenant = { id: 1, slug: 'mercury', hosting_shape: 'co-tenant', status: 'requested', owner_builder_id: 7, port: 3003, db_name: 'mercury', domain: DOMAIN };
+const activeStandalone = { id: 18, slug: 'spike', hosting_shape: 'standalone', status: 'active', owner_builder_id: 7, port: 3010, db_name: 'spike', domain: 'spike.example.com' };
+const WEB_ENV = 'PORT=3010\nBONGOS_PUBLIC_ORIGIN=https://old.example.com\n';
+
+// `served` = the hosts Caddy's resolved config carries once a snippet is written — the
+// fake flips to them after the first .caddy write, like the real import would.
+function harness({ onDemand = ASK_27, importsSnippets = true, reloadFails = false } = {}) {
+  const cmds = [], writes = [], statuses = [];
+  let snippetWritten = null;
+  const exec = (cmd, opts = {}) => {
+    cmds.push({ cmd, opts });
+    if (cmd.startsWith('caddy adapt')) return { ok: true, stdout: adapted({ onDemand, hosts: importsSnippets && snippetWritten ? [snippetWritten] : [] }) };
+    if (/cat\b.*web\.env/.test(cmd)) return { ok: true, stdout: WEB_ENV };
+    if (/reload caddy/.test(cmd) && reloadFails) throw new Error('Job for caddy.service failed');
+    return { ok: true, stdout: '' };
+  };
+  const deps = {
+    apply: true, log: () => {}, sleep: async () => {},
+    db: { query: async () => ({ rows: [] }) },
+    provisioning: {
+      setInstanceStatus: async (_db, _id, s) => { statuses.push(s); }, recordEvent: async () => {},
+      recordDnsNote: async () => {}, clearReleasedDomains: async () => {},
+    },
+    exec,
+    writeFile: (p, body) => { writes.push(p); if (p.endsWith('.caddy')) snippetWritten = (/^(\S+) \{/.exec(body) || [])[1] || null; return { ok: true }; },
+    doApi: null,
+    checkDnsTokenScope: async () => ({ reachable: true, zone: 'example.com' }),
+    getGithubToken: async () => null,
+  };
+  const ran = (re) => cmds.some((c) => re.test(c.cmd));
+  return { deps, cmds, writes, statuses, ran };
+}
+
+test('provision: a box with no tls-check ask is refused before anything on it changes', async () => {
+  const h = harness({ onDemand: null });
+  const r = await P.provisionInstance(coTenant, h.deps);
+  assert.equal(r.ok, false);
+  assert.match(r.error, /^Caddy preflight failed: .*on_demand_tls/);
+  assert.equal(h.writes.length, 0, 'no file written');
+  assert.ok(!h.ran(/createdb|systemctl/), 'no database or service touched');
+  assert.deepEqual(h.statuses, [], 'the instance never flips to provisioning');
+});
+
+test('provision: a snippet Caddy never imports fails the run instead of reporting success, and Caddy is not reloaded', async () => {
+  const h = harness({ importsSnippets: false });
+  const r = await P.provisionInstance(coTenant, h.deps);
+  assert.equal(r.ok, false);
+  assert.match(r.error, /^Caddy wiring failed: .*import \/etc\/caddy\/sites\/\*\.caddy/);
+  assert.ok(h.writes.some((p) => p.endsWith('/mercury.caddy')), 'the snippet was written first — that is what the check proves Caddy reads');
+  assert.ok(!h.ran(/reload caddy/));
+  assert.ok(!h.ran(/healthz/), 'never reaches the healthz step');
+});
+
+test('provision: a wired box reloads Caddy loudly — a rejected reload fails the run', async () => {
+  const ok = harness();
+  assert.equal((await P.provisionInstance(coTenant, ok.deps)).ok, true);
+  const reload = ok.cmds.find((c) => /reload caddy/.test(c.cmd));
+  assert.ok(reload, 'reloads');
+  assert.notEqual(reload.opts.allowFail, true, 'not allowFail');
+  await assert.rejects(P.provisionInstance(coTenant, harness({ reloadFails: true }).deps), /caddy\.service failed/);
+});
+
+test('provision: a domainless instance and a dry run never call caddy adapt', async () => {
+  const bare = harness({ onDemand: null });
+  assert.equal((await P.provisionInstance({ ...coTenant, domain: null }, bare.deps)).ok, true);
+  const dry = harness({ onDemand: null });
+  dry.deps.apply = false;
+  await P.provisionInstance(coTenant, dry.deps);
+  assert.ok(!bare.ran(/caddy adapt/) && !dry.ran(/caddy adapt/));
+});
+
+test('domain-attach: refused before the env patch without the ask; fails loudly when the snippet is not imported', async () => {
+  const noAsk = harness({ onDemand: null });
+  const r1 = await P.domainAttachInstance(activeStandalone, noAsk.deps);
+  assert.equal(r1.ok, false);
+  assert.match(r1.error, /^Caddy preflight failed/);
+  assert.equal(noAsk.writes.length, 0, 'web.env untouched');
+  assert.ok(!noAsk.ran(/systemctl/));
+
+  const noImport = harness({ importsSnippets: false });
+  const r2 = await P.domainAttachInstance(activeStandalone, noImport.deps);
+  assert.equal(r2.ok, false);
+  assert.match(r2.error, /^Caddy wiring failed: .*spike\.example\.com/);
+  assert.ok(!noImport.ran(/reload caddy/));
+
+  const wired = harness();
+  assert.equal((await P.domainAttachInstance(activeStandalone, wired.deps)).ok, true);
+  assert.notEqual(wired.cmds.find((c) => /reload caddy/.test(c.cmd)).opts.allowFail, true);
+});

package/tests/status_company_attribution.mjs

@@ -0,0 +1,60 @@
+// tests/status_company_attribution.mjs — the status page footer's company clause
+// comes from the branding pack, and disappears whole when the pack names no company
+// (task 1002853). Before it, a vanilla instance's CORE-served status page credited
+// the founder's own logistics company as its maker.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { applyBrandTokens } = require('../src/bongos/serve-internal.js');
+const { clientBranding } = require('../src/branding.js');
+const { brandTokens } = require('../scripts/status-mirror-sync.js');
+
+const PAGE = readFileSync(new URL('../modules/status-ui/public/index.html', import.meta.url), 'utf8');
+const brand = (company) => ({ identity: { productName: 'Acme Rockets', worldName: 'Acme', company }, currency: { label: 'tokens' } });
+const footer = (html) => html.match(/<footer[\s\S]*?<\/footer>/)[0];
+const stamp = (company) => footer(applyBrandTokens(PAGE, brand(company), 'https://acme.example', '', '', '', ''));
+
+test('the source page names no company and carries every company slot as a token', () => {
+  assert.doesNotMatch(PAGE, /hermeslines|cleveland/i);
+  for (const t of ['companyName', 'companySite', 'companyTagline']) assert.ok(PAGE.includes(`{{${t}}}`), `{{${t}}} is missing`);
+});
+
+test('a pack with no company drops the whole attribution sentence, not half of it', () => {
+  const out = stamp({ name: '', site: 'https://ignored.example', tagline: 'ignored' });
+  assert.doesNotMatch(out, /is the work of|ignored/);
+  assert.doesNotMatch(out, /\{\{|brand-if/);
+  assert.match(out, /Tokens are wrought/, 'the neighbouring footer lines survive');
+});
+
+test('a full company renders the linked name and its tagline', () => {
+  const out = stamp({ name: 'Acme Corp', site: 'https://acme-corp.example', tagline: 'a rocket works in Dayton' });
+  assert.match(out, /<p>Acme is the work of <a href="https:\/\/acme-corp\.example" target="_blank" rel="noopener"><strong>Acme Corp<\/strong><\/a>, a rocket works in Dayton\.<\/p>/);
+  assert.doesNotMatch(out, /\{\{|brand-if/);
+});
+
+test('a company with no site or tagline renders the bare name, never an empty href or a dangling comma', () => {
+  const out = stamp({ name: 'Acme Corp', site: '', tagline: '' });
+  assert.match(out, /<p>Acme is the work of <strong>Acme Corp<\/strong>\.<\/p>/);
+  assert.doesNotMatch(out, /href=""|, \./);
+});
+
+test('company values are escaped like every other token', () => {
+  const out = stamp({ name: 'A<b>', site: 'https://x.example/"onmouseover="x', tagline: '' });
+  assert.ok(out.includes('<strong>A&lt;b&gt;</strong>'));
+  assert.ok(out.includes('href="https://x.example/&quot;onmouseover=&quot;x"'));
+});
+
+test('the off-box mirror stamps the footer exactly as the served page does (KEEP IN SYNC)', () => {
+  for (const company of [{ name: '', site: '', tagline: '' }, { name: 'Acme Corp', site: 'https://acme-corp.example', tagline: 'a rocket works' }, { name: 'Acme Corp', site: '', tagline: '' }]) {
+    assert.equal(footer(brandTokens(PAGE, brand(company), 'https://acme.example')), stamp(company));
+  }
+});
+
+test('clientBranding exposes the company site and tagline the footer stamps from', () => {
+  const c = clientBranding({ identity: { company: { name: 'Acme Corp', site: 'https://acme-corp.example', tagline: 'a rocket works' } } });
+  assert.deepEqual(c.identity.company, { name: 'Acme Corp', site: 'https://acme-corp.example', tagline: 'a rocket works' });
+  assert.deepEqual(clientBranding({}).identity.company, { name: '', site: '', tagline: '' });
+});