@bongos/core 1.19.1032 → 1.19.1034

package/tests/upgrade_migrate.mjs

@@ -0,0 +1,195 @@
+// tests/upgrade_migrate.mjs — `bongos upgrade` migrates an ADOPTED project that declares
+// no migrate script, instead of rolling itself back (task 1004274; found preparing the
+// task 1004047 catch-up pass).
+//
+// The catch-up pass could not reach mercury: an adopted Python/Flask project whose
+// package.json is exactly what the adopt layer mints — name, private, dependencies, no
+// scripts. upgrade.js migrated with `npm run migrate` only, so every upgrade of it died
+// at step 4, after the pin had moved and the new core was installed, and rolled back —
+// restarting a live app to change nothing — while the dry run reported nothing wrong.
+//
+// Pinned here: the fallback is the core's own migrate.sh, byte-identical to what a
+// scaffold's script runs; a declared script still wins; the dry run says which one will
+// run, on a line the Deploy page's pre-flight parser picks up; and the real command
+// resolves the instance even when whoever launched the upgrade left a stray INIT_CWD.
+//
+// Run:  node --test tests/upgrade_migrate.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, realpathSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const { migratePlan, CORE_MIGRATE_SCRIPT } = require('../scripts/gds/upgrade-migrate.js');
+const u = require('../scripts/gds/upgrade.js');
+const init = require('../scripts/gds/init.js');
+const { parsePreflight } = require('../scripts/gds/provision-core-upgrade.js');
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const fixture = (prefix) => realpathSync(mkdtempSync(path.join(tmpdir(), prefix)));
+
+// A project exactly as the adopt layer leaves one that had no package.json of its own —
+// built BY that layer, so this cannot drift from what adoption really writes.
+function adoptedProject({ installed = '1.19.312' } = {}) {
+  const dir = fixture('upgrade-migrate-adopted-');
+  const { pkg, action } = init.mergeCoreDependency(null, { coreRange: `file:vendor/bongos-core-${installed}.tgz`, name: 'mercury' });
+  assert.equal(action, 'created', 'fixture: the adopt layer minted the package.json');
+  assert.deepEqual(Object.keys(pkg).sort(), ['dependencies', 'name', 'private'], 'fixture: mercury\'s real shape — no scripts at all');
+  writeFileSync(path.join(dir, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`);
+  const core = path.join(dir, 'node_modules', '@bongos', 'core');
+  mkdirSync(core, { recursive: true });
+  writeFileSync(path.join(core, 'package.json'), `${JSON.stringify({ name: '@bongos/core', version: installed })}\n`);
+  return dir;
+}
+
+function scaffoldedProject(scripts = { migrate: init.INSTANCE_MIGRATE_SCRIPT, start: init.INSTANCE_START_SCRIPT }) {
+  const dir = fixture('upgrade-migrate-scaffold-');
+  writeFileSync(path.join(dir, 'package.json'), `${JSON.stringify({ name: 'charter', private: true, scripts, dependencies: { '@bongos/core': '1.19.871' } }, null, 2)}\n`);
+  return dir;
+}
+
+// Records every spawn as "cmd args…" plus its options. The pre-flight's database
+// resolver is answered with a name (as the real one answers on a provisioned box), and
+// `npm install` flips the installed core to `installTo` — all a successful install needs
+// to look like here.
+function recordingRun(calls, { dir, installTo, db = 'mercury' } = {}) {
+  return (cmd, args = [], opts = {}) => {
+    calls.push({ line: `${cmd} ${args.join(' ')}`.trim(), opts });
+    if (cmd === 'git' && args[0] === 'status') return { status: 0, stdout: '' };
+    if (cmd === process.execPath && String(args[1] || '').includes('instanceDbName')) return { status: 0, stdout: db };
+    if (cmd === 'npm' && args[0] === 'install' && installTo) {
+      writeFileSync(path.join(dir, 'node_modules', '@bongos', 'core', 'package.json'), `${JSON.stringify({ name: '@bongos/core', version: installTo })}\n`);
+    }
+    return { status: 0, stdout: '' };
+  };
+}
+
+test('the fallback IS the scaffold\'s own migrate script, byte for byte', () => {
+  assert.equal(`bash ${CORE_MIGRATE_SCRIPT}`, init.INSTANCE_MIGRATE_SCRIPT,
+    'an adopted project must be migrated by exactly the command a greenfield scaffold declares');
+});
+
+test('a project with no migrate script is migrated by the core\'s migrate.sh, from its own root', () => {
+  const dir = adoptedProject();
+  const plan = migratePlan(dir, { env: { PATH: '/usr/bin', PGDATABASE: 'mercury', INIT_CWD: '/somewhere/else' } });
+  assert.equal(plan.via, 'core-script');
+  assert.equal(plan.cmd, 'bash');
+  assert.deepEqual(plan.args, [CORE_MIGRATE_SCRIPT]);
+  assert.equal(plan.env.INIT_CWD, dir, 'INIT_CWD is what npm run would set — the project, never an inherited stray');
+  assert.equal(plan.env.PGDATABASE, 'mercury', 'the database the runner named still reaches migrate.sh');
+  assert.match(plan.note, /declares no migrate script/);
+});
+
+test('scripts without a migrate entry, or a blank one, also fall back', () => {
+  assert.equal(migratePlan(scaffoldedProject({ start: 'node app.js' })).via, 'core-script');
+  assert.equal(migratePlan(scaffoldedProject({ migrate: '   ' })).via, 'core-script');
+});
+
+test('a declared migrate script still wins, whatever it says', () => {
+  for (const migrate of [init.INSTANCE_MIGRATE_SCRIPT, 'node scripts/own-migrate.js']) {
+    const plan = migratePlan(scaffoldedProject({ migrate }));
+    assert.equal(plan.via, 'npm-script');
+    assert.deepEqual([plan.cmd, ...plan.args], ['npm', 'run', 'migrate']);
+    assert.equal(plan.env, null, 'npm sets INIT_CWD itself, so nothing is overridden');
+    assert.equal(plan.note, null, 'the ordinary case adds no pre-flight line');
+  }
+});
+
+test('a missing or unparseable package.json keeps the old command rather than guessing', () => {
+  assert.equal(migratePlan(fixture('upgrade-migrate-empty-')).via, 'npm-script');
+  const bad = fixture('upgrade-migrate-bad-');
+  writeFileSync(path.join(bad, 'package.json'), '{ not json');
+  assert.equal(migratePlan(bad).via, 'npm-script');
+});
+
+test('runMigrate spawns the plan: npm on a scaffold, the core script on an adopted project', () => {
+  const calls = [];
+  u.runMigrate(scaffoldedProject(), recordingRun(calls));
+  const adopted = adoptedProject();
+  u.runMigrate(adopted, recordingRun(calls));
+  assert.equal(calls[0].line, 'npm run migrate');
+  assert.equal(calls[0].opts.env, undefined, 'the scaffold path inherits the environment exactly as before');
+  assert.equal(calls[1].line, `bash ${CORE_MIGRATE_SCRIPT}`);
+  assert.equal(calls[1].opts.cwd, adopted);
+  assert.equal(calls[1].opts.env.INIT_CWD, adopted);
+});
+
+test('a full registry upgrade of an adopted project migrates it instead of rolling back', async () => {
+  const dir = adoptedProject({ installed: '1.19.312' });
+  const calls = [];
+  const res = await u.runUpgrade(
+    { to: '1.19.1029', registry: true, instance: dir, service: 'mercury', healthCheck: false },
+    {
+      log: () => {}, err: () => {},
+      run: recordingRun(calls, { dir, installTo: '1.19.1029' }),
+      materialize: () => ({ skills: 0 }),
+      regenerateApiArtifacts: () => ({ ok: true, ran: [] }),
+      databaseUrl: '', pgDatabase: '',
+    },
+  );
+  const lines = calls.map((c) => c.line);
+  assert.equal(res.ok, true, `the upgrade completes: ${res.error || ''}`);
+  assert.ok(!res.rolledBack, 'and was not rolled back');
+  assert.ok(lines.includes(`bash ${CORE_MIGRATE_SCRIPT}`), 'the schema moved with the code');
+  assert.ok(!lines.includes('npm run migrate'), 'the missing script was never asked for');
+  assert.ok(lines.indexOf(`bash ${CORE_MIGRATE_SCRIPT}`) < lines.indexOf('systemctl restart mercury'), 'and migrate still runs before the restart that makes the code live');
+});
+
+test('the dry run names the fallback on a line the Deploy page\'s pre-flight shows', async () => {
+  const dir = adoptedProject();
+  const out = [];
+  const res = await u.runUpgrade(
+    { to: '1.19.1029', registry: true, instance: dir, dryRun: true },
+    { log: (m) => out.push(m), err: () => {}, run: recordingRun([]) },
+  );
+  assert.equal(res.ok, true);
+  const text = out.join('\n');
+  assert.match(text, new RegExp(`would: npm install → bash ${CORE_MIGRATE_SCRIPT.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')} →`));
+  const { checks } = parsePreflight(text);
+  assert.ok(checks.some((c) => /declares no migrate script/.test(c)), `the door's parser carries it: ${JSON.stringify(checks)}`);
+  assert.deepEqual(JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8')).dependencies,
+    { '@bongos/core': 'file:vendor/bongos-core-1.19.312.tgz' }, 'and the dry run moved nothing');
+});
+
+test('the dry run of an ordinary scaffold is unchanged', async () => {
+  const dir = scaffoldedProject();
+  const core = path.join(dir, 'node_modules', '@bongos', 'core');
+  mkdirSync(core, { recursive: true });
+  writeFileSync(path.join(core, 'package.json'), `${JSON.stringify({ name: '@bongos/core', version: '1.19.871' })}\n`);
+  const out = [];
+  await u.runUpgrade({ to: '1.19.1029', registry: true, instance: dir, dryRun: true }, { log: (m) => out.push(m), err: () => {}, run: recordingRun([]) });
+  const text = out.join('\n');
+  assert.match(text, /would: npm install → npm run migrate →/);
+  assert.doesNotMatch(text, /declares no migrate script/);
+});
+
+// The real migrate.sh, through its DB-free --print-roots seam (tests/migrate_root_resolution.mjs):
+// the fallback must find the PROJECT, not the core package and not a stray INIT_CWD.
+test('the real fallback command resolves the project as its instance root, despite a stray INIT_CWD', (t) => {
+  const dir = adoptedProject();
+  writeFileSync(path.join(dir, 'bongos.config.json'), JSON.stringify({ instanceRoot: '.' }));
+  const core = path.join(dir, 'node_modules', '@bongos', 'core');
+  // Swap the stub for the real core, so the script that runs is the one that ships.
+  execFileSync(process.execPath, ['-e', 'require("fs").rmSync(process.argv[1], { recursive: true, force: true })', core]);
+  try { symlinkSync(REPO_ROOT, core, 'dir'); } catch (e) {
+    if (e.code === 'EPERM' || e.code === 'EACCES') return t.skip('this platform refuses symlinks without elevation');
+    throw e;
+  }
+  const stray = fixture('upgrade-migrate-stray-');
+  const base = { ...process.env, INIT_CWD: stray };
+  for (const k of Object.keys(base)) if (/_INSTANCE_ROOT$/.test(k)) delete base[k];
+  const rootsOf = (out) => Object.fromEntries(out.split('\n').map((l) => /^(INVOKE_CWD|CORE_ROOT|INSTANCE_ROOT)=(.*)$/.exec(l)).filter(Boolean).map((m) => [m[1], m[2]]));
+
+  const plan = migratePlan(dir, { env: base });
+  const roots = rootsOf(execFileSync(plan.cmd, [...plan.args, '--print-roots'], { cwd: dir, env: plan.env, encoding: 'utf8' }));
+  assert.equal(roots.INSTANCE_ROOT, dir, 'migrate.sh migrates THIS project');
+
+  // And the override is load-bearing: the same script with the inherited value is misaimed.
+  const blind = rootsOf(execFileSync('bash', [CORE_MIGRATE_SCRIPT, '--print-roots'], { cwd: dir, env: base, encoding: 'utf8' }));
+  assert.notEqual(blind.INSTANCE_ROOT, dir, 'without INIT_CWD pinned, a stray value decides which project is migrated');
+});