@bongos/core 1.24.6 → 1.24.7

package/tests/autopickup_cap.mjs

@@ -2,7 +2,8 @@
 // (task 1004677 / BV2.TW19a, ADR 0371 D3, D5, D6).
 //
 // Pinned here (DB-free; the race lives in tests/autopickup_cap_db.mjs):
-//   1. the two parsers and the resolver: off by default, cap 20 by default, an
+//   1. the parsers and the resolver: off by default, cap 200 by default (task
+//      1005003; it was 20), per-rank caps read from one JSON row, an
 //      unusable stored value reported and never thrown, a dead DB answers defaults;
 //   2. the refusal ladder: not a tweak, switch off, round limit, monthly cap, and the
 //      lock is taken BEFORE either count;
@@ -35,7 +36,12 @@ async function withPool(query, fn) {
   pool.query = query;
   try { return await fn(); } finally { pool.query = saved; }
 }
-const settingsRows = (map) => async (_sql, [key]) => ({ rows: key in map ? [{ key, value: map[key] }] : [] });
+// Answers both the single-key read (getSetting) and the one-query batch read
+// (key = ANY($1)) that resolveTweakAutopickup makes.
+const settingsRows = (map) => async (_sql, [key]) => {
+  const keys = Array.isArray(key) ? key : [key];
+  return { rows: keys.filter((k) => k in map).map((k) => ({ key: k, value: map[k] })) };
+};
 
 // ---- 1. the setting ---------------------------------------------------------
 
@@ -50,11 +56,11 @@ test('the parsers accept exactly off|on and a whole positive cap', () => {
   assert.match(parseAutopickupCap('100000').reason, /out of range/);
 });
 
