deepdebug-local-agent 1.0.22 → 1.0.23

package/test/adapters/cobol/cobol.test.js

@@ -0,0 +1,217 @@
+// test/adapters/cobol/cobol.test.js
+// Plan 02-11 contract tests for CobolLogAdapter.
+// 10 tests covering AC-1/2/3/9/10, AD-6 CRLF tolerance + 80-col fixed-width
+// preservation, multi-pattern parser (S0C7, SQLCODE, IEF, FILE STATUS),
+// and parser-isolation surface.
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  writeFileSync,
+  appendFileSync,
+  truncateSync,
+  mkdtempSync,
+  rmSync,
+  openSync,
+  writeSync,
+  closeSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { CobolLogAdapter } from '../../../src/adapters/cobol/index.js';
+import {
+  COBOL_COMPLETION_REGEX,
+  COBOL_SQLCODE_REGEX,
+  COBOL_IEF_REGEX,
+  COBOL_FILE_STATUS_REGEX,
+} from '../../../src/adapters/cobol/cobol-parser.js';
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), 'cobol-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    const t = setTimeout(() => {
+      adapter.off('error', onErr);
+      resolve(events);
+    }, timeoutMs);
+    t.unref?.();
+  });
+}
+
+describe('CobolLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'spool1.txt'), 'SYSTEM COMPLETION CODE=0C7  pre-existing\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits S0C7 event with 6-key alphabetical-sorted shape (AC-2)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, '  SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(
+      Object.keys(events[0]).sort().join(','),
+      'adapter,errorCode,file,message,source,timestamp',
+    );
+    assert.equal(events[0].adapter, 'cobol');
+    assert.equal(events[0].errorCode, 'S0C7');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits SQLCODE -805 event', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      f,
+      'DSNT408I SQLCODE = -805, ERROR: DBRM OR PACKAGE NAME PROD.CUSTUPD NOT FOUND IN PLAN\n',
+    );
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.equal(events[0].errorCode, '-805');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits FILE STATUS 35 event', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, "IGZ0035S - FILE STATUS 35 - File 'CUSTIN' was not found.\n");
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.match(events[0].errorCode, /^(FILE_STATUS_35|IGZ0035S)$/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('CRLF line endings tolerated (AD-6 z/OS spool trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\r\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    const fd = openSync(f, 'a');
+    const buf = Buffer.from(
+      '  SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007\r\n',
+      'utf8',
+    );
+    writeSync(fd, buf, 0, buf.length);
+    closeSync(fd);
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.equal(events[0].errorCode, 'S0C7');
+    // \r artifact must NOT appear in event.message
+    assert.equal(
+      events[0].message.includes('\r'),
+      false,
+      'event.message must not contain raw \\r artifact',
+    );
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('80-col padded ABEND header preserves column-1 control char (AD-6 fixed-width trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    // Line begins with column-1 '0' (page-eject control char), padded to 80 cols
+    const line =
+      '0SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007                               ';
+    assert.equal(line.length, 80);
+    appendFileSync(f, line + '\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    // message should retain the leading '0' control char
+    assert.equal(
+      events[0].message[0],
+      '0',
+      'column-1 control char must not be trimmed',
+    );
+    assert.equal(events[0].errorCode, 'S0C7');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent — start/start/stop/stop (AC-1)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'spool1.txt'), '');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation — truncate + append (AC-10)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'old\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'SYSTEM COMPLETION CODE=0C7\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent — nonexistent spoolDir does not throw', async () => {
+    const adapter = new CobolLogAdapter({
+      spoolDir: '/nonexistent-' + Date.now(),
+      interval: 200,
+    });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regexes isolated and exported as named consts', () => {
+    assert.ok(COBOL_COMPLETION_REGEX instanceof RegExp);
+    assert.ok(COBOL_SQLCODE_REGEX instanceof RegExp);
+    assert.ok(COBOL_IEF_REGEX instanceof RegExp);
+    assert.ok(COBOL_FILE_STATUS_REGEX instanceof RegExp);
+    assert.ok('SYSTEM COMPLETION CODE=0C7'.match(COBOL_COMPLETION_REGEX));
+    assert.ok('SQLCODE = -805'.match(COBOL_SQLCODE_REGEX));
+    assert.ok('IEF450I DAILY01 STEP01 - ABEND'.match(COBOL_IEF_REGEX));
+    assert.ok('FILE STATUS 35'.match(COBOL_FILE_STATUS_REGEX));
+  });
+});

package/test/adapters/ibmmq/ibmmq.test.js

