@bongos/core 1.23.18 → 1.23.20

package/tests/community_movers.mjs

@@ -0,0 +1,280 @@
+// tests/community_movers.mjs — the rising builder and the projects on the move behind the
+// row under the crowns on the hub's /community home (task 1002983).
+//
+// DB-free. A fake pool answers each statement by its shape. Which snapshots open and close
+// the 30 days, and the baseline a quiet row brings, need a real Postgres:
+// tests/community_movers_db.mjs.
+//
+// What this pins:
+//   1. the statement: the crowns' period rows by the year's rule over the last 30 days, the
+//      numbers predicate, and a quiet row's live total as its baseline.
+//   2. the rising builder: under RISING_BASE_MAX before, at least one work, the crowns' tie
+//      order; a builder who may not be shown is not counted.
+//   3. the projects: named only on the map with the Public door, ranked by works then
+//      credits, at most PROJECTS_MAX, counting only builders who may be shown.
+//   4. the memo: the 30 days computed once per MOVERS_TTL_MS, who and which projects asked
+//      on every read.
+//   5. the route: no-store, the same body with or without credentials, the 500 envelope,
+//      and its own rate-limit scope.
+//
+// Run:  node tests/community_movers.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+const { rollupVisibleSql } = require('../modules/platform-identity/account-visibility.js');
+const { onMapSql } = require('../modules/platform-identity/projects-feed.js');
+const flat = (s) => s.replace(/\s+/g, ' ').trim();
+const NUMBERS = flat(rollupVisibleSql('pa'));
+const ON_MAP = flat(onMapSql('p'));
+
+// ---- fake engine ------------------------------------------------------------
+
+const isRows = (sql) => /^WITH act AS/.test(sql) && /LEFT JOIN per_project pp/.test(sql);
+const isWho = (sql) => /FROM platform_identity_accounts pa WHERE pa\.github_id = ANY\(\$1::bigint\[\]\)/.test(sql);
+const isNamed = (sql) => /FROM platform_identity_sso_clients c JOIN platform_identity_projects p/.test(sql);
+
+const engine = {
+  calls: [],
+  rows: [],          // the 30 days' statement's rows
+  shown: new Set(),  // github_ids the numbers predicate admits
+  named: {},         // client_id → { name, origin } on the map with the Public door
+  throwOn: null,
+  query: async (text, params = []) => {
+    const sql = flat(String(text));
+    engine.calls.push({ sql, params });
+    if (engine.throwOn && engine.throwOn(sql)) { engine.throwOn = null; throw new Error('boom'); }
+    if (isRows(sql)) return { rows: engine.rows };
+    if (isWho(sql)) {
+      const rows = params[0].filter((id) => engine.shown.has(id))
+        .map((id) => ({ github_id: id, handle: `h${id}`, github_login: `l${id}`, display_name: `D${id}`, avatar_url: null }));
+      return { rows };
+    }
+    if (isNamed(sql)) {
+      const rows = params[0].filter((c) => engine.named[c]).map((c) => ({ client_id: c, ...engine.named[c] }));
+      return { rows };
+    }
+    throw new Error(`fake pool: unexpected statement ${sql.slice(0, 80)}`);
+  },
+};
+function reset() {
+  Object.assign(engine, { calls: [], rows: [], shown: new Set(), named: {}, throwOn: null });
+  movers.clearMoversMemo();
+}
+const callsOf = (pred) => engine.calls.filter((c) => pred(c.sql));
+// One (project, builder) row as the statement returns it: deltas null for a quiet row.
+const r = (client, id, credits, ships, base, karma = 0) => ({
+  client_id: client, github_id: id, credits: credits == null ? null : String(credits),
+  tasks_shipped: ships == null ? null : String(ships), karma: credits == null ? null : String(karma), base_credits: String(base),
+});
+
+// Pin the module doorway (ADR 0083) BEFORE the modules load.
+const moduleApiPath = require.resolve('../src/module-api.js');
+require.cache[moduleApiPath] = {
+  id: moduleApiPath, filename: moduleApiPath, loaded: true,
+  exports: {
+    pool: engine,
+    corsPublicGet: () => (_req, res, next) => { res.set('Access-Control-Allow-Origin', '*'); next(); },
+    logger: () => ({ error: () => {}, info: () => {}, warn: () => {} }),
+  },
+};
+
+const movers = require('../modules/platform-identity/community-movers.js');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRoutes = require('../modules/platform-identity/routes/community-leaderboard.js');
+
+const NOW = '2026-10-28T09:30:00.000Z';
+const read = (now = NOW) => movers.readMovers({ now: new Date(now), pool: engine });
+
+// ---- 1. the statement ---------------------------------------------------------
+
+await t('the 30 days: the crowns’ period rows by the year’s rule, the numbers predicate, a quiet row’s live total as its baseline', async () => {
+  reset();
+  const out = await read();
+  const [s] = callsOf(isRows);
+  assert.ok(s.sql.includes(NUMBERS), 'the leaderboard’s numbers predicate');
+  assert.match(s.sql, /COALESCE\(e\.credits, 0\)::bigint - COALESCE\(b\.credits, CASE WHEN act\.first_seen_at >= \$1::timestamptz THEN 0 ELSE f\.credits END, 0\) AS credits/, 'the year’s baseline: never a lifetime');
+  assert.match(s.sql, /WHERE b\.credits IS NOT NULL OR act\.first_seen_at >= \$1::timestamptz OR f\.credits IS NOT NULL \)/);
+  assert.match(s.sql, /COALESCE\(pp\.base_credits, a\.credits::bigint\) AS base_credits/, 'a row with no history in the 30 days brings its live total');
+  assert.match(s.sql, /LEFT JOIN per_project pp ON pp\.client_id = act\.client_id AND pp\.github_id = act\.github_id$/);
+  assert.deepEqual(s.params.map((d) => d.toISOString()), ['2026-09-28T09:30:00.000Z', NOW], 'rolling: the 30 days up to now');
+  assert.deepEqual(out, { window: { start: '2026-09-28T09:30:00.000Z', end: NOW }, rising: null, projects: [] });
+});
+
+// ---- 2. the rising builder ----------------------------------------------------
+
+await t('the rising builder: most credits among those under the base cap with a shipped work', async () => {
+  reset();
+  engine.rows = [
+    r('p1', '1', 900, 4, 500),            // a veteran: over the cap
+    r('p1', '2', 300, 2, movers.RISING_BASE_MAX - 1),
+    r('p1', '3', 400, 0, 0),              // no work shipped
+    r('p1', '4', 250, 1, 0),
+  ];
+  engine.shown = new Set(['1', '2', '3', '4']);
+  const { rising } = await read();
+  assert.deepEqual(rising, { handle: 'h2', github_login: 'l2', display_name: 'D2', avatar_url: null, credits: 300, tasks_shipped: 2 });
+  assert.doesNotMatch(JSON.stringify(rising), /github_id|karma/, 'the crown’s fields and no more');
+});
+
+await t('the base is summed across every project, a quiet one included, and exactly the cap is over it', async () => {
+  reset();
+  engine.rows = [
+    r('p1', '2', 300, 2, 40),
+    r('p2', '2', null, null, 60),         // quiet: its live total is its baseline
+    r('p1', '4', 250, 1, 0),
+  ];
+  engine.shown = new Set(['2', '4']);
+  assert.equal((await read()).rising.handle, 'h4', '40 + 60 is not under 100');
+});
+
+await t('ties go to works shipped, then karma, then handle', async () => {
+  reset();
+  engine.rows = [r('p1', '5', 200, 1, 0, 9), r('p1', '6', 200, 2, 0, 0), r('p1', '7', 200, 2, 0, 1)];
+  engine.shown = new Set(['5', '6', '7']);
+  assert.equal((await read()).rising.handle, 'h7');
+  reset();
+  engine.rows = [r('p1', '8', 200, 2, 0, 1), r('p1', '7', 200, 2, 0, 1)];
+  engine.shown = new Set(['7', '8']);
+  assert.equal((await read()).rising.handle, 'h7', 'handle, by code unit');
+});
+
+await t('a builder who may not be shown is not the rising builder, and nobody takes it in their place unless they qualify', async () => {
+  reset();
+  engine.rows = [r('p1', '2', 300, 2, 0), r('p1', '4', 250, 1, 0)];
+  engine.shown = new Set(['4']);
+  assert.equal((await read()).rising.handle, 'h4');
+  const [who] = callsOf(isWho);
+  assert.ok(who.sql.includes(NUMBERS), 'who is shown: the numbers predicate');
+  assert.deepEqual(who.params[0].sort(), ['2', '4']);
+  reset();
+  engine.rows = [r('p1', '2', 300, 2, 0)];
+  assert.equal((await read()).rising, null);
+});
+
+// ---- 3. the projects on the move ------------------------------------------------
+
+await t('the projects: named only on the map with the Public door, by works then credits, at most PROJECTS_MAX', async () => {
+  reset();
+  engine.shown = new Set(['1', '2', '3']);
+  engine.rows = [
+    r('a', '1', 100, 3, 0), r('a', '2', 50, 1, 0),   // 4 works, 150
+    r('b', '1', 900, 4, 0),                          // 4 works, 900
+    r('c', '3', 10, 1, 0),
+    r('d', '3', 10, 1, 0),
+    r('e', '3', 20, 1, 0),
+    r('f', '3', 5, 1, 0),
+    r('g', '3', 0, 0, 0),                            // nothing shipped
+    r('hidden', '3', 999, 9, 0),                     // private or stealth: not named
+  ];
+  for (const c of ['a', 'b', 'c', 'd', 'e', 'f', 'g']) engine.named[c] = { name: c.toUpperCase(), origin: `https://${c}.example` };
+  const { projects } = await read();
+  assert.deepEqual(projects.map((p) => p.name), ['B', 'A', 'E', 'C', 'D'], 'works, then credits, then name');
+  assert.equal(projects.length, movers.PROJECTS_MAX);
+  assert.deepEqual(projects[1], { name: 'A', origin: 'https://a.example', tasks_shipped: 4, credits: 150 });
+  const [named] = callsOf(isNamed);
+  assert.ok(named.sql.includes(`${ON_MAP} AND p.visibility = 'public'`), 'a profile’s naming rule (task 1003558)');
+  assert.doesNotMatch(JSON.stringify(projects), /client_id|github_id|"hidden"/);
+});
+
+await t('a project counts only the builders who may be shown', async () => {
+  reset();
+  engine.shown = new Set(['1']);
+  engine.rows = [r('a', '1', 100, 1, 0), r('a', '2', 500, 5, 0), r('b', '2', 900, 9, 0)];
+  engine.named = { a: { name: 'A', origin: 'https://a.example' }, b: { name: 'B', origin: 'https://b.example' } };
+  const { projects } = await read();
+  assert.deepEqual(projects, [{ name: 'A', origin: 'https://a.example', tasks_shipped: 1, credits: 100 }]);
+  assert.deepEqual(callsOf(isNamed)[0].params[0], ['a'], 'a project only a hidden builder moved is not even asked about');
+});
+
+// ---- 4. the memo ------------------------------------------------------------------
+
+await t('the 30 days are computed once per MOVERS_TTL_MS; who and which projects are asked every read', async () => {
+  reset();
+  engine.rows = [r('a', '2', 300, 2, 0)];
+  engine.shown = new Set(['2']);
+  engine.named = { a: { name: 'A', origin: 'https://a.example' } };
+  const t0 = Date.parse(NOW);
+  assert.equal((await read(t0)).rising.handle, 'h2');
+  engine.shown = new Set();            // the builder hides
+  delete engine.named.a;               // and the project closes its door
+  const hid = await read(t0 + movers.MOVERS_TTL_MS - 1);
+  assert.equal(hid.rising, null, 'a hide beats the memo');
+  assert.deepEqual(hid.projects, [], 'so does a closed door');
+  assert.equal(hid.window.end, NOW, 'inside the memo: the window it was computed for');
+  assert.equal(callsOf(isRows).length, 1);
+  assert.equal(callsOf(isWho).length, 2);
+  await read(t0 + movers.MOVERS_TTL_MS);
+  assert.equal(callsOf(isRows).length, 2, 'stale: computed again');
+  await read(t0 - 1000);
+  assert.equal(callsOf(isRows).length, 3, 'a clock that runs backwards is never served from the memo');
+});
+
+// ---- 5. the route -----------------------------------------------------------------
+
+function serve() {
+  const app = express();
+  app.use(attachFail);
+  app.use('/api/bongos', buildRoutes());
+  const server = app.listen(0, '127.0.0.1');
+  return new Promise((resolve) => server.once('listening', () => resolve(server)));
+}
+function get(server, path_, headers = {}) {
+  return new Promise((resolve, reject) => {
+    http.get({ host: '127.0.0.1', port: server.address().port, path: path_, headers }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body, json: body ? JSON.parse(body) : null }));
+    }).on('error', reject);
+  });
+}
+
+const server = await serve();
+const URL_ = '/api/bongos/community/movers';
+
+await t('GET /community/movers: the window, the rising builder and the projects; no-store; CORS-open; the same for every viewer', async () => {
+  reset();
+  engine.rows = [r('a', '2', 300, 2, 0)];
+  engine.shown = new Set(['2']);
+  engine.named = { a: { name: 'A', origin: 'https://a.example' } };
+  const anon = await get(server, URL_);
+  assert.equal(anon.status, 200);
+  assert.equal(anon.headers['cache-control'], 'no-store');
+  assert.equal(anon.headers['access-control-allow-origin'], '*');
+  assert.deepEqual(Object.keys(anon.json), ['window', 'rising', 'projects']);
+  assert.equal(anon.json.rising.handle, 'h2');
+  assert.equal(anon.json.projects[0].name, 'A');
+  assert.doesNotMatch(anon.body, /github_id|client_id/);
+  const signedIn = await get(server, URL_, { Cookie: 'bongos_session=x', Authorization: 'Bearer y' });
+  assert.equal(signedIn.body, anon.body, 'the route reads no session');
+});
+
+await t('a failure is the 500 envelope, never a stack', async () => {
+  reset();
+  engine.throwOn = isRows;
+  const res = await get(server, URL_);
+  assert.equal(res.status, 500);
+  assert.equal(res.json.error.code, 'community_movers_failed');
+  assert.doesNotMatch(res.body, /boom/);
+});
+
+await t('its own rate-limit budget, not the board’s, the week’s or the crowns’', () => {
+  const { _internals } = buildRoutes;
+  assert.equal(_internals.MOVERS_READ_RATE_SCOPE, 'community-movers-read');
+  assert.equal(new Set([_internals.MOVERS_READ_RATE_SCOPE, _internals.CROWNS_READ_RATE_SCOPE, _internals.READ_RATE_SCOPE, _internals.WEEK_READ_RATE_SCOPE]).size, 4);
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/community_movers_db.mjs

@@ -0,0 +1,147 @@
+// tests/community_movers_db.mjs — task 1002983 (the rising builder and the projects on the
+// move; real DB).
+//
+// Proves against real SQL what a fake pool cannot (tests/community_movers.mjs): the 30 days
+// keep the year's baseline rule (a lifetime brought into them counts from its first snapshot
+// inside, a row first seen inside from zero), a quiet row's live total counts toward the
+// "under 100 before" test, a hidden builder counts nowhere, and a private project is never
+// named, however much it shipped.
+//
+// The read is global (every eligible builder on the hub), so the fixture's 30 days end in
+// March 2099: a shared database's real builders have no snapshot there, so they ship nothing
+// in them and the shipped-work floor keeps them out.
+//
+// Real-DB integration test: self-skips without a reachable Postgres; in the INTEGRATION set
+// (scripts/bongos/run-unit-tests.js) so the DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=... node tests/community_movers_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const { readMovers, clearMoversMemo } = require('../modules/platform-identity/community-movers.js');
+
+const here = dirname(fileURLToPath(import.meta.url));
+const MIG_DIR = join(here, '..', 'modules', 'platform-identity', 'migrations');
+const migrationSql = (f) => readFileSync(join(MIG_DIR, f), 'utf8');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`community_movers_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const R = 90298301, V = 90298302, Q = 90298303, L = 90298304, N = 90298305, S = 90298306, HIDDEN = 90298307;
+const IDS = [R, V, Q, L, N, S, HIDDEN];
+const P1 = 't1002983-p1', P2 = 't1002983-p2', P3 = 't1002983-p3', PRIV = 't1002983-priv';
+const CLIENTS = [P1, P2, P3, PRIV];
+const origin = (c) => `https://${c}.example`;
+const NOW = new Date('2099-03-12T10:00:00.000Z'); // the 30 days open 2099-02-10T10:00Z
+const OLD = new Date('2098-06-01T00:00:00Z');
+const d = (iso) => new Date(iso);
+const q = (sql, params) => pool.query(sql, params);
+
+async function cleanup() {
+  await q(`DELETE FROM platform_identity_activity_snapshots WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_builder_project_activity WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_accounts WHERE github_id = ANY($1::bigint[])`, [IDS]).catch(() => {});
+  await q(`DELETE FROM platform_identity_projects WHERE origin = ANY($1::text[])`, [CLIENTS.map(origin)]).catch(() => {});
+  await q(`DELETE FROM platform_identity_sso_clients WHERE client_id = ANY($1::text[])`, [CLIENTS]).catch(() => {});
+}
+async function account(id, handle, { hide = false } = {}) {
+  await q(
+    `INSERT INTO platform_identity_accounts
+       (github_id, github_login, display_name, handle, profile_state, account_visibility, hide_stats, terms_accepted_at)
+     VALUES ($1, $2, $2, $2, 'active', 'public', $3, now())`,
+    [id, handle, hide],
+  );
+}
+async function project(client, name, visibility) {
+  await q(`INSERT INTO platform_identity_sso_clients (client_id, secret_hash, name, origin) VALUES ($1, 'x', $2, $3)`, [client, name, origin(client)]);
+  await q(
+    `INSERT INTO platform_identity_projects (origin, name, description, featured, status, visibility, visibility_source)
+     VALUES ($1, $2, 'described', false, 'active', $3, 'control-plane')`,
+    [origin(client), name, visibility],
+  );
+}
+// One (project, builder) row: its live totals, when the hub first saw it, and its snapshots.
+async function row(client, id, live, firstSeen, history) {
+  await q(
+    `INSERT INTO platform_identity_builder_project_activity (client_id, github_id, credits, tasks_shipped, karma, first_seen_at) VALUES ($1, $2, $3, 0, 0, $4)`,
+    [client, id, live, firstSeen],
+  );
+  for (const [when, credits, ships] of history) {
+    await q(
+      `INSERT INTO platform_identity_activity_snapshots (client_id, github_id, credits, tasks_shipped, karma, reported_at) VALUES ($1, $2, $3, $4, 0, $5)`,
+      [client, id, credits, ships, d(when)],
+    );
+  }
+}
+const read = () => { clearMoversMemo(); return readMovers({ now: NOW, pool }); };
+const who = (w) => w && [w.handle, w.credits, w.tasks_shipped];
+const strip = (ps) => ps.map((p) => [p.name, p.tasks_shipped, p.credits]);
+
+let pass = 0;
+const same = (actual, expected, msg) => { assert.deepEqual(actual, expected, msg); pass++; console.log(`  ok - ${msg}`); };
+
+try {
+  for (const f of [
+    'platform_identity_001_tables.sql', 'platform_identity_004_projects.sql', 'platform_identity_005_builder_activity.sql',
+    'platform_identity_007_profile_consent.sql', 'platform_identity_008_handle.sql',
+    'platform_identity_011_project_visibility.sql', 'platform_identity_012_account_privacy.sql',
+    'platform_identity_019_terms_acceptance.sql', 'platform_identity_020_visibility_pull.sql',
+    'platform_identity_022_activity_snapshots.sql', 'platform_identity_032_weekly_features.sql',
+  ]) await q(migrationSql(f));
+  await cleanup();
+
+  for (const [id, h] of [[R, 'r'], [V, 'v'], [Q, 'q'], [L, 'l'], [N, 'n'], [S, 's']]) await account(id, `t1002983-${h}`);
+  await account(HIDDEN, 't1002983-hidden', { hide: true });
+  await project(P1, 'Alpha', 'public');
+  await project(P2, 'Beta', 'public');
+  await project(PRIV, 'Shut', 'private');
+
+  // R: 40 before the 30 days, then 300 and two works in them — the rising builder.
+  await row(P1, R, 340, OLD, [['2099-02-01T00:00:00Z', 40, 0], ['2099-03-01T00:00:00Z', 340, 2]]);
+  // V: a veteran — 5000 before, 900 and four works in them.
+  await row(P1, V, 5900, OLD, [['2099-02-01T00:00:00Z', 5000, 50], ['2099-03-01T00:00:00Z', 5900, 54]]);
+  // Q: 400 and three works on a project first seen inside (from zero), but 800 on a project
+  // with no history in the 30 days at all, so Q had 800 before them and is not rising.
+  await row(P2, Q, 400, d('2099-02-14T00:00:00Z'), [['2099-02-15T00:00:00Z', 400, 3]]);
+  await row(P3, Q, 800, OLD, []);
+  // L: a lifetime brought into the 30 days — no snapshot before them, seen before
+  // first_seen_at existed. Counted from its first snapshot inside: 150 and a work, never 90150.
+  await row(P1, L, 90150, null, [['2099-02-20T00:00:00Z', 90000, 40], ['2099-03-02T00:00:00Z', 90150, 41]]);
+  // N: first seen inside, so from zero: 250 and a work.
+  await row(P2, N, 250, d('2099-02-12T00:00:00Z'), [['2099-02-12T00:00:00Z', 250, 1]]);
+  // S: seven works on the private project.
+  await row(PRIV, S, 70, d('2099-02-11T00:00:00Z'), [['2099-02-11T00:00:00Z', 70, 7]]);
+  // HIDDEN out-earns and out-ships everyone on Alpha, and the leaderboard may not show them.
+  await row(P1, HIDDEN, 9000, OLD, [['2099-02-01T00:00:00Z', 0, 0], ['2099-03-01T00:00:00Z', 9000, 9]]);
+
+  const first = await read();
+  same([first.window.start, first.window.end], ['2099-02-10T10:00:00.000Z', '2099-03-12T10:00:00.000Z'], 'the 30 days up to now');
+  same(who(first.rising), ['t1002983-r', 300, 2], 'rising: R’s 300 — V, Q and L had 100 or more before (Q by a quiet project, L by its first snapshot), and hidden counts nowhere');
+  same(strip(first.projects), [['Alpha', 7, 1350], ['Beta', 4, 650]],'projects: works then credits; L counted from its first snapshot, hidden not counted, the private project never named');
+  same(first.projects[0].origin, origin(P1), 'a project links to its own address');
+  same(JSON.stringify(first).match(/github_id|client_id/), null, 'github_id and client_id never cross');
+
+  await q(`UPDATE platform_identity_accounts SET hide_stats = true WHERE github_id = $1`, [R]);
+  const hid = await readMovers({ now: NOW, pool }); // inside the memo
+  same(who(hid.rising), ['t1002983-n', 250, 1], 'R hides: the next one under the cap rises, without waiting for the memo');
+  same(strip(hid.projects), [['Alpha', 5, 1050], ['Beta', 4, 650]], 'and R’s numbers leave Alpha too');
+
+  await q(`UPDATE platform_identity_projects SET visibility = 'stealth' WHERE origin = $1`, [origin(P1)]);
+  same(strip((await readMovers({ now: NOW, pool })).projects), [['Beta', 4, 650]],'a project that goes stealth leaves the strip on the next read');
+
+  console.log(`\ncommunity_movers_db.mjs: ${pass} passed`);
+} finally {
+  await cleanup();
+  await pool.end();
+}

package/tests/hub_account_page.mjs

@@ -135,8 +135,8 @@ test('the bands say what the hub’s say and lead into /projects; Account is the
   assert.deepEqual(bandLinks(bandOf(PAGE, 'menuProjects')), [
     ['Sky', '/projects?view=map'], ['Table', '/projects?view=map&sub=table'],
     ['Your projects', '/projects?view=mine'], ['New project', '/projects?view=new'],
-    // the Community menu's four sub-pages, folded into the band under 480px (tasks 1003363, 1002981)
-    ['Leaderboard', '/community'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
+    // the Community menu's five sub-pages, folded into the band under 480px (tasks 1003363, 1002981, 1004902)
+    ['Community home', '/community'], ['Leaderboard', '/community/leaderboard'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
     ['Builders you may know', '/connections#connSuggest'],
   ], 'this page has no views of its own, so every item names /projects in full');
   assert.deepEqual(bandLinks(bandOf(PAGE, 'menuProfile')), [