@bongos/core 1.19.171 → 1.19.173

package/tests/handle_machinery.mjs

@@ -0,0 +1,143 @@
+// tests/handle_machinery.mjs — P01, task 1002797 (goal 1000045; real DB).
+//
+// Proves migration 008's seeding + the go-forward handle machinery against real
+// SQL (the plpgsql seeding loop and the partial unique index cannot run on
+// pg-mem — the tests/profile_rollup_consent.mjs precedent):
+//   1. seeding dedupes case-colliding logins oldest-first with -2, -3 suffixes;
+//      reserved logins never seed bare; an unusable login → builder-<github_id>
+//   2. upsertAccount seeds a NEW account's handle, suffixing past taken ones
+//   3. ensureHandle never clobbers a seeded handle
+//   4. setAccountHandle: rename keeps the old handle in previous_handle and
+//      starts the rate-limit clock; a second rename inside the window is
+//      refused; an expired window allows; a case-insensitive collision → taken;
+//      reserved words are refused
+//
+// Real-DB integration test: self-skips without a reachable Postgres; in the
+// INTEGRATION set so the default DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=... node tests/handle_machinery.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 pi = require('../modules/platform-identity/platform-identity.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(`handle_machinery.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+// High-numbered fixture ids so a shared DB can never collide with real data.
+const TWIN_A = 9002797001, TWIN_B = 9002797002, RESV = 9002797003, JUNK = 9002797004, FRESH = 9002797005;
+const ALL_IDS = [TWIN_A, TWIN_B, RESV, JUNK, FRESH];
+
+const q = (sql, params) => pool.query(sql, params);
+async function cleanup() {
+  await q(`DELETE FROM platform_identity_accounts WHERE github_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
+}
+
+let pass = 0;
+const ok = (cond, msg) => { assert.ok(cond, msg); pass++; console.log(`  ok - ${msg}`); };
+const handleOf = async (id) => (await pi.getAccount(id, { pool })).handle;
+
+try {
+  // The module's actual migrations (idempotent). 008 runs AFTER the fixture
+  // rows exist so its seeding loop has NULL handles to seed — exactly the
+  // legacy-rows-at-deploy shape.
+  await q(migrationSql('platform_identity_001_tables.sql'));
+  await q(migrationSql('platform_identity_004_projects.sql'));
+  await q(migrationSql('platform_identity_005_builder_activity.sql'));
+  await q(migrationSql('platform_identity_007_profile_consent.sql'));
+  // On a DB where 008 already ran the columns exist and the raw inserts below
+  // simply land with handle NULL — the re-run seeds only those. Idempotence is
+  // part of what this proves.
+  await q(migrationSql('platform_identity_008_handle.sql')).catch(() => {});
+  await cleanup();
+
+  await q(
+    `INSERT INTO platform_identity_accounts (github_id, github_login, created_at)
+     VALUES ($1, 'P01SeedTwin', now() - interval '10 minutes'),
+            ($2, 'p01seedtwin', now() - interval '9 minutes'),
+            ($3, 'admin',       now() - interval '8 minutes'),
+            ($4, '___',         now() - interval '7 minutes')`,
+    [TWIN_A, TWIN_B, RESV, JUNK],
+  );
+  await q(migrationSql('platform_identity_008_handle.sql'));
+
+  // --- 1. seeding ----------------------------------------------------------
+  ok((await handleOf(TWIN_A)) === 'p01seedtwin', 'oldest of a case-colliding pair seeds the bare handle');
+  ok((await handleOf(TWIN_B)) === 'p01seedtwin-2', 'the younger twin gets the -2 suffix');
+  ok((await handleOf(RESV)) === 'admin-2', 'a reserved login never seeds bare — suffixed from -2');
+  ok((await handleOf(JUNK)) === `builder-${JUNK}`, 'a login that contributes nothing seeds builder-<github_id>');
+
+  // --- 2. go-forward seeding via upsertAccount ------------------------------
+  const fresh = await pi.upsertAccount({ githubId: FRESH, githubLogin: 'P01SeedTwin' }, { pool });
+  ok(fresh.handle === 'p01seedtwin-3', 'a new account collides past every taken suffix');
+
+  // --- 3. ensureHandle never clobbers ---------------------------------------
+  const again = await pi.ensureHandle({ githubId: FRESH, githubLogin: 'renamed-login' }, { pool });
+  ok(again === 'p01seedtwin-3', 'ensureHandle on a seeded account returns the existing handle untouched');
+
+  // --- 4. renames -----------------------------------------------------------
+  const r1 = await pi.setAccountHandle({ githubId: FRESH, handle: 'P01-Renamed' }, { pool });
+  ok(r1.handle === 'p01-renamed' && r1.previous_handle === 'p01seedtwin-3',
+    'rename lowercases, keeps the old handle in the 301 slot');
+
+  const r2 = await pi.setAccountHandle({ githubId: FRESH, handle: 'p01-again' }, { pool });
+  ok(r2.error === 'rate_limited' && !!r2.retry_at, 'a second rename inside the window is refused with retry_at');
+  ok((await handleOf(FRESH)) === 'p01-renamed', 'the refused rename changed nothing');
+
+  await q(`UPDATE platform_identity_accounts SET handle_changed_at = now() - interval '8 days' WHERE github_id = $1`, [FRESH]);
+  const r3 = await pi.setAccountHandle({ githubId: FRESH, handle: 'p01-again' }, { pool });
+  ok(r3.handle === 'p01-again' && r3.previous_handle === 'p01-renamed', 'an expired window allows the rename; the 301 slot rolls forward');
+
+  await q(`UPDATE platform_identity_accounts SET handle_changed_at = now() - interval '8 days' WHERE github_id = $1`, [FRESH]);
+  const r4 = await pi.setAccountHandle({ githubId: FRESH, handle: 'P01SEEDTWIN' }, { pool });
+  ok(r4.error === 'handle_taken', 'a case-insensitive collision with a live handle is refused');
+
+  const r5 = await pi.setAccountHandle({ githubId: FRESH, handle: 'u' }, { pool });
+  ok(r5.error === 'reserved_handle', 'reserved words are refused on rename');
+
+  // --- 5. resolution (R05, task 1002281) ------------------------------------
+  // FRESH is 'p01-again' with previous 'p01-renamed'; everything is still
+  // provisional (fail-closed) at this point.
+  const prov = await pi.resolveHandle('p01-again', { pool });
+  ok(prov === null, 'a provisional account is not addressable — even by its current handle');
+
+  await q(`UPDATE platform_identity_accounts SET profile_state = 'active' WHERE github_id = ANY($1::bigint[])`, [[FRESH, TWIN_A]]);
+
+  const cur = await pi.resolveHandle('P01-Again', { pool });
+  ok(cur && cur.account && cur.account.handle === 'p01-again', 'the current handle resolves case-insensitively');
+
+  const moved = await pi.resolveHandle('p01-renamed', { pool });
+  ok(moved && moved.moved_to === 'p01-again', 'the previous handle answers a move to the current one');
+
+  const page = await pi.getPublicProfileByHandle('p01-again', { pool });
+  ok(page && page.account && page.account.member_since && !('github_id' in page.account),
+    'the public read carries the identity band, never the join key');
+  ok('cross_project' in page, 'the cross_project key is always present on a 200 (null = hidden/none)');
+
+  // Another active account claims the freed previous handle → the exact
+  // current-handle match beats the stale 301 (documented squat-forward rule).
+  await q(`UPDATE platform_identity_accounts SET handle = 'p01-renamed' WHERE github_id = $1`, [TWIN_A]);
+  const claimed = await pi.resolveHandle('p01-renamed', { pool });
+  ok(claimed && claimed.account && Number(claimed.account.github_id) === TWIN_A,
+    'an exact current-handle match wins over another account previous-handle claim');
+
+  console.log(`\nhandle_machinery: ${pass} assertions passed`);
+} finally {
+  await cleanup();
+  await pool.end().catch(() => {});
+}