@underpostnet/cyberia 3.3.73 → 3.3.76

package/test/unit/deploy-log-table.test.js

@@ -85,7 +85,7 @@ const stream = [
 let workDir;
 let streamPath;
 
-const runQuiet = ({ tty = false, plain = false, ci = false, exitCode = 0 } = {}) => {
+const runQuiet = ({ tty = false, plain = false, ci = false, debug = false, exitCode = 0 } = {}) => {
   const command = `exit ${exitCode}`;
   const script = [
     'status=0',
@@ -106,6 +106,8 @@ const runQuiet = ({ tty = false, plain = false, ci = false, exitCode = 0 } = {})
   delete env.GITHUB_ACTIONS;
   delete env.RUN_QUIET_CI;
   if (ci) env.RUN_QUIET_CI = 'github';
+  delete env.RUN_QUIET_DEBUG;
+  if (debug) env.RUN_QUIET_DEBUG = '1';
 
   const [file, args] = tty ? ['script', ['-qec', `bash ${scriptPath}`, '/dev/null']] : ['bash', [scriptPath]];
   return execFileSync(file, args, { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
@@ -128,7 +130,7 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
    * Runs the helper against an arbitrary stream and reports the exit status rather than
    * throwing, so a failing step is an assertion rather than a caught exception.
    */
-  const runWith = (lines, exitCode = 0) => {
+  const runWith = (lines, exitCode = 0, mode = { RUN_QUIET_PLAIN: '1' }) => {
     const logPath = path.join(failDir, 'stream.log');
     fs.writeFileSync(logPath, `${lines.join('\n')}\n`);
     const scriptPath = path.join(failDir, 'run.sh');
@@ -141,9 +143,12 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
         'echo REACHED_NEXT_STEP',
       ].join('\n'),
     );
-    const env = { ...process.env, RUN_QUIET_PLAIN: '1' };
+    const env = { ...process.env };
     delete env.GITHUB_ACTIONS;
     delete env.RUN_QUIET_CI;
+    delete env.RUN_QUIET_PLAIN;
+    delete env.RUN_QUIET_DEBUG;
+    Object.assign(env, mode);
     try {
       const stdout = execFileSync('bash', [scriptPath], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
       return { status: 0, stdout, stderr: '' };
@@ -158,6 +163,41 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
 
   afterEach(() => fs.removeSync(failDir));
 
+  // The failure report names two files and prints nothing out of them, so what the step captured
+  // is read back from the file rather than from the transcript.
+  const errorLog = (result) => {
+    const named = /error trace:\s+(\S+)/.exec(result.stderr);
+    expect(named, 'the failure report names an error trace').to.not.equal(null);
+    return fs.readFileSync(named[1], 'utf8');
+  };
+
+  it('latches a fatal runtime state in every rendering, including the debug stream', () => {
+    // The latch is parsed, not rendered. Turning the display off must not turn it off with it, or
+    // an audit run reports success on a deployment that never came up.
+    const podFatal = 'Target pod: dd-test-blue | Pod status: Running | Runtime status: error';
+
+    for (const [name, mode] of [
+      ['plain', { RUN_QUIET_PLAIN: '1' }],
+      ['ci', { RUN_QUIET_CI: 'github' }],
+      ['debug', { RUN_QUIET_DEBUG: '1' }],
+    ]) {
+      const result = runWith([podFatal], 0, mode);
+      expect(result.status, name).to.equal(1);
+      expect(result.stderr, name).to.include('reported a fatal runtime state but exited 0');
+      expect(result.stdout, name).to.not.include('REACHED_NEXT_STEP');
+    }
+  });
+
+  it('latches a fatal runtime state reported only by a monitor event, in the debug stream too', () => {
+    // The event arrives as a multi-line JSON block, so the state machine that reads it has to run
+    // in a mode that renders none of it.
+    const emitted = emit('08:11:33', 'runtime', 'runtime_error', 'error').split('\n');
+    const result = runWith(emitted, 0, { RUN_QUIET_DEBUG: '1' });
+
+    expect(result.status).to.equal(1);
+    expect(result.stdout, 'debug shows the event it latched on').to.include('"status": "error"');
+  });
+
   it('propagates a non-zero command status so `set -e` stops the deployment', () => {
     const result = runWith([podLine(POD_A, 'Running', 'running-deployment')], 7);
     expect(result.status).to.equal(7);
@@ -184,7 +224,10 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
     expect(result.status).to.equal(1);
     expect(result.stdout).to.not.include('REACHED_NEXT_STEP');
     expect(result.stderr).to.include('fatal runtime state but exited 0');
-    expect(result.stderr).to.include(POD_A);
+    // The pod name is captured output: a CI transcript is readable by anyone with the job log,
+    // so the latch detail belongs in the error log and nowhere else.
+    expect(result.stderr).to.not.include(POD_A);
+    expect(errorLog(result)).to.include(`pod ${POD_A}: runtime status=error`);
   });
 
   it('fails on a fatal runtime status carried by a monitor event rather than a pod row', () => {
@@ -196,7 +239,8 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
       0,
     );
     expect(result.status).to.equal(1);
-    expect(result.stderr).to.include('runtime event: status=error');
+    expect(result.stderr).to.not.include('status=error');
+    expect(errorLog(result)).to.include('runtime event: status=error');
   });
 
   it('never hands off to the traffic switch on a pod reporting the fatal state', () => {
@@ -318,6 +362,33 @@ describe('deploy log table (run_quiet filter)', () => {
     expect(out).to.not.include(CHATTER_LINE);
   });
 
+  it('streams every line verbatim in debug mode, rendering nothing of its own', () => {
+    const out = runQuiet({ debug: true });
+
+    // What the other modes consume is exactly what an operator opened this session to read: the
+    // monitor's own JSON, and the report lines the table replaces.
+    expect(out).to.include('deploy-monitor');
+    expect(out).to.include('"phase": "kubernetes"');
+    expect(out).to.include('Target pod: ');
+    expect(out).to.include(READY_LINE);
+    expect(out).to.include(CHATTER_LINE);
+
+    // Nothing is rendered on top of the stream: no table, no CI section, no hand-off.
+    expect(out).to.not.include('POD NAME');
+    expect(out).to.not.include('refresh #');
+    expect(out).to.not.include('::group::');
+    expect(out).to.not.include('▶ Switch traffic');
+  });
+
+  it('keeps debug mode a passthrough even where a CI log would fold frames', () => {
+    // Debug is the operator asking for the stream, so it wins over the rendering the destination
+    // would otherwise get: a collapsed section hides exactly what the run is being watched for.
+    const out = runQuiet({ debug: true, ci: true });
+
+    expect(out).to.not.include('::group::');
+    expect(out).to.include('deploy-monitor');
+  });
+
   it('falls back to plain rows on a terminal when RUN_QUIET_PLAIN is set', function () {
     if (!hasScript) return this.skip();
     const out = runQuiet({ tty: true, plain: true });

package/test/unit/downloader-integrity.test.js

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * @module downloader-integrity.test
+ * @description Covers the contract a split-artifact transfer depends on: a download either
+ * produces the whole file or produces none. A response that ends early still ends, so the write
+ * stream finishes and, without a length check, a short file is reported as a completed download
+ * and only surfaces later as a corrupt archive assembled from it.
+ *
+ * Uses 'chai' for assertions.
+ */
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+import http from 'http';
+import Downloader from '../../src/server/storage/downloader.js';
+
+const BODY = Buffer.from('a'.repeat(64 * 1024));
+
+/** Serves one response shape and resolves the base URL it listens on. */
+const serverFactory = (handler) =>
+  new Promise((resolve) => {
+    const server = http.createServer(handler);
+    server.listen(0, '127.0.0.1', () => resolve({ server, url: `http://127.0.0.1:${server.address().port}/part` }));
+  });
+
+describe('download integrity', () => {
+  let fixturePath;
+  let running;
+
+  beforeEach(() => {
+    fixturePath = fs.mkdtempSync('/tmp/engine-downloader-');
+    running = [];
+  });
+
+  afterEach(async () => {
+    for (const server of running) await new Promise((resolve) => server.close(resolve));
+    fs.removeSync(fixturePath);
+  });
+
+  const serve = async (handler) => {
+    const { server, url } = await serverFactory(handler);
+    running.push(server);
+    return url;
+  };
+
+  it('saves a complete response and reports the path', async () => {
+    const url = await serve((request, response) => {
+      response.writeHead(200, { 'content-length': String(BODY.length) });
+      response.end(BODY);
+    });
+    const target = `${fixturePath}/whole.bin`;
+
+    expect(await Downloader.downloadFile(url, target)).to.equal(target);
+    expect(fs.statSync(target).size).to.equal(BODY.length);
+  });
+
+  it('rejects a response that stops short of its declared length, and leaves no partial file', async () => {
+    const url = await serve((request, response) => {
+      response.writeHead(200, { 'content-length': String(BODY.length) });
+      response.write(BODY.subarray(0, 1024));
+      // Ending early is what a cut-short transfer looks like to the client: the stream still ends.
+      response.destroy();
+    });
+    const target = `${fixturePath}/short.bin`;
+
+    let thrown;
+    await Downloader.downloadFile(url, target).catch((error) => (thrown = error));
+
+    expect(thrown, 'a truncated transfer must not resolve').to.not.equal(undefined);
+    expect(fs.existsSync(target), 'a partial file is indistinguishable from a whole one').to.equal(false);
+  });
+
+  it('accepts a response that declares no length, since nothing can be checked against', async () => {
+    const url = await serve((request, response) => {
+      response.writeHead(200, { 'transfer-encoding': 'chunked' });
+      response.end(BODY);
+    });
+    const target = `${fixturePath}/chunked.bin`;
+
+    expect(await Downloader.downloadFile(url, target)).to.equal(target);
+    expect(fs.statSync(target).size).to.equal(BODY.length);
+  });
+
+  it('rejects a request the server refuses, and leaves no file', async () => {
+    const url = await serve((request, response) => {
+      response.writeHead(404);
+      response.end();
+    });
+    const target = `${fixturePath}/missing.bin`;
+
+    let thrown;
+    await Downloader.downloadFile(url, target).catch((error) => (thrown = error));
+
+    expect(thrown).to.not.equal(undefined);
+    expect(fs.existsSync(target)).to.equal(false);
+  });
+});

package/test/unit/file-reference-registry.test.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * @module file-reference-registry.test
+ * @description Covers `src/api/file/file.ref.js`: the mapping of a model to the fields that hold
+ * a File `_id`, and the two deletions built on it. Every writer that removes a document reads
+ * this registry to take the blobs it owned with it, so what is asserted here is what keeps the
+ * File collection free of unreachable documents.
+ *
+ * Uses 'chai' for assertions.
+ */
+
+import { expect } from 'chai';
+import {
+  deleteOwnedFiles,
+  deleteUnreferencedFiles,
+  documentFileIds,
+  fileRefApis,
+  fileRefFields,
+} from '../../src/api/file/file.ref.js';
+
+/** Minimal collection: the helpers only run `find(filter, projection).lean()` and `deleteMany`. */
+const collection = (docs) => ({
+  docs,
+  find(filter) {
+    const clauses = filter.$or ?? [filter];
+    const matched = docs.filter((doc) =>
+      clauses.some((clause) =>
+        Object.entries(clause).every(([field, condition]) => {
+          const value = doc[field];
+          if (value === undefined || value === null) return false;
+          return condition.$in.map(String).includes(String(value));
+        }),
+      ),
+    );
+    return { lean: async () => matched };
+  },
+  async deleteMany({ _id: { $in } }) {
+    const removing = new Set($in.map(String));
+    const before = docs.length;
+    this.docs = docs = docs.filter((doc) => !removing.has(String(doc._id)));
+    return { deletedCount: before - docs.length };
+  },
+});
+
+describe('the File reference registry', () => {
+  it('answers the fields of a registered api and nothing for an unregistered one', () => {
+    expect(fileRefFields('atlas-sprite-sheet')).to.deep.equal(['fileId', 'minifyFileId', 'idlePreviewFileId']);
+    expect(fileRefFields('cyberia-map')).to.deep.equal(['thumbnail', 'preview']);
+    expect(fileRefFields('object-layer')).to.deep.equal([]);
+    expect(fileRefApis()).to.include('cyberia-audio');
+  });
+
+  it('reads ids out of documents by field, skipping the ones that hold none', () => {
+    const docs = [{ fileId: 'a', minifyFileId: 'b' }, { fileId: 'a' }, { minifyFileId: null }];
+    expect(documentFileIds(docs, ['fileId', 'minifyFileId'])).to.deep.equal(['a', 'b']);
+  });
+});
+
+describe('deleting the files a collection owned', () => {
+  it('removes the ids no surviving document holds', async () => {
+    const files = collection([{ _id: 'atlas-1' }, { _id: 'minify-1' }, { _id: 'unrelated' }]);
+    const atlases = collection([]);
+
+    const removed = await deleteOwnedFiles({
+      File: files,
+      Owner: atlases,
+      fields: ['fileId', 'minifyFileId'],
+      ids: ['atlas-1', 'minify-1'],
+    });
+
+    expect(removed).to.equal(2);
+    expect(files.docs.map((doc) => doc._id)).to.deep.equal(['unrelated']);
+  });
+
+  it('keeps an id a survivor still points at', async () => {
+    // Renders are content addressed, so a duplicate document of the same item resolves to the
+    // same File id. Dropping the duplicate must not blind the document that remains.
+    const files = collection([{ _id: 'shared' }, { _id: 'gone' }]);
+    const atlases = collection([{ _id: 'survivor', fileId: 'shared', minifyFileId: null }]);
+
+    const removed = await deleteOwnedFiles({
+      File: files,
+      Owner: atlases,
+      fields: ['fileId', 'minifyFileId'],
+      ids: ['shared', 'gone'],
+    });
+
+    expect(removed).to.equal(1);
+    expect(files.docs.map((doc) => doc._id)).to.deep.equal(['shared']);
+  });
+
+  it('deletes nothing when handed no candidates', async () => {
+    const files = collection([{ _id: 'kept' }]);
+    expect(await deleteOwnedFiles({ File: files, Owner: collection([]), fields: ['fileId'], ids: [] })).to.equal(0);
+    expect(files.docs).to.have.lengthOf(1);
+  });
+});
+
+describe('sweeping files no registered model references', () => {
+  const loadedModels = (overrides = {}) => {
+    const models = Object.fromEntries(fileRefApis().map((api) => [api, collection([])]));
+    return { ...models, ...overrides };
+  };
+
+  it('refuses to delete while a registered api has no model to read', async () => {
+    // An unreadable collection cannot be shown to hold no reference, and a sweep that assumed
+    // otherwise would delete a live blob belonging to another domain.
+    const files = collection([{ _id: 'candidate' }]);
+    const models = loadedModels();
+    delete models.document;
+
+    const result = await deleteUnreferencedFiles({
+      File: files,
+      ids: ['candidate'],
+      getModel: (api) => {
+        if (!models[api]) throw new Error(`Model not loaded: ${api}`);
+        return models[api];
+      },
+    });
+
+    expect(result.skipped).to.equal('document');
+    expect(result.removed).to.equal(0);
+    expect(files.docs).to.have.lengthOf(1);
+  });
+
+  it('deletes only the candidates every model agrees it never references', async () => {
+    const files = collection([{ _id: 'orphan' }, { _id: 'held' }]);
+    const models = loadedModels({ 'cyberia-map': collection([{ _id: 'map', thumbnail: 'held', preview: null }]) });
+
+    const result = await deleteUnreferencedFiles({
+      File: files,
+      ids: ['orphan', 'held'],
+      getModel: (api) => models[api],
+    });
+
+    expect(result.skipped).to.equal('');
+    expect(result.removed).to.equal(1);
+    expect(files.docs.map((doc) => doc._id)).to.deep.equal(['held']);
+  });
+});