@bongos/core 1.19.1013 → 1.19.1015

package/tests/fleet_cost_view.mjs

@@ -0,0 +1,189 @@
+// tests/fleet_cost_view.mjs — Cost view v1 (task 1001949, ADR 0327): the fleet cost page
+// for the platform owner, and the one estimate line on a cloud-host owner's project page.
+//
+// The rule every case below leans on: an UNPRICED cost (null) renders as unpriced and never
+// as $0, and never moves a total. A $0 there would be a price nobody quoted.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import http from 'node:http';
+import vm from 'node:vm';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (p) => readFileSync(p, 'utf8').replace(/\r\n/g, '\n');
+const costs = require(path.join(HALL, 'fleet-costs.js'));
+const FIXTURE = JSON.parse(read(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'provisioning__fleet__cost-ledger.json')));
+
+// ── the fleet page's builders ────────────────────────────────────────────────
+const row = (over) => ({ id: '1', slug: 'p', owner: 'o', hosting_shape: 'cloud-host', tier: null, status: 'active', platform_monthly_usd: 0, owner_monthly_usd: null, ...over });
+const cells = (html) => [...html.matchAll(/<td[^>]*>([\s\S]*?)<\/td>/g)].map((m) => m[1].replace(/<[^>]+>/g, '').trim());
+const foot = (html) => html.slice(html.indexOf('<tfoot>'));
+
+test('money: whole dollars stay whole, cents show two places, and an unpriced value has no price', () => {
+  assert.equal(costs.money(13), '$13');
+  assert.equal(costs.money(12.5), '$12.50');
+  assert.equal(costs.money(0), '$0');
+  assert.equal(costs.money(null), null);
+  assert.equal(costs.money(undefined), null);
+});
+
+test('an unpriced row reads "not priced yet", never $0 — and a real $0 still reads $0', () => {
+  const html = costs.ledgerHtml({
+    instances: [row({ slug: 'a', platform_monthly_usd: 0, owner_monthly_usd: null })],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 1 } },
+  });
+  const [, , , , us, owner] = cells(html.slice(0, html.indexOf('<tfoot>')));
+  assert.equal(us, '$0', 'a cloud-host costs us a real, measured $0');
+  assert.equal(owner, 'not priced yet');
+});
+
+test('a total sums only priced rows and names how many it left out', () => {
+  const html = costs.ledgerHtml({
+    instances: [
+      row({ slug: 'cp', hosting_shape: 'control-plane', tier: 's-1vcpu-2gb', platform_monthly_usd: 12, owner_monthly_usd: 0 }),
+      row({ slug: 'priced', tier: 'starter+basic-256mb', owner_monthly_usd: 13 }),
+      row({ slug: 'bare', owner_monthly_usd: null }),
+    ],
+    totals: { platform: { monthly_usd: 12, unpriced: 0 }, owner: { monthly_usd: 13, unpriced: 1 } },
+  });
+  const [us, owner] = cells(foot(html));
+  assert.equal(us, '$12');
+  assert.equal(owner, '$13 + 1 not priced', 'the null row is counted, not summed');
+});
+
+test('a column with NOTHING priced has no total — the sum of no prices is not $0', () => {
+  const html = costs.ledgerHtml({
+    instances: [row({ slug: 'a' }), row({ slug: 'b' })],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 2 } },
+  });
+  const [us, owner] = cells(foot(html));
+  assert.equal(us, '$0', 'every row prices at a real $0 for us');
+  assert.equal(owner, 'not priced yet', 'the owner total is not printed as $0');
+});
+
+test('the harness fixture reads as live does today: our box priced, every owner bill but ours unpriced', () => {
+  const [us, owner] = cells(foot(costs.ledgerHtml(FIXTURE)));
+  assert.equal(us, '$12');
+  assert.equal(owner, '$0 + 2 not priced, 1 not visible');
+});
+
+test('the total says what its cells say: a self-hosted bill is "not visible", not "not priced"', () => {
+  const byo = (slug) => row({ slug, hosting_shape: 'byo-host' });
+  const mixed = costs.ledgerHtml({
+    instances: [row({ slug: 'p', tier: 'starter+basic-256mb', owner_monthly_usd: 13 }), byo('a'), byo('b')],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 13, unpriced: 2 } },
+  });
+  assert.equal(cells(foot(mixed))[1], '$13 + 2 not visible');
+  const allByo = costs.ledgerHtml({ instances: [byo('a'), byo('b')], totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 2 } } });
+  assert.equal(cells(foot(allByo))[1], 'not visible to us');
+});
+
+test('a self-hosted owner\'s bill is not ours to see — a different absence from an unrecorded plan', () => {
+  const html = costs.ledgerHtml({ instances: [row({ hosting_shape: 'byo-host' })], totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 1 } } });
+  assert.equal(cells(html)[5], 'not visible to us');
+  assert.equal(cells(html)[2], 'Self-hosted');
+});
+
+test('every row of the fixture is listed, a missing plan says so, and row text is escaped', () => {
+  const html = costs.ledgerHtml(FIXTURE);
+  for (const r of FIXTURE.instances) assert.ok(html.includes(`>${r.slug}<`), `${r.slug} is a row`);
+  assert.match(html, /none recorded/);
+  const hostile = costs.ledgerHtml({ instances: [row({ slug: '<img src=x onerror=1>', owner: '"q"' })], totals: {} });
+  assert.doesNotMatch(hostile, /<img/);
+  assert.match(hostile, /&lt;img src=x onerror=1&gt;/);
+});
+
+test('no projects renders a sentence, not an empty table', () => {
+  assert.match(costs.ledgerHtml({ instances: [], totals: {} }), /No projects are hosted here yet/);
+  assert.match(costs.ledgerHtml(null), /No projects are hosted here yet/);
+});
+
+// ── the page: its wiring and its gate ────────────────────────────────────────
+test('the page loads the builders before its chrome and reads the ledger route', () => {
+  const html = read(path.join(HALL, 'fleet.html'));
+  assert.ok(html.indexOf('fleet-costs.js') !== -1 && html.indexOf('fleet-costs.js') < html.indexOf('/fleet.js'), 'fleet-costs.js loads first');
+  const js = read(path.join(HALL, 'fleet.js'));
+  assert.match(js, /\/provisioning\/fleet\/cost-ledger/);
+  assert.match(js, /status === 403[\s\S]{0,200}fl-sealed/, 'a refusal shows the sealed state');
+});
+
+test('the page gate is the atom the ledger route checks, and the nav mirrors its floor', () => {
+  const route = read(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'));
+  assert.match(route, /router\.get\('\/provisioning\/fleet\/cost-ledger', auth\.requireBuilder, auth\.requirePermission\('provisioning\.fleet\.manage'\)/);
+  assert.match(read(path.join(ROOT, 'src', 'bongos', 'auth.js')), /requireFleetPage: Object\.freeze\(\{ permission: 'provisioning\.fleet\.manage'/);
+  // The nav is cosmetic (the page gate is the wall); 'government' is the metic floor.
+  const { byKey } = require(path.join(ROOT, 'modules', 'government', 'catalog.js'));
+  assert.equal(byKey('provisioning.fleet.manage').floor, 'metic');
+  assert.match(read(path.join(HALL, 'shell.js')), /href: '\/fleet', gate: 'government', module: 'provisioning'/);
+});
+
+// ── the owner's line on their own project page ───────────────────────────────
+const HUB = read(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'));
+function hubFn(name) {
+  const start = HUB.indexOf(`function ${name}(`);
+  assert.ok(start !== -1, `${name} is defined in projects.html`);
+  const end = HUB.indexOf('\n  function ', start + 1);
+  const box = {};
+  vm.runInNewContext(`${HUB.slice(start, end)}\nbox.fn = ${name};`, { box });
+  return box.fn;
+}
+
+test('the owner\'s hosting-bill line: a price when the plan is known, "not priced yet" when not', () => {
+  const hostingBill = hubFn('hostingBill');
+  assert.equal(hostingBill(null), 'not priced yet');
+  assert.equal(hostingBill(undefined), 'not priced yet');
+  assert.equal(hostingBill(13), '$13/month, estimated. Render bills you directly.');
+  assert.equal(hostingBill(12.5), '$12.50/month, estimated. Render bills you directly.');
+});
+
+test('the line is shown only on a live cloud-host — a self-hosted owner\'s bill is theirs', () => {
+  const body = HUB.slice(HUB.indexOf('function renderManage('), HUB.indexOf("$('mMeta').innerHTML", HUB.indexOf('function renderManage(')));
+  assert.match(body, /if \(inst\.hosting_shape === 'cloud-host' && inst\.status !== 'torn_down'\) rows\.push\(\['hosting bill', hostingBill\(inst\.owner_monthly_usd\)\]\);/);
+});
+
+// ── the payload the owner's page reads ───────────────────────────────────────
+const provisioning = require(path.join(ROOT, 'modules', 'provisioning', 'provisioning.js'));
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+let detailRow = null;
+provisioning.getInstanceById = async () => detailRow;
+provisioning.getOpenIntent = async () => null;
+provisioning.getLatestOAuthManifestForInstance = async () => null;
+require(path.join(ROOT, 'modules', 'provisioning', 'catalog-bridge.js')).healInstanceCatalog = async () => {};
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+const express = require('express');
+const app = express();
+app.use((_req, res, next) => {
+  res.fail = (code, opts) => res.status(typeof opts === 'number' ? opts : (opts && opts.status) || 400).json({ error: { code } });
+  next();
+});
+app.use('/api/bongos', require(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'))());
+const getJson = (url) => new Promise((resolve, reject) => {
+  http.get(url, (res) => { let d = ''; res.on('data', (c) => { d += c; }); res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(d || 'null') })); }).on('error', reject);
+});
+
+test('GET /provisioning/instances/:id carries the owner\'s estimate — null until a plan is recorded', async () => {
+  const server = app.listen(0);
+  await new Promise((r) => server.once('listening', r));
+  const url = `http://127.0.0.1:${server.address().port}/api/bongos/provisioning/instances/41`;
+  const base = { id: 41, owner_builder_id: 7, slug: 'p', status: 'active', hosting_shape: 'cloud-host', description: 'd' };
+  try {
+    detailRow = { ...base, tier: null };
+    let r = await getJson(url);
+    assert.equal(r.status, 200);
+    assert.ok('owner_monthly_usd' in r.body.instance, 'the field is present');
+    assert.equal(r.body.instance.owner_monthly_usd, null, 'no plan: unpriced, not 0');
+    detailRow = { ...base, tier: 'starter+basic-256mb' };
+    r = await getJson(url);
+    assert.equal(r.body.instance.owner_monthly_usd, 13, 'the ledger\'s own price for the named plan');
+    detailRow = { ...base, owner_builder_id: 8, tier: 'starter+basic-256mb' };
+    r = await getJson(url);
+    assert.equal(r.status, 404, 'another builder\'s project answers nothing');
+  } finally {
+    server.close();
+  }
+});