@bongos/core 1.19.346 → 1.19.348

package/tests/update_channel.mjs

@@ -8,6 +8,8 @@
 //   4. parseNpmViewVersions — the array / bare-string / empty shapes npm view emits.
 //   5. listAvailableVersions — ok + fail-soft with an injected runner.
 //   6. loadSubscriptions — missing/malformed → empty; channel default + validate; env kept; dropless.
+//   7. describeRoster — an empty roster REPORTS WHY, and is an alarm on a control plane (task 1003158).
+//   8. subscriptionStaleness — releases the channel was entitled to and did not take = "the upgrader stopped".
 //
 // DB-free + network-free (every external is injected). Run:  node tests/update_channel.mjs
 
@@ -182,6 +184,129 @@ t('loadSubscriptions: an entry without a dir is dropped (cannot be upgraded)', (
   assert.equal(r.instances[0].slug, 'real');
 });
 
+// ---- describeRoster: fails closed, no longer fails quiet (task 1003158) ----
+//
+// The regression these pin: before this, a missing manifest, a malformed manifest and a deliberately
+// empty roster were INDISTINGUISHABLE — all three returned a bare `instances: []` and the routine
+// shrugged. cloudbongos.com sat 36 releases behind for days because "nothing happened" looked
+// identical to "nothing needed to happen". Every empty roster must now say WHY, every run.
+
+t('loadSubscriptions: missing file reports reason manifest-absent (not just an empty list)', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'otb-subs-none2-'));
+  const r = uc.loadSubscriptions({ instanceDir: dir });
+  assert.deepEqual(r.instances, []);
+  assert.equal(r.reason, uc.ROSTER_ABSENT);
+  assert.equal(r.dropped, 0);
+});
+
+t('loadSubscriptions: malformed JSON reports reason manifest-malformed + keeps the error', () => {
+  const dir = scratchWith('{ not valid');
+  const r = uc.loadSubscriptions({ instanceDir: dir });
+  assert.equal(r.reason, uc.ROSTER_MALFORMED);
+  assert.match(r.error, /malformed JSON/);
+});
+
+t('loadSubscriptions: parsed-but-unsubscribable reports roster-empty and COUNTS the drops', () => {
+  const dir = scratchWith({ instances: [{ slug: 'ghost' }, { slug: 'alsoghost' }] });
+  const r = uc.loadSubscriptions({ instanceDir: dir });
+  assert.deepEqual(r.instances, []);
+  assert.equal(r.reason, uc.ROSTER_EMPTY);
+  assert.equal(r.dropped, 2);
+});
+
+t('loadSubscriptions: a usable roster reports ok', () => {
+  const dir = scratchWith({ instances: [{ slug: 'cb', dir: '/srv/cb' }] });
+  const r = uc.loadSubscriptions({ instanceDir: dir });
+  assert.equal(r.reason, uc.ROSTER_OK);
+  assert.equal(r.dropped, 0);
+});
+
+t('describeRoster: an empty roster on a CONTROL PLANE is an alarm, not a shrug', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'otb-subs-cp-'));
+  const d = uc.describeRoster(uc.loadSubscriptions({ instanceDir: dir }), { controlPlane: true });
+  assert.equal(d.level, 'alarm');
+  assert.match(d.message, /CONTROL PLANE/);
+  assert.match(d.message, /subscribing NOTHING/);
+});
+
+t('describeRoster: the same empty roster on a plain instance is only a warn (shipped default)', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'otb-subs-plain-'));
+  const d = uc.describeRoster(uc.loadSubscriptions({ instanceDir: dir }));
+  assert.equal(d.level, 'warn');
+  assert.match(d.message, /shipped default/);
+});
+
+t('describeRoster: a malformed manifest is an alarm everywhere', () => {
+  const d = uc.describeRoster(uc.loadSubscriptions({ instanceDir: scratchWith('{ nope') }));
+  assert.equal(d.level, 'alarm');
+  assert.match(d.message, /MALFORMED/);
+});
+
+t('describeRoster: partial loss is surfaced — a healthy-looking sweep that silently skips a row', () => {
+  const dir = scratchWith({ instances: [{ slug: 'cb', dir: '/srv/cb' }, { slug: 'ghost' }] });
+  const d = uc.describeRoster(uc.loadSubscriptions({ instanceDir: dir }));
+  assert.equal(d.level, 'warn');
+  assert.equal(d.dropped, 1);
+  assert.match(d.message, /DROPPED/);
+});
+
+t('describeRoster: a clean roster is ok and says how many it holds', () => {
+  const dir = scratchWith({ instances: [{ slug: 'cb', dir: '/srv/cb' }] });
+  const d = uc.describeRoster(uc.loadSubscriptions({ instanceDir: dir }), { controlPlane: true });
+  assert.equal(d.level, 'ok');
+  assert.equal(d.count, 1);
+});
+
+// ---- subscriptionStaleness: watching the watcher ---------------------------
+
+const RELEASES = Array.from({ length: 41 }, (_, i) => `1.19.${250 + i}`); // 1.19.250 … 1.19.290
+
+t('subscriptionStaleness: reproduces the incident — 1.19.254 on patch is 36 releases behind, stale', () => {
+  const st = uc.subscriptionStaleness({ installed: '1.19.254', channel: 'patch', available: RELEASES });
+  assert.equal(st.behind, 36);
+  assert.equal(st.target, '1.19.290');
+  assert.equal(st.stale, true);
+});
+
+t('subscriptionStaleness: a swept instance is 0 behind and not stale', () => {
+  const st = uc.subscriptionStaleness({ installed: '1.19.290', channel: 'patch', available: RELEASES });
+  assert.equal(st.behind, 0);
+  assert.equal(st.target, null);
+  assert.equal(st.stale, false);
+});
+
+t('subscriptionStaleness: a busy publish-on-merge day under the threshold does NOT cry wolf', () => {
+  const st = uc.subscriptionStaleness({ installed: '1.19.287', channel: 'patch', available: RELEASES });
+  assert.equal(st.behind, 3);
+  assert.equal(st.stale, false);
+});
+
+t('subscriptionStaleness: a pinned instance is never stale (declining is not neglect)', () => {
+  const st = uc.subscriptionStaleness({ installed: '1.19.254', channel: 'pinned', available: RELEASES });
+  assert.equal(st.behind, 0);
+  assert.equal(st.stale, false);
+});
+
+t('subscriptionStaleness: counts only what the CHANNEL may take — minors/majors are not a backlog', () => {
+  const st = uc.subscriptionStaleness({ installed: '1.19.254', channel: 'patch', available: ['1.20.0', '1.20.7', '2.0.0'] });
+  assert.equal(st.behind, 0);
+  assert.equal(st.stale, false);
+  // the same list on the minor channel IS a backlog
+  assert.equal(uc.subscriptionStaleness({ installed: '1.19.254', channel: 'minor', available: ['1.20.0', '1.20.7', '2.0.0'] }).behind, 2);
+});
+
+t('subscriptionStaleness: threshold is overridable; a bad threshold falls back to the default', () => {
+  assert.equal(uc.subscriptionStaleness({ installed: '1.19.287', channel: 'patch', available: RELEASES, threshold: 1 }).stale, true);
+  assert.equal(uc.subscriptionStaleness({ installed: '1.19.287', channel: 'patch', available: RELEASES, threshold: 'nonsense' }).threshold, uc.DEFAULT_STALENESS_THRESHOLD);
+});
+
+t('describeStaleness: silent when healthy, explicit about "the upgrader stopped" when not', () => {
+  assert.equal(uc.describeStaleness(uc.subscriptionStaleness({ installed: '1.19.290', channel: 'patch', available: RELEASES })), null);
+  const msg = uc.describeStaleness(uc.subscriptionStaleness({ installed: '1.19.254', channel: 'patch', available: RELEASES }), { slug: 'cloudbongos.com' });
+  assert.match(msg, /cloudbongos\.com is 36 patch releases behind/);
+  assert.match(msg, /upgrader has most likely stopped/);
+});
+
 console.log(`\nupdate_channel: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);