@xemahq/repo-build-tooling 0.8.2 → 0.9.0

package/src/smoke-refusal.mjs

@@ -0,0 +1,79 @@
+// `xema-composed-image smoke-refusal <image>`: boots the composed-process image's
+// own host with a declaration it must refuse (two members on one port,
+// `declaration-refusal.mjs`) and fails unless the host exits non-zero, names the
+// collision, and constructed no member. Run after the image is pushed and before
+// anything seals it.
+//
+// The members are `--member <biomeId>/<componentKey>` (twice), else the first two
+// of the image's own member index. Their facts are derived inside the image by the
+// kernel (`derive-member-facts.mjs`), never restated. Needs only `docker` and the
+// image reference: no git history, no install.
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { gradeRefusal, refusalEnvironment } from './declaration-refusal.mjs';
+
+const DERIVE_FACTS = fileURLToPath(new URL('./derive-member-facts.mjs', import.meta.url));
+
+/**
+ * Bound on the host's run. Justified: a host that does NOT refuse starts and
+ * serves forever, so without a bound the failure this smoke exists for would
+ * hang the job instead of failing it. Refusal needs only two members' module
+ * graphs loaded; minutes is generous on any runner.
+ */
+export const HOST_RUN_TIMEOUT_MS = 5 * 60 * 1000;
+
+function dockerWith(spawn) {
+  return (args, options = {}) => {
+    const result = spawn('docker', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, ...options });
+    if (result.error && result.error.code !== 'ETIMEDOUT') throw result.error;
+    return result;
+  };
+}
+
+/** Returns the grade's problems (empty when the declaration-level refusal holds) and the members used. */
+export function runRefusalSmoke({ image, members = [], spawn = spawnSync, log = console.log, write = (text) => process.stdout.write(text) }) {
+  if (!image) throw new Error('usage: xema-composed-image smoke-refusal <image> [--member <biomeId>/<componentKey>]x2');
+  const docker = dockerWith(spawn);
+  const inImage = (nodeArgs, input) => {
+    const result = docker(['run', '--rm', '-i', '--entrypoint', 'node', image, ...nodeArgs], { input });
+    if (result.status !== 0) {
+      throw new Error(`docker run ${image} node ${nodeArgs.join(' ')} exited ${result.status}:\n${result.stderr}`);
+    }
+    return result.stdout.trim();
+  };
+
+  const keys =
+    members.length > 0
+      ? members
+      : JSON.parse(
+          inImage([
+            '-p',
+            'JSON.stringify(Object.keys(require(process.env.XEMA_COMPOSED_MEMBER_INDEX).members).sort().slice(0, 2))',
+          ]),
+        );
+  if (keys.length !== 2) throw new Error(`the refusal scenario needs two members; got ${keys.length} (${keys.join(', ')})`);
+  const facts = JSON.parse(inImage(['--input-type=module', '-', ...keys], readFileSync(DERIVE_FACTS, 'utf8')));
+
+  const env = refusalEnvironment(keys, facts);
+  const name = `declaration-refusal-smoke-${process.pid}`;
+  const envArgs = Object.keys(env).flatMap((variable) => ['-e', variable]);
+  const run = docker(['run', '--rm', '--name', name, ...envArgs, image], {
+    env: { ...process.env, ...env },
+    timeout: HOST_RUN_TIMEOUT_MS,
+  });
+  if (run.status === null) docker(['rm', '--force', name]);
+  const output = `${run.stdout ?? ''}${run.stderr ?? ''}`;
+  write(output);
+
+  const problems = gradeRefusal({ status: run.status, output }, keys);
+  if (problems.length > 0) {
+    throw new Error(
+      `the declaration-level refusal did not hold for ${keys.join(' + ')}:\n${problems.map((problem) => `  - ${problem}`).join('\n')}`,
+    );
+  }
+  log(`declaration-level refusal holds: ${keys.join(' + ')} on one port, exit ${run.status}, no member constructed`);
+  return keys;
+}

package/src/smoke-refusal.test.mjs

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { portCollisionMessage } from './declaration-refusal.mjs';
+import { runRefusalSmoke } from './smoke-refusal.mjs';
+
+const KEYS = ['alpha/alpha-api', 'beta/beta-api'];
+const REFUSED = `[xema-composed-process] refused to start — Error: ${portCollisionMessage(KEYS)}\n`;
+
+/** A docker double: answers the in-image node calls and the host run. */
+function fakeDocker({ hostStatus, hostOutput }) {
+  const calls = [];
+  const spawn = (command, args, options) => {
+    calls.push({ command, args, options });
+    if (args.includes('--entrypoint')) {
+      const script = args.slice(args.indexOf('node') + 2);
+      if (script[0] === '-p') return { status: 0, stdout: JSON.stringify(KEYS) };
+      if (script[0] === '--input-type=module' && script[1] === '-') return { status: 0, stdout: JSON.stringify([{ fact: 1 }]) };
+    }
+    if (args[0] === 'run' && args.includes('--name')) return { status: hostStatus, stdout: hostOutput, stderr: '' };
+    return { status: 0, stdout: '', stderr: '' };
+  };
+  return { spawn, calls };
+}
+
+test('the smoke passes when the host refuses the declaration, with members from the index', () => {
+  const { spawn, calls } = fakeDocker({ hostStatus: 1, hostOutput: REFUSED });
+  const lines = [];
+  const keys = runRefusalSmoke({ image: 'ghcr.io/o/img@sha256:x', spawn, log: (l) => lines.push(l), write() {} });
+  assert.deepEqual(keys, KEYS);
+  const host = calls.find((call) => call.args.includes('--name'));
+  assert.equal(host.args.at(-1), 'ghcr.io/o/img@sha256:x');
+  assert.ok(host.args.includes('XEMA_PROCESS_DEFINITION'));
+  assert.match(lines[0], /refusal holds/);
+});
+
+test('explicit members are used instead of the index, and need exactly two', () => {
+  const { spawn, calls } = fakeDocker({ hostStatus: 1, hostOutput: REFUSED });
+  runRefusalSmoke({ image: 'i', members: KEYS, spawn, log() {}, write() {} });
+  assert.ok(!calls.some((call) => call.args.includes('-p')));
+  assert.throws(() => runRefusalSmoke({ image: 'i', members: ['only/one'], spawn, log() {}, write() {} }), /needs two members/);
+});
+
+test('a host that starts fails the smoke', () => {
+  const { spawn } = fakeDocker({ hostStatus: 0, hostOutput: 'probing on 8080' });
+  assert.throws(() => runRefusalSmoke({ image: 'i', spawn, log() {}, write() {} }), /did not hold[\s\S]*did not refuse/);
+});
+
+test('a host that never exits is removed and fails the smoke', () => {
+  const { spawn, calls } = fakeDocker({ hostStatus: null, hostOutput: REFUSED });
+  assert.throws(() => runRefusalSmoke({ image: 'i', spawn, log() {}, write() {} }), /did not exit/);
+  assert.ok(calls.some((call) => call.args[0] === 'rm' && call.args.includes('--force')));
+});
+
+test('an image is required', () => {
+  assert.throws(() => runRefusalSmoke({ spawn() {} }), /usage/);
+});