@bongos/core 1.21.156 → 1.21.158

package/tests/module_store_publish.mjs

@@ -195,6 +195,7 @@ test('store: a key or version that could escape the store dir is refused before
 // A fake pg pool: `state` is the registry, answers are computed from it.
 function fakeDb(state = { modules: {}, versions: [] }) {
   const log = [];
+  state.channels = state.channels || [];
   const client = {
     async query(sql, params = []) {
       log.push(sql.trim().split(/\s+/).slice(0, 2).join(' '));
@@ -211,6 +212,10 @@ function fakeDb(state = { modules: {}, versions: [] }) {
         const row = { id: state.versions.length + 1, module_key: params[0], version: params[1] };
         state.versions.push(row); return { rows: [row] };
       }
+      if (/^INSERT INTO store_module_version_channels/.test(sql)) {
+        state.channels.push({ version_id: params[0], channel: params[1], reason: params[2], set_by: params[3] });
+        return { rows: [] };
+      }
       return { rows: [] };
     },
     release() {},
@@ -256,6 +261,33 @@ test('registry: a version is published once, and never older than the latest', a
   assert.equal(ok.ok, true, 'numeric, not string, ordering: 1.10.0 > 1.2.0');
 });
 
+// Task 1003803, ADR 0344 D2: every new version, first release or update, lands on
+// the tester channel. Publish takes no channel at all, so there is no flag to omit
+// or misspell; reaching everyone is the promotion gate's later act (task 1003804).
+test('channel: a first release lands on tester, recorded with who published it', async () => {
+  const db = fakeDb();
+  const r = await store.publishVersion(input(), { db: db.pool });
+  assert.equal(r.ok, true);
+  assert.equal(r.channel, 'tester');
+  assert.deepEqual(db.state.channels, [{ version_id: 1, channel: 'tester', reason: 'new_version', set_by: 7 }]);
+});
+
+test('channel: an update lands on tester too, never straight to general', async () => {
+  const state = { modules: { weather: { module_key: 'weather', author_id: 7, status: 'listed' } },
+    versions: [{ id: 1, module_key: 'weather', version: '1.1.0' }] };
+  const db = fakeDb(state);
+  const r = await store.publishVersion(input({ channel: 'general' }), { db: db.pool });
+  assert.equal(r.ok, true);
+  assert.equal(r.channel, 'tester', 'a channel named by the caller is not a way past testers');
+  assert.deepEqual(db.state.channels.map((c) => c.channel), ['tester']);
+});
+
+test('channel: a refused publish records no channel', async () => {
+  const db = fakeDb({ modules: { weather: { module_key: 'weather', author_id: 7, status: 'listed' } }, versions: [] });
+  await store.publishVersion(input({ builderId: 8 }), { db: db.pool });
+  assert.deepEqual(db.state.channels, []);
+});
+
 test('registry: if putting the file in place fails, the row is rolled back', async () => {
   const db = fakeDb();
   await assert.rejects(

package/tests/module_testing.mjs

@@ -0,0 +1,171 @@
+// tests/module_testing.mjs — a project elects to test new module versions first
+// (task 1003802, ADR 0344 D1). Two halves, no port and no real DB:
+//   - the rule: module-testing.js over an in-memory project_settings, through
+//     its deps seam — never a tester by default, reversible, "general only";
+//   - the routes: the real handlers off the real router, with pool.js replaced
+//     in the require cache (the tests/module_store_listing.mjs harness).
+//
+// Run:  node tests/module_testing.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+// ---- an in-memory project_settings, behind the real setSetting/getSetting SQL ----
+const rows = new Map();
+const pool = {
+  async query(sql, params = []) {
+    if (/FROM project_settings WHERE key = \$1/.test(sql)) {
+      const r = rows.get(params[0]);
+      return { rows: r ? [r] : [] };
+    }
+    if (/INSERT INTO project_settings/.test(sql)) {
+      const r = { key: params[0], value: params[1], updated_by: params[2], updated_at: 't' };
+      rows.set(params[0], r);
+      return { rows: [r] };
+    }
+    return { rows: [] };
+  },
+};
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => ({ ...pool, release() {} }), query: pool.query } } };
+
+const { readTesting, setTester, setGeneralOnly, testsVersionsOf, parseGeneralOnly } = require('../src/bongos/module-testing.js');
+const buildModulesRouter = require('../src/bongos/routes/modules.js');
+const { listModules } = buildModulesRouter;
+
+function handlerFor(router, method, p) {
+  const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);
+  assert.ok(layer, `no ${method.toUpperCase()} ${p} on the router`);
+  const stack = layer.route.stack;
+  return { handle: stack[stack.length - 1].handle, names: stack.map((s) => s.name) };
+}
+
+async function invoke(handle, req) {
+  const res = {
+    statusCode: 200, body: undefined, headers: {},
+    json(b) { this.body = b; return this; },
+    status(c) { this.statusCode = c; return this; },
+    set(k, v) { this.headers[k] = v; return this; },
+    // Both shapes res.fail is called with: (code, { status, message }) and the
+    // validator's (code, 400, details).
+    fail(code, opts) {
+      const o = typeof opts === 'number' ? { status: opts } : opts;
+      this.statusCode = o.status; this.body = { error: code, ...o }; return this;
+    },
+  };
+  let nextErr = null;
+  await handle({ params: {}, body: {}, builder: { id: 7 }, ...req }, res, (err) => { nextErr = err; });
+  if (nextErr) throw nextErr;
+  return res;
+}
+
+// ---------------------------------------------------------------------------
+// the rule
+// ---------------------------------------------------------------------------
+
+test('a project is never a tester by default', async () => {
+  rows.clear();
+  const t = await readTesting();
+  assert.deepEqual(t, { tester: false, general_only: [], updated_at: null, updated_by: null });
+  assert.equal(testsVersionsOf(t, 'discord'), false);
+});
+
+test('opting in is an act, and it is reversible', async () => {
+  rows.clear();
+  const on = await setTester(true, 7);
+  assert.equal(on.tester, true);
+  assert.equal(on.updated_by, '7', 'who switched it is recorded');
+  assert.equal(testsVersionsOf(on, 'discord'), true);
+  const off = await setTester(false, 7);
+  assert.equal(off.tester, false);
+  assert.equal(testsVersionsOf(off, 'discord'), false);
+});
+
+test('a module marked general only keeps general versions while the rest test', async () => {
+  rows.clear();
+  await setTester(true, 7);
+  await setGeneralOnly('economy', true, 7);
+  const t = await setGeneralOnly('discord', true, 7);
+  assert.deepEqual(t.general_only, ['discord', 'economy']);
+  assert.equal(testsVersionsOf(t, 'economy'), false);
+  assert.equal(testsVersionsOf(t, 'memory'), true);
+  const back = await setGeneralOnly('economy', false, 7);
+  assert.deepEqual(back.general_only, ['discord']);
+  assert.equal(testsVersionsOf(back, 'economy'), true);
+});
+
+test('a "general only" mark survives the switch going off and on', async () => {
+  rows.clear();
+  await setTester(true, 7);
+  await setGeneralOnly('economy', true, 7);
+  await setTester(false, 7);
+  const t = await setTester(true, 7);
+  assert.deepEqual(t.general_only, ['economy']);
+});
+
+test('an unreadable stored value reads as NOT a tester, and keeps the keys it can read', async () => {
+  rows.clear();
+  rows.set('modules.tester', { key: 'modules.tester', value: 'yes please', updated_by: null, updated_at: 't' });
+  assert.equal((await readTesting()).tester, false, 'only "on" is on');
+  assert.deepEqual(parseGeneralOnly('not json'), []);
+  assert.deepEqual(parseGeneralOnly('{"a":1}'), []);
+  assert.deepEqual(parseGeneralOnly('["economy", 4, "Bad Key", "economy", "discord"]'), ['discord', 'economy']);
+});
+
+test('setGeneralOnly refuses something that is not a module key', async () => {
+  await assert.rejects(() => setGeneralOnly('../etc', true, 7), /not a module key/);
+});
+
+// ---------------------------------------------------------------------------
+// the routes
+// ---------------------------------------------------------------------------
+
+test('GET /modules/testing: any signed-in builder can see the switch', async () => {
+  rows.clear();
+  const { handle, names } = handlerFor(buildModulesRouter(), 'get', '/modules/testing');
+  assert.equal(names.length, 2, `expected requireBuilder + handler, got ${names.join(', ')}`);
+  const res = await invoke(handle, {});
+  assert.equal(res.body.tester, false);
+  assert.equal(res.headers['Cache-Control'], 'no-store');
+});
+
+test('POST /modules/testing and /modules/:key/general-only take the module.enable permission', () => {
+  const router = buildModulesRouter();
+  for (const p of ['/modules/testing', '/modules/:key/general-only']) {
+    const { names } = handlerFor(router, 'post', p);
+    assert.equal(names.length, 3, `${p}: requireBuilder + requirePermission + handler, got ${names.join(', ')}`);
+  }
+  const src = require('node:fs').readFileSync(require.resolve('../src/bongos/routes/modules.js'), 'utf8');
+  assert.match(src, /router\.post\('\/modules\/testing', auth\.requireBuilder, auth\.requirePermission\('module\.enable'\)/);
+  assert.match(src, /router\.post\('\/modules\/:key\/general-only', auth\.requireBuilder, auth\.requirePermission\('module\.enable'\)/);
+});
+
+test('POST /modules/testing: switches on and off, and says what it means', async () => {
+  rows.clear();
+  const { handle } = handlerFor(buildModulesRouter(), 'post', '/modules/testing');
+  const on = await invoke(handle, { body: { tester: true } });
+  assert.equal(on.body.tester, true);
+  assert.match(on.body.note, /new module versions first/);
+  const off = await invoke(handle, { body: { tester: false } });
+  assert.equal(off.body.tester, false);
+  assert.match(off.body.note, /back on general versions from its next update/);
+  const bad = await invoke(handle, { body: { tester: 'on' } });
+  assert.equal(bad.statusCode, 400, 'an affirmative act is a boolean, not a string that looks like one');
+});
+
+test('POST /modules/:key/general-only: only a module this project has', async () => {
+  rows.clear();
+  const { handle } = handlerFor(buildModulesRouter(), 'post', '/modules/:key/general-only');
+  const known = listModules()[0].key;
+  const ok = await invoke(handle, { params: { key: known }, body: { general_only: true } });
+  assert.equal(ok.statusCode, 200);
+  assert.equal(ok.body.general_only_this, true);
+  assert.deepEqual(ok.body.general_only, [known]);
+  const missing = await invoke(handle, { params: { key: 'no-such-module-here' }, body: { general_only: true } });
+  assert.equal(missing.statusCode, 404);
+  const badKey = await invoke(handle, { params: { key: 'Not_A_Key' }, body: { general_only: true } });
+  assert.equal(badKey.statusCode, 400);
+});