@bongos/core 1.21.123 → 1.21.125

package/tests/local_land_proof.mjs

@@ -0,0 +1,173 @@
+// tests/local_land_proof.mjs
+//
+// task 1004633 — a merged task on an instance with no GitHub credential becomes
+// 'shipped'. The owner's mercury project merged task 48 locally and pushed main;
+// with no server credential the ship route refused (the compare API threw
+// PUSH_UNCONFIGURED) and the reconciler returned early, so the task sat at
+// 'confirmed' with its merge on origin/main. These pin the three halves of the fix:
+//   1. isOnOriginMain proves a tip against a REAL repository's origin ref, and a
+//      merge that never reached origin does not count;
+//   2. landProvenForTask falls back to it when there is no token;
+//   3. the unconfigured reconciler sweep ships a proven row, and only that row.
+//
+// Run:  node tests/local_land_proof.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const local = require('../modules/lifecycle/local-land-proof.js');
+const gh = require('../modules/lifecycle/github-push.js');
+const reconciler = require('../modules/lifecycle/publish-reconciler.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  ok  ${name}`);
+  } catch (err) {
+    failed++;
+    console.log(`  FAIL ${name}\n       ${err && err.stack}`);
+  }
+}
+
+const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+
+// A bare origin plus a clone, the shape of a laptop-mode instance checkout.
+function mkRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'local-land-proof-'));
+  const origin = path.join(dir, 'origin.git');
+  const work = path.join(dir, 'work');
+  git(dir, 'init', '--quiet', '--bare', '-b', 'main', origin);
+  git(dir, 'clone', '--quiet', origin, work);
+  git(work, 'config', 'user.email', 't@example.com');
+  git(work, 'config', 'user.name', 't');
+  git(work, 'checkout', '--quiet', '-b', 'main');
+  fs.writeFileSync(path.join(work, 'a.txt'), 'a\n');
+  git(work, 'add', 'a.txt');
+  git(work, 'commit', '--quiet', '-m', 'base');
+  git(work, 'push', '--quiet', 'origin', 'main');
+  return { dir, work };
+}
+
+function commit(work, file) {
+  fs.writeFileSync(path.join(work, file), `${file}\n`);
+  git(work, 'add', file);
+  git(work, 'commit', '--quiet', '-m', file);
+  return git(work, 'rev-parse', 'HEAD');
+}
+
+await test('a tip merged and pushed to origin/main is proven', async () => {
+  const { dir, work } = mkRepo();
+  try {
+    git(work, 'checkout', '--quiet', '-b', 'task-48');
+    const tip = commit(work, 'b.txt');
+    git(work, 'checkout', '--quiet', 'main');
+    git(work, 'merge', '--quiet', '--no-ff', '-m', 'Merge task-48: (no value summary)', 'task-48');
+    git(work, 'push', '--quiet', 'origin', 'main');
+    assert.equal(await local.isOnOriginMain({ sha: tip }, { root: work }), true);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+await test('a merge into local main that never reached origin is NOT proven', async () => {
+  const { dir, work } = mkRepo();
+  try {
+    const tip = commit(work, 'c.txt'); // on local main, unpushed
+    assert.equal(await local.isOnOriginMain({ sha: tip }, { root: work }), false);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+await test('an unknown commit or a ref-shaped value is not proven', async () => {
+  const { dir, work } = mkRepo();
+  try {
+    assert.equal(await local.isOnOriginMain({ sha: 'c'.repeat(40) }, { root: work }), false);
+    assert.equal(await local.isOnOriginMain({ sha: 'HEAD' }, { root: work }), false, 'a ref must never resolve');
+    assert.equal(await local.isOnOriginMain({ sha: 'a'.repeat(40), base: '../x' }, { root: work }), false);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+await test('no usable checkout throws LOCAL_PROOF_UNAVAILABLE, never a silent false', async () => {
+  const broken = async () => { const e = new Error('spawn git ENOENT'); e.code = 'ENOENT'; throw e; };
+  await assert.rejects(
+    local.isOnOriginMain({ sha: 'a'.repeat(40) }, { git: broken }),
+    (e) => e.code === 'LOCAL_PROOF_UNAVAILABLE'
+  );
+});
+
+await test('a caller that already fetched (the sweep) is not made to fetch again per row', async () => {
+  const calls = [];
+  const fake = async (args) => { calls.push(args[0]); };
+  await local.isOnOriginMain({ sha: 'a'.repeat(40) }, { git: fake });
+  await local.isOnOriginMain({ sha: 'b'.repeat(40) }, { git: fake, fetched: true });
+  await local.isOnOriginMain({ sha: 'c'.repeat(40) }, { git: fake, fetched: true });
+  assert.deepEqual(calls, ['fetch', 'merge-base', 'merge-base', 'merge-base']);
+});
+
+await test('landProvenForTask with no credential proves the tip from the local checkout', async () => {
+  const saved = { t: process.env.GITHUB_PUSH_TOKEN, a: process.env.GITHUB_APP_ID, k: process.env.GITHUB_APP_PRIVATE_KEY };
+  delete process.env.GITHUB_PUSH_TOKEN; delete process.env.GITHUB_APP_ID; delete process.env.GITHUB_APP_PRIVATE_KEY;
+  try {
+    const asked = [];
+    const localLandProof = { isOnOriginMain: async ({ sha }) => { asked.push(sha); return sha === 'a'.repeat(40); } };
+    const yes = await gh.landProvenForTask({ taskId: 48, publishedSha: 'a'.repeat(40), status: null }, { localLandProof });
+    assert.equal(yes.proven, true);
+    const no = await gh.landProvenForTask({ taskId: 49, publishedSha: 'b'.repeat(40), status: null }, { localLandProof });
+    assert.equal(no.proven, false);
+    assert.deepEqual(asked, ['a'.repeat(40), 'b'.repeat(40)]);
+  } finally {
+    for (const [k, v] of [['GITHUB_PUSH_TOKEN', saved.t], ['GITHUB_APP_ID', saved.a], ['GITHUB_APP_PRIVATE_KEY', saved.k]]) {
+      if (v === undefined) delete process.env[k]; else process.env[k] = v;
+    }
+  }
+});
+
+await test('the unconfigured sweep ships a proven tip — and only that row', async () => {
+  const PROVEN = 'a'.repeat(40);
+  const shipped = [];
+  const events = [];
+  const rows = [
+    { task_id: 48, builder_id: 7, worktree_name: 'task-48', published_head_sha: PROVEN },
+    { task_id: 49, builder_id: 7, worktree_name: 'task-49', published_head_sha: 'b'.repeat(40) },
+    { task_id: 50, builder_id: 7, worktree_name: 'task-50', published_head_sha: null },
+  ];
+  const r = await reconciler.runSweep({
+    db: {
+      listConfirmedTasksForReconcile: async () => rows,
+      shipTask: async (a) => { shipped.push(a); return { id: a.taskId }; },
+    },
+    githubPush: { isConfigured: () => false },
+    localLandProof: {
+      sweepByLocalProof: (rs, o) => local.sweepByLocalProof(rs, { ...o, proof: async ({ sha }) => sha === PROVEN }),
+    },
+    emit: async (name, t) => { events.push([name, t.id]); },
+    log: () => {},
+    error: () => {},
+  });
+  assert.equal(r.skipped, 'unconfigured');
+  assert.equal(r.reconciled, 1);
+  assert.equal(r.checked, 2, 'the row with no tip has nothing local to prove');
+  assert.deepEqual(shipped.map((s) => s.taskId), [48]);
+  assert.equal(shipped[0].landAssurance.kind, 'proof');
+  assert.deepEqual(events, [['task.shipped', 48]]);
+});
+
+await test('a sweep racing another flip is not an error (TASK_NOT_CONFIRMED)', async () => {
+  const r = await local.sweepByLocalProof(
+    [{ task_id: 48, builder_id: 7, published_head_sha: 'a'.repeat(40) }],
+    {
+      db: { shipTask: async () => { const e = new Error('x'); e.code = 'TASK_NOT_CONFIRMED'; throw e; } },
+      emit: async () => {}, log: () => {}, error: () => {},
+      proof: async () => true,
+    }
+  );
+  assert.deepEqual(r, { checked: 1, reconciled: 0, errors: 0 });
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/publish_reconciler.mjs

@@ -205,7 +205,9 @@ function mkDeps({
 
 // ---------------------------------------------------------------------------
 
-test('no push credential → no-op (skipped: unconfigured), never touches the DB', async () => {
+// task 1004633: an unconfigured sweep now reads the confirmed rows (to prove a recorded tip
+// from the local checkout), but a row with no tip still ships nothing and GitHub is never asked.
+test('no push credential → skipped: unconfigured; a row with no tip ships nothing, GitHub never called', async () => {
   const deps = mkDeps({ configured: false, rows: [{ task_id: 1, builder_id: 9, worktree_name: 'wt' }] });
   const r = await reconciler.runSweep(deps);
   assert.equal(r.skipped, 'unconfigured');