Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

test(lib): make concurrent-write test actually concurrent + use regex matcher for assert.throws

Jamkrisd904edc6156b
diff --git a/tests/lib/session-bridge.test.js b/tests/lib/session-bridge.test.js
index 6e57f8fca..632c2fdce 100644
--- a/tests/lib/session-bridge.test.js
+++ b/tests/lib/session-bridge.test.js
@@ -151,10 +151,19 @@ function runTests() {
if (
test('concurrent writeBridgeAtomic does not throw ENOENT or corrupt the bridge file', () => {
+ // Spawn two child processes that BOTH stay alive at the same time
+ // and call writeBridgeAtomic in a tight loop. `spawnSync` would
+ // run them sequentially (blocking on each), which would never
+ // exercise the race the fix targets. Instead a sync runner script
+ // launches both as async `spawn` children inside its own process,
+ // waits for both to exit, and reports their statuses on stdout —
+ // and the test calls *that* runner via `spawnSync`. The runner is
+ // the only place that needs the event loop.
const { spawnSync } = require('child_process');
const path = require('path');
const testId = `test-bridge-race-${Date.now()}-${process.pid}`;
const writerPath = path.join(__dirname, '..', '__tmp_bridge_writer.js');
+ const runnerPath = path.join(__dirname, '..', '__tmp_bridge_race_runner.js');
const bridgeLib = path.join(__dirname, '..', '..', 'scripts', 'lib', 'session-bridge');
fs.writeFileSync(
writerPath,
@@ -167,13 +176,38 @@ function runTests() {
].join('\n'),
'utf8'
);
+ fs.writeFileSync(
+ runnerPath,
+ [
+ "'use strict';",
+ "const { spawn } = require('child_process');",
+ "const [, , writerPath, sid] = process.argv;",
+ "const c1 = spawn(process.execPath, [writerPath, sid, 'A'], { stdio: ['ignore','pipe','pipe'] });",
+ "const c2 = spawn(process.execPath, [writerPath, sid, 'B'], { stdio: ['ignore','pipe','pipe'] });",
+ "const exits = {};",
+ "const stderrs = { A: '', B: '' };",
+ "c1.stderr.on('data', chunk => { stderrs.A += chunk.toString(); });",
+ "c2.stderr.on('data', chunk => { stderrs.B += chunk.toString(); });",
+ "let done = 0;",
+ "function onExit(tag) { return function(code) { exits[tag] = code; if (++done === 2) finish(); }; }",
+ "c1.on('exit', onExit('A'));",
+ "c2.on('exit', onExit('B'));",
+ "function finish() {",
+ " process.stdout.write(JSON.stringify({ exits, stderrs }));",
+ " process.exit(0);",
+ "}",
+ ].join('\n'),
+ 'utf8'
+ );
try {
- const r1 = spawnSync('node', [writerPath, testId, 'A'], { encoding: 'utf8' });
- const r2 = spawnSync('node', [writerPath, testId, 'B'], { encoding: 'utf8' });
- assert.strictEqual(r1.status, 0,
- `writer A should exit 0 (no ENOENT), got ${r1.status}: ${r1.stderr}`);
- assert.strictEqual(r2.status, 0,
- `writer B should exit 0 (no ENOENT), got ${r2.status}: ${r2.stderr}`);
+ const result = spawnSync('node', [runnerPath, writerPath, testId], { encoding: 'utf8' });
+ assert.strictEqual(result.status, 0,
+ `race runner should exit 0, got ${result.status}: ${result.stderr}`);
+ const parsed = JSON.parse(result.stdout);
+ assert.strictEqual(parsed.exits.A, 0,
+ `writer A should exit 0 (no ENOENT), got ${parsed.exits.A}: ${parsed.stderrs.A}`);
+ assert.strictEqual(parsed.exits.B, 0,
+ `writer B should exit 0 (no ENOENT), got ${parsed.exits.B}: ${parsed.stderrs.B}`);
// Final file must be parseable JSON and belong to one of the writers.
const final = readBridge(testId);
assert.ok(final && typeof final === 'object',
@@ -183,6 +217,7 @@ function runTests() {
} finally {
try { fs.unlinkSync(getBridgePath(testId)); } catch { /* ignore */ }
try { fs.unlinkSync(writerPath); } catch { /* ignore */ }
+ try { fs.unlinkSync(runnerPath); } catch { /* ignore */ }
}
})
)
@@ -202,8 +237,14 @@ function runTests() {
// Plant a directory at the target path so renameSync (target.tmp → target) fails.
fs.mkdirSync(target);
try {
- assert.throws(() => writeBridgeAtomic(testId, { x: 1 }),
- 'expected rename failure to surface');
+ assert.throws(
+ () => writeBridgeAtomic(testId, { x: 1 }),
+ // renameSync of a regular file onto an existing directory throws
+ // EISDIR on Linux, EPERM on macOS, ENOTDIR on some BSDs. Accept
+ // any of those so the test stays portable across CI runners.
+ /EISDIR|EPERM|ENOTDIR|ENOENT/,
+ 'expected rename failure to surface'
+ );
// Count any leaked tmp files. The pid+nonce suffix is unique per
// call, so we look for any matching pattern under os.tmpdir().
const prefix = path.basename(target) + '.' + process.pid + '.';