@bongos/core 1.21.108 → 1.21.110

package/tests/tweak_unattended.mjs

@@ -0,0 +1,274 @@
+// tests/tweak_unattended.mjs — /tweak --page <id> --unattended halts by releasing,
+// and the server, not the worker, holds its rules (task 1004678 / BV2.TW19b,
+// ADR 0371 D8).
+//
+//   1. tweak-halt.js: every halt releases the round with fixed wording, and
+//      copy-apply's exits map onto those halts;
+//   2. NO LAND WITHOUT THE ARTIST: every statement in the lifecycle that writes
+//      status 'confirmed' is enumerated from the source, and each one is either
+//      the artist's approval, the owner's override, or refuses a page tweak.
+//      confirmTask (the --skip-grade / grader-bypass path) is driven for real;
+//   3. NO FILE OUTSIDE THE PAGE: autopickup-files.js over the server's own read of
+//      the pull request's files, and the real publish route refusing (409, PR
+//      closed, never armed) when an auto_pickup round strays.
+// No DB, no network: fake pools, the real router, stubbed GitHub reads.
+//
+// Run:  node tests/tweak_unattended.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+const { test, summary } = makeRunner();
+
+// ---- 1. halts ---------------------------------------------------------------
+
+const halt = require('../scripts/gds/tweak-halt.js');
+
+await test('each ADR 0371 D8 halt has fixed wording; an unknown code has none', () => {
+  for (const code of ['claim_refused', 'nothing_applied', 'ship_check_stale', 'grader_unavailable']) {
+    assert.equal(typeof halt.haltNote(code), 'string', code);
+  }
+  assert.equal(halt.haltNote('anything the worker says'), null);
+  assert.throws(() => halt.releaseWithNote(9, 'free text', { spawn: () => ({ status: 0 }) }), /unknown halt code/);
+});
+
+await test('copy-apply exits map to halts; a clean apply is not a halt', () => {
+  assert.equal(halt.haltForCopyApplyExit(0), null);
+  assert.equal(halt.haltForCopyApplyExit(2), 'nothing_applied');
+  assert.equal(halt.haltForCopyApplyExit(3), 'registry_mismatch');
+  assert.equal(halt.haltForCopyApplyExit(4), 'reread_failed');
+  assert.equal(halt.haltForCopyApplyExit(5), 'wrong_page');
+  assert.equal(halt.haltForCopyApplyExit(99), 'nothing_applied', 'an unknown failure still halts');
+});
+
+await test('a halt RELEASES the round through release.js, with the fixed note as its reason', () => {
+  const calls = [];
+  const exit = halt.releaseWithNote(4321, 'grader_unavailable', { spawn: (cmd, argv) => { calls.push(argv); return { status: 0 }; } });
+  assert.equal(exit, 0);
+  assert.equal(calls.length, 1);
+  const [script, task, flag, reason] = calls[0];
+  assert.match(script.replace(/\\/g, '/'), /scripts\/gds\/release\.js$/);
+  assert.equal(task, '4321');
+  assert.equal(flag, '--reason');
+  assert.equal(reason, `[tweak-unattended:grader_unavailable] ${halt.HALT_NOTES.grader_unavailable}`);
+});
+
+await test('copy-apply --unattended releases on every non-zero batch exit (wired, not just documented)', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/copy-apply.js'), 'utf8');
+  const at = src.indexOf("hasFlag('--unattended') && code !== 0");
+  assert.ok(at > 0, 'the unattended branch tests every non-zero exit');
+  assert.ok(src.slice(at, at + 300).includes('halt.releaseWithNote(taskId, halt.haltForCopyApplyExit(code))'), 'and releases through tweak-halt');
+  assert.match(src, /arg\('--page'\)/);
+});
+
+await test('the skill documents the mode and never offers --skip-grade to it', () => {
+  const skill = fs.readFileSync(path.join(ROOT, 'modules/copy-desk/skills/tweak/SKILL.md'), 'utf8');
+  const section = skill.slice(skill.indexOf('## Unattended mode'), skill.indexOf('## What happens next'));
+  assert.ok(section.length > 200, 'the unattended section exists');
+  assert.match(section, /--page <page-id> --unattended/);
+  assert.match(section, /tweak-halt\.js/);
+  assert.match(section, /Never `--skip-grade`/);
+});
+
+// ---- 2. no land without the artist -----------------------------------------
+
+const achievements = require('../modules/economy/achievements.js');
+achievements.evaluateAfterShip = async () => [];
+achievements.evaluateAfterCreditAward = async () => [];
+achievements.evaluateAfterClaim = async () => [];
+achievements.reconcileBuilderAchievements = async () => [];
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+const db = require('../modules/lifecycle/db.js');
+
+// Every lifecycle statement that sets a TASK to confirmed, found from the source.
+// A new one reds this test until it is listed below with why it holds.
+const CONFIRM_WRITERS = {
+  'db-grade.js': 'promoteToConfirmed: applyGrade withholds it for a page tweak (isPageTweak), approveHeldTweak is the artist',
+  'db-overrides.js': "decideOverrideRequest: the owner's override request",
+  'db-ship.js': 'confirmTask: refuses a page tweak (PAGE_TWEAK_NEEDS_ARTIST)',
+};
+
+await test('every confirm path in the lifecycle is listed, and each holds the artist gate', () => {
+  const dir = path.join(ROOT, 'modules/lifecycle');
+  const found = [];
+  for (const f of fs.readdirSync(dir).filter((n) => n.endsWith('.js'))) {
+    const src = fs.readFileSync(path.join(dir, f), 'utf8');
+    const n = (src.match(/UPDATE tasks\s+SET status = 'confirmed'/g) || []).length;
+    for (let i = 0; i < n; i++) found.push(f);
+  }
+  assert.deepEqual(found.sort(), Object.keys(CONFIRM_WRITERS).sort(), 'one confirm write per listed file, and no other');
+  const grade = fs.readFileSync(path.join(dir, 'db-grade.js'), 'utf8');
+  assert.match(grade, /held = tweakHold\.isPageTweak/);
+  assert.match(grade, /gradeResult\.passed && task\.status === 'completed' && !held/);
+  const approve = fs.readFileSync(path.join(dir, 'page-tweak-approve.js'), 'utf8');
+  assert.match(approve, /isHeldForArtist/, 'approve runs the promotion only on a held round');
+});
+
+function confirmPool(source) {
+  return makeSqlAwareClient((s) => {
+    if (/SELECT builder_id FROM claims/.test(s)) return { rows: [{ builder_id: 25 }] };
+    if (/^SELECT source FROM tasks/.test(s)) return { rows: [{ source }] };
+    if (/^UPDATE tasks/.test(s)) return { rows: [{ id: 7, title: 't', credits_reward: 10, kind: 'feature' }] };
+    return { rows: [] };
+  });
+}
+
+await test('confirmTask (the --skip-grade path) REFUSES a page tweak and writes nothing', async () => {
+  const pool = confirmPool('page-tweak');
+  await assert.rejects(() => db.confirmTask({ taskId: 7, builderId: 1 }, { pool }), (e) => e.code === 'PAGE_TWEAK_NEEDS_ARTIST');
+  assert.ok(!pool._client.queries.some((q) => /^\s*UPDATE tasks/.test(String(q.sql))), 'no status write');
+});
+
+await test('confirmTask on every other task confirms as before', async () => {
+  for (const source of ['planning-session', 'page-tweak-unplaced', null]) {
+    const out = await db.confirmTask({ taskId: 7, builderId: 1 }, { pool: confirmPool(source) });
+    assert.equal(out.taskStatus, 'confirmed', String(source));
+  }
+});
+
+await test('POST /tasks/:id/confirm maps the refusal to a 409 that names the artist', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/routes/tasks.js'), 'utf8');
+  assert.match(src, /err\.code === 'PAGE_TWEAK_NEEDS_ARTIST'\) return res\.fail\('page_tweak_needs_artist', \{ status: 409/);
+});
+
+// ---- 3. no file outside the page -------------------------------------------
+
+const apf = require('../modules/lifecycle/autopickup-files.js');
+const pcheck = require('../src/bongos/permission-path-check.js');
+const INV = { pages: [{ id: 'landing:index', files: ['modules/public-landing/public/index.html', 'modules/public-landing/public/landing.css'], states_files: ['modules/public-landing/public/index.states.json'] }] };
+const ROUND = { id: 7, source: 'page-tweak', source_ref: 'page-tweak/landing:index/r2', auto_pickup: true };
+const files = (...p) => p.map((x) => ({ path: x }));
+const run = (over = {}, deps = {}) => apf.autoPickupFileRefusal({ taskId: 7, prNumber: 77 }, {
+  readRound: async () => ({ ...ROUND, ...over }),
+  readInventory: () => INV,
+  getPullRequestFiles: async () => files('modules/public-landing/public/index.html', 'docs/copy-registry.json', 'docs/page-readings.json'),
+  matchProtected: pcheck.matchProtected,
+  ...deps,
+});
+
+await test('an auto_pickup round touching only its page and the regenerated files publishes', async () => {
+  assert.equal(await run(), null);
+});
+
+await test('a file outside the page is refused and named', async () => {
+  const r = await run({}, { getPullRequestFiles: async () => files('modules/public-landing/public/index.html', 'modules/hall-ui/public/goals.js') });
+  assert.equal(r.code, 'auto_pickup_outside_page');
+  assert.deepEqual(r.outside, ['modules/hall-ui/public/goals.js']);
+  assert.match(apf.refusalMessage(r), /goals\.js/);
+});
+
+await test('a protected path is refused even when it is on the regenerated list', async () => {
+  const r = await run({}, { getPullRequestFiles: async () => files('modules/public-landing/public/index.html', 'CLAUDE.md') });
+  assert.equal(r.code, 'auto_pickup_outside_page');
+  assert.deepEqual(r.protected, ['CLAUDE.md']);
+});
+
+await test('fail closed: unreadable files, a list at the cap, an unknown page, a bad ref', async () => {
+  assert.equal((await run({}, { getPullRequestFiles: async () => { throw new Error('502'); } })).code, 'auto_pickup_files_unreadable');
+  const cap = Array.from({ length: 300 }, () => ({ path: 'modules/public-landing/public/index.html' }));
+  assert.equal((await run({}, { getPullRequestFiles: async () => cap })).code, 'auto_pickup_files_unreadable');
+  assert.equal((await run({ source_ref: 'page-tweak/landing:gone/r1' })).code, 'auto_pickup_page_unknown');
+  assert.equal((await run({ source_ref: 'nonsense' })).code, 'auto_pickup_page_unknown');
+  assert.equal((await run({}, { readInventory: () => { throw new Error('ENOENT'); } })).code, 'auto_pickup_page_unknown');
+});
+
+await test('an UNMARKED claim, or any other task, is never checked (no GitHub read)', async () => {
+  let reads = 0;
+  const count = { getPullRequestFiles: async () => { reads++; return files('anything.js'); } };
+  assert.equal(await run({ auto_pickup: false }, count), null);
+  assert.equal(await run({ auto_pickup: null }, count), null);
+  assert.equal(await run({ source: 'planning-session' }, count), null);
+  assert.equal(await apf.autoPickupFileRefusal({ taskId: 7, prNumber: 77 }, { readRound: async () => null, ...count }), null);
+  assert.equal(reads, 0);
+});
+
+await test('the round read is one query naming the latest claim\'s mark', async () => {
+  const pool = makeSqlAwareClient(() => ({ rows: [ROUND] }));
+  const r = await apf.readRound(7, pool._client || pool);
+  assert.equal(r.auto_pickup, true);
+  const q = (pool._client || pool).queries.map((x) => String(x.sql).replace(/\s+/g, ' '));
+  assert.equal(q.length, 1);
+  assert.match(q[0], /SELECT c\.auto_pickup FROM claims c WHERE c\.task_id = t\.id ORDER BY c\.claimed_at DESC, c\.id DESC LIMIT 1/);
+});
+
+await test('the page files come from the real inventory for a real page', () => {
+  const inv = JSON.parse(fs.readFileSync(path.join(ROOT, 'docs/page-inventory.json'), 'utf8'));
+  const page = inv.pages.find((p) => (p.files || []).length);
+  assert.ok(apf.pageFiles(inv, page.id).includes(page.files[0]));
+  assert.equal(apf.pageFiles(inv, 'nope:nope'), null);
+});
+
+// The real publish route.
+const express = require('express');
+const api = require('../src/module-api.js');
+const gp = require('../modules/lifecycle/github-push.js');
+const prAssign = require('../modules/lifecycle/pr-assign.js');
+const prClose = require('../modules/lifecycle/github-pr-close.js');
+const pageTweakReads = require('../modules/lifecycle/page-tweak-reads.js');
+
+let round = ROUND;
+let prFiles = files('modules/public-landing/public/index.html');
+let armCalls = 0, closed = [];
+api.requireBuilder = (req, res, next) => { req.builder = { id: 1, rank: 'archon', github_login: 'the-archon' }; next(); };
+db.getLastClaimHolder = async () => ({ builder_id: 5, github_login: 'some-builder' });
+db.setClaimPublishedSha = async () => {};
+api.pool.query = async () => ({ rows: [round] });
+gp.isConfigured = () => true;
+gp.pushBundle = async () => ({ head_sha: 'a'.repeat(40) });
+gp.openOrFindPullRequest = async () => ({ number: 77, url: 'https://github.com/o/r/pull/77', node_id: 'N' });
+gp.enableAutoMergeDetailed = async () => { armCalls++; return { ok: true }; };
+gp.getPullRequestFiles = async () => prFiles;
+gp.setCommitStatus = async () => true;
+prAssign.assignPullRequest = async () => ({ assigned: true });
+prClose.closePullRequest = async ({ number }) => { closed.push(number); return { ok: true }; };
+pageTweakReads.heldForArtistFailClosed = async () => true;
+
+const app = express();
+app.use((req, res, next) => { res.fail = (code, status, extra) => res.status(typeof status === 'number' ? status : (status && status.status) || 500).json({ error: code, ...(extra || {}) }); next(); });
+app.use(require('../modules/lifecycle/routes/tasks.js')());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const base = `http://127.0.0.1:${server.address().port}`;
+const publish = async () => {
+  const res = await fetch(`${base}/tasks/7/publish-branch`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ branch: 'task-7', head_sha: 'a'.repeat(40), bundle_b64: Buffer.from('b').toString('base64'), value_summary: 'Page tweak.' }),
+  });
+  return { status: res.status, body: await res.json() };
+};
+
+await test('publish: an auto_pickup round that strays is REFUSED 409, its PR closed, never armed', async () => {
+  round = ROUND; prFiles = files('modules/public-landing/public/index.html', 'src/server.js'); armCalls = 0; closed = [];
+  const r = await publish();
+  assert.equal(r.status, 409, JSON.stringify(r.body));
+  assert.equal(r.body.error, 'auto_pickup_outside_page');
+  assert.ok(r.body.outside.includes('src/server.js'));
+  assert.deepEqual(closed, [77]);
+  assert.equal(armCalls, 0);
+});
+
+await test('publish: an auto_pickup round inside its page publishes (held, so not armed)', async () => {
+  round = ROUND; prFiles = files('modules/public-landing/public/index.html'); closed = [];
+  const r = await publish();
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(closed, []);
+});
+
+await test('publish: an ordinary task is not checked, whatever its files', async () => {
+  round = { id: 7, source: 'planning-session', source_ref: null, auto_pickup: null }; prFiles = files('src/server.js'); closed = [];
+  const r = await publish();
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(closed, []);
+});
+server.close();
+
+summary();