@underpostnet/cyberia 3.3.0 → 3.3.73

package/test/e2e/event-e2e-public-ingress-down.js

@@ -0,0 +1,45 @@
+import Underpost from '../../src/index.js';
+
+/** The ports HAProxy publishes on the hub; blocking these takes every host down. */
+const EDGE_PORTS = '80,443';
+
+/**
+ * End-to-end rehearsal for `public-ingress-down`.
+ *
+ * The outage is induced where the public edge actually terminates — the hub —
+ * by blocking inbound traffic on the published ports. That is the one fault
+ * that takes every host down at once, which is the condition this event
+ * remediates; stopping a workload would produce the partial state the handler
+ * deliberately refuses to act on.
+ *
+ * The block is scoped to those ports rather than to every port, because
+ * remediation reaches the hub over SSH: a total ingress block would drop the
+ * connection that repairs it and leave the edge unrecoverable from anywhere but
+ * the provider console. `--unblock-all-ingress`, which the handler runs, clears
+ * this block along with any other.
+ *
+ * @module test/event-e2e-public-ingress-down.js
+ */
+export default {
+  description: 'Blocks public ingress on each hub, then verifies the edge is restored and every host answers again.',
+
+  async subjects({ options }) {
+    return Underpost.event.subjectSelection('hub', options).map((hubHost) => {
+      const target = Underpost.event.hubTarget(hubHost);
+      return {
+        label: `ingress via ${target.nodeName || hubHost}`,
+        probes: Underpost.event.publicIngressUrls().map((entry) => ({ module: 'http_2xx', target: entry.url })),
+        dispatchOptions: { nodes: target.nodeName || hubHost },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand(`node bin ip --block-ingress-port ${EDGE_PORTS}`, subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand(`node bin ip --unblock-ingress-port ${EDGE_PORTS}`, subject.remote);
+  },
+};

package/test/e2e/event-e2e-wireguard-server-down.js

@@ -0,0 +1,38 @@
+import Underpost from '../../src/index.js';
+
+/**
+ * End-to-end rehearsal for `wireguard-server-down`.
+ *
+ * Every registered hub is rehearsed, or those `--nodes` selects. A hub is
+ * taken down the only way an operator can reach it while its tunnel is dead —
+ * through the external SSH endpoint registered for it — which is also the path
+ * the remediation must use. Stopping the interface any other way would not
+ * exercise that dependency.
+ *
+ * @module test/event-e2e-wireguard-server-down.js
+ */
+export default {
+  description: 'Stops WireGuard on each hub over its registered management SSH, then verifies the repair.',
+
+  async subjects({ options }) {
+    return Underpost.event.subjectSelection('hub', options).map((hubHost) => {
+      const target = Underpost.event.hubTarget(hubHost);
+      if (!target.address)
+        throw new Error(`[event] the tunnel address of hub ${hubHost} is underivable; nothing can be probed`);
+      return {
+        label: `hub ${target.nodeName || hubHost}`,
+        probes: [{ module: 'icmp', target: target.address }],
+        dispatchOptions: { nodes: target.nodeName || hubHost },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-stop', subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-start', subject.remote);
+  },
+};

package/test/e2e/event-e2e-wireguard-spoke-down.js

@@ -0,0 +1,40 @@
+import Underpost from '../../src/index.js';
+
+/**
+ * End-to-end rehearsal for `wireguard-spoke-down`.
+ *
+ * Every peer of this node's hub is rehearsed, or those `--nodes` /
+ * `--spoke` selects, one at a time. Each is taken down through the same
+ * identity chain the remediation resolves — locally for the selected control
+ * node, over LAN SSH for a worker — so a spoke that can be broken but not
+ * repaired fails the rehearsal rather than an outage.
+ *
+ * @module test/event-e2e-wireguard-spoke-down.js
+ */
+export default {
+  description: 'Stops WireGuard on each registered spoke, then verifies the repair of that spoke alone.',
+
+  async subjects({ options }) {
+    const hubAddress = Underpost.event.hubAddress();
+    return Underpost.event.subjectSelection('spoke', options).map((spokeId) => {
+      const spoke = Underpost.event.spokes().find((entry) => entry.id === spokeId);
+      const target = Underpost.event.spokeTarget(spokeId);
+      return {
+        label: `spoke ${spokeId}`,
+        // The local spoke is proved through the hub tunnel: its own 10.0.0.x stays
+        // reachable on the machine itself even when the tunnel carries nothing.
+        probes: [{ module: 'icmp', target: spoke.local ? hubAddress : spoke.address }],
+        dispatchOptions: { spoke: spokeId },
+        remote: { user: target.user, host: target.host },
+      };
+    });
+  },
+
+  async break(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-stop', subject.remote);
+  },
+
+  async restore(context, subject) {
+    return await Underpost.event.runCommand('node bin wireguard --wireguard-start', subject.remote);
+  },
+};

package/test/{api.test.js → integration/app/api.test.js}

@@ -1,29 +1,48 @@
 'use strict';
 
 import axios from 'axios';
-import dotenv from 'dotenv';
+import express from 'express';
 
 import { expect } from 'chai';
-import { loggerFactory } from '../src/server/logger.js';
-
-dotenv.config();
-
-const PORT = parseInt(process.env.PORT) + 1;
+import { TestRouter } from '../../../src/api/test/test.router.js';
+import { loggerFactory } from '../../../src/server/ops/logger.js';
 
 const logger = loggerFactory(import.meta);
 
 await logger.setUpInfo();
 
-const BASE_URL =
-  process.env.NODE_ENV === 'development'
-    ? `http://localhost:${PORT}/${process.env.BASE_API}`
-    : `https://www.nexodev.org/api`;
-
 describe(`GET 'Test' API Request `, async () => {
+  const app = express();
+  app.use('/api/test', TestRouter.router({ authMiddleware: (_req, _res, next) => next() }));
+
+  let server;
+  let baseUrl;
+
+  beforeAll(
+    () =>
+      new Promise((resolve, reject) => {
+        server = app.listen(0, '127.0.0.1', () => {
+          baseUrl = `http://127.0.0.1:${server.address().port}/api`;
+          resolve();
+        });
+        server.on('error', reject);
+      }),
+  );
+
+  afterAll(
+    () =>
+      new Promise((resolve, reject) =>
+        server.close((error) => {
+          if (error) reject(error);
+          else resolve();
+        }),
+      ),
+  );
+
   {
     const youtubeId = '2aib-pmgUdQ';
-    const url = `${BASE_URL}/test/youtube-id/?url=https://www.youtube.com/watch?v=${youtubeId}`;
     it(`youtube id from raw youtube url`, async () => {
+      const url = `${baseUrl}/test/youtube-id/?url=https://www.youtube.com/watch?v=${youtubeId}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);
@@ -32,8 +51,8 @@ describe(`GET 'Test' API Request `, async () => {
   }
   {
     const email = 'test@gmail.com';
-    const url = `${BASE_URL}/test/verify-email/?email=${email}`;
     it(`valid format email`, async () => {
+      const url = `${baseUrl}/test/verify-email/?email=${email}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);
@@ -42,8 +61,8 @@ describe(`GET 'Test' API Request `, async () => {
   }
   {
     const password = 'Password123!';
-    const url = `${BASE_URL}/test/is-strong-password/?password=${password}`;
     it(`valid password`, async () => {
+      const url = `${baseUrl}/test/is-strong-password/?password=${password}`;
       logger.info('request info', { url });
       const res = await axios.get(url);
       logger.info('response', res.data);

package/test/integration/app/cyberia/cyberia-cli-plain-reads.test.js

@@ -0,0 +1,30 @@
+'use strict';
+
+import { expect } from 'chai';
+import { execFileSync } from 'node:child_process';
+import fs from 'fs-extra';
+
+// The reroute notice is diagnostic output, so it must not reach stdout: a caller reading a value
+// out of `--plain` would otherwise parse the banner as the value. Spawning the real CLI is the
+// only way to observe the two streams apart, and it belongs to this tier because the cyberia CLI
+// boots on the native packages the product manifest pins — repositories that only run
+// `unit,infra,app` never install them.
+describe('rerouted plain reads stay machine-readable', () => {
+  const CYBERIA_CLI = 'bin/cyberia.js';
+  const repoRoot = new URL('../../../../', import.meta.url);
+
+  it.skipIf(!fs.existsSync(new URL(CYBERIA_CLI, repoRoot)))(
+    'prints nothing for a key the store lacks',
+    () => {
+      const stdout = execFileSync(
+        process.execPath,
+        [CYBERIA_CLI, 'host', 'get', '--plain', 'UNDERPOST_TEST_MISSING_KEY'],
+        { cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+      );
+      expect(stdout.trim()).to.equal('');
+      // A cold CLI start imports the whole command surface; the budget is for the import, not the
+      // read, and is stated here rather than left to the runner default a loaded machine exceeds.
+    },
+    60000,
+  );
+});

package/test/{cyberia-instance-conf-defaults.test.js → integration/app/cyberia/cyberia-instance-conf-defaults.test.js}

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import {
   fillInstanceConfDefaults,
   CYBERIA_INSTANCE_CONF_DEFAULTS,
-} from '../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+} from '../../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
 
 // The CyberiaInstanceConfSchema fields that must always be present after a
 // backfill. Mirrors cyberia-instance-conf.model.js (minus instanceCode, which