@bongos/core 1.20.83 → 1.21.2

package/tests/upgrade_commit_identity.mjs

@@ -0,0 +1,89 @@
+// tests/upgrade_commit_identity.mjs
+//
+// task 1004514: a landed core move left its pin STAGED but uncommitted whenever the project's
+// git named nobody (no user.name/user.email in the repo or for the account the move runs as).
+// `git commit` refused, persistPin reported "could not commit", the move still landed, and the
+// NEXT move read those leftovers as a dirty tree. Seen live on cloudbongos.com, 2026-10-01.
+//
+// These run persistPin against a REAL repo with every identity source switched off (global
+// config pointed at /dev/null, system config disabled, invented identities refused), so the refusal is git's own. The first
+// test proves the environment really does refuse; without it the fix test could pass vacuously.
+//
+// Run:  node --test tests/upgrade_commit_identity.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { persistPin } = require('../scripts/gds/upgrade.js');
+const { commitIdentityEnv } = require('../scripts/gds/upgrade-commit-identity.js');
+
+// user.useConfigOnly: git on a Mac invents an identity from the hostname, where the box's git
+// refuses; this makes every machine refuse the way the box did.
+const ISOLATE = { GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1',
+  GIT_CONFIG_COUNT: '1', GIT_CONFIG_KEY_0: 'user.useConfigOnly', GIT_CONFIG_VALUE_0: 'true' };
+const IDENTITY_VARS = ['GIT_AUTHOR_NAME', 'GIT_AUTHOR_EMAIL', 'GIT_COMMITTER_NAME', 'GIT_COMMITTER_EMAIL', 'EMAIL'];
+let saved;
+const dirs = [];
+
+before(() => {
+  saved = Object.fromEntries([...Object.keys(ISOLATE), ...IDENTITY_VARS].map((k) => [k, process.env[k]]));
+  Object.assign(process.env, ISOLATE);
+  for (const k of IDENTITY_VARS) delete process.env[k];
+});
+after(() => {
+  for (const [k, v] of Object.entries(saved)) { if (v === undefined) delete process.env[k]; else process.env[k] = v; }
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+const git = (cwd, ...args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
+
+// A repo whose first commit carries a one-off identity, then names nobody — the live shape.
+function repoWithPinChange({ identity = null } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), 'pin-identity-'));
+  dirs.push(dir);
+  git(dir, 'init', '-q', '-b', 'main');
+  if (identity) { git(dir, 'config', 'user.name', identity.name); git(dir, 'config', 'user.email', identity.email); }
+  writeFileSync(join(dir, 'package.json'), '{"dependencies":{"@bongos/core":"1.20.77"}}\n');
+  writeFileSync(join(dir, 'package-lock.json'), '{}\n');
+  git(dir, '-c', 'user.name=scaffold', '-c', 'user.email=scaffold@example.invalid', 'add', '-A');
+  git(dir, '-c', 'user.name=scaffold', '-c', 'user.email=scaffold@example.invalid', 'commit', '-qm', 'scaffold');
+  writeFileSync(join(dir, 'package.json'), '{"dependencies":{"@bongos/core":"1.20.78"}}\n');
+  return dir;
+}
+
+const quiet = () => {};
+const pin = (dir) => persistPin({ instanceDir: dir, fromVersion: '1.20.77', toVersion: '1.20.78', commitPin: true, push: false }, spawnSync, quiet, quiet);
+
+test('the environment really names nobody: a plain commit is refused', () => {
+  const dir = repoWithPinChange();
+  git(dir, 'add', 'package.json');
+  const r = git(dir, 'commit', '-m', 'probe');
+  assert.notEqual(r.status, 0, 'git must refuse here, or the next test proves nothing');
+});
+
+test('a repo that names nobody still gets its pin committed, signed as the provisioner', () => {
+  const dir = repoWithPinChange();
+  const r = pin(dir);
+  assert.equal(r.committed, true, `persistPin: ${JSON.stringify(r)}`);
+  assert.equal(git(dir, 'status', '--porcelain').stdout, '', 'nothing staged or left behind for the next move');
+  const who = git(dir, 'log', '-1', '--format=%an <%ae>|%s').stdout.trim();
+  assert.match(who, /^Cloud Bongos <bot@[^>]+>\|pin @bongos\/core 1\.20\.78 \(was 1\.20\.77\)$/);
+});
+
+test('a repo that names someone keeps signing as them', () => {
+  const dir = repoWithPinChange({ identity: { name: 'Owner Person', email: 'owner@example.invalid' } });
+  assert.equal(commitIdentityEnv(dir, spawnSync), null, 'no fallback when git already has an answer');
+  assert.equal(pin(dir).committed, true);
+  assert.equal(git(dir, 'log', '-1', '--format=%an <%ae>').stdout.trim(), 'Owner Person <owner@example.invalid>');
+});
+
+test('an identity the caller already put in the env is not replaced', () => {
+  const dir = repoWithPinChange();
+  assert.equal(commitIdentityEnv(dir, spawnSync, { ...process.env, GIT_AUTHOR_EMAIL: 'ci@example.invalid' }), null);
+});