@@ -0,0 +1,122 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFileSync, appendFileSync, truncateSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { IbmMqLogAdapter } from '../../../src/adapters/ibmmq/index.js';
+import { IBMMQ_AMQ_REGEX } from '../../../src/adapters/ibmmq/ibmmq-parser.js';
+
+function tempErrorsDir() {
+  return mkdtempSync(join(tmpdir(), 'ibmmq-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    setTimeout(() => { adapter.off('error', onErr); resolve(events); }, timeoutMs);
+  });
+}
+
+describe('IbmMqLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempErrorsDir();
+    writeFileSync(join(root, 'AMQERR01.LOG'), 'AMQ7472W: pre-existing line\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0, 'no events should fire for pre-existing content');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits 6-key event on AMQERR line (AC-2)', async () => {
+    const root = tempErrorsDir();
+    const f = join(root, 'AMQERR01.LOG');
+    writeFileSync(f, '-- start --\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, 'AMQ7472W: Object Q.ORDER.IN, type queue, get returned 2033 (MQRC_NO_MSG_AVAILABLE).\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(Object.keys(events[0]).sort().join(','), 'adapter,errorCode,file,message,source,timestamp');
+    assert.equal(events[0].adapter, 'ibmmq');
+    assert.equal(events[0].errorCode, 'AMQ7472W');
+    assert.equal(events[0].file, f);
+    assert.match(events[0].message, /AMQ7472W/);
+    assert.equal(events[0].source, root);
+    assert.match(events[0].timestamp, /^\d{4}-\d{2}-\d{2}T/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const root = tempErrorsDir();
+    writeFileSync(join(root, 'AMQERR01.LOG'), '');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start(); // idempotent
+    await adapter.stop();
+    await adapter.stop(); // idempotent
+    await adapter.start();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation: truncate + append (AC-10)', async () => {
+    const root = tempErrorsDir();
+    const f = join(root, 'AMQERR01.LOG');
+    writeFileSync(f, 'AMQ0000I: old\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'AMQ9540E: queue manager name error.\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1, 'rotation should produce at least 1 event');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent — no event, no throw', async () => {
+    const adapter = new IbmMqLogAdapter({ errorsDir: '/nonexistent-' + Date.now(), interval: 200 });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regex exported and isolated', () => {
+    assert.ok(IBMMQ_AMQ_REGEX instanceof RegExp);
+    const m = 'AMQ7472W: Object ...'.match(IBMMQ_AMQ_REGEX);
+    assert.ok(m);
+    assert.equal(m[1], 'AMQ7472W');
+  });
+
+  test('glob anchored — AMQERR04.LOG not watched', async () => {
+    const root = tempErrorsDir();
+    // Create AMQERR04.LOG (NOT in 01..03 range) and a random file
+    const out = join(root, 'AMQERR04.LOG');
+    const random = join(root, 'random.log');
+    writeFileSync(out, '');
+    writeFileSync(random, '');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(out, 'AMQ9999E: should not be emitted\n');
+    appendFileSync(random, 'AMQ9999E: should not be emitted\n');
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0, 'adapter must not watch outside AMQERR0[1-3].LOG glob');
+    rmSync(root, { recursive: true, force: true });
+  });
+});

package/test/adapters/oracle-forms/oracle-forms.test.js

@@ -0,0 +1,180 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  writeFileSync,
+  appendFileSync,
+  truncateSync,
+  mkdtempSync,
+  rmSync,
+  openSync,
+  writeSync,
+  closeSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { OracleFormsLogAdapter } from '../../../src/adapters/oracle-forms/index.js';
+import { ORACLE_FORMS_REGEX } from '../../../src/adapters/oracle-forms/oracle-forms-parser.js';
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), 'forms-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    const t = setTimeout(() => {
+      adapter.off('error', onErr);
+      resolve(events);
+    }, timeoutMs);
+    t.unref?.();
+  });
+}
+
+describe('OracleFormsLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'forms.trc'), 'Line 1: ORA-01403: no data found\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits 6-key event for ORA line (AC-2)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, 'Line 44: ORA-01403: no data found\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(
+      Object.keys(events[0]).sort().join(','),
+      'adapter,errorCode,file,message,source,timestamp',
+    );
+    assert.equal(events[0].adapter, 'oracle-forms');
+    assert.equal(events[0].errorCode, 'ORA-01403');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits FRM event', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      f,
+      'Line 89: FRM-40735: ON-ERROR trigger raised unhandled exception ORA-20100.\n',
+    );
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(events[0].errorCode, 'FRM-40735');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('Latin-1 bytes do not crash adapter (AD-6 mojibake trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    // Append Latin-1 bytes including 0xE9 ("é"): "Line 102: ORA-06502: Café\n"
+    const fd = openSync(f, 'a');
+    const latin1 = Buffer.from([
+      0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x30, 0x32, 0x3a, 0x20, 0x4f, 0x52,
+      0x41, 0x2d, 0x30, 0x36, 0x35, 0x30, 0x32, 0x3a, 0x20, 0x43, 0x61, 0x66,
+      0xe9, 0x0a,
+    ]);
+    writeSync(fd, latin1, 0, latin1.length);
+    closeSync(fd);
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(
+      events.length >= 1,
+      'adapter should not crash on Latin-1 byte; should still emit ORA-06502',
+    );
+    assert.equal(events[0].errorCode, 'ORA-06502');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'forms.trc'), '');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation: truncate + append (AC-10)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'Line 1: OLD ORA-99999: stale\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'Line 1: ORA-01403: no data found\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent', async () => {
+    const adapter = new OracleFormsLogAdapter({
+      traceDir: '/nonexistent-' + Date.now(),
+      interval: 200,
+    });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regex isolated', () => {
+    assert.ok(ORACLE_FORMS_REGEX instanceof RegExp);
+    const m1 = 'Line 44: ORA-01403: no data found'.match(ORACLE_FORMS_REGEX);
+    assert.ok(m1);
+    assert.equal(m1[1], 'ORA-01403');
+    const m2 = 'Line 89: FRM-40735: ON-ERROR ...'.match(ORACLE_FORMS_REGEX);
+    assert.ok(m2);
+    assert.equal(m2[1], 'FRM-40735');
+  });
+
+  test('glob anchored — *.log not watched', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'other.log'), '');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      join(root, 'other.log'),
+      'Line 1: ORA-01403: should not be emitted\n',
+    );
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+});

