@bongos/core 1.19.1063 → 1.19.1064

package/tests/tweak_batch_apply.mjs

@@ -0,0 +1,265 @@
+// tests/tweak_batch_apply.mjs — copy-apply.js --batch lands a whole page round
+// (task 1004322 / BV2.TW11; ADR 0341 D4).
+//
+// The done-when: "/tweak applies a multi-line page batch ... a refused line is
+// named, not skipped." Two layers:
+//   1. the pure core (applyBatchToSources) over fixture sources and a registry
+//      built by the REAL extractors, so a line is matched exactly the way the
+//      inventory reads it;
+//   2. the whole command (batchMain) on a FIXTURE ROUND: a page-tweak task read
+//      from a fake API, its files from an in-memory tree, the registry
+//      regenerated by the real extractors over the files it wrote, and the
+//      page-tweak-applied block PATCHed back and parsed by the one reader.
+// No DB, no network, no browser (the page re-read is the one stubbed step; the
+// real re-read is page-reader.js --stale, covered by tests/page_reader.mjs).
+//
+// Run:  node tests/tweak_batch_apply.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ci = require('../scripts/gds/copy-inventory.js');
+const pages = require('../modules/copy-desk/pages.js');
+const apply = require('../scripts/gds/copy-apply.js');
+
+const { test, summary } = makeRunner();
+const REPO_ROOT = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+const HTML = 'modules/public-landing/public/fixture-tweak.html';
+const JS = 'modules/hall-ui/public/fixture-tweak.js';
+const OTHER = 'modules/public-landing/public/fixture-other.html';
+const SURFACE_OF = { [HTML]: 'landing', [JS]: 'builders-hall', [OTHER]: 'landing' };
+
+const TREE = () => ({
+  [HTML]: `<!doctype html>
+<html><body>
+<main>
+  <h1>Welcome to the studio</h1>
+  <p>Take a page and rewrite every word of it.</p>
+  <p>Every word counts, and every word is yours.</p>
+  <button>Take next</button>
+</main>
+</body></html>
+`,
+  [JS]: "'use strict';\nfunction render(el, n) {\n  el.innerHTML = `<p>You have ${n} pages waiting for review</p>`;\n}\n",
+  [OTHER]: '<!doctype html>\n<html><body>\n<p>Take next</p>\n</body></html>\n',
+});
+
+// The registry the inventory would write over a tree: the real extractors, the
+// real stable id, the span dropped exactly as buildRegistry drops it.
+function registryOver(tree) {
+  const entries = [];
+  for (const [rel, source] of Object.entries(tree)) {
+    const rows = rel.endsWith('.html') ? ci.fromHtml({ source, rel }) : ci.fromJs({ source, rel });
+    for (const { start, end, ...row } of rows) entries.push({ id: ci.stableId(SURFACE_OF[rel], row.text), surface: SURFACE_OF[rel], ...row });
+  }
+  return { entries, counts: { strings: entries.length } };
+}
+
+const REG = registryOver(TREE());
+const row = (text, file) => REG.entries.find((e) => e.text === text && (!file || e.file === file));
+const line = (key, before, after, file, extra = {}) => {
+  const r = row(extra.registryText || before, file);
+  return { key, section: 'main', before, after, placement: 'placed', file: r ? r.file : file, line: r ? r.line : 1, string_id: r ? r.id : 'ffffffffffff', ...extra.override };
+};
+
+const BATCH = () => ({
+  page_id: 'landing:fixture',
+  reading_hash: 'r-before',
+  submitted_at: '2026-09-28T00:00:00Z',
+  lines: [
+    line('L0001', 'Welcome to the studio', 'Welcome to your studio', HTML),
+    line('L0002', 'Take a page and rewrite every word of it.', 'Take a page and make every word of it yours.', HTML),
+    line('L0003', 'You have {…} pages waiting for review', 'There are {…} pages waiting for you', JS),
+    line('L0004', 'Take next', 'Take the next page', HTML),
+  ],
+});
+
+const readerOf = (tree) => (rel) => { if (!(rel in tree)) throw new Error(`ENOENT ${rel}`); return tree[rel]; };
+
+await test('a multi-line batch applies every line, across files, holes put back', () => {
+  const tree = TREE();
+  const out = apply.applyBatchToSources({ batch: BATCH(), registry: REG, readSource: readerOf(tree) });
+  assert.deepEqual(out.refused, []);
+  assert.deepEqual(out.applied.map((a) => a.key), ['L0001', 'L0002', 'L0003', 'L0004'], 'reported in PAGE order');
+  const html = out.sources.get(HTML);
+  assert.match(html, /<h1>Welcome to your studio<\/h1>/);
+  assert.match(html, /<p>Take a page and make every word of it yours\.<\/p>/);
+  assert.match(html, /<button>Take the next page<\/button>/);
+  assert.match(html, /Every word counts, and every word is yours\./, 'an untouched line is untouched');
+  assert.equal(out.sources.get(JS), "'use strict';\nfunction render(el, n) {\n  el.innerHTML = `<p>There are ${n} pages waiting for you</p>`;\n}\n", 'the ${n} expression is re-injected, not the {…} placeholder');
+  assert.ok(!out.sources.has(OTHER), 'the same sentence in ANOTHER file is left alone: the line names its own file');
+});
+
+await test('a refused line is NAMED, with its code, and the rest of the batch still lands', () => {
+  const b = BATCH();
+  b.lines.push(
+    // the page changed after submit: its string is gone from the registry
+    { key: 'L0005', section: 'main', before: 'A sentence no page shows', after: 'Still not shown', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' },
+    // the rewrite drops the value the page drops in
+    line('L0006', 'You have {…} pages waiting for review', 'Lots of pages are waiting', JS),
+    // a fragment that appears twice inside its string
+    line('L0007', 'word', 'phrase', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+    // a fragment that is not inside its string at all
+    line('L0008', 'nowhere in it', 'still nowhere', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+  );
+  // and a registry row that points outside every surface
+  const reg = { entries: [...REG.entries, { id: 'aaaaaaaaaaaa', surface: 'landing', text: 'Secret', file: 'config/secret.html', line: 1, origin: 'html-text' }] };
+  b.lines.push({ key: 'L0009', section: 'main', before: 'Secret', after: 'Public', placement: 'placed', file: 'config/secret.html', line: 1, string_id: 'aaaaaaaaaaaa' });
+  const out = apply.applyBatchToSources({ batch: b, registry: reg, readSource: readerOf(TREE()) });
+  assert.deepEqual(out.refused.map((x) => [x.key, x.code]), [
+    ['L0005', 'target_gone'],
+    ['L0006', 'placeholder_mismatch'],
+    ['L0007', 'ambiguous_target'],
+    ['L0008', 'no_exact_span'],
+    ['L0009', 'path_outside_surface'],
+  ]);
+  for (const x of out.refused) assert.ok(apply.REFUSAL_CODES.includes(x.code), `${x.code} is a named code`);
+  assert.equal(out.applied.length, 4, 'the four good lines still applied');
+  assert.equal(out.applied.length + out.refused.length, b.lines.length, 'NO line is skipped silently: every line is applied or refused');
+});
+
+await test('two lines inside ONE string compose: the second is resolved against what the first left', () => {
+  const b = { page_id: 'landing:fixture', lines: [
+    line('L0001', 'Every word counts', 'Each word matters', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+    line('L0002', 'is yours', 'belongs to you', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+  ] };
+  const out = apply.applyBatchToSources({ batch: b, registry: REG, readSource: readerOf(TREE()) });
+  assert.deepEqual(out.refused, []);
+  assert.match(out.sources.get(HTML), /<p>Each word matters, and every word belongs to you\.<\/p>/);
+});
+
+await test('a string id shared by two files resolves to the row in the line\'s own file', () => {
+  const r = apply.registryRowFor({ string_id: row('Take next', OTHER).id, file: OTHER, line: 3 }, new Map([[row('Take next', OTHER).id, REG.entries.filter((e) => e.text === 'Take next')]]));
+  assert.equal(r.file, OTHER);
+});
+
+await test('the applied block leaves shared lines out of lines_after and carries each refusal', () => {
+  const block = apply.appliedBlockFor({
+    pageId: 'landing:fixture',
+    appliedAt: '2026-09-28T01:00:00Z',
+    readingPage: { reading_hash: 'r-after', lines: [
+      { key: 'L0001', text: 'Skip to content', placement: 'shared' },
+      { key: 'L0002', text: 'Welcome to your studio', placement: 'placed' },
+      { key: 'L0003', text: 'Something unplaced', placement: 'unplaced' },
+    ] },
+    refused: [{ key: 'L0005', code: 'target_gone', detail: { x: 1 } }],
+  });
+  assert.deepEqual(block.lines_after, ['Welcome to your studio', 'Something unplaced']);
+  assert.deepEqual(block.refused, [{ key: 'L0005', code: 'target_gone' }], 'key and code only');
+  const parsed = pages.parseAppliedBlock(pages.composeAppliedBlock(block));
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.applied.reading_hash_after, 'r-after');
+});
+
+// ---- the whole command on a fixture round ---------------------------------
+
+function fixtureRound(batch) {
+  const page = { id: batch.page_id, title: 'Fixture' };
+  return [pages.roundTaskBody(page, 1), '', pages.composeBatchBlock({ ...batch, unplaced_tasks: [] })].join('\n');
+}
+
+function harness({ batch, source = 'page-tweak', registryOverride = null, rereadOk = true } = {}) {
+  const tree = TREE();
+  const abs = (rel) => path.join(REPO_ROOT, rel);
+  const files = new Map(Object.entries(tree).map(([rel, s]) => [abs(rel), s]));
+  const writes = [];
+  const calls = [];
+  const task = { id: '5001', source, description: fixtureRound(batch) };
+  const deps = {
+    log: () => {},
+    readFile: (p) => { if (!files.has(p)) throw new Error(`ENOENT ${p}`); return files.get(p); },
+    writeFile: (p, s) => { writes.push(p); files.set(p, s); },
+    registry: REG,
+    regenerateRegistry: () => ({ reg: registryOverride || registryOver(Object.fromEntries(Object.keys(tree).map((rel) => [rel, files.get(abs(rel))]))) }),
+    reread: () => (rereadOk ? { ok: true } : { ok: false, code: 'no_browser' }),
+    readingFor: () => ({ reading_hash: 'r-after', lines: [{ key: 'L0001', text: 'Skip to content', placement: 'shared' }, { key: 'L0002', text: 'Welcome to your studio', placement: 'placed' }] }),
+    api: async (method, url, body) => {
+      calls.push({ method, url, body });
+      if (method === 'GET') return { ok: true, status: 200, data: { task } };
+      if (method === 'PATCH') { task.description = body.description; return { ok: true, status: 200, data: { task } }; }
+      return { ok: false, status: 405 };
+    },
+  };
+  return { deps, files, writes, calls, task, abs };
+}
+
+await test('END TO END: a fixture round is applied, its files written, and the applied block recorded on the task', async () => {
+  const b = BATCH();
+  b.lines.push({ key: 'L0005', section: 'main', before: 'A sentence no page shows', after: 'Still not shown', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' });
+  const h = harness({ batch: b });
+  const code = await apply.batchMain({ taskId: '5001', now: () => '2026-09-28T02:00:00Z' }, h.deps);
+  assert.equal(code, 0);
+  assert.match(h.files.get(h.abs(HTML)), /Welcome to your studio/);
+  assert.match(h.files.get(h.abs(JS)), /There are \$\{n\} pages waiting for you/);
+  assert.deepEqual(h.writes.sort(), [h.abs(HTML), h.abs(JS)].sort(), 'only the files the batch changed are written');
+  const patch = h.calls.find((c) => c.method === 'PATCH');
+  assert.ok(patch, 'the applied block is written back to the round');
+  assert.equal(patch.url, '/api/bongos/tasks/5001');
+  const applied = pages.parseAppliedBlock(patch.body.description);
+  assert.equal(applied.ok, true, 'one applied block, readable by the one reader');
+  assert.deepEqual(applied.applied.refused, [{ key: 'L0005', code: 'target_gone' }], 'the refused line is named on the task, not skipped');
+  assert.equal(applied.applied.reading_hash_after, 'r-after');
+  assert.deepEqual(applied.applied.lines_after, ['Welcome to your studio']);
+  assert.equal(pages.parseBatchBlock(patch.body.description).ok, true, 'the frozen batch is kept beside it');
+  const presence = pages.blockPresence(patch.body.description);
+  assert.equal(presence.applied, true);
+  assert.equal(presence.applied_at, '2026-09-28T02:00:00Z');
+});
+
+await test('a re-apply REPLACES the applied block rather than adding a second', async () => {
+  const h = harness({ batch: BATCH() });
+  await apply.batchMain({ taskId: '5001', now: () => 't1' }, h.deps);
+  const h2 = harness({ batch: BATCH() });
+  h2.task.description = h.task.description;
+  await apply.batchMain({ taskId: '5001', now: () => 't2' }, h2.deps);
+  assert.equal(pages.parseAppliedBlock(h2.task.description).ok, true, 'still exactly one applied block');
+  assert.equal(pages.parseAppliedBlock(h2.task.description).applied.applied_at, 't2');
+});
+
+await test('--dry-run writes no file and no task', async () => {
+  const h = harness({ batch: BATCH() });
+  const code = await apply.batchMain({ taskId: '5001', dryRun: true }, h.deps);
+  assert.equal(code, 0);
+  assert.deepEqual(h.writes, []);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('every line refused: exit 2, and the refusals are still recorded on the task', async () => {
+  const h = harness({ batch: { page_id: 'landing:fixture', reading_hash: 'r', submitted_at: 't', lines: [
+    { key: 'L0005', section: 'main', before: 'Gone', after: 'Still gone', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' },
+  ] } });
+  const code = await apply.batchMain({ taskId: '5001' }, h.deps);
+  assert.equal(code, 2);
+  const patch = h.calls.find((c) => c.method === 'PATCH');
+  assert.deepEqual(pages.parseAppliedBlock(patch.body.description).applied.refused, [{ key: 'L0005', code: 'target_gone' }]);
+});
+
+await test('the regenerated registry not showing the new wording is a hard stop (exit 3), before any task write', async () => {
+  const h = harness({ batch: BATCH(), registryOverride: REG });
+  const code = await apply.batchMain({ taskId: '5001' }, h.deps);
+  assert.equal(code, 3);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('a page that cannot be re-read stops before the applied block (exit 4): no block from a stale reading', async () => {
+  const h = harness({ batch: BATCH(), rereadOk: false });
+  assert.equal(await apply.batchMain({ taskId: '5001' }, h.deps), 4);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('--batch refuses a task that is not a page tweak', async () => {
+  const h = harness({ batch: BATCH(), source: 'copy-proposal' });
+  const logged = [];
+  const origErr = console.error;
+  console.error = (m) => logged.push(String(m));
+  try { assert.equal(await apply.batchMain({ taskId: '5001' }, h.deps), 2); } finally { console.error = origErr; }
+  assert.ok(logged.some((m) => m.includes('not_a_page_tweak')));
+  assert.deepEqual(h.writes, []);
+});
+
+summary();