@underpostnet/cyberia 3.2.90 → 3.3.73

package/test/support/shell-harness.js

@@ -0,0 +1,73 @@
+'use strict';
+
+import shell from 'shelljs';
+
+/**
+ * Deterministic stand-in for the host commands `shellExec` shells out to.
+ *
+ * `shellExec` resolves `shell.exec` off the shelljs module object on every call,
+ * so replacing that one property reaches every caller — the CLI entrypoints, the
+ * nftables statics, the WireGuard sync steps — without any of them taking an
+ * injection seam they do not otherwise need.
+ *
+ * @module test/support/shell-harness.js
+ */
+
+/**
+ * Builds a shelljs `ShellString`-shaped result.
+ *
+ * `shellExec` branches on `.code` and returns either `.stdout` or the object
+ * itself, and callers that skip `{ stdout: true }` interpolate the result
+ * directly — so the object has to stringify to its stdout the way shelljs does.
+ */
+const shellResult = ({ code = 0, stdout = '', stderr = '' } = {}) => ({
+  code,
+  stdout,
+  stderr,
+  toString: () => stdout,
+});
+
+const matches = (command, match) => {
+  if (typeof match === 'function') return match(command);
+  if (match instanceof RegExp) return match.test(command);
+  return `${command}`.includes(match);
+};
+
+/**
+ * Installs the `shell.exec` stub for one test.
+ *
+ * @param {object[]} [routes] - `{ match, code, stdout, stderr, throws }` in
+ *   priority order; the first whose `match` (substring, RegExp or predicate)
+ *   hits decides the result. Unmatched commands succeed with empty output.
+ * @param {object} [options]
+ * @param {object} [options.fallback] - Result for a command no route matched.
+ * @returns {{calls: string[], ran: Function, count: Function, route: Function, restore: Function}}
+ */
+const shellHarness = (routes = [], { fallback = {} } = {}) => {
+  const calls = [];
+  const table = [...routes];
+
+  const spy = vi.spyOn(shell, 'exec').mockImplementation((command, _options, callback) => {
+    calls.push(command);
+    const route = table.find((entry) => matches(command, entry.match));
+    if (route?.throws) throw route.throws instanceof Error ? route.throws : new Error(`${route.throws}`);
+    const result = shellResult(route ?? fallback);
+    // shelljs hands the async path `(code, stdout, stderr)`; `shellExec` returns
+    // whatever `shell.exec` returned without inspecting it in that mode.
+    if (typeof callback === 'function') callback(result.code, result.stdout, result.stderr);
+    return result;
+  });
+
+  return {
+    calls,
+    /** Whether any command matched. */
+    ran: (match) => calls.some((command) => matches(command, match)),
+    /** How many commands matched. */
+    count: (match) => calls.filter((command) => matches(command, match)).length,
+    /** Adds a route ahead of the existing ones, for a mid-test change of host state. */
+    route: (entry) => table.unshift(entry),
+    restore: () => spy.mockRestore(),
+  };
+};
+
+export { shellHarness, shellResult };

package/test/unit/build-template.test.js

