@bongos/core 1.20.36 → 1.20.38

package/tests/update_channel_db.mjs

@@ -0,0 +1,124 @@
+// tests/update_channel_db.mjs — the unattended sweep follows the update rule set on /deploy
+// (task 1004468, ADR 0357).
+//
+// WHY. /deploy writes provisioning_instances.update_channel (task 1004445), and the Upgrade button
+// obeys it — but the sweep read only the roster file, so cloudbongos.com was set to `minor` on the
+// site and still swept as `patch` (task 1004451's failed proof). These pin the rule: a project row
+// wins, the roster is the fallback, and every fallback says why.
+//
+// Run:  node --test tests/update_channel_db.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const uc = require('../scripts/gds/update-channel.js');
+
+const AVAILABLE = ['1.20.36', '1.20.37', '1.21.0', '2.0.0'];
+const entry = (over = {}) => ({ slug: 'cloudbongos', dir: '/home/lars/cloudbongos', channel: 'patch', env: {}, ...over });
+const dbOf = (rows) => ({ ok: true, channels: new Map(Object.entries(rows)) });
+const targetFor = (inst) => uc.resolveChannelTarget({ installed: '1.20.37', channel: inst.channel, available: AVAILABLE });
+
+test('DB minor + roster patch: the /deploy rule wins and a 1.21.0 target is chosen', () => {
+  const [inst] = uc.applyDbChannels([entry()], dbOf({ cloudbongos: 'minor' }));
+  assert.equal(inst.channel, 'minor');
+  assert.equal(inst.channelSource, uc.CHANNEL_SOURCE_DEPLOY);
+  assert.equal(inst.rosterChannel, 'patch');
+  assert.match(inst.channelNote, /set on \/deploy \(roster says patch, ignored\)/);
+  assert.equal(targetFor(inst), '1.21.0');
+  // Control: the roster alone would have held it on the patch line.
+  assert.equal(targetFor(entry()), null);
+});
+
+test('no project row for the slug: the roster wins, and the log says why', () => {
+  const [inst] = uc.applyDbChannels([entry({ slug: 'charter', channel: 'patch' })], dbOf({ cloudbongos: 'minor' }));
+  assert.equal(inst.channel, 'patch');
+  assert.equal(inst.channelSource, uc.CHANNEL_SOURCE_ROSTER);
+  assert.match(inst.channelNote, /no project row for this slug/);
+});
+
+test('DB pinned: the sweep skips it even when the roster says minor', () => {
+  const [inst] = uc.applyDbChannels([entry({ channel: 'minor' })], dbOf({ cloudbongos: 'pinned' }));
+  assert.equal(inst.channel, 'pinned');
+  assert.equal(targetFor(inst), null);
+  // subscribe.js skips on exactly this value, and decides it AFTER the DB rule is applied.
+  const src = readFileSync(path.join(ROOT, '.claude/scheduled-tasks/core-update-subscription/subscribe.js'), 'utf8');
+  const applied = src.indexOf('channel.applyDbChannels(');
+  const skip = src.indexOf("inst.channel === 'pinned'");
+  assert.ok(applied > 0 && skip > applied, 'the pinned skip must read the channel after the /deploy rule is applied');
+});
+
+test('database unreachable: every entry keeps its roster channel and carries the reason', () => {
+  const insts = uc.applyDbChannels([entry(), entry({ slug: 'charter', channel: 'minor' })], { ok: false, reason: 'psql not found' });
+  assert.deepEqual(insts.map((i) => i.channel), ['patch', 'minor']);
+  for (const i of insts) assert.match(i.channelNote, /from the roster — psql not found/);
+});
+
+test('an unknown value in the row normalises like any channel (never widens)', () => {
+  const [inst] = uc.applyDbChannels([entry()], dbOf({ cloudbongos: 'major' }));
+  assert.equal(inst.channel, uc.normalizeChannel('major'));
+  assert.notEqual(inst.channel, 'minor');
+});
+
+test('readDbChannels: no database named → not read, with the reason, and psql is never spawned', () => {
+  let spawned = false;
+  const r = uc.readDbChannels({ env: {}, run: () => { spawned = true; } });
+  assert.equal(r.ok, false);
+  assert.match(r.reason, /no DATABASE_URL or PGDATABASE/);
+  assert.equal(spawned, false);
+});
+
+test('readDbChannels: parses psql -At tab output into slug → channel, from the sweep env only', () => {
+  let args;
+  const run = (cmd, a) => { args = [cmd, ...a]; return { status: 0, stdout: 'cloudbongos\tminor\ncharter\tpatch\n\n', stderr: '' }; };
+  const r = uc.readDbChannels({ env: { PGDATABASE: 'cloudbongos' }, run });
+  assert.equal(r.ok, true);
+  assert.equal(r.channels.get('cloudbongos'), 'minor');
+  assert.equal(r.channels.get('charter'), 'patch');
+  assert.equal(r.channels.size, 2);
+  assert.deepEqual(args.slice(0, 3), ['psql', '-d', 'cloudbongos']);
+  assert.ok(args.includes('ON_ERROR_STOP=1'));
+});
+
+test('readDbChannels: DATABASE_URL is preferred over PGDATABASE', () => {
+  let target;
+  uc.readDbChannels({ env: { DATABASE_URL: 'postgres://u@h/db', PGDATABASE: 'x' }, run: (_c, a) => { target = a[1]; return { status: 0, stdout: '' }; } });
+  assert.equal(target, 'postgres://u@h/db');
+});
+
+test('readDbChannels: a missing table or psql fails soft with a one-line reason', () => {
+  const noTable = uc.readDbChannels({ env: { PGDATABASE: 'db' }, run: () => ({ status: 1, stdout: '', stderr: 'ERROR:  relation "provisioning_instances" does not exist\nLINE 1: ...' }) });
+  assert.equal(noTable.ok, false);
+  assert.equal(noTable.reason, 'psql exit 1: no provisioning_instances table (provisioning module off?)');
+  const noPsql = uc.readDbChannels({ env: { PGDATABASE: 'db' }, run: () => ({ error: Object.assign(new Error('spawn psql ENOENT'), { code: 'ENOENT' }) }) });
+  assert.deepEqual(noPsql, { ok: false, reason: 'psql not found' });
+});
+
+test('readDbChannels: psql stderr never reaches the reason (it can name a DB user or host)', () => {
+  const stderr = 'psql: error: connection to server at "db.internal.example" (10.0.0.5), port 5432 failed: FATAL:  password authentication failed for user "cloudbongos_admin"';
+  const r = uc.readDbChannels({ env: { DATABASE_URL: 'postgres://x' }, run: () => ({ status: 2, stdout: '', stderr }) });
+  assert.equal(r.reason, "psql exit 2: the sweep's database login was refused");
+  for (const leak of ['db.internal.example', '10.0.0.5', 'cloudbongos_admin']) assert.ok(!r.reason.includes(leak), `reason leaked ${leak}`);
+  assert.equal(uc.psqlFailureClass('something nobody anticipated for user "secret_user"'), 'query failed');
+});
+
+test('channelLine: the sweep log names the channel and where it came from', () => {
+  const [fromDeploy, fromRoster] = uc.applyDbChannels(
+    [entry(), entry({ slug: 'charter', channel: 'patch' })], dbOf({ cloudbongos: 'minor' }));
+  assert.equal(uc.channelLine(fromDeploy), '  • cloudbongos: channel minor, set on /deploy (roster says patch, ignored)');
+  assert.equal(uc.channelLine(fromRoster), '  • charter: channel patch, from the roster — no project row for this slug');
+  const src = readFileSync(path.join(ROOT, '.claude/scheduled-tasks/core-update-subscription/subscribe.js'), 'utf8');
+  assert.match(src, /console\.log\(channel\.channelLine\(inst\)\)/);
+});
+
+test('subscribe.js reads the DB from its own env, never an entry env (which names that instance\'s DB)', () => {
+  const src = readFileSync(path.join(ROOT, '.claude/scheduled-tasks/core-update-subscription/subscribe.js'), 'utf8');
+  assert.match(src, /channel\.readDbChannels\(\{ env: process\.env \}\)/);
+  // A core too old to carry the reader must keep the roster rather than crash the sweep.
+  assert.match(src, /typeof channel\.readDbChannels === 'function'/);
+});