@bongos/core 1.21.168 → 1.21.170

package/src/bongos/module-store.js

@@ -256,12 +256,34 @@ function isFreePrice(priceRow) {
   return priceRow.price_cents === 0 || priceRow.price_credits === 0;
 }
 
+// The release channels a project is handed versions from (task 1003805, ADR 0344
+// D1/D2): a project that tests this module gets tester AND general versions, every
+// other project general only. 'withdrawn' is never in either list, so a withdrawn
+// version is never handed out (a copy already installed keeps working, ADR 0338 D2).
+function servedChannels(tester) {
+  return tester ? ['tester', 'general'] : ['general'];
+}
+
+// A version's current channel is its newest store_module_version_channels row
+// (core_276): a move is a new row, never an update. One probe per version into
+// idx_store_module_version_channels_current. `idCol` is the outer query's version
+// id column, and only these two literals are accepted, so no text reaches the SQL.
+const VERSION_ID_COLS = new Set(['store_module_versions.id', 'v.id']);
+function currentChannelSql(idCol) {
+  if (!VERSION_ID_COLS.has(idCol)) throw new Error(`currentChannelSql: unexpected column ${idCol}`);
+  return `(SELECT c.channel FROM store_module_version_channels c
+           WHERE c.version_id = ${idCol} ORDER BY c.set_at DESC, c.id DESC LIMIT 1)`;
+}
+
 // Resolve what an acquire of `key` (optionally at an exact `version`) would hand
 // over. Refuses an unknown or delisted module (ADR 0338 D2: a delisted module takes
 // no new acquisitions and serves no further versions) and an unknown version. With
 // no version asked for, the newest published version (semver order, not text).
+// `channels` (from servedChannels) limits it to versions currently on those
+// channels — the newest one there, or a refusal for an exact version that is not;
+// null skips the channel check (recording a version already placed).
 // Returns { ok: true, module, version, price, free } or { ok: false, status, code, message }.
