Retry processor startup on port conflicts in test helpers

- export `getFreePort` from fixture helper for reuse
- retry queue processor startup up to 5 times when `EADDRINUSE` occurs, reallocating API port
- treat `null` like `undefined` in `waitFor` so polling only resolves on real values

Author: Mike Roberts

tests/helpers/fixture.ts

@@ -20,7 +20,7 @@ interface CreateFixtureOptions {
     teams?: Record<string, TeamConfig>;
 }
 
-async function getFreePort(): Promise<number> {
+export async function getFreePort(): Promise<number> {
     return await new Promise((resolve, reject) => {
         const server = net.createServer();
         server.listen(0, '127.0.0.1', () => {

tests/helpers/processor.ts

@@ -1,7 +1,7 @@
 import { ChildProcess, spawn } from 'child_process';
 import { getQueueStatus } from './http';
 import { REPO_ROOT } from './paths';
-import { TestFixture } from './fixture';
+import { getFreePort, TestFixture } from './fixture';
 import { waitFor } from './wait';
 
 export interface ProcessorHandle {
@@ -14,79 +14,93 @@ export async function startProcessor(
     fixture: TestFixture,
     env: Record<string, string> = {}
 ): Promise<ProcessorHandle> {
-    let outputBuffer = '';
-    let exited = false;
+    for (let attempt = 0; attempt < 5; attempt++) {
+        let outputBuffer = '';
+        let exited = false;
 
-    const child = spawn(process.execPath, ['dist/queue-processor.js'], {
-        cwd: REPO_ROOT,
-        env: {
-            ...process.env,
-            NODE_ENV: 'test',
-            HOME: fixture.homeDir,
-            TINYCLAW_HOME: fixture.tinyclawHome,
-            TINYCLAW_API_PORT: String(fixture.apiPort),
-            ...env,
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
+        const child = spawn(process.execPath, ['dist/queue-processor.js'], {
+            cwd: REPO_ROOT,
+            env: {
+                ...process.env,
+                NODE_ENV: 'test',
+                HOME: fixture.homeDir,
+                TINYCLAW_HOME: fixture.tinyclawHome,
+                TINYCLAW_API_PORT: String(fixture.apiPort),
+                ...env,
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
 
-    child.stdout?.setEncoding('utf8');
-    child.stderr?.setEncoding('utf8');
-    child.stdout?.on('data', (chunk: string) => {
-        outputBuffer += chunk;
-    });
-    child.stderr?.on('data', (chunk: string) => {
-        outputBuffer += chunk;
-    });
-    child.on('exit', () => {
-        exited = true;
-    });
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk: string) => {
+            outputBuffer += chunk;
+        });
+        child.stderr?.on('data', (chunk: string) => {
+            outputBuffer += chunk;
+        });
+        child.on('exit', () => {
+            exited = true;
+        });
 
-    await waitFor(async () => {
-        if (exited) {
-            throw new Error(`Queue processor exited before readiness:\n${outputBuffer}`);
-        }
         try {
-            return await getQueueStatus(fixture.baseUrl);
-        } catch {
-            return undefined;
-        }
-    }, 10_000);
+            await waitFor(async () => {
+                if (exited) {
+                    throw new Error(`Queue processor exited before readiness:\n${outputBuffer}`);
+                }
+                try {
+                    return await getQueueStatus(fixture.baseUrl);
+                } catch {
+                    return undefined;
+                }
+            }, 10_000);
 
-    return {
-        child,
-        async stop() {
-            if (exited) {
-                return;
-            }
+            return {
+                child,
+                async stop() {
+                    if (exited) {
+                        return;
+                    }
 
-            const exitPromise = new Promise<void>((resolve) => {
-                child.once('exit', () => resolve());
-            });
-            let timeoutId: NodeJS.Timeout | undefined;
+                    const exitPromise = new Promise<void>((resolve) => {
+                        child.once('exit', () => resolve());
+                    });
+                    let timeoutId: NodeJS.Timeout | undefined;
 
-            child.kill('SIGTERM');
-            await Promise.race([
-                exitPromise,
-                new Promise<void>((resolve, reject) => {
-                    timeoutId = setTimeout(() => {
-                        if (!exited) {
-                            child.kill('SIGKILL');
+                    child.kill('SIGTERM');
+                    await Promise.race([
+                        exitPromise,
+                        new Promise<void>((resolve, reject) => {
+                            timeoutId = setTimeout(() => {
+                                if (!exited) {
+                                    child.kill('SIGKILL');
+                                }
+                                reject(new Error(`Timed out stopping queue processor:\n${outputBuffer}`));
+                            }, 5_000);
+                        }),
+                    ]).catch(async (error) => {
+                        await exitPromise;
+                        throw error;
+                    }).finally(() => {
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
                         }
-                        reject(new Error(`Timed out stopping queue processor:\n${outputBuffer}`));
-                    }, 5_000);
-                }),
-            ]).catch(async (error) => {
-                await exitPromise;
+                    });
+                },
+                output() {
+                    return outputBuffer;
+                },
+            };
+        } catch (error) {
+            if (!outputBuffer.includes('EADDRINUSE') || attempt === 4) {
                 throw error;
-            }).finally(() => {
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
-                }
-            });
-        },
-        output() {
-            return outputBuffer;
-        },
-    };
+            }
+
+            fixture.apiPort = await getFreePort();
+            fixture.baseUrl = `http://127.0.0.1:${fixture.apiPort}`;
+            await new Promise(resolve => child.once('exit', resolve));
+        }
+    }
+
+    throw new Error('Queue processor could not start after retrying port allocation');
 }

tests/helpers/wait.ts

@@ -7,7 +7,7 @@ export async function waitFor<T>(
 
     while (Date.now() - start < timeoutMs) {
         const result = await check();
-        if (result !== undefined) {
+        if (result !== undefined && result !== null) {
             return result;
         }
         await new Promise(resolve => setTimeout(resolve, intervalMs));