@bongos/core 1.21.163 → 1.21.164

package/tests/tweak_land_heal.mjs

@@ -0,0 +1,139 @@
+// tests/tweak_land_heal.mjs — an approved page tweak lands without hand repair
+// (task 1004775).
+//
+// Two approved page-tweak rounds branch from the same main and each re-read their
+// own page, so both rewrite docs/page-readings.json — and both rewrite its top
+// `counts` line, so git conflicted on every pair and the second round stranded as
+// unresolvable_conflict until a person merged it. The heal: the otb-regen merge
+// driver merges the file PER PAGE (page-reader.js mergeReadingDocs) and recomputes
+// the counts, so the merge the conflict-resolve self-heal (and ship's own merge of
+// main) runs comes out clean.
+//
+//   1. the pure rule: per page, one side's change wins; both sides changing one
+//      page differently stays a conflict, named;
+//   2. WHOLE PATH: a real git repo wired with the real driver and .gitattributes
+//      rule; round A and round B branch from one main, A lands (main moves), B
+//      merges main exactly as the self-heal does — exit 0, no markers, both
+//      rounds' readings present, counts recomputed. No person involved;
+//   3. the .gitattributes line exists (the driver only runs for paths it names).
+//
+// Run:  node tests/tweak_land_heal.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const PR = require('../scripts/gds/page-reader.js');
+const regen = require('../scripts/gds/git-merge-regen.js');
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { test, summary } = makeRunner();
+
+function page(id, word) {
+  const lines = [{ key: 'L0001', section: 'main', text: `${word} heading`, placement: 'placed' }, { key: 'L0002', section: 'main', text: 'Skip', placement: 'shared' }];
+  return {
+    id, surface: 'landing', title: id, states_read: ['default'], files_hash: `f-${word}`, reading_hash: `r-${word}`,
+    counts: { lines: 2, placed: 1, shared: 1, unplaced: 0 }, omitted: { data: 0 }, notes: [], lines,
+  };
+}
+const doc = (pages) => PR.serialize(PR.buildDoc(pages));
+const BASE = () => [page('landing:index', 'old'), page('landing:about', 'old'), page('landing:legal', 'old')];
+
+await test('per page: each side\'s re-read is kept, counts recomputed', () => {
+  const base = BASE();
+  const ours = BASE(); ours[0] = page('landing:index', 'ours'); ours[0].counts.placed = 5; ours[0].counts.lines = 6;
+  const theirs = BASE(); theirs[1] = page('landing:about', 'theirs');
+  const m = PR.mergeReadingDocs({ base: doc(base), ours: doc(ours), theirs: doc(theirs) });
+  assert.equal(m.ok, true);
+  const out = JSON.parse(m.content);
+  assert.deepEqual(out.pages.map((p) => p.reading_hash), ['r-ours', 'r-theirs', 'r-old']);
+  assert.equal(out.counts.placed, 7, 'counts are summed from the merged pages');
+  assert.equal(m.content, doc([ours[0], theirs[1], base[2]]), 'byte-identical to what the reader would write');
+});
+
+await test('both sides re-reading ONE page differently stays a conflict, named', () => {
+  const ours = BASE(); ours[0] = page('landing:index', 'ours');
+  const theirs = BASE(); theirs[0] = page('landing:index', 'theirs');
+  const m = PR.mergeReadingDocs({ base: doc(BASE()), ours: doc(ours), theirs: doc(theirs) });
+  assert.equal(m.ok, false);
+  assert.deepEqual(m.conflicted, ['landing:index']);
+  assert.equal(regen.regenerateResolved('docs/page-readings.json', { base: doc(BASE()), ours: doc(ours), theirs: doc(theirs) }).ok, false);
+});
+
+await test('a page only one side added lands where that side put it; a removed page stays removed', () => {
+  const theirs = [...BASE().slice(0, 1), page('landing:new', 'x'), ...BASE().slice(1)];
+  const ours = BASE().filter((p) => p.id !== 'landing:legal');
+  const m = PR.mergeReadingDocs({ base: doc(BASE()), ours: doc(ours), theirs: doc(theirs) });
+  assert.equal(m.ok, true);
+  assert.deepEqual(JSON.parse(m.content).pages.map((p) => p.id), ['landing:index', 'landing:new', 'landing:about']);
+});
+
+await test('.gitattributes routes docs/page-readings.json through the otb-regen driver', () => {
+  const attrs = fs.readFileSync(path.join(ROOT, '.gitattributes'), 'utf8');
+  assert.match(attrs, /^docs\/page-readings\.json\s+merge=otb-regen\s*$/m);
+  assert.equal(regen.REGENERABLE.has('docs/page-readings.json'), true);
+});
+
+await test('WHOLE PATH: two rounds from one main both land; the second merges main with no person', () => {
+  const driver = path.join(ROOT, 'scripts/gds/git-merge-regen.js').replace(/\\/g, '/');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'otb-tweak-land-'));
+  const g = (...a) => {
+    const r = spawnSync('git', a, { cwd: tmp, encoding: 'utf8' });
+    return { status: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+  };
+  const RJ = path.join(tmp, 'docs', 'page-readings.json');
+  const write = (pages, html) => {
+    fs.writeFileSync(RJ, doc(pages));
+    for (const [f, s] of Object.entries(html || {})) fs.writeFileSync(path.join(tmp, f), s);
+  };
+  try {
+    g('init', '-q', '-b', 'main');
+    g('config', 'user.email', 't@t'); g('config', 'user.name', 't');
+    g('config', 'core.autocrlf', 'false');
+    g('config', 'merge.otb-regen.driver', `node "${driver}" %O %A %B %P`);
+    fs.writeFileSync(path.join(tmp, '.gitattributes'), 'docs/page-readings.json merge=otb-regen\n');
+    fs.mkdirSync(path.join(tmp, 'docs'));
+    write(BASE(), { 'index.html': 'Old index heading\n', 'about.html': 'Old about heading\n' });
+    g('add', '-A'); g('commit', '-qm', 'base');
+
+    // Round A (landing:index) and round B (landing:about), both applied from this main.
+    g('checkout', '-qb', 'round-a');
+    const a = BASE(); a[0] = page('landing:index', 'A'); a[0].counts.placed = 3;
+    write(a, { 'index.html': 'New index heading\n' });
+    g('add', '-A'); g('commit', '-qm', 'round A applied');
+    g('checkout', '-q', 'main');
+    g('checkout', '-qb', 'round-b');
+    const b = BASE(); b[1] = page('landing:about', 'B'); b[1].counts.placed = 4;
+    write(b, { 'about.html': 'New about heading\n' });
+    g('add', '-A'); g('commit', '-qm', 'round B applied');
+
+    // Round A lands: main moves.
+    g('checkout', '-q', 'main');
+    assert.equal(g('merge', '-q', '--no-ff', '--no-edit', 'round-a').status, 0);
+
+    // Before this task: the counts line conflicts. Now: the self-heal's merge is clean.
+    g('checkout', '-q', 'round-b');
+    const merge = g('merge', '--no-edit', 'main');
+    assert.equal(merge.status, 0, `round B must merge main clean; got ${merge.status} :: ${merge.out}`);
+    assert.equal(g('diff', '--name-only', '--diff-filter=U').out.trim(), '');
+    const healed = fs.readFileSync(RJ, 'utf8');
+    assert.ok(!regen.hasMarkers(healed), 'no conflict markers');
+    const out = JSON.parse(healed);
+    assert.deepEqual(out.pages.map((p) => p.reading_hash), ['r-A', 'r-B', 'r-old'], 'both rounds\' readings are present');
+    assert.equal(out.counts.placed, 3 + 4 + 1, 'counts regenerated from the merged pages');
+    assert.equal(healed, doc([a[0], b[1], BASE()[2]]));
+
+    // And round B then lands on main as a fast-forward of what the self-heal pushed.
+    g('checkout', '-q', 'main');
+    assert.equal(g('merge', '-q', '--ff-only', 'round-b').status, 0, 'round B lands');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+summary();