@bongos/core 1.19.180 → 1.19.182

package/tests/idea_task_ship_credit.mjs

@@ -0,0 +1,117 @@
+// tests/idea_task_ship_credit.mjs
+//
+// task 1002998 (BV1.R174 / IC4, goal 1000067) — stream 1 of the ideator credit
+// lane: as each task descended from an idea SHIPS, pay the idea's author
+// 5 × grade-factor, once. ADR 0172. Replaces the ADR 0023 25% slice at ship.
+//
+// The done-when as assertions: a shipped task under a Full Idea pays
+// 5 × completeness%; under a Quick idea pays 5 × the flat factor; a Full Idea
+// that became a GOAL pays on EVERY one of its shipped tasks (the one-idea-many-
+// tasks point); re-running never double-pays per (idea, task); cost-plus-only
+// does NOT suppress it; a task with no source idea pays nothing.
+//
+// awardIdeaTaskShipCredit is exercised over a stub client whose credit_log is a
+// set of reasons and whose lineage/idea/grade SELECT returns a scripted row —
+// so the grade-factor math and the per-(idea,task) idempotency are proven
+// without a DB.
+//
+// Run:  node tests/idea_task_ship_credit.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const credits = require('../modules/economy/credits.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// `source` is the {idea_id, captured_by, grade, completeness} the lineage SELECT
+// returns for a task (null → no source idea). `credited` is the in-memory ledger.
+function stubClient(source) {
+  const credited = [];
+  return {
+    credited,
+    async query(sql, params) {
+      if (/FROM ideas_task_lineage/i.test(sql)) {
+        return { rows: source ? [source] : [] };
+      }
+      if (/INSERT INTO credit_log/i.test(sql)) {
+        assert.match(sql, /builder_id = \$1 AND reason = \$4/, 'idempotency must be builder-scoped for the index');
+        const reason = params[3];
+        if (credited.some((r) => r.reason === reason)) return { rowCount: 0, rows: [] };
+        credited.push({ builder_id: params[0], task_id: params[1], delta: params[2], reason });
+        return { rowCount: 1, rows: [] };
+      }
+      return { rows: [] };
+    },
+  };
+}
+
+const ON = { ideatorCredit: true };
+
+await test('a shipped task under a FULL idea pays 5 × completeness%', async () => {
+  const c = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 80 });
+  const r = await credits.awardIdeaTaskShipCredit(c, { taskId: 100, config: ON });
+  assert.equal(r.credited, 4, '5 × 0.80 = 4');
+  assert.equal(r.reason, 'paid');
+  assert.equal(c.credited[0].builder_id, 3);
+  assert.equal(c.credited[0].reason, 'idea.credit.task_ship:7:100');
+});
+
+await test('a shipped task under a QUICK idea pays 5 × the flat factor', async () => {
+  const c = stubClient({ idea_id: 7, captured_by: 3, grade: 'quick', completeness: null });
+  const r = await credits.awardIdeaTaskShipCredit(c, { taskId: 100, config: ON });
+  assert.equal(r.credited, Math.round(credits.IDEA_TASK_SHIP_BASE * credits.QUICK_IDEA_FACTOR)); // 5 × 0.6 = 3
+});
+
+await test('a full idea with 100% pays the full base; a spark falls back to the quick factor', async () => {
+  const full = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 100 });
+  assert.equal((await credits.awardIdeaTaskShipCredit(full, { taskId: 100, config: ON })).credited, 5);
+  const spark = stubClient({ idea_id: 7, captured_by: 3, grade: 'spark', completeness: null });
+  assert.equal((await credits.awardIdeaTaskShipCredit(spark, { taskId: 100, config: ON })).credited, 3);
+});
+
+await test('one idea → many tasks: EACH shipped task pays (the whole point of stream 1)', async () => {
+  // same idea 7, three different tasks — three separate credits
+  for (const taskId of [100, 101, 102]) {
+    const c = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 80 });
+    const r = await credits.awardIdeaTaskShipCredit(c, { taskId, config: ON });
+    assert.equal(r.credited, 4, `task ${taskId} pays`);
+    assert.equal(c.credited[0].reason, `idea.credit.task_ship:7:${taskId}`, 'distinct per task');
+  }
+});
+
+await test('re-running the same (idea, task) never double-pays', async () => {
+  const c = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 80 });
+  const first = await credits.awardIdeaTaskShipCredit(c, { taskId: 100, config: ON });
+  const second = await credits.awardIdeaTaskShipCredit(c, { taskId: 100, config: ON });
+  assert.equal(first.credited, 4);
+  assert.equal(second.credited, 0);
+  assert.equal(second.reason, 'already_paid');
+  assert.equal(c.credited.length, 1);
+});
+
+await test('COST-PLUS-ONLY does NOT suppress stream 1 — the ideator lane pays', async () => {
+  const policy = credits.rewardPolicy({ mode: 'cost-plus-only' });
+  assert.equal(policy.perTaskCredit, false);
+  const c = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 80 });
+  const r = await credits.awardIdeaTaskShipCredit(c, { taskId: 100, config: policy });
+  assert.equal(r.credited, 4, 'paid despite cost-plus-only');
+});
+
+await test('the lane opted out, or a task with no source idea, pays nothing', async () => {
+  const off = stubClient({ idea_id: 7, captured_by: 3, grade: 'full', completeness: 80 });
+  assert.equal((await credits.awardIdeaTaskShipCredit(off, { taskId: 100, config: { ideatorCredit: false } })).reason, 'ideator_lane_off');
+  const orphan = stubClient(null);
+  const r = await credits.awardIdeaTaskShipCredit(orphan, { taskId: 100, config: ON });
+  assert.equal(r.credited, 0);
+  assert.equal(r.reason, 'no_source_idea');
+});
+
+console.log(`\nidea_task_ship_credit: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/profile_fields.mjs

@@ -0,0 +1,133 @@
+// tests/profile_fields.mjs — P02, task 1002798 (goal 1000045; real DB).
+//
+// Proves migration 009 + the profile-fields machinery against real SQL (the
+// handle_machinery.mjs precedent):
+//   1. setAccountProfileFields on an UNSEEN builder creates a fail-closed
+//      provisional account, seeds the handle, stores bio + links
+//   2. the ADR 0156 mirror: setting display_name stamps source='user', and a
+//      later upsertAccount re-sync (the check-in shape) keeps its hands off the
+//      name while github_login/avatar_url still re-sync; a never-renamed
+//      account still follows GitHub renames
+//   3. the UPDATE branch touches ONLY the fields sent — bio alone leaves
+//      links/display_name alone, and never demotes profile_state or flips
+//      hide_stats
+//   4. links REPLACE wholesale; null clears; a rejected link writes nothing
+//   5. the public read (getPublicProfileByHandle) carries bio + links
+//
+// 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/profile_fields.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(`profile_fields.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 FRESH = 9002798001, SYNCED = 9002798002;
+const ALL_IDS = [FRESH, SYNCED];
+
+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 acctOf = (id) => pi.getAccount(id, { pool });
+
+try {
+  await q(migrationSql('platform_identity_001_tables.sql'));
+  await q(migrationSql('platform_identity_007_profile_consent.sql'));
+  await q(migrationSql('platform_identity_008_handle.sql'));
+  await q(migrationSql('platform_identity_009_profile_fields.sql'));
+  // Idempotence is part of what this proves.
+  await q(migrationSql('platform_identity_009_profile_fields.sql'));
+  await cleanup();
+
+  // --- 1. INSERT branch: unseen builder fills their profile ahead of time ---
+  const first = await pi.setAccountProfileFields({
+    githubId: FRESH, githubLogin: 'P02Fresh', displayName: 'GH Fresh', avatarUrl: 'https://a.example/f.png',
+    fields: { bio: '  Builds bongos in the cloud.  ', links: { website: 'https://fresh.example', x: 'https://x.com/fresh' } },
+  }, { pool });
+  ok(first.bio === 'Builds bongos in the cloud.', 'INSERT branch stores the trimmed bio');
+  ok(first.links.website === 'https://fresh.example/' && first.links.x === 'https://x.com/fresh', 'INSERT branch stores normalized links');
+  ok(first.handle === 'p02fresh', 'the create path seeds the handle, like every other account-creating upsert');
+  let a = await acctOf(FRESH);
+  ok(a.profile_state === 'provisional', 'a profile-fields write never grants consent — fail-closed provisional');
+  ok(a.display_name === 'GH Fresh' && a.display_name_source === 'github', 'no display_name sent → GitHub-derived name, source stays github');
+
+  // --- 2. the ADR 0156 mirror ----------------------------------------------
+  const named = await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'P02Fresh', fields: { display_name: 'Fresh, Renamed' } }, { pool });
+  ok(named.display_name === 'Fresh, Renamed', 'setting display_name writes it');
+  a = await acctOf(FRESH);
+  ok(a.display_name_source === 'user', 'and stamps display_name_source=user');
+
+  await pi.upsertAccount({ githubId: FRESH, githubLogin: 'p02fresh-renamed', displayName: 'GH Clobber', avatarUrl: 'https://a.example/new.png' }, { pool });
+  a = await acctOf(FRESH);
+  ok(a.display_name === 'Fresh, Renamed', 'a check-in re-sync does NOT clobber a user-set name');
+  ok(a.github_login === 'p02fresh-renamed' && a.avatar_url === 'https://a.example/new.png', 'github_login + avatar_url still re-sync unconditionally');
+
+  await pi.upsertAccount({ githubId: SYNCED, githubLogin: 'p02synced', displayName: 'GH Old' }, { pool });
+  await pi.upsertAccount({ githubId: SYNCED, githubLogin: 'p02synced', displayName: 'GH New' }, { pool });
+  a = await acctOf(SYNCED);
+  ok(a.display_name === 'GH New', 'a never-renamed account still follows GitHub renames');
+
+  // --- 3. the UPDATE branch touches only what was sent ----------------------
+  await q(`UPDATE platform_identity_accounts SET profile_state = 'active', hide_stats = true WHERE github_id = $1`, [FRESH]);
+  await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: { bio: 'Just the bio.' } }, { pool });
+  a = await acctOf(FRESH);
+  ok(a.bio === 'Just the bio.', 'bio alone updates');
+  ok(a.links.website === 'https://fresh.example/', 'links untouched by a bio-only write');
+  ok(a.display_name === 'Fresh, Renamed', 'display_name untouched by a bio-only write');
+  ok(a.profile_state === 'active' && a.hide_stats === true, 'profile_state + hide_stats never move on a profile-fields write');
+
+  // --- 4. links replace wholesale; null clears; rejects write nothing -------
+  await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: { links: { discord: 'https://discord.gg/bongos' } } }, { pool });
+  a = await acctOf(FRESH);
+  ok(a.links.discord === 'https://discord.gg/bongos' && !a.links.website && !a.links.x, 'a links write replaces the whole set');
+
+  const bad = await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: { bio: 'never lands', links: { linkedin: 'https://evil.example/in' } } }, { pool });
+  ok(bad.error === 'invalid_link' && bad.reason === 'wrong_host', 'a host-pinned type refuses a foreign host');
+  a = await acctOf(FRESH);
+  ok(a.bio === 'Just the bio.' && a.links.discord === 'https://discord.gg/bongos', 'a rejected write writes NOTHING — not even the valid fields beside it');
+
+  const none = await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: {} }, { pool });
+  ok(none.error === 'no_fields', 'an empty fields object is refused, not a silent no-op');
+
+  await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: { bio: null, links: null } }, { pool });
+  a = await acctOf(FRESH);
+  ok(a.bio === null && a.links === null, 'null clears bio and links');
+
+  // --- 5. the public read carries the fields --------------------------------
+  await pi.setAccountProfileFields({ githubId: FRESH, githubLogin: 'p02fresh-renamed', fields: { bio: 'Public bio.', links: { website: 'https://fresh.example' } } }, { pool });
+  const page = await pi.getPublicProfileByHandle('p02fresh', { pool });
+  ok(page.account.bio === 'Public bio.' && page.account.links.website === 'https://fresh.example/', 'getPublicProfileByHandle serves bio + links');
+  ok(!('display_name_source' in page.account), 'display_name_source never crosses the public whitelist');
+
+  console.log(`\nprofile_fields: ${pass} checks passed`);
+} catch (e) {
+  console.error(`\nFAIL after ${pass} checks: ${e.message}`);
+  process.exitCode = 1;
+} finally {
+  await cleanup();
+  await pool.end().catch(() => {});
+}