@bongos/core 1.20.77 → 1.20.79

package/tests/update_subscription_engine.mjs

@@ -766,3 +766,102 @@ test('the post-upgrade net re-probes, rather than reusing the set from before th
   assert.match(beforeSpawn, /const pre = pinState\(inst\.dir, spawnSync, generated\);/,
     'the heal runs before the bump, so it reads the core installed THEN');
 });
+
+// ── the follow (task 1004297, ADR 0360) ─────────────────────────────────────────────
+//
+// followTarget is the sweep's whole decision about WHICH version an instance moves to. It
+// runs the REAL update-channel.js math; only the registry read is stood in for, the way
+// every other case here injects its externals.
+
+const UC = require('../scripts/gds/update-channel.js');
+const PUBLISHED = ['1.19.1039', '1.19.1040', '1.19.1041', '1.20.0'];
+// The real module, with its dist-tags read answering from `tags` (or failing).
+function channelWith(tags) {
+  return {
+    ...UC,
+    readReleaseTags: () => (tags ? UC.readReleaseTags({ run: () => ({ status: 0, stdout: JSON.stringify(tags) }) })
+      : UC.readReleaseTags({ run: () => ({ status: 1, stderr: 'npm ERR! network timeout' }) })),
+  };
+}
+const aim = (inst, channel) => S.followTarget({ inst: entry(inst), installed: '1.19.1039', channel, versions: PUBLISHED, env: {} });
+
+test('follow candidates: the platform takes the newest version its channel allows, whatever is released', () => {
+  assert.deepEqual(aim({ follow: 'candidates' }, channelWith({ latest: '1.19.1039' })), { follow: 'candidates', target: '1.19.1041', held: null });
+});
+
+test('follow released: every other project stops at the released label', () => {
+  assert.deepEqual(aim({ follow: 'released' }, channelWith({ latest: '1.19.1040', next: '1.19.1041' })), { follow: 'released', target: '1.19.1040', held: null });
+  assert.deepEqual(aim({ follow: 'released' }, channelWith({ latest: '1.19.1039' })), { follow: 'released', target: null, held: null }, 'up to date on the release');
+});
+
+test('follow released with an unreadable label is SKIPPED, never upgraded on a guess', () => {
+  const r = aim({ follow: 'released' }, channelWith(null));
+  assert.equal(r.target, undefined);
+  assert.match(r.skip, /could not read which version is released \(npm ERR! network timeout\)/);
+});
+
+test('a core that predates the follow keeps the old reading: every published version', () => {
+  const { readReleaseTags, versionsForFollow, ...oldCore } = UC;
+  assert.equal(aim({}, oldCore).target, '1.19.1041', 'no follow on the entry — the roster came from an older core');
+  assert.equal(aim({ follow: 'released' }, oldCore).target, '1.19.1041', 'no dist-tags reader: before the split every version was a release');
+});
+
+test('the sweep asks followTarget, and says the follow on every line it prints', () => {
+  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const main = src.slice(src.indexOf('function main('));
+  assert.match(main, /followTarget\(\{ inst, installed, channel, versions: listed\.versions/);
+  assert.doesNotMatch(main, /resolveChannelTarget\(\{ installed, channel: inst\.channel, available: listed\.versions/, 'the unfiltered list never reaches the target');
+  assert.match(main, /follows: \$\{aim\.follow\}/);
+});
+
+// ── a version that failed here is held, not retried every sweep (task 1004297) ──────
+//
+// At a 15-minute cadence an unguarded lane would install a bad version, fail its health
+// check, restart the service and roll back four times an hour until a fix was published.
+
+const NOW = Date.parse('2026-09-26T18:00:00Z');
+const hoursAgo = (h) => new Date(NOW - h * 3600000).toISOString();
+
+test('a held version is skipped and named; a NEWER version is still taken at once', () => {
+  const held = S.heldVersions({ demo: [{ version: '1.19.1041', at: hoursAgo(1), reason: 'exit 1' }] }, 'demo', NOW);
+  const r = S.followTarget({ inst: entry({ follow: 'candidates' }), installed: '1.19.1039', channel: UC, versions: ['1.19.1040', '1.19.1041'], env: {}, held });
+  assert.equal(r.target, '1.19.1040', 'the held version is not retried');
+  assert.deepEqual(r.held, { version: '1.19.1041', at: hoursAgo(1), reason: 'exit 1' });
+
+  const fixed = S.followTarget({ inst: entry({ follow: 'candidates' }), installed: '1.19.1039', channel: UC, versions: ['1.19.1040', '1.19.1041', '1.19.1042'], env: {}, held });
+  assert.equal(fixed.target, '1.19.1042', 'the fix is taken the moment it is published');
+  assert.equal(fixed.held, null, 'and no hold is reported, because none changed the answer');
+});
+
+test('a hold is per instance and expires after a day', () => {
+  const refusals = { demo: [{ version: '1.19.1041', at: hoursAgo(25) }, { version: '1.19.1042', at: hoursAgo(2) }], other: [{ version: '1.19.1043', at: hoursAgo(1) }] };
+  assert.deepEqual([...S.heldVersions(refusals, 'demo', NOW).keys()], ['1.19.1042'], 'a day-old failure is retried');
+  assert.deepEqual([...S.heldVersions(refusals, 'nobody', NOW).keys()], []);
+  assert.equal(S.REFUSAL_HOLD_MS, 24 * 3600000);
+  for (const bad of [null, 'x', { demo: 'x' }, { demo: [null, { version: 7 }, { version: '1.0.0', at: 'not a date' }] }]) {
+    assert.deepEqual([...S.heldVersions(bad, 'demo', NOW).keys()], [], JSON.stringify(bad));
+  }
+});
+
+test('recordRefusal writes outside the instance, keeps only live holds, and never throws', () => {
+  const dir = mkdtempSync(path.join(tmpdir(), 'refusals-'));
+  const file = path.join(dir, 'nested', 'core-update-refused.json');
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1041', reason: 'exit 1', now: NOW - 30 * 3600000 }), true);
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1042', reason: 'exit 1', now: NOW }), true);
+  const all = JSON.parse(readFileSync(file, 'utf8'));
+  assert.deepEqual(all.demo.map((r) => r.version), ['1.19.1042'], 'the expired hold was dropped on write');
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1042', now: NOW + 1000 }), true);
+  assert.equal(JSON.parse(readFileSync(file, 'utf8')).demo.length, 1, 'the same version is one row, re-dated');
+  assert.equal(S.recordRefusal({ file: null, slug: 'demo', version: '1' }), false);
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1', writeFile: () => { throw new Error('EROFS'); } }), false, 'a failed write costs a retry, not the sweep');
+  assert.deepEqual(S.readRefusals(path.join(dir, 'missing.json')), {});
+});
+
+test('the sweep holds a version only when it did not go in', () => {
+  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const at = src.indexOf('if (res.status !== 0) {');
+  const failBranch = src.slice(at, src.indexOf('failed++; continue;', at));
+  assert.match(failBranch, /if \(readInstalledCoreVersion\(inst\.dir\) !== target\) \{\s*const held = recordRefusal\(/);
+  assert.match(src, /held: heldVersions\(refusals, label, Date\.now\(\)\)/, 'every target is chosen with the holds applied');
+  assert.match(src, /return path\.join\(require\('\.\.\/\.\.\/src\/instance-config\.js'\)\.configHome\(\), REFUSALS_FILE\)/, 'the record lives in the config home, never the instance tree');
+});

package/tests/upgrade_migrate.mjs

@@ -47,7 +47,7 @@ function adoptedProject({ installed = '1.19.312' } = {}) {
   return dir;
 }
 
-function scaffoldedProject(scripts = { migrate: init.INSTANCE_MIGRATE_SCRIPT, start: init.INSTANCE_START_SCRIPT }) {
+function scaffoldedProject(scripts = { migrate: init.INSTANCE_MIGRATE_SCRIPT, hall: init.INSTANCE_HALL_SCRIPT }) {
   const dir = fixture('upgrade-migrate-scaffold-');
   writeFileSync(path.join(dir, 'package.json'), `${JSON.stringify({ name: 'charter', private: true, scripts, dependencies: { '@bongos/core': '1.19.871' } }, null, 2)}\n`);
   return dir;