-async function resolveAcquirable(key, { version = null, db } = {}) {
+async function resolveAcquirable(key, { version = null, channels = null, db } = {}) {
   const pool = db || require('./pool').pool;
   const refuse = (status, code, message) => ({ ok: false, status, code, message });
   const { rows: [mod] } = await pool.query(
@@ -270,16 +292,28 @@ async function resolveAcquirable(key, { version = null, db } = {}) {
   if (mod.status === 'delisted') return refuse(409, 'module_delisted', `"${key}" is delisted: it can no longer be acquired or downloaded (ADR 0338 D2).`);
   const { rows: versions } = await pool.query(
     `SELECT id, module_key, version, core_version, tree_sha256, tarball_sha256, tarball_bytes,
-            artifact_path, published_at
+            artifact_path, published_at, ${currentChannelSql('store_module_versions.id')} AS channel
        FROM store_module_versions WHERE module_key = $1`, [key]);
+  const served = (r) => !channels || channels.includes(r.channel);
   let row;
   if (version) {
     row = versions.find((r) => r.version === version);
     if (!row) return refuse(404, 'version_not_found', `"${key}" has no published version ${version}.`);
+    if (!served(row)) {
+      return refuse(409, 'version_not_on_channel', row.channel === 'withdrawn'
+        ? `"${key}" ${version} was withdrawn: it is no longer handed out.`
+        : `"${key}" ${version} is still with testers, and this project takes general versions of it.`);
+    }
   } else {
-    row = versions.filter((r) => parseVersion(r.version))
+    row = versions.filter((r) => parseVersion(r.version) && served(r))
       .sort((a, b) => cmp(parseVersion(a.version), parseVersion(b.version))).pop();
-    if (!row) return refuse(404, 'no_versions', `"${key}" has no published version yet.`);
+    if (!row) {
+      if (!versions.length) return refuse(404, 'no_versions', `"${key}" has no published version yet.`);
+      const testing = versions.some((r) => r.channel === 'tester');
+      return refuse(404, 'no_versions_on_channel', testing
+        ? `"${key}" has no version on the channel this project takes yet: its newest is still with testers.`
+        : `"${key}" has no version this project can be handed: every version was withdrawn.`);
+    }
   }
   const { rows: [price] } = await pool.query(
     `SELECT price_cents, price_credits, set_at FROM store_module_prices
@@ -321,21 +355,25 @@ async function publishedVersionSet(keys, { db } = {}) {
 // takes no entitlement and refuses nothing, so a delisted module still answers,
 // with its status, and the caller says it gets no further versions (ADR 0338 D2).
 // A key the store does not know is simply absent. One query for the whole list.
-// Returns { [key]: { version, core_version, status } }.
-async function latestVersions(keys, { db } = {}) {
+// `channelsFor(key)` (servedChannels per module) counts only versions on the
+// channels this project takes, so upgrade reports what update would hand over
+// (task 1003805); a key with nothing on them is absent too.
+// Returns { [key]: { version, core_version, status, channel } }.
+async function latestVersions(keys, { db, channelsFor = null } = {}) {
   if (!keys.length) return {};
   const pool = db || require('./pool').pool;
   const { rows } = await pool.query(
-    `SELECT v.module_key, v.version, v.core_version, m.status
+    `SELECT v.module_key, v.version, v.core_version, m.status, ${currentChannelSql('v.id')} AS channel
        FROM store_module_versions v JOIN store_modules m ON m.module_key = v.module_key
       WHERE v.module_key = ANY($1)`, [keys]);
   const out = {};
   for (const r of rows) {
     const next = parseVersion(r.version);
     if (!next) continue;
+    if (channelsFor && !channelsFor(r.module_key).includes(r.channel)) continue;
     const have = out[r.module_key];
     if (have && cmp(parseVersion(have.version), next) >= 0) continue;
-    out[r.module_key] = { version: r.version, core_version: r.core_version, status: r.status };
+    out[r.module_key] = { version: r.version, core_version: r.core_version, status: r.status, channel: r.channel };
   }
   return out;
 }
@@ -383,6 +421,6 @@ function versionArtifactFile(row, { dir = storeDir() } = {}) {
 
 module.exports = {
   stageArtifact, commitArtifact, removeArtifact, relativeArtifactPath, publishVersion,
-  isFreePrice, resolveAcquirable, resolveReadable, publishedVersionSet, latestVersions, versionArtifactFile,
+  isFreePrice, servedChannels, resolveAcquirable, resolveReadable, publishedVersionSet, latestVersions, versionArtifactFile,
   delistModule, delistedKeySet, storeDir, storeDirFor, migrateLegacyStore,
 };

package/src/bongos/routes/modules.js

@@ -96,7 +96,7 @@ const moduleAssessVersion = require('../../../scripts/gds/module-assess-version'
 const { checkEntitlement, listEntitlements, grantEntitlement, recordAcquired } = require('../module-entitlements');
 const {
   stageArtifact, commitArtifact, removeArtifact, relativeArtifactPath, publishVersion,
-  resolveAcquirable, resolveReadable, publishedVersionSet, latestVersions, versionArtifactFile,
+  servedChannels, resolveAcquirable, resolveReadable, publishedVersionSet, latestVersions, versionArtifactFile,
   delistModule, delistedKeySet, migrateLegacyStore,
 } = require('../module-store');
 const {
@@ -111,9 +111,20 @@ const log = require('../logger').logger.child({ src: 'modules' });
 // as unused exports and tripped the dead-code ratchet that held this branch out of main.
 const { listOverrides, setOverride } = require('../module-overrides');
 const { listCatalog, SORT_PARTS } = require('../module-listing');
-const { readTesting, setTester, setGeneralOnly } = require('../module-testing');
+const { readTesting, setTester, setGeneralOnly, testsVersionsOf } = require('../module-testing');
 const { readStanding, releaseHeld } = require('../module-promotion');
 
+// The channels this project takes, per module (task 1003805, ADR 0344 D1/D2): a
+// tester project gets tester and general versions, except of a module it marked
+// "general only"; everyone else gets general. A choice that cannot be read reads as
+// NOT a tester (module-testing.js), so it hands out general, never tester.
+async function projectChannels() {
+  let testing = null;
+  try { testing = await readTesting(); }
+  catch (e) { log.warn({ err: e.message }, 'tester choice unreadable; serving general versions'); }
+  return (key) => servedChannels(testsVersionsOf(testing, key));
+}
+
 // The sentence for a toggle that waits on a restart (task 1004463). 'routes' are the
 // module's pages, 'pollers' its background jobs. PURE.
 function restartNote(waits, enabled) {
@@ -667,9 +678,12 @@ module.exports = function buildModulesRouter() {
   // here changes what runs on this instance (install never enables; the CLI places
   // files on the CALLER's checkout).
   //
-  // Channels: every version is on the general channel until the channel table
-  // (task 1003815) and "install honours the channel" (task 1003805) land; those
-  // add the channel check to step 1 and step 2, beside the entitlement check.
+  // Channels (task 1003805, ADR 0344): steps 1 and 2 hand out only versions on a
+  // channel this project takes (projectChannels) — with no version asked for, the
+  // newest there. Install and update share step 1, so both honour it. A project
+  // that stops testing keeps the tester version it has; its next update is the
+  // newest general one, and update only moves forward, so nothing rolls back.
+  // Step 3 records what was already placed, so it does not re-check the channel.
   router.post('/store/modules/:key/acquire', auth.requireBuilder,
     asyncHandler('POST /store/modules/:key/acquire', async (req, res) => {
       const { key } = req.params;
@@ -681,7 +695,7 @@ module.exports = function buildModulesRouter() {
       if (wanted != null && !parseVersion(String(wanted))) {
         return res.fail('bad_version', { status: 400, message: 'A version is exact X.Y.Z.' });
       }
-      const r = await resolveAcquirable(key, { version: wanted || null });
+      const r = await resolveAcquirable(key, { version: wanted || null, channels: (await projectChannels())(key) });
       if (!r.ok) return res.fail(r.code, { status: r.status, message: r.message });
 
       const holder = { moduleKey: key, holderKind: 'builder', holderRef: String(req.builder.id) };
@@ -706,7 +720,7 @@ module.exports = function buildModulesRouter() {
         tarball_sha256: v.tarball_sha256,
         tree_sha256: v.tree_sha256,
         tarball_bytes: Number(v.tarball_bytes),
-        channel: 'general',
+        channel: v.channel,
         entitlement: held.entitlement,
       });
     }));
@@ -717,7 +731,7 @@ module.exports = function buildModulesRouter() {
       if (!KEY_RE.test(key) || !parseVersion(version)) {
         return res.fail('bad_request', { status: 400, message: 'A module key is lowercase kebab-case and a version is exact X.Y.Z.' });
       }
-      const r = await resolveAcquirable(key, { version });
+      const r = await resolveAcquirable(key, { version, channels: (await projectChannels())(key) });
       if (!r.ok) return res.fail(r.code, { status: r.status, message: r.message });
       const held = await checkEntitlement({ moduleKey: key, holderKind: 'builder', holderRef: String(req.builder.id) });
       if (!held.entitled) {
@@ -801,7 +815,9 @@ module.exports = function buildModulesRouter() {
 
   // The newest published version of each named module — what `bongos upgrade`
   // compares an instance's installed store modules against to report the updates
-  // available (task 1003787). `?keys=a,b,c`, at most STORE_LATEST_MAX_KEYS.
+  // available (task 1003787). `?keys=a,b,c`, at most STORE_LATEST_MAX_KEYS. Only
+  // versions on a channel this project takes count (task 1003805), so it reports
+  // exactly what `bongos module update` would hand over.
   //
   // rank: any-builder — a read of public store metadata (version numbers and the
   // core range each needs, the same facts the how-to page shows). It takes no
@@ -814,7 +830,7 @@ module.exports = function buildModulesRouter() {
       if (!keys.length || keys.length > STORE_LATEST_MAX_KEYS || !keys.every((k) => KEY_RE.test(k))) {
         return res.fail('bad_request', { status: 400, message: `keys is a comma-separated list of 1 to ${STORE_LATEST_MAX_KEYS} module keys (lowercase kebab-case).` });
       }
-      const latest = await latestVersions(keys);
+      const latest = await latestVersions(keys, { channelsFor: await projectChannels() });
       res.set('Cache-Control', 'no-store');
       res.json({ latest });
     }));

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.168'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.170'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/hall_approval_queue.mjs

@@ -311,6 +311,41 @@ await test('empty, closed with Escape, and focus goes back where it was', async
   assert.deepEqual(b.counts, [0]);
 });
 
+// task 1004765: a round SUBMITTED but never applied sat unseen for weeks. The
+// server lists it apart (not_applied), the panel shows it below the reviewable
+// page, marked, with how long it has waited, and with no verb; the door counts
+// only what can be reviewed.
+await test('submitted but not applied: listed apart, marked, how long, no verbs, not in the door count', async () => {
+  const NOW = Date.parse('2026-10-20T12:00:00Z');
+  const submitted = {
+    id: 60, status: 'ready', holder_id: null, artist_id: ME, artist_login: 'me', updated_at: '2026-09-29T08:00:00Z',
+    source_ref: pages.roundSourceRef('landing:projects', 2),
+    description: ['Page tweak round 2.', pages.composeBatchBlock({ page_id: 'landing:projects', reading_hash: 'h', submitted_at: '2026-09-29T08:00:00Z', lines: [{ key: 'L0002', section: 'list', before: 'Every project', after: 'All of them', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' }] })].join('\n\n'),
+  };
+  const tasks = [...TASKS.filter((t) => t.id !== 42), submitted];
+  const data = pageStatus.composeApprovals({ inventory: INVENTORY, tasks, builderId: ME, crafts: ['artist'], now: NOW });
+  assert.equal(data.count, 1, 'the door counts reviewable rounds only');
+  assert.deepEqual(data.queue.map((q) => q.task_id), ['41']);
+  assert.deepEqual(data.not_applied.map((r) => [r.page_id, r.task_id, r.state_word, r.waited_days, r.line_count]),
+    [['landing:projects', '60', 'Submitted, waiting to be applied', 21, 1]]);
+
+  const b = bootPanel({ answers: { [APPROVALS]: { ok: true, ...data }, [vis(41)]: slotsFor(41) } });
+  await b.panel.open(); await settle(); await settle();
+  assert.equal(text(b.q('.aq-pending__h')), 'Submitted, not applied yet (1)');
+  const row = b.q('.aq-pending__row');
+  assert.match(text(row), /Projects/);
+  assert.match(text(row), /not applied yet/);
+  assert.match(text(row), /Submitted, waiting to be applied · waiting 21 days\. The words are waiting to be applied/);
+  assert.equal(row.querySelectorAll('button').length, 0, 'no approve or send-back on a page nobody applied');
+  assert.deepEqual(b.counts, [1]);
+
+  const empty = bootPanel({ answers: { [APPROVALS]: { ok: true, ...pageStatus.composeApprovals({ inventory: INVENTORY, tasks: [submitted], builderId: ME, crafts: ['artist'], now: NOW }) } } });
+  await empty.panel.open(); await settle();
+  assert.equal(text(empty.q('.aq-title')), 'Nothing waiting', 'nothing to review');
+  assert.ok(empty.q('.aq-pending__row'), 'but the submitted page is still shown');
+  assert.deepEqual(empty.counts, [0]);
+});
+
 // ── the writes: only the host's, and the host's are the studio's allowlist ──
 
 await test('the panel writes only through the writes it is handed; the studio hands it its own WRITE_ROUTES', () => {

package/tests/module_assess_installs.mjs

@@ -20,7 +20,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const { MIN_HOLDERS, assessInstall, assessReliability, recordInstallSignals } = require('../scripts/gds/module-assess-installs.js');
+const { MIN_HOLDERS, PRIOR_TESTERS, assessInstall, assessReliability, assessTesterFeedback, recordInstallSignals } = require('../scripts/gds/module-assess-installs.js');
 const reports = require('../src/bongos/module-usage-reports.js');
 const { ERROR_CODE_RE } = require('../src/bongos/module-usage-reports.js');
 const { cmdInstall } = require('../scripts/gds/module.js');
@@ -146,11 +146,13 @@ test('the switch: off writes an opt-out row, on deletes it', async () => {
 
 // ---- the re-score ----
 
-function scoringDb({ latest, days, current = [] }) {
+function scoringDb({ latest, days, current = [], testerInstalls = [], testerDays = [] }) {
   return fakeDb([
-    [/FROM module_install_reports r/, () => ({ rows: latest })],
-    [/FROM module_runtime_error_counts r/, () => ({ rows: days })],
-    [/part IN \('install', 'reliability'\)/, () => ({ rows: current })],
+    [/FROM module_install_reports r\s/, () => ({ rows: latest })],
+    [/FROM module_runtime_error_counts r\s/, () => ({ rows: days })],
+    [/FROM module_install_reports ir/, () => ({ rows: testerInstalls })],
+    [/FROM module_runtime_error_counts ec/, () => ({ rows: testerDays })],
+    [/part IN \('install', 'reliability', 'tester_feedback'\)/, () => ({ rows: current })],
     [/INSERT INTO module_assessment_signals/, () => ({ rows: [] })],
     [/SELECT DISTINCT ON \(part\) id, part, outcome, score, sample_size/, () => ({ rows: [] })],
     [/FROM module_assessment_scores/, () => ({ rows: [] })],
@@ -173,7 +175,10 @@ test('re-score: writes a signal row only for a part whose result moved, then re-
   const latest = [{ ok: true }, { ok: true }, { ok: false, error_code: 'place_failed' }];
   const db = scoringDb({
     latest, days: [],
-    current: [{ part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 }],
+    current: [
+      { part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 },
+      { part: 'tester_feedback', outcome: 'no_data', score: null, sample_size: 0 },
+    ],
   });
   const res = await recordInstallSignals(5, { db });
   assert.deepEqual(res.written, ['install'], 'reliability is unchanged, so no new row');
@@ -184,12 +189,73 @@ test('re-score: writes a signal row only for a part whose result moved, then re-
   const again = scoringDb({ latest, days: [], current: [
     { part: 'install', outcome: 'scored', score: 67, sample_size: 3 },
     { part: 'reliability', outcome: 'no_data', score: null, sample_size: 0 },
+    { part: 'tester_feedback', outcome: 'no_data', score: null, sample_size: 0 },
   ] });
   const res2 = await recordInstallSignals(5, { db: again });
   assert.deepEqual(res2.written, []);
   assert.ok(!again.calls.some((c) => /INSERT/.test(c.sql)), 'nothing moved, nothing written');
 });
 
+// ---- tester feedback (task 1003806, ADR 0344 D5) ----
+
+const testers = (n, { failed = 0, erroring = 0 } = {}) => {
+  const installs = Array.from({ length: n }, (_, i) => ({ holder_kind: 'instance', holder_ref: `p${i}`, ok: i >= failed, error_code: i < failed ? 'place_failed' : null }));
+  const days = Array.from({ length: erroring }, (_, i) => ({ holder_kind: 'instance', holder_ref: `p${n - 1 - i}`, error_count: 2 }));
+  return { installs, days };
+};
+
+test('Tester feedback: no tester reports is no_data, and fewer than MIN_HOLDERS is pending', () => {
+  assert.equal(assessTesterFeedback({}).outcome, 'no_data');
+  const s = assessTesterFeedback(testers(MIN_HOLDERS - 1));
+  assert.equal(s.outcome, 'pending');
+  assert.equal(s.score, null);
+});
+
+test('Tester feedback: a tester it went well for installed cleanly AND hit no runtime errors', () => {
+  const s = assessTesterFeedback(testers(20, { failed: 2, erroring: 3 }));
+  assert.equal(s.detail.went_well, 15);
+  assert.equal(s.detail.install_failed, 2);
+  assert.equal(s.detail.with_errors, 3);
+  assert.equal(s.detail.errors, 6);
+  assert.equal(s.score, Math.round((100 * (15 + PRIOR_TESTERS / 2)) / (20 + PRIOR_TESTERS)));
+});
+
+test('Tester feedback: a tester who only sent error counts still counts once', () => {
+  const s = assessTesterFeedback({ installs: [], days: [
+    { holder_kind: 'instance', holder_ref: 'a', error_count: 0 },
+    { holder_kind: 'instance', holder_ref: 'a', error_count: 0 },
+    { holder_kind: 'instance', holder_ref: 'b', error_count: 0 },
+    { holder_kind: 'builder', holder_ref: 'a', error_count: 1 },
+  ] });
+  assert.equal(s.sample_size, 3);
+  assert.equal(s.detail.went_well, 2);
+});
+
+test('Tester feedback: sample size weighs — a few friendly testers cannot outrank many real ones', () => {
+  const few = assessTesterFeedback(testers(3)).score;
+  const many = assessTesterFeedback(testers(200, { failed: 10 })).score;
+  assert.ok(many > few, `200 testers at 95% (${many}) must beat 3 at 100% (${few})`);
+  assert.ok(assessTesterFeedback(testers(200)).score >= 95, 'a large clean sample still scores high');
+});
+
+test('re-score: tester reports are read only inside the tester window, author excluded', async () => {
+  const t4 = testers(4);
+  const db = scoringDb({ latest: [], days: [], testerInstalls: t4.installs, testerDays: t4.days });
+  const res = await recordInstallSignals(5, { db });
+  assert.ok(res.written.includes('tester_feedback'));
+  assert.equal(res.signals.tester_feedback.score, Math.round((100 * (4 + PRIOR_TESTERS / 2)) / (4 + PRIOR_TESTERS)));
+  for (const [table, a, when] of [['module_install_reports', 'ir', /ir\.reported_at >= t\.start AND \(t\.stop IS NULL OR ir\.reported_at < t\.stop\)/],
+                                  ['module_runtime_error_counts', 'ec', /ec\.day >= t\.start::date AND \(t\.stop IS NULL OR ec\.day <= t\.stop::date\)/]]) {
+    const sql = db.calls.find((c) => c.sql.includes(`FROM ${table} ${a}`)).sql;
+    assert.match(sql, /c1\.channel = 'tester'/, `${table}: the window opens on the tester channel`);
+    assert.match(sql, /c2\.channel <> 'tester' AND c2\.set_at > s\.start/, `${table}: and closes when it leaves it`);
+    assert.match(sql, when, `${table}: only reports inside the window`);
+    assert.ok(sql.includes(`NOT (${a}.holder_kind = 'builder' AND ${a}.holder_ref = m.author_id::text)`), `${table}: excludes the author`);
+  }
+  const insert = db.calls.find((c) => /INSERT INTO module_assessment_signals/.test(c.sql) && c.params[1] === 'tester_feedback');
+  assert.deepEqual(insert.params.slice(0, 5), [5, 'tester_feedback', 'scored', res.signals.tester_feedback.score, 4]);
+});
+
 // ---- the migration: there is nowhere to put anything but counts ----
 
 test('core_273: three additive tables whose columns hold counts and codes only', () => {

package/tests/module_channel_install.mjs

@@ -0,0 +1,112 @@
+// tests/module_channel_install.mjs — install and update honour the channel a
+// project is on (task 1003805, ADR 0344 D1/D2, ADR 0338 D2).
+//
+// WHY. The channels exist (core_276) and new versions land on tester (task
+// 1003803), but until acquire reads them, every project got the newest version
+// whatever its channel. These pin the rule: a tester project gets the newest on
+// tester or general, everyone else the newest on general, nobody a withdrawn one,
+// and `bongos upgrade` reports the same version update would hand over. Run
+// against a fake pg client; the routes are pinned in their source.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { servedChannels, resolveAcquirable, latestVersions } = require('../src/bongos/module-store.js');
+const { testsVersionsOf } = require('../src/bongos/module-testing.js');
+
+const row = (version, channel) => ({ id: 1, module_key: 'weather', version, channel, core_version: '^1.0.0', tarball_sha256: 'a'.repeat(64), tree_sha256: 'b'.repeat(64), tarball_bytes: 10, artifact_path: `weather/weather-${version}.tgz` });
+
+function fakeDb(versions) {
+  return {
+    async query(sql) {
+      if (sql.includes('FROM store_modules ')) return { rows: [{ module_key: 'weather', status: 'listed' }] };
+      if (sql.includes('FROM store_module_versions')) return { rows: versions };
+      if (sql.includes('FROM store_module_prices')) return { rows: [] };
+      throw new Error(`unhandled: ${sql}`);
+    },
+  };
+}
+const SHELF = [row('1.0.0', 'general'), row('1.1.0', 'general'), row('1.2.0', 'tester'), row('2.0.0', 'withdrawn')];
+const GENERAL = servedChannels(false);
+const TESTER = servedChannels(true);
+
+test('a tester project takes tester and general versions, everyone else general, nobody withdrawn', () => {
+  assert.deepEqual(TESTER, ['tester', 'general']);
+  assert.deepEqual(GENERAL, ['general']);
+  for (const c of [TESTER, GENERAL]) assert.ok(!c.includes('withdrawn'));
+});
+
+test('"general only" keeps a tester project on general for that one module', () => {
+  const testing = { tester: true, general_only: ['weather'] };
+  assert.deepEqual(servedChannels(testsVersionsOf(testing, 'weather')), GENERAL);
+  assert.deepEqual(servedChannels(testsVersionsOf(testing, 'clock')), TESTER);
+  assert.deepEqual(servedChannels(testsVersionsOf(null, 'clock')), GENERAL, 'an unreadable choice is not a tester');
+});
+
+test('with no version asked for, each project gets the newest on its own channels', async () => {
+  const general = await resolveAcquirable('weather', { channels: GENERAL, db: fakeDb(SHELF) });
+  assert.equal(general.version.version, '1.1.0');
+  assert.equal(general.version.channel, 'general');
+  const tester = await resolveAcquirable('weather', { channels: TESTER, db: fakeDb(SHELF) });
+  assert.equal(tester.version.version, '1.2.0', 'the newer withdrawn 2.0.0 is never handed out');
+  assert.equal(tester.version.channel, 'tester');
+});
+
+test('an exact version off the project\'s channels is refused, never handed over', async () => {
+  const early = await resolveAcquirable('weather', { version: '1.2.0', channels: GENERAL, db: fakeDb(SHELF) });
+  assert.equal(early.ok, false);
+  assert.equal(early.code, 'version_not_on_channel');
+  assert.match(early.message, /testers/);
+  const gone = await resolveAcquirable('weather', { version: '2.0.0', channels: TESTER, db: fakeDb(SHELF) });
+  assert.equal(gone.code, 'version_not_on_channel');
+  assert.match(gone.message, /withdrawn/);
+  assert.equal((await resolveAcquirable('weather', { version: '1.0.0', channels: GENERAL, db: fakeDb(SHELF) })).ok, true);
+});
+
+test('a module whose only version is still with testers has nothing for a general project yet', async () => {
+  const r = await resolveAcquirable('weather', { channels: GENERAL, db: fakeDb([row('1.0.0', 'tester')]) });
+  assert.equal(r.code, 'no_versions_on_channel');
+  assert.equal(r.status, 404);
+  assert.match(r.message, /testers/);
+  const gone = await resolveAcquirable('weather', { channels: TESTER, db: fakeDb([row('1.0.0', 'withdrawn')]) });
+  assert.equal(gone.code, 'no_versions_on_channel');
+  assert.match(gone.message, /withdrawn/);
+});
+
+test('no channels means no channel check — recording a version already placed', async () => {
+  const r = await resolveAcquirable('weather', { version: '2.0.0', db: fakeDb(SHELF) });
+  assert.equal(r.ok, true);
+});
+
+test('upgrade reports the newest version on the channels this project takes', async () => {
+  const db = { async query() { return { rows: SHELF.map((r) => ({ ...r, status: 'listed' })) }; } };
+  const general = await latestVersions(['weather'], { db, channelsFor: () => GENERAL });
+  assert.equal(general.weather.version, '1.1.0');
+  const tester = await latestVersions(['weather'], { db, channelsFor: () => TESTER });
+  assert.equal(tester.weather.version, '1.2.0');
+  assert.equal(tester.weather.channel, 'tester');
+  const none = await latestVersions(['weather'], { db, channelsFor: () => ['nothing'] });
+  assert.deepEqual(none, {});
+});
+
+test('the acquire, download and latest routes ask the project\'s channels; recording does not', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  const route = (decl) => {
+    const start = src.indexOf(decl);
+    assert.ok(start !== -1, decl);
+    return src.slice(start, src.indexOf('}));', start));
+  };
+  const acquire = route("router.post('/store/modules/:key/acquire'");
+  assert.match(acquire, /resolveAcquirable\(key, \{ version: wanted \|\| null, channels: \(await projectChannels\(\)\)\(key\) \}\)/);
+  assert.match(acquire, /channel: v\.channel,/);
+  assert.doesNotMatch(acquire, /channel: 'general'/);
+  assert.match(route("router.get('/store/modules/:key/versions/:version/tarball'"), /channels: \(await projectChannels\(\)\)\(key\)/);
+  assert.match(route("router.get('/store/modules/latest'"), /latestVersions\(keys, \{ channelsFor: await projectChannels\(\) \}\)/);
+  assert.doesNotMatch(route("router.post('/store/modules/:key/acquired'"), /channels/);
+});

package/tests/module_upgrade_updates.mjs

@@ -24,7 +24,7 @@ const pool = {
       return {
         rows: state.versions
           .filter((v) => params[0].includes(v.module_key) && state.modules[v.module_key])
-          .map((v) => ({ ...v, status: state.modules[v.module_key].status })),
+          .map((v) => ({ channel: 'general', ...v, status: state.modules[v.module_key].status })),
       };
     }
     return { rows: [] };
@@ -236,7 +236,7 @@ test('the route is open to any signed-in builder: requireBuilder and no permissi
 test('the route answers the newest version per key, in semver order', async () => {
   const r = await ask('weather');
   assert.equal(r.statusCode, 200, JSON.stringify(r.body));
-  assert.deepEqual(r.body.latest.weather, { version: '1.10.0', core_version: '^1.2.0', status: 'listed' });
+  assert.deepEqual(r.body.latest.weather, { version: '1.10.0', core_version: '^1.2.0', status: 'listed', channel: 'general' });
   assert.equal(r.headers['Cache-Control'], 'no-store');
 });