package/tests/wizard_demo.mjs

@@ -111,14 +111,21 @@ let created = null;
 let started = null;
 provisioning.getInstanceBySlug = async () => null;
 provisioning.getInstanceByDomain = async () => null;
+// The order the create does things in (task 1004506): the birth stamp and the demo
+// marker must both be on the row BEFORE the provision intent exists, so the runner's
+// web.env carries them. 'old-one' stands for a project that already existed.
+const order = [];
+const birth = require('../modules/provisioning/birth.js');
+birth.stampBirth = async (_db, id) => { order.push(`birth:${id}`); };
 provisioning.createInstance = async (_db, args) => {
   created = args;
-  return { instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: 'requested', hosting_shape: 'byo-host', detail: args.detail || {} }, created: true };
+  const fresh = args.slug !== 'old-one';
+  return { instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: fresh ? 'requested' : 'active', hosting_shape: 'byo-host', detail: args.detail || {} }, created: fresh };
 };
-provisioning.enqueueIntent = async (_db, _id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
+provisioning.enqueueIntent = async (_db, _id, action) => { order.push(`enqueue:${action}`); return { intent: { id: 9, action, state: 'pending' }, created: true }; };
 provisioning.getOpenIntent = async () => null;
 provisioning.recordEvent = async () => {};
-demo.startDemoProject = async (_db, _p, id, d) => { started = { id, d }; return null; };
+demo.startDemoProject = async (_db, _p, id, d) => { started = { id, d }; order.push(`demo:${id}`); return null; };
 api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
 let stored = null;
 provisioning.getInstanceById = async (_db, id) => (id === 41 ? { id: 41, owner_builder_id: 7, demo: stored } : null);
@@ -158,6 +165,25 @@ test('the create files a normal project marked demo, with the demo\'s picked ans
   assert.equal((await post('/provisioning/instances', { slug: 'bad-demo', hosting_shape: 'byo-host', demo: { people: 99, hours_each: 4 } })).status, 400);
 });
 
+test('a new project is stamped born, once, before its provision intent; an existing one never is (task 1004506)', async () => {
+  order.length = 0;
+  assert.equal((await post('/provisioning/instances', { slug: 'born-demo', hosting_shape: 'byo-host', demo: { people: 2, hours_each: 3 } })).status, 201);
+  assert.deepEqual(order, ['birth:41', 'demo:41', 'enqueue:provision'], 'the marker and the demo box are on the row before the runner can read it');
+  order.length = 0;
+  assert.equal((await post('/provisioning/instances', { slug: 'born-real', hosting_shape: 'byo-host' })).status, 201);
+  assert.deepEqual(order, ['birth:41', 'enqueue:provision'], 'a real project is born too, with no demo box');
+  order.length = 0;
+  const again = await post('/provisioning/instances', { slug: 'old-one', hosting_shape: 'byo-host' });
+  assert.ok(again.status < 300, JSON.stringify(again.body));
+  assert.ok(!order.some((o) => o.startsWith('birth:') || o.startsWith('demo:')), 'a re-request of a project that already exists is never born (spec D8)');
+  const keep = birth.stampBirth;
+  birth.stampBirth = async () => { throw new Error('db hiccup'); };
+  try {
+    assert.equal((await post('/provisioning/instances', { slug: 'unlucky', hosting_shape: 'byo-host' })).status, 201,
+      'a missed marker costs the project its genesis, never its creation');
+  } finally { birth.stampBirth = keep; }
+});
+
 test('keep your planet? over the route: the owner answers once', async () => {
   stored = demo.demoRecord({ people: 3, hours_each: 4 }, new Date(Date.now() - 5 * 3600000));
   const r = await post('/provisioning/instances/41/demo', { outcome: 'kept' });