@@ -0,0 +1,97 @@
+'use strict';
+
+import { execSync } from 'node:child_process';
+import os from 'node:os';
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+
+import { DefaultConf } from '../../conf.js';
+import {
+  ensureTemplateCheckout,
+  gitOriginRepositoryName,
+  pruneTemplateWorkTree,
+  validateTemplatePath,
+} from '../../src/server/runtime/conf.js';
+import { TEMPLATE_PRESERVED_ENTRIES } from '../../src/projects/underpost/catalog-underpost.js';
+
+const gitCheckout = (originUrl) => {
+  const path = fs.mkdtempSync(`${os.tmpdir()}/underpost-template-`);
+  execSync('git init -q', { cwd: path });
+  if (originUrl) execSync(`git remote add origin ${originUrl}`, { cwd: path });
+  return path;
+};
+
+describe('template checkout guard', () => {
+  const created = [];
+  const checkout = (originUrl) => {
+    const path = gitCheckout(originUrl);
+    created.push(path);
+    return path;
+  };
+
+  afterAll(() => created.forEach((path) => fs.removeSync(path)));
+
+  it('accepts a checkout whose origin is the template repository', () => {
+    const path = checkout('https://github.com/underpostnet/pwa-microservices-template.git');
+    expect(ensureTemplateCheckout({ toPath: path, githubUsername: 'underpostnet', noClone: true })).to.equal(false);
+  });
+
+  it('rejects a checkout carrying another repository history', () => {
+    // Publishing a deploy id swaps the checkout `.git` for its product repo, and
+    // an assembly that trusted it would read that product's package.json identity
+    // back into the base template.
+    const path = checkout('https://github.com/underpostnet/engine-test-cyberia.git');
+    expect(() => ensureTemplateCheckout({ toPath: path, githubUsername: 'underpostnet', noClone: true })).to.throw(
+      'not a underpostnet/pwa-microservices-template checkout',
+    );
+  });
+
+  it('reports no origin for a checkout that declares none and for a plain directory', () => {
+    expect(gitOriginRepositoryName(checkout())).to.equal(null);
+    const plain = fs.mkdtempSync(`${os.tmpdir()}/underpost-plain-`);
+    created.push(plain);
+    expect(gitOriginRepositoryName(plain)).to.equal(null);
+  });
+});
+
+describe('template work tree prune', () => {
+  it('keeps only the entries a rebuild cannot reconstruct', () => {
+    const path = fs.mkdtempSync(`${os.tmpdir()}/underpost-prune-`);
+    fs.outputFileSync(`${path}/.git/HEAD`, 'ref: refs/heads/master\n');
+    fs.outputFileSync(`${path}/node_modules/underpost/index.js`, '');
+    fs.outputFileSync(`${path}/src/client/components/core/RenamedAway.js`, '');
+    fs.outputFileSync(`${path}/package.json`, '{}');
+
+    pruneTemplateWorkTree(path, TEMPLATE_PRESERVED_ENTRIES);
+
+    expect(fs.readdirSync(path).sort()).to.deep.equal(['.git', 'node_modules']);
+    fs.removeSync(path);
+  });
+});
+
+// The filter resolves the base template against the default host and client that only
+// the engine's conf declares; a product build ships its own deploy conf instead.
+const defaultHostConf = DefaultConf.server?.['default.net']?.['/'];
+const describeBaseTemplate = describe.skipIf(!defaultHostConf?.apis?.length || !DefaultConf.client?.default?.services);
+
+describeBaseTemplate('template path selection', () => {
+  // A skipped suite still runs its body at collection time, so nothing here may dereference
+  // a conf the product build does not ship.
+  const apis = defaultHostConf?.apis ?? [];
+
+  it('carries the api entrypoint that sits next to the api directory', () => {
+    // `src/api.js` is a documented development entrypoint, not one of the API
+    // modules the deploy conf selects between.
+    expect(validateTemplatePath('.//src/api.js')).to.equal(true);
+  });
+
+  it('carries the api modules the conf declares, and the shared types', () => {
+    for (const api of apis) expect(validateTemplatePath(`.//src/api/${api}/${api}.service.js`), api).to.equal(true);
+    expect(validateTemplatePath('.//src/api/types.js')).to.equal(true);
+  });
+
+  it('drops an api module the conf does not declare', () => {
+    expect(validateTemplatePath('.//src/api/not-a-declared-api/not-a-declared-api.service.js')).to.equal(false);
+  });
+});

package/test/unit/build-workflow-offline.test.js