-test('an untouched project is off with a cap of 20', async () => {
+test('an untouched project is off with a cap of 200 and no rank caps', async () => {
   assert.equal(DEFAULT_AUTOPICKUP, 'off');
-  assert.equal(DEFAULT_AUTOPICKUP_CAP, 20);
+  assert.equal(DEFAULT_AUTOPICKUP_CAP, 200);
   const r = await withPool(settingsRows({}), () => resolveTweakAutopickup());
-  assert.deepEqual(r, { mode: 'off', cap: 20, source: { mode: 'default', cap: 'default' }, invalid: [] });
+  assert.deepEqual(r, { mode: 'off', cap: 200, rank_caps: {}, source: { mode: 'default', cap: 'default' }, invalid: [] });
   assert.match(describeTweakAutopickup(r), /waits until a person/);
 });
 
@@ -63,7 +69,7 @@ test('stored values are read; an unusable one is reported and falls back', async
     () => resolveTweakAutopickup());
   assert.equal(r.mode, 'on');
   assert.equal(r.source.mode, 'project_settings');
-  assert.equal(r.cap, 20);
+  assert.equal(r.cap, 200);
   assert.equal(r.invalid.length, 1);
   assert.equal(r.invalid[0].raw, 'lots');
   assert.match(describeTweakAutopickup({ mode: 'on', cap: 7 }), /up to 7 a month/);
@@ -72,7 +78,7 @@ test('stored values are read; an unusable one is reported and falls back', async
 test('a database that cannot be read answers the defaults', async () => {
   const r = await withPool(async () => { throw new Error('db down'); }, () => resolveTweakAutopickup());
   assert.equal(r.mode, 'off');
-  assert.equal(r.cap, 20);
+  assert.equal(r.cap, 200);
 });
 
 // ---- 2. the refusal ladder --------------------------------------------------
@@ -128,7 +134,7 @@ test('the monthly cap refuses at the cap and admits below it', async () => {
 test('claimTask runs the gate before the insert, and names the column only on a marked claim', () => {
   const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'db-claims.js'), 'utf8');
   const body = src.slice(src.indexOf('async function claimTask('), src.indexOf('async function claimTasksBatch'));
-  const gate = body.indexOf('autoPickupRefusal(client, task, autoPickupSettings)');
+  const gate = body.indexOf('autoPickupRefusal(client, task, autoPickupSettings, builderRank)');
   const insert = body.indexOf('INSERT INTO claims');
   assert.ok(gate > 0 && insert > gate, 'the gate runs inside the transaction, before the insert');
   assert.match(body.slice(gate, insert), /if \(refusal\) throw refusal;/, 'a refusal stops the claim');
@@ -155,15 +161,19 @@ const fakeRes = () => ({
   json(p) { this.payload = p; return this; },
 });
 
-function buildRouter({ used = 4 } = {}) {
+function buildRouter({ used = 4, rankCaps = {} } = {}) {
   const ps = api.projectSettings;
   const saved = { resolve: ps.resolveTweakAutopickup, set: ps.set };
   const writes = [];
-  const state = { mode: 'off', cap: 20 };
+  const state = { mode: 'off', cap: 20, rank_caps: { ...rankCaps } };
   ps.resolveTweakAutopickup = async () => ({ ...state, source: { mode: 'default', cap: 'default' }, invalid: [] });
   ps.set = async (key, value, by) => {
     writes.push({ key, value, by });
-    if (key === 'tweak.autopickup') state.mode = value; else state.cap = value;
+    if (key === 'tweak.autopickup') state.mode = value;
+    else if (key.startsWith('tweak.autopickup_rank_cap.')) {
+      const rank = key.slice('tweak.autopickup_rank_cap.'.length);
+      if (value === '') delete state.rank_caps[rank]; else state.rank_caps[rank] = value;
+    } else state.cap = value;
   };
   const autopickup = require('../modules/lifecycle/autopickup.js');
   const savedCount = autopickup.countThisMonth;
@@ -234,3 +244,185 @@ test('core_275 is additive: one nullable column, recorded in schema_migrations',
   assert.doesNotMatch(sql, /NOT NULL|DROP /);
   assert.match(sql, /INSERT INTO schema_migrations \(version\) VALUES \('core_275_claims_auto_pickup'\)/);
 });
+
+// ---- 5. the cap per project and per builder rank (task 1005003) ------------
+
+const { rankCapKey } = require('../src/bongos/project-settings.js');
+const { effectiveCap } = require('../modules/lifecycle/autopickup.js');
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+
+test('a project override and a rank override are both read, in ONE query', async () => {
+  assert.equal(rankCapKey('xenos'), 'tweak.autopickup_rank_cap.xenos');
+  let queries = 0;
+  const rows = settingsRows({
+    [SETTING_KEYS.TWEAK_AUTOPICKUP]: 'on',
+    [SETTING_KEYS.TWEAK_AUTOPICKUP_CAP]: '40',
+    'tweak.autopickup_rank_cap.xenos': '5',
+    'tweak.autopickup_rank_cap.archon': '80',
+    'tweak.autopickup_rank_cap.metic': '', // cleared: follows the project cap
+    'tweak.autopickup_rank_cap.olympian': '9', // off the live ladder: never read
+  });
+  const r = await withPool(async (sql, params) => { queries += 1; return rows(sql, params); }, () => resolveTweakAutopickup());
+  assert.equal(queries, 1, 'mode, cap and every rank cap come back in one round trip');
+  assert.equal(r.cap, 40);
+  assert.deepEqual(r.rank_caps, { xenos: 5, archon: 80 });
+  assert.deepEqual(r.invalid, []);
+  assert.equal(describeTweakAutopickup(r),
+    'On: a running Autobongos runner applies submitted pages on its own, up to 40 a month. Some builder ranks have their own limit: xenos 5, archon 80. The artist still approves every one.');
+
+  const bad = await withPool(settingsRows({ 'tweak.autopickup_rank_cap.xenos': '-1' }), () => resolveTweakAutopickup());
+  assert.deepEqual(bad.rank_caps, {}, 'an unusable rank row falls back to the project cap');
+  assert.equal(bad.invalid.length, 1);
+  assert.equal(bad.invalid[0].where, "project_settings['tweak.autopickup_rank_cap.xenos']");
+});
+
+test('the effective cap is the rank\'s own cap, else the project cap', () => {
+  const s = { mode: 'on', cap: 200, rank_caps: { xenos: 5 } };
+  assert.deepEqual(effectiveCap(s, 'xenos'), { cap: 5, from: 'rank' });
+  assert.deepEqual(effectiveCap(s, 'metic'), { cap: 200, from: 'project' });
+  assert.deepEqual(effectiveCap(s, null), { cap: 200, from: 'project' });
+  assert.deepEqual(effectiveCap({ cap: 200 }, 'xenos'), { cap: 200, from: 'project' }, 'no rank caps at all');
+});
+
+test('the default cap of 200 admits round 199 and refuses at 200', async () => {
+  const s = { mode: 'on', cap: DEFAULT_AUTOPICKUP_CAP, rank_caps: {} };
+  assert.equal(await autoPickupRefusal(fakeClient({ month: 199 }), tweak, s, 'metic'), null);
+  const r = await autoPickupRefusal(fakeClient({ month: 200 }), tweak, s, 'metic');
+  assert.equal(r.code, 'AUTO_PICKUP_CAP_REACHED');
+  assert.equal(r.cap, 200);
+  assert.equal(r.cap_from, 'project');
+  assert.equal(r.message, 'Auto-pickup has used this month\'s 200 rounds, so submitted pages wait for a person until next month.');
+});
+
+test('a rank override replaces the project cap for that rank only, both ways', async () => {
+  const s = { mode: 'on', cap: 50, rank_caps: { xenos: 10, archon: 80 } };
+  // lower than the project cap: refuses a xenos runner where a metic one is admitted
+  const lower = await autoPickupRefusal(fakeClient({ month: 10 }), tweak, s, 'xenos');
+  assert.equal(lower.code, 'AUTO_PICKUP_CAP_REACHED');
+  assert.equal(lower.cap, 10);
+  assert.equal(lower.cap_from, 'rank');
+  assert.match(lower.message, /reached 10, the limit this project sets for a xenos builder's runner, so submitted pages wait for a person/);
+  assert.equal(await autoPickupRefusal(fakeClient({ month: 10 }), tweak, s, 'metic'), null);
+  // higher than the project cap: admits an archon runner past the project's number
+  assert.equal(await autoPickupRefusal(fakeClient({ month: 60 }), tweak, s, 'archon'), null);
+  assert.equal((await autoPickupRefusal(fakeClient({ month: 60 }), tweak, s, 'metic')).code, 'AUTO_PICKUP_CAP_REACHED');
+});
+
+test('claimTask passes the claimer\'s rank, read inside the transaction, to the gate', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'db-claims.js'), 'utf8');
+  const body = src.slice(src.indexOf('async function claimTask('), src.indexOf('async function claimTasksBatch'));
+  const rankRead = body.indexOf('const builderRank = builderRows[0] ? builderRows[0].rank : null;');
+  const gate = body.indexOf('autoPickupRefusal(client, task, autoPickupSettings, builderRank)');
+  assert.ok(rankRead > 0 && gate > rankRead);
+});
+
+test('the read reports the caller\'s own cap and what is left of it', async () => {
+  const { route, restore } = buildRouter({ used: 4, rankCaps: { xenos: 6 } });
+  try {
+    const get = handler(route('get', '/project-settings/tweak-autopickup'));
+    const x = fakeRes();
+    await get({ builder: { id: 1, rank: 'xenos' } }, x);
+    assert.deepEqual([x.payload.my_cap, x.payload.my_cap_from, x.payload.remaining_this_month], [6, 'rank', 2]);
+    assert.deepEqual(x.payload.rank_caps, { xenos: 6 });
+    const m = fakeRes();
+    await get({ builder: { id: 2, rank: 'metic' } }, m);
+    assert.deepEqual([m.payload.my_cap, m.payload.my_cap_from, m.payload.remaining_this_month], [20, 'project', 16]);
+  } finally { restore(); }
+});
+
+test('rank_caps is a partial update: a number sets, null clears, an unnamed rank is kept', async () => {
+  const { route, writes, restore } = buildRouter({ rankCaps: { xenos: 5, thetes: 9 } });
+  try {
+    const patch = handler(route('patch', '/project-settings/tweak-autopickup'));
+    const res = fakeRes();
+    await patch({ body: { rank_caps: { metic: 30, xenos: null } }, builder: { id: 7, rank: 'metic' } }, res);
+    assert.equal(res.code, null);
+    // One single-row upsert per named rank — never a read-modify-write of a shared
+    // object, so it cannot overwrite a rank someone else is editing at the same time.
+    assert.deepEqual(writes, [
+      { key: 'tweak.autopickup_rank_cap.metic', value: 30, by: 7 },
+      { key: 'tweak.autopickup_rank_cap.xenos', value: '', by: 7 },
+    ]);
+    assert.deepEqual(res.payload.rank_caps, { thetes: 9, metic: 30 });
+    assert.equal(res.payload.my_cap, 30);
+  } finally { restore(); }
+});
+
+test('two people saving two different ranks at once both keep their edit', async () => {
+  const { route, restore } = buildRouter();
+  try {
+    const patch = handler(route('patch', '/project-settings/tweak-autopickup'));
+    const a = fakeRes();
+    const b = fakeRes();
+    await Promise.all([
+      patch({ body: { rank_caps: { xenos: 5 } }, builder: { id: 7 } }, a),
+      patch({ body: { rank_caps: { archon: 80 } }, builder: { id: 8 } }, b),
+    ]);
+    const after = fakeRes();
+    await handler(route('get', '/project-settings/tweak-autopickup'))({ builder: { id: 9, rank: 'metic' } }, after);
+    assert.deepEqual(after.payload.rank_caps, { xenos: 5, archon: 80 });
+  } finally { restore(); }
+});
+
+test('an unknown rank or a bad rank number writes nothing, the project cap included', async () => {
+  const { route, writes, restore } = buildRouter();
+  try {
+    const patch = handler(route('patch', '/project-settings/tweak-autopickup'));
+    const unknown = fakeRes();
+    await patch({ body: { cap: 100, rank_caps: { olympian: 5 } }, builder: { id: 7 } }, unknown);
+    assert.equal(unknown.code, 'bad_tweak_autopickup');
+    assert.match(unknown.payload.message, /unknown rank 'olympian'/);
+    const zero = fakeRes();
+    await patch({ body: { cap: 100, rank_caps: { xenos: 0 } }, builder: { id: 7 } }, zero);
+    assert.match(zero.payload.message, /rank_caps\.xenos: must be positive/);
+    assert.equal(writes.length, 0);
+  } finally { restore(); }
+});
+
+// The server's permission check on the write, run for real: the route's own
+// requirePermission layer, against a stub government port (the
+// tests/government_require_permission.mjs double). Whoever holds
+// project.settings.manage — the project owner, or anyone granted it — passes; a
+// builder without it is refused with 403 before the handler runs.
+async function runWriteGate(heldKeys) {
+  const { route, restore } = buildRouter();
+  try {
+    const stack = route('patch', '/project-settings/tweak-autopickup').stack;
+    const gate = stack[1].handle;
+    assert.equal(gate.name, 'permissionGate', 'the second layer is the kernel permission gate');
+    seams._reset();
+    seams.registerProvider('government', { resolveBuilderPermissions: async () => heldKeys });
+    const res = { _status: null, _json: null, status(c) { this._status = c; return this; }, json(b) { this._json = b; return this; } };
+    attachFail({}, res, () => {});
+    let passed = false;
+    await gate({ builder: { id: 7, rank: 'metic' }, body: { rank_caps: { xenos: 5 } } }, res, () => { passed = true; });
+    return { passed, res };
+  } finally { seams._reset(); restore(); }
+}
+
+test('a builder holding project.settings.manage may set the caps', async () => {
+  const { passed, res } = await runWriteGate(['project.settings.manage']);
+  assert.equal(passed, true);
+  assert.equal(res._status, null);
+});
+
+test('a builder without project.settings.manage is refused', async () => {
+  const { passed, res } = await runWriteGate(['idea.triage']);
+  assert.equal(passed, false);
+  assert.equal(res._status, 403);
+  assert.equal(res._json.error.code, 'permission_forbidden');
+  assert.deepEqual(res._json.error.details.required, ['project.settings.manage']);
+});
+
+test('the settings page row offers the project cap and one box per live rank', () => {
+  const { tweakCapRow } = require('../modules/lifecycle/routes/project-settings.js');
+  const row = tweakCapRow({ mode: 'off', cap: 200, rank_caps: { xenos: 5 }, source: { cap: 'default' }, invalid: [] });
+  assert.equal(row.key, 'tweak_round_cap');
+  assert.equal(row.editable, true);
+  assert.equal(row.value.cap, 200);
+  assert.deepEqual(row.value.ranks, api.LIVE_RANK_LADDER.map((rank) => ({ rank, cap: rank === 'xenos' ? 5 : null })));
+  const page = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'project-settings.js'), 'utf8');
+  assert.match(page, /row\.key === 'tweak_round_cap'/);
+  assert.match(page, /sendJson\('PATCH', '\/project-settings\/tweak-autopickup', \{ cap: Number\(\$\('ps-tweak-cap'\)\.value\), rank_caps: rankCaps \}\)/);
+});

package/tests/project_settings_page.mjs

@@ -65,9 +65,11 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
     list: gc.listCategories,
     set: api.projectSettings.set,
     resolveShipMode: api.projectSettings.resolveShipMode,
+    resolveTweak: api.projectSettings.resolveTweakAutopickup,
   };
   api.resolveRotDays = async () => timer;
   api.projectSettings.resolveShipMode = async () => ({ mode: 'auto', source: 'default', chosen: false, invalid: null });
+  api.projectSettings.resolveTweakAutopickup = async () => ({ mode: 'off', cap: 200, rank_caps: {}, source: { mode: 'default', cap: 'default', rank_caps: 'default' }, invalid: [] });
   // reward: WORKING_REWARD (default) | null (port absent) | 'throws' (rewardConfig raises).
   const rewardPort = reward === 'throws'
     ? { rewardConfig: () => { throw new Error('reward boom'); } }
@@ -84,6 +86,7 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
     gc.listCategories = saved.list;
     api.projectSettings.set = saved.set;
     api.projectSettings.resolveShipMode = saved.resolveShipMode;
+    api.projectSettings.resolveTweakAutopickup = saved.resolveTweak;
   };
   // The handler is the LAST layer on the matching route (requireBuilder and the
   // permission gate sit in front); calling it directly is what keeps this a unit test