package/test/adapters/registry.test.js

@@ -0,0 +1,101 @@
+// test/adapters/registry.test.js
+// Contract tests for the Phase 2 adapter registry — Plan 02-12 Wave 3.
+// Validates loadAdapters() construction, allowed-stack enforcement, and
+// stopAll() lifecycle/timeout behaviour (AC-4, AC-11).
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  loadAdapters,
+  stopAll,
+  ALLOWED_STACK_LIST,
+} from '../../src/adapters/index.js';
+
+describe('adapter registry', () => {
+  test('loadAdapters({legacyStacks:[]}) returns []', () => {
+    assert.deepEqual(loadAdapters({ legacyStacks: [] }), []);
+  });
+
+  test('loadAdapters({}) returns [] (missing legacyStacks treated as empty)', () => {
+    assert.deepEqual(loadAdapters({}), []);
+  });
+
+  test('loadAdapters({legacyStacks:["sap"]}) returns 1 SapLogAdapter, unstarted', () => {
+    const adapters = loadAdapters({ legacyStacks: ['sap'] });
+    assert.equal(adapters.length, 1);
+    assert.equal(adapters[0].constructor.name, 'SapLogAdapter');
+    assert.equal(adapters[0].isRunning, false);
+  });
+
+  test('loadAdapters with all 5 stacks returns 5 unstarted adapters', () => {
+    const adapters = loadAdapters({ legacyStacks: ALLOWED_STACK_LIST.slice() });
+    assert.equal(adapters.length, 5);
+    const ctorNames = adapters.map((a) => a.constructor.name).sort();
+    assert.deepEqual(
+      ctorNames,
+      [
+        'As400LogAdapter',
+        'CobolLogAdapter',
+        'IbmMqLogAdapter',
+        'OracleFormsLogAdapter',
+        'SapLogAdapter',
+      ],
+    );
+    for (const a of adapters) assert.equal(a.isRunning, false);
+  });
+
+  test('loadAdapters({legacyStacks:["unknown"]}) throws with stack name', () => {
+    assert.throws(
+      () => loadAdapters({ legacyStacks: ['unknown'] }),
+      /unknown/,
+    );
+  });
+
+  test('loadAdapters propagates per-stack config to constructor', () => {
+    const adapters = loadAdapters({
+      legacyStacks: ['sap'],
+      sap: { sapDir: '/tmp/test-sap', instanceNumber: '42', interval: 1234 },
+    });
+    assert.equal(adapters[0].sapDir, '/tmp/test-sap');
+    assert.equal(adapters[0].instanceNumber, '42');
+    assert.equal(adapters[0].interval, 1234);
+  });
+
+  test('stopAll([]) resolves silently', async () => {
+    await stopAll([]);
+  });
+
+  test('stopAll(undefined) resolves silently', async () => {
+    await stopAll(undefined);
+  });
+
+  test('stopAll calls stop() on each adapter', async () => {
+    let stopped = 0;
+    const fake = { stop: async () => { stopped++; } };
+    await stopAll([fake, fake, fake]);
+    assert.equal(stopped, 3);
+  });
+
+  test('stopAll respects timeout — slow stop does not block forever', async () => {
+    const slow = { stop: () => new Promise(() => { /* never resolve */ }) };
+    const before = Date.now();
+    await stopAll([slow], 200);
+    const elapsed = Date.now() - before;
+    assert.ok(elapsed < 1000, `stopAll should return within timeout; took ${elapsed}ms`);
+  });
+
+  test('stopAll swallows per-adapter stop() errors (never throws)', async () => {
+    const bad = { stop: async () => { throw new Error('boom'); } };
+    const good = { stop: async () => { /* ok */ } };
+    // Should resolve without rejecting.
+    await stopAll([bad, good, bad]);
+  });
+
+  test('ALLOWED_STACK_LIST is the canonical 5-stack list, frozen', () => {
+    assert.deepEqual(
+      [...ALLOWED_STACK_LIST].sort(),
+      ['as400', 'cobol', 'ibmmq', 'oracle-forms', 'sap'],
+    );
+    assert.equal(Object.isFrozen(ALLOWED_STACK_LIST), true);
+  });
+});