@@ -0,0 +1,132 @@
+'use strict';
+
+import { expect } from 'chai';
+import { execFileSync } from 'node:child_process';
+import fs from 'fs-extra';
+import { EXECUTION_PROFILE_ENV_KEY, withExecutionProfile } from '../../src/server/build/execution.js';
+import { shellExec } from '../../src/server/runtime/process.js';
+
+const sourceUrl = (relative) => new URL(`../../${relative}`, import.meta.url);
+const readSource = (relative) => fs.readFileSync(sourceUrl(relative), 'utf8');
+const hasSource = (relative) => fs.existsSync(sourceUrl(relative));
+
+// A product build strips the CLIs it does not own, so an absent product entrypoint
+// is a CLI this tree does not ship, not a failure.
+const CYBERIA_CLI = 'bin/cyberia.js';
+
+describe('shellExec enforces the active execution profile', () => {
+  const originalProfile = process.env[EXECUTION_PROFILE_ENV_KEY];
+
+  afterEach(() => {
+    if (originalProfile === undefined) delete process.env[EXECUTION_PROFILE_ENV_KEY];
+    else process.env[EXECUTION_PROFILE_ENV_KEY] = originalProfile;
+  });
+
+  it('runs local build work under HERMETIC_BUILD', () => {
+    withExecutionProfile('HERMETIC_BUILD', () => {
+      expect(`${shellExec('echo hermetic', { stdout: true, silent: true, disableLog: true })}`.trim()).to.equal(
+        'hermetic',
+      );
+    });
+  });
+
+  it('elides a cluster write and reports success rather than throwing', () => {
+    withExecutionProfile('HERMETIC_BUILD', () => {
+      // The gate must not look like a failure: the manifest build calls this on a box with
+      // no apiserver, and a throw here is exactly the breakage the profile exists to remove.
+      const result = shellExec('kubectl delete secret underpost-config -n default --ignore-not-found');
+      expect(result.code).to.equal(0);
+      expect(result.stderr).to.equal('');
+    });
+  });
+
+  it('answers an elided cluster read with the empty result callers already handle', () => {
+    withExecutionProfile('HERMETIC_BUILD', () => {
+      expect(shellExec('kubectl get svc x -n default', { stdout: true })).to.equal('');
+      expect(`${shellExec('kubectl get svc x -n default')}`).to.equal('');
+    });
+  });
+
+  it('runs the same cluster command under LIVE_CLUSTER', () => {
+    withExecutionProfile('LIVE_CLUSTER', () => {
+      // Reaches the shell; without a cluster it exits non-zero, which is the live contract.
+      const result = shellExec('kubectl get svc definitely-absent -n default', {
+        silentOnError: true,
+        silent: true,
+        disableLog: true,
+      });
+      expect(result.code).to.not.equal(0);
+    });
+  });
+});
+
+describe('e2e-build runs without a cluster', () => {
+  const runSource = readSource('src/cli/run.js');
+  const runner = runSource.slice(
+    runSource.indexOf(`'build-cluster-deployment-manifests':`),
+    runSource.indexOf('@method monitor-ui'),
+  );
+
+  it('declares HERMETIC_BUILD instead of appending bypass flags', () => {
+    expect(runner).to.include(`withExecutionProfile('HERMETIC_BUILD'`);
+    expect(runner).to.not.include('--disable-update-underpost-config');
+  });
+
+  it('still builds both environments through the resolved CLI', () => {
+    const deployCommands = runner.match(/\$\{underpost\} deploy [^`]*/g) ?? [];
+    expect(deployCommands).to.have.lengthOf(2);
+    expect(runner).to.include('dd development');
+    expect(runner).to.include('dd production --cert');
+  });
+
+  it('re-enters this checkout rather than any globally installed underpost', () => {
+    // Regression: auto-resolution prefers a global install, which on a root shell runs a
+    // different package against this repo's cwd — it failed on a missing dd.router.
+    expect(runner).to.include(`cli('underpost', { local: true })`);
+    expect(runner).to.not.match(/\bcli\(\)/);
+  });
+});
+
+describe('binary resolution is centralized', () => {
+  it('leaves no hand-rolled underpost/node-bin branch behind', () => {
+    for (const file of ['src/cli/run.js', 'src/cli/db.js', 'src/cli/monitor.js']) {
+      expect(readSource(file), file).to.not.include(`'node bin' : 'underpost'`);
+    }
+  });
+
+  it('re-enters the executing package from every multi-stage runner', () => {
+    // Regression: `run dev-cluster` resolved to whatever underpost was globally installed.
+    // A stale one looked for credential seeds under engine-private/ after this version moved
+    // them to engine-private/deploy/, so MongoDB bootstrapped with empty root credentials and
+    // died on "not authorized". A re-entrant stage must run the code its parent runs.
+    for (const file of ['src/cli/run.js', 'src/cli/monitor.js']) {
+      const source = readSource(file);
+      expect(source, file).to.not.match(/cli\('underpost',\s*\{\s*local:\s*options\.dev/);
+      expect(source, file).to.not.match(/\bcli\(\)/);
+    }
+  });
+
+  it.skipIf(!hasSource(CYBERIA_CLI))('never shells out to a bare global underpost from the cyberia CLI', () => {
+    const shelledOut = readSource(CYBERIA_CLI).match(
+      /(?<!\$\{cli\(\)\} )\bunderpost (?=clone|pull|push|cmt|run|start|deploy|secret)/g,
+    );
+    expect(shelledOut, `unresolved underpost invocations: ${shelledOut}`).to.equal(null);
+  });
+
+  it('replaces a checkout without depending on what that checkout installed', () => {
+    // Regression: the pre-pull clean ran through the global `underpost`, which is linked at
+    // the very tree being replaced — a node left without dependencies failed the pull that
+    // would have repaired it, and the fresh checkout was then used uninstalled.
+    const source = readSource('src/cli/run.js');
+    const runner = source.slice(source.indexOf('    pull: (path'), source.indexOf(`'ssh-deploy':`));
+    expect(runner).to.not.match(/shellExec\(`underpost /);
+    expect(runner).to.include('Underpost.repo.clean(');
+    expect(runner).to.include('npm install');
+  });
+
+  it('exposes the profile as one root-level flag rather than per-command bypasses', () => {
+    const cliSource = readSource('src/cli/index.js');
+    expect(cliSource).to.include(`program.option(\n  '--profile <profile>'`);
+    expect(cliSource).to.include(`program.hook('preAction'`);
+  });
+});

package/test/unit/catalog.test.js

@@ -0,0 +1,71 @@
+'use strict';
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+import { EMPTY_CATALOG, loadProductCatalogs } from '../../src/server/build/catalog.js';
+import { TEST_TIERS } from '../../src/server/build/testing.js';
+
+// A broken catalog path fails during template assembly, long after the commit
+// that broke it, so the tree is asserted here instead.
+//
+// A base template has had every product stripped out, including the catalogs
+// that describe the strip — there is nothing left to assert against, and the
+// paths these check are the ones it legitimately no longer carries.
+const catalogs = await loadProductCatalogs();
+const describeProducts = describe.skipIf(catalogs.length === 0);
+
+describeProducts('product catalogs', () => {
+  it('every catalog carries the uniform shape', () => {
+    for (const catalog of catalogs)
+      for (const key of Object.keys(EMPTY_CATALOG)) expect(catalog, key).to.have.property(key);
+  });
+
+  it('every engine path packaged into a product CLI exists', () => {
+    for (const { templatePaths } of catalogs)
+      for (const path of templatePaths) expect(fs.existsSync(`.${path}`), path).to.equal(true);
+  });
+
+  it('every path stripped from the base template exists', () => {
+    for (const { stripPaths } of catalogs)
+      for (const path of stripPaths) expect(fs.existsSync(path), path).to.equal(true);
+  });
+
+  it('every moved or copied source exists', () => {
+    // `sourceMoves` alone are exempt: they read from private sibling repos that
+    // are an external input and are not expected to be checked out here.
+    for (const { moves, copies } of catalogs)
+      for (const [source] of [...moves, ...copies]) expect(fs.existsSync(source), source).to.equal(true);
+  });
+
+  it('resolves paths against the roots the build actually uses', () => {
+    // `templatePaths` are copied as `.${path}`, `stripPaths` as `${toPath}/${path}`.
+    for (const { templatePaths, stripPaths } of catalogs) {
+      for (const path of templatePaths) expect(path, path).to.match(/^\//);
+      for (const path of stripPaths) expect(path, path).to.match(/^\.\//);
+    }
+  });
+});
+
+describeProducts('product catalogs and the test tiers', () => {
+  // A tier a product strips from the base template but does not ship is a tier
+  // nothing runs: the template keeps no tests for the code it removed, and the
+  // product CLI arrives without the suite that covers what it added.
+  const strippedTiers = TEST_TIERS.filter(({ directory }) =>
+    catalogs.some(({ stripPaths }) => stripPaths.includes(`./${directory}`)),
+  );
+
+  it('has products that own at least one tier', () => {
+    expect(strippedTiers).to.not.be.empty;
+  });
+
+  it('gives every tier a directory that exists in an unsliced tree', () => {
+    for (const { name, directory } of TEST_TIERS) expect(fs.existsSync(directory), name).to.equal(true);
+  });
+
+  it('ships every tier it strips from the base template', () => {
+    for (const { name, directory } of strippedTiers) {
+      const owner = catalogs.find(({ stripPaths }) => stripPaths.includes(`./${directory}`));
+      expect(owner.templatePaths, name).to.include(`/${directory}`);
+    }
+  });
+});