@@ -103,22 +106,22 @@ const CATS = [
   { id: 2, slug: 'retired-thing', label: 'Retired thing', sort_order: 20, active: false },
 ];
 
-test('one read returns all six fundamentals, each naming where its value came from', async () => {
+test('one read returns all seven fundamentals, each naming where its value came from', async () => {
   const { handlerFor, restore } = buildRouterWithStubs({ timer: TIMER_OK, categories: CATS });
   try {
     const res = fakeRes();
     await handlerFor('get', '/project-settings')({ query: {} }, res);
     const rows = res.payload.rows;
-    assert.equal(rows.length, 6, 'the page draws six rows, so the read returns six');
+    assert.equal(rows.length, 7, 'the page draws seven rows, so the read returns seven');
     assert.deepEqual(rows.map((r) => r.key),
-      ['ship_mode', 'rot_timer', 'work_categories', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
+      ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
     // Provenance is the point of the page: every row says where its value came from.
     for (const r of rows) {
       assert.ok(r.reads && r.reads.file, `${r.key} names no file`);
       assert.ok(r.sentence && r.sentence.length > 20, `${r.key} has no readable sentence`);
     }
-    // Three knobs: the criterion's two, plus ship mode (task 1004628).
-    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['ship_mode', 'rot_timer', 'work_categories']);
+    // Four knobs: the criterion's two, ship mode (task 1004628) and the monthly tweak-round cap (task 1005003).
+    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories']);
     // A no-store receipt: a cached settings read is wrong the moment a knob turns.
     assert.equal(res.headers['Cache-Control'], 'no-store');
   } finally { restore(); }