ppef 1.0.1 → 1.1.0

package/dist/executor/__tests__/parallel-executor.unit.test.js

@@ -1,12 +1,150 @@
 /**
  * Unit tests for ParallelExecutor
  *
- * Tests worker name generation, run batch distribution, and shard path generation.
+ * Tests worker name generation, run batch distribution, shard path generation,
+ * and the new DI-enabled ParallelExecutor class.
  */
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import { strict as assert } from "node:assert";
-import { shardPath } from "../parallel-executor.js";
+import { shardPath, generateWorkerNames, ParallelExecutor, } from "../parallel-executor.js";
+/**
+ * Create a minimal ExecutorConfig for testing.
+ */
+function createTestConfig(timeoutMs = 0) {
+    return {
+        continueOnError: false,
+        repetitions: 1,
+        seedBase: 42,
+        timeoutMs,
+        collectProvenance: false,
+    };
+}
+/**
+ * Create a minimal PlannedRun for testing.
+ */
+function createTestRun(override) {
+    return {
+        sutId: "test-sut",
+        caseId: "test-case",
+        repetition: 0,
+        seed: 42,
+        ...override,
+    };
+}
+/**
+ * Mock logger for testing.
+ */
+class MockLogger {
+    logs = [];
+    log(message) {
+        this.logs.push(message);
+    }
+    debug(message) {
+        this.logs.push(message);
+    }
+    info(message) {
+        this.logs.push(message);
+    }
+    warn(message) {
+        this.logs.push(message);
+    }
+    clear() {
+        this.logs = [];
+    }
+}
+/**
+ * Mock child process for testing.
+ */
+class MockChildProcess {
+    exitCode = 0;
+    listeners = new Map();
+    on(event, listener) {
+        this.listeners.set(event, listener);
+        return this;
+    }
+    /**
+     * Simulate process exit.
+     */
+    exit(code) {
+        const listener = this.listeners.get("exit");
+        if (listener) {
+            listener(code);
+        }
+    }
+}
+/**
+ * Mock process spawner for testing.
+ */
+class MockProcessSpawner {
+    spawnedProcesses = [];
+    spawn(command, args, options) {
+        const process = new MockChildProcess();
+        this.spawnedProcesses.push({
+            command,
+            args,
+            options: {
+                cwd: options.cwd ?? "/default",
+                stdio: options.stdio ?? "inherit",
+                env: options.env ?? {},
+            },
+            process,
+        });
+        return process;
+    }
+    clear() {
+        this.spawnedProcesses = [];
+    }
+}
+/**
+ * Mock system info for testing.
+ */
+class MockSystemInfo {
+    cpuCount = 4;
+    nodePath = "/path/to/node";
+    packageRoot = "/path/to/project";
+    env = {
+        NODE_ENV: "test",
+        PATH: "/usr/bin:/bin",
+    };
+}
 describe("ParallelExecutor", () => {
+    describe("generateWorkerNames", () => {
+        it("should generate the requested number of unique names", () => {
+            const count = 5;
+            const names = generateWorkerNames(count);
+            assert.strictEqual(names.length, count);
+            assert.strictEqual(new Set(names).size, count); // All unique
+        });
+        it("should generate names with hyphen-separated pattern", () => {
+            const names = generateWorkerNames(3);
+            for (const name of names) {
+                assert.ok(name.includes("-"), `Name ${name} should contain hyphens`);
+                const parts = name.split("-");
+                assert.strictEqual(parts.length, 3, `Name ${name} should have 3 parts`);
+            }
+        });
+        it("should generate unique names for large counts", () => {
+            const count = 20;
+            const names = generateWorkerNames(count);
+            assert.strictEqual(names.length, count);
+            assert.strictEqual(new Set(names).size, count);
+        });
+        it("should handle single worker", () => {
+            const names = generateWorkerNames(1);
+            assert.strictEqual(names.length, 1);
+            assert.ok(names[0].includes("-"));
+        });
+        it("should not repeat names across multiple calls", () => {
+            const count = 10;
+            const names1 = generateWorkerNames(count);
+            const names2 = generateWorkerNames(count);
+            // Each set should have unique names
+            assert.strictEqual(new Set(names1).size, count);
+            assert.strictEqual(new Set(names2).size, count);
+            // The two sets may overlap, but that's acceptable due to randomness
+            // What matters is each individual call returns unique names
+        });
+    });
     describe("shardPath", () => {
         it("should generate zero-padded worker indices", () => {
             const path0 = shardPath("/tmp/checkpoints", 0);
@@ -27,176 +165,308 @@ describe("ParallelExecutor", () => {
             assert.ok(path.includes("/my/checkpoint/dir"));
             assert.ok(path.includes("checkpoint-worker-05.json"));
         });
+        it("should handle relative checkpoint directories", () => {
+            const path = shardPath("checkpoints", 3);
+            assert.ok(path.includes("checkpoints"));
+            assert.ok(path.includes("checkpoint-worker-03.json"));
+        });
+        it("should handle empty checkpoint directory", () => {
+            const path = shardPath("", 7);
+            assert.ok(path.includes("checkpoint-worker-07.json"));
+        });
+    });
+});
+describe("ParallelExecutorOptions", () => {
+    describe("defaults", () => {
+        it("should use default checkpoint directory when not specified", () => {
+            const options = {};
+            const checkpointDir = options.checkpointDir ?? "/default/path";
+            assert.strictEqual(checkpointDir, "/default/path");
+        });
+        it("should use custom checkpoint directory when specified", () => {
+            const options = { checkpointDir: "/custom/path" };
+            const checkpointDir = options.checkpointDir;
+            assert.strictEqual(checkpointDir, "/custom/path");
+        });
+        it("should use default workers when not specified", () => {
+            const options = {};
+            // Default is CPU count, but we can't test that directly
+            // Just verify the undefined case falls back
+            assert.strictEqual(options.workers, undefined);
+        });
+        it("should use custom workers when specified", () => {
+            const options = { workers: 4 };
+            assert.strictEqual(options.workers, 4);
+        });
+    });
+});
+describe("path handling utilities", () => {
+    describe("dist directory detection", () => {
+        it("should detect Unix-style dist paths", () => {
+            const unixDistPath = "/path/to/project/dist/cli.js";
+            // Extract directory from file path
+            const lastSlashIndex = unixDistPath.lastIndexOf("/");
+            const entryDir = unixDistPath.substring(0, lastSlashIndex);
+            const endsWithUnixDist = entryDir.endsWith("/dist");
+            assert.ok(endsWithUnixDist);
+        });
+        it("should not detect non-dist paths", () => {
+            const nonDistPath = "/path/to/project/index.js";
+            const lastSlashIndex = nonDistPath.lastIndexOf("/");
+            const entryDir = nonDistPath.substring(0, lastSlashIndex);
+            const endsWithDist = entryDir.endsWith("/dist");
+            assert.ok(!endsWithDist);
+        });
+        it("should handle paths with dist in middle", () => {
+            const pathWithDistInMiddle = "/path/to/dist/middle/cli.js";
+            const lastSlashIndex = pathWithDistInMiddle.lastIndexOf("/");
+            const entryDir = pathWithDistInMiddle.substring(0, lastSlashIndex);
+            const endsWithDist = entryDir.endsWith("/dist");
+            assert.ok(!endsWithDist);
+        });
+        it("should detect nested dist paths", () => {
+            const nestedDistPath = "/path/to/project/sub/dist/cli.js";
+            const lastSlashIndex = nestedDistPath.lastIndexOf("/");
+            const entryDir = nestedDistPath.substring(0, lastSlashIndex);
+            const endsWithDist = entryDir.endsWith("/dist");
+            assert.ok(endsWithDist);
+        });
+        it("should handle Windows-style backslash dist paths", () => {
+            // Windows paths use backslashes
+            // String.raw`\dist` produces a literal backslash
+            const windowsBackslashDist = String.raw `\dist`;
+            assert.strictEqual(windowsBackslashDist, "\\dist");
+            // Test that endsWith works with backslash paths
+            const windowsDir = "C:\\path\\to\\project\\dist";
+            assert.ok(windowsDir.endsWith(windowsBackslashDist));
+        });
+    });
+});
+describe("ParallelExecutor class with DI", () => {
+    let mockLogger;
+    let mockSpawner;
+    let mockSystemInfo;
+    beforeEach(() => {
+        mockLogger = new MockLogger();
+        mockSpawner = new MockProcessSpawner();
+        mockSystemInfo = new MockSystemInfo();
+    });
+    describe("constructor", () => {
+        it("should use default dependencies when none provided", () => {
+            const executor = new ParallelExecutor();
+            assert.ok(executor);
+        });
+        it("should use provided dependencies", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            assert.ok(executor);
+        });
+        it("should use partial dependencies", () => {
+            const executor = new ParallelExecutor(mockLogger);
+            assert.ok(executor);
+        });
     });
-    describe("run batch distribution (conceptual)", () => {
-        /**
-         * The executeParallel function uses the following algorithm:
-         * 1. Calculate batch size = ceil(runs.length / numWorkers)
-         * 2. Split runs into batches using slice(i, i + batchSize)
-         *
-         * This test verifies the algorithm produces expected results.
-         */
+    describe("createBatches", () => {
         it("should distribute runs evenly across workers", () => {
-            const runs = Array.from({ length: 100 }, (_, index) => ({
-                runId: `run${index}`,
-                sutId: "sut",
-                caseId: "case",
-                repetition: 0,
-                seed: index,
-            }));
-            const numberWorkers = 4;
-            const batchSize = Math.ceil(runs.length / numberWorkers); // 25
-            const batches = [];
-            for (let index = 0; index < runs.length; index += batchSize) {
-                batches.push(runs.slice(index, index + batchSize));
-            }
-            assert.strictEqual(batches.length, 4);
-            assert.strictEqual(batches[0].length, 25);
-            assert.strictEqual(batches[1].length, 25);
-            assert.strictEqual(batches[2].length, 25);
-            assert.strictEqual(batches[3].length, 25);
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [
+                { runId: "run1", sutId: "sut1", caseId: "case1", repetition: 0, seed: 1 },
+                { runId: "run2", sutId: "sut1", caseId: "case2", repetition: 0, seed: 2 },
+                { runId: "run3", sutId: "sut1", caseId: "case3", repetition: 0, seed: 3 },
+                { runId: "run4", sutId: "sut1", caseId: "case4", repetition: 0, seed: 4 },
+            ];
+            // Access private method via testing
+            //
+            const batches = executor._createBatches(runs, 2);
+            assert.strictEqual(batches.length, 2);
+            assert.strictEqual(batches[0].runIds.length, 2);
+            assert.strictEqual(batches[1].runIds.length, 2);
+            assert.deepStrictEqual(batches[0].runIds, ["run1", "run2"]);
+            assert.deepStrictEqual(batches[1].runIds, ["run3", "run4"]);
         });
         it("should handle uneven distribution", () => {
-            const runs = Array.from({ length: 10 }, (_, index) => ({
-                runId: `run${index}`,
-                sutId: "sut",
-                caseId: "case",
-                repetition: 0,
-                seed: index,
-            }));
-            const numberWorkers = 3;
-            const batchSize = Math.ceil(runs.length / numberWorkers); // 4
-            const batches = [];
-            for (let index = 0; index < runs.length; index += batchSize) {
-                batches.push(runs.slice(index, index + batchSize));
-            }
-            assert.strictEqual(batches.length, 3);
-            assert.strictEqual(batches[0].length, 4);
-            assert.strictEqual(batches[1].length, 4);
-            assert.strictEqual(batches[2].length, 2); // Last batch gets remainder
-        });
-        it("should handle single worker", () => {
-            const runs = Array.from({ length: 50 }, (_, index) => ({
-                runId: `run${index}`,
-                sutId: "sut",
-                caseId: "case",
-                repetition: 0,
-                seed: index,
-            }));
-            const numberWorkers = 1;
-            const batchSize = Math.ceil(runs.length / numberWorkers); // 50
-            const batches = [];
-            for (let index = 0; index < runs.length; index += batchSize) {
-                batches.push(runs.slice(index, index + batchSize));
-            }
-            assert.strictEqual(batches.length, 1);
-            assert.strictEqual(batches[0].length, 50);
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [
+                { runId: "run1", sutId: "sut1", caseId: "case1", repetition: 0, seed: 1 },
+                { runId: "run2", sutId: "sut1", caseId: "case2", repetition: 0, seed: 2 },
+                { runId: "run3", sutId: "sut1", caseId: "case3", repetition: 0, seed: 3 },
+            ];
+            //
+            const batches = executor._createBatches(runs, 2);
+            assert.strictEqual(batches.length, 2);
+            assert.strictEqual(batches[0].runIds.length, 2);
+            assert.strictEqual(batches[1].runIds.length, 1);
         });
         it("should handle more workers than runs", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
             const runs = [
-                { runId: "run0", sutId: "sut", caseId: "case", repetition: 0, seed: 0 },
-                { runId: "run1", sutId: "sut", caseId: "case", repetition: 0, seed: 1 },
+                { runId: "run1", sutId: "sut1", caseId: "case1", repetition: 0, seed: 1 },
             ];
-            const numberWorkers = 5;
-            const batchSize = Math.ceil(runs.length / numberWorkers); // 1
-            const batches = [];
-            for (let index = 0; index < runs.length; index += batchSize) {
-                batches.push(runs.slice(index, index + batchSize));
-            }
-            // With batchSize=1, we get 2 batches (one per run)
-            // The last 3 workers would get empty batches in the actual implementation
-            assert.ok(batches.length >= 2);
-            assert.strictEqual(batches[0].length, 1);
-            assert.strictEqual(batches[1].length, 1);
+            //
+            const batches = executor._createBatches(runs, 4);
+            assert.strictEqual(batches.length, 1);
+            assert.strictEqual(batches[0].runIds.length, 1);
         });
-    });
-    describe("run filter generation (conceptual)", () => {
-        /**
-         * Each worker receives a run filter as a JSON array of run IDs.
-         * This test verifies the filter format.
-         */
-        it("should generate JSON array of run IDs for each batch", () => {
+        it("should handle empty runs", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [];
+            //
+            const batches = executor._createBatches(runs, 2);
+            assert.strictEqual(batches.length, 0);
+        });
+        it("should create proper batch metadata", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
             const runs = [
-                { runId: "alpha", sutId: "sut", caseId: "case", repetition: 0, seed: 0 },
-                { runId: "bravo", sutId: "sut", caseId: "case", repetition: 0, seed: 1 },
-                { runId: "charlie", sutId: "sut", caseId: "case", repetition: 0, seed: 2 },
+                { runId: "run1", sutId: "sut1", caseId: "case1", repetition: 0, seed: 1 },
+                { runId: "run2", sutId: "sut1", caseId: "case2", repetition: 0, seed: 2 },
             ];
-            const numberWorkers = 2;
-            const batchSize = Math.ceil(runs.length / numberWorkers); // 2
-            const runFilters = [];
-            for (let index = 0; index < runs.length; index += batchSize) {
-                const batch = runs.slice(index, index + batchSize);
-                const runIds = new Set(batch.map((r) => r.runId));
-                runFilters.push(JSON.stringify([...runIds]));
-            }
-            assert.strictEqual(runFilters.length, 2);
-            const filter0 = JSON.parse(runFilters[0]);
-            const filter1 = JSON.parse(runFilters[1]);
-            assert.ok(filter0.includes("alpha"));
-            assert.ok(filter0.includes("bravo"));
-            assert.ok(filter1.includes("charlie"));
+            //
+            const batches = executor._createBatches(runs, 2);
+            assert.strictEqual(batches[0].index, 0);
+            assert.strictEqual(batches[0].firstRunId, "run1");
+            assert.strictEqual(batches[0].lastRunId, "run1");
+            assert.ok(batches[0].filter.startsWith("["));
+            assert.ok(batches[0].filter.endsWith("]"));
         });
     });
-    describe("worker names generation (conceptual)", () => {
-        /**
-         * Worker names follow the pattern: {adjective}-{noun}-{hex-suffix}
-         * This test verifies names are unique and well-formatted.
-         */
-        it("should generate unique worker names", () => {
-            // The actual implementation uses random adjectives, nouns, and hex suffix
-            // Here we verify the pattern is followed
-            const adjectives = ["swift", "nimble", "quick"];
-            const nouns = ["runner", "worker", "processor"];
-            const usedNames = new Set();
-            const names = [];
-            for (let index = 0; index < 10; index++) {
-                const adj = adjectives[index % adjectives.length];
-                const noun = nouns[index % nouns.length];
-                const suffix = index.toString(16).padStart(4, "0"); // Simulate hex suffix
-                const name = `${adj}-${noun}-${suffix}`;
-                // Verify uniqueness
-                assert.ok(!usedNames.has(name));
-                usedNames.add(name);
-                names.push(name);
-            }
-            assert.strictEqual(names.length, 10);
-            assert.strictEqual(new Set(names).size, 10); // All unique
+    describe("createWorkerConfigs", () => {
+        it("should create worker configs with proper arguments", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const batches = [
+                {
+                    index: 0,
+                    runIds: ["run1", "run2"],
+                    filter: '["run1","run2"]',
+                    firstRunId: "run1",
+                    lastRunId: "run2",
+                },
+            ];
+            //
+            const configs = executor._createWorkerConfigs(batches, ["worker-1"], "/path/to/cli.js", "/checkpoints", 5000);
+            assert.strictEqual(configs.length, 1);
+            assert.strictEqual(configs[0].index, 0);
+            assert.strictEqual(configs[0].name, "worker-1");
+            assert.strictEqual(configs[0].checkpointPath, "/checkpoints/checkpoint-worker-00.json");
+            assert.deepStrictEqual(configs[0].arguments, [
+                "/path/to/cli.js",
+                "evaluate",
+                "--phase=execute",
+                "--checkpoint-mode=file",
+                '--run-filter=["run1","run2"]',
+                "--timeout=5000",
+            ]);
         });
-    });
-    describe("spawn arguments (conceptual)", () => {
-        /**
-         * Verify that workers are spawned with correct arguments.
-         */
-        it("should include checkpoint-path argument for each worker", () => {
-            const checkpointDir = "/tmp/checkpoints";
-            const workerIndex = 2;
-            const checkpointPath = shardPath(checkpointDir, workerIndex);
-            assert.ok(checkpointPath.includes("checkpoint-worker-02.json"));
-            assert.ok(checkpointPath.includes(checkpointDir));
-        });
-        it("should include worker-index in environment variables", () => {
-            const workerIndex = 3;
-            const environmentVariable = `GRAPHBOX_WORKER_INDEX=${workerIndex}`;
-            assert.strictEqual(environmentVariable, "GRAPHBOX_WORKER_INDEX=3");
-        });
-        it("should include total-workers in environment variables", () => {
-            const totalWorkers = 5;
-            const environmentVariable = `GRAPHBOX_TOTAL_WORKERS=${totalWorkers}`;
-            assert.strictEqual(environmentVariable, "GRAPHBOX_TOTAL_WORKERS=5");
+        it("should not include timeout when timeoutMs is 0", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const batches = [
+                {
+                    index: 0,
+                    runIds: ["run1"],
+                    filter: '["run1"]',
+                    firstRunId: "run1",
+                    lastRunId: "run1",
+                },
+            ];
+            //
+            const configs = executor._createWorkerConfigs(batches, ["worker-1"], "/path/to/cli.js", "/checkpoints", 0);
+            assert.ok(!configs[0].arguments.includes("--timeout="));
+        });
+        it("should include proper environment variables", () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const batches = [
+                {
+                    index: 0,
+                    runIds: ["run1"],
+                    filter: '["run1"]',
+                    firstRunId: "run1",
+                    lastRunId: "run1",
+                },
+            ];
+            //
+            const configs = executor._createWorkerConfigs(batches, ["worker-1"], "/path/to/cli.js", "/checkpoints", 5000);
+            assert.strictEqual(configs[0].env.GRAPHBOX_WORKER_NAME, "worker-1");
+            assert.strictEqual(configs[0].env.GRAPHBOX_WORKER_INDEX, "0");
+            assert.strictEqual(configs[0].env.GRAPHBOX_TOTAL_WORKERS, "1");
+            assert.strictEqual(configs[0].env.GRAPHBOX_CHECKPOINT_DIR, "/checkpoints");
+            assert.strictEqual(configs[0].env.GRAPHBOX_CHECKPOINT_PATH, "/checkpoints/checkpoint-worker-00.json");
+            assert.strictEqual(configs[0].env.NODE_OPTIONS, "--max-old-space-size=4096");
         });
     });
-});
-describe("ParallelExecutorOptions", () => {
-    describe("defaults", () => {
-        it("should use default checkpoint directory when not specified", () => {
-            const options = {};
-            const checkpointDir = options.checkpointDir ?? "/default/path";
-            assert.strictEqual(checkpointDir, "/default/path");
+    describe("execute", () => {
+        it("should spawn workers for each batch", async () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [
+                createTestRun({ runId: "run1", caseId: "case1" }),
+                createTestRun({ runId: "run2", caseId: "case2" }),
+                createTestRun({ runId: "run3", caseId: "case3" }),
+                createTestRun({ runId: "run4", caseId: "case4" }),
+            ];
+            const config = createTestConfig(1000);
+            // Simulate worker exits
+            setTimeout(() => {
+                for (const spawned of mockSpawner.spawnedProcesses) {
+                    spawned.process.exit(0);
+                }
+            }, 10);
+            const result = await executor.execute(runs, [], [], config);
+            assert.strictEqual(mockSpawner.spawnedProcesses.length, mockSystemInfo.cpuCount);
+            assert.strictEqual(result.results.length, 0);
+            assert.strictEqual(result.errors.length, 0);
         });
-        it("should use custom checkpoint directory when specified", () => {
-            const options = { checkpointDir: "/custom/path" };
-            const checkpointDir = options.checkpointDir;
-            assert.strictEqual(checkpointDir, "/custom/path");
+        it("should use system defaults when options not provided", async () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [createTestRun({ runId: "run1", caseId: "case1" })];
+            // Simulate worker exit
+            setTimeout(() => {
+                for (const spawned of mockSpawner.spawnedProcesses) {
+                    spawned.process.exit(0);
+                }
+            }, 10);
+            await executor.execute(runs, [], [], createTestConfig(0));
+            assert.strictEqual(mockSpawner.spawnedProcesses.length, 1);
+            assert.strictEqual(mockSpawner.spawnedProcesses[0].command, mockSystemInfo.nodePath);
+        });
+        it("should log execution information", async () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [createTestRun({ runId: "run1", caseId: "case1" })];
+            // Simulate worker exit
+            setTimeout(() => {
+                for (const spawned of mockSpawner.spawnedProcesses) {
+                    spawned.process.exit(0);
+                }
+            }, 10);
+            await executor.execute(runs, [], [], createTestConfig(5000));
+            assert.ok(mockLogger.logs.some((log) => log.includes("Spawning")));
+            assert.ok(mockLogger.logs.some((log) => log.includes("Checkpoint directory")));
+            assert.ok(mockLogger.logs.some((log) => log.includes("timeout")));
+        });
+        it("should handle custom worker count", async () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [
+                createTestRun({ runId: "run1", caseId: "case1" }),
+                createTestRun({ runId: "run2", caseId: "case2" }),
+                createTestRun({ runId: "run3", caseId: "case3" }),
+            ];
+            // Simulate worker exits
+            setTimeout(() => {
+                for (const spawned of mockSpawner.spawnedProcesses) {
+                    spawned.process.exit(0);
+                }
+            }, 10);
+            const result = await executor.execute(runs, [], [], createTestConfig(0), { workers: 2 });
+            assert.strictEqual(mockSpawner.spawnedProcesses.length, 2);
+            assert.strictEqual(result.results.length, 0);
+        });
+        it("should return empty results by design", async () => {
+            const executor = new ParallelExecutor(mockLogger, mockSpawner, mockSystemInfo);
+            const runs = [createTestRun({ runId: "run1", caseId: "case1" })];
+            // Simulate worker exit
+            setTimeout(() => {
+                for (const spawned of mockSpawner.spawnedProcesses) {
+                    spawned.process.exit(0);
+                }
+            }, 10);
+            const result = await executor.execute(runs, [], [], createTestConfig(0));
+            assert.deepStrictEqual(result, { results: [], errors: [] });
         });
     });
 });