@dionlarson/playwright-orchestrator-core 1.3.1 → 1.3.3

package/dist/playwright-tools/test-result-reporter.js

@@ -1,3 +1,4 @@
+import { writeFileSync } from 'node:fs';
 export default class TestResultReporter {
     testResults = [];
     testCases = [];
@@ -58,6 +59,13 @@ export default class TestResultReporter {
                 retry,
             })),
         };
-        console.log(JSON.stringify(output));
+        const outputFile = process.env.PLAYWRIGHT_ORCHESTRATOR_RESULT_FILE;
+        if (outputFile) {
+            writeFileSync(outputFile, JSON.stringify(output));
+        }
+        else {
+            // Fallback to stdout if no file specified
+            console.log(JSON.stringify(output));
+        }
     }
 }

package/dist/test-runner.d.ts

@@ -12,7 +12,6 @@ export declare class TestRunner {
     private runTestsUntilAvailable;
     private removePreviousReports;
     private runTest;
-    private parseTestResult;
     private buildParams;
     private createTempConfig;
 }

package/dist/test-runner.js

@@ -1,11 +1,22 @@
 import { createHash } from 'node:crypto';
-import child_process from 'node:child_process';
+import child_process, { spawn } from 'node:child_process';
 import { promisify } from 'node:util';
-import { rm, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { TestExecutionReporter } from './reporters/test-execution-reporter.js';
 import path from 'node:path';
 import * as uuid from 'uuid';
 const exec = promisify(child_process.exec);
+function spawnPassthrough(command, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, {
+            env,
+            shell: true,
+            stdio: 'inherit' // Full passthrough - all output goes directly to terminal
+        });
+        proc.on('close', (code) => resolve(code ?? 1));
+        proc.on('error', reject);
+    });
+}
 export class TestRunner {
     adapter;
     runId;
@@ -17,11 +28,14 @@ export class TestRunner {
         this.outputFolder = options.output;
     }
     async runTests() {
+        console.log(`[orchestrator] Starting shard for run ${this.runId}`);
         await this.removePreviousReports();
         const config = await this.adapter.startShard(this.runId);
+        console.log(`[orchestrator] Shard started. Workers: ${config.workers}, Config: ${config.configFile || 'default'}`);
         config.configFile = await this.createTempConfig(config.configFile);
         try {
             await this.runTestsUntilAvailable(config);
+            console.log(`[orchestrator] All tests completed, finishing shard`);
             await this.adapter.finishShard(this.runId);
             await this.adapter.dispose();
             this.reporter.printSummary();
@@ -33,9 +47,14 @@ export class TestRunner {
     }
     async runTestsUntilAvailable(config) {
         const runningTests = new Set();
+        console.log(`[orchestrator] Fetching first test...`);
         let next = await this.adapter.getNextTest(this.runId, config);
+        console.log(`[orchestrator] First test: ${next ? `[${next.project}] ${next.file}:${next.position}` : 'none available'}`);
+        let testCount = 0;
         while (next || runningTests.size > 0) {
             if (next && runningTests.size < config.workers) {
+                testCount++;
+                console.log(`[orchestrator] Running test #${testCount}: [${next.project}] ${next.file}:${next.position}`);
                 const testPromise = this.runTest(next, config).then(() => {
                     runningTests.delete(testPromise);
                 });
@@ -46,49 +65,61 @@ export class TestRunner {
                 await Promise.race(runningTests);
             }
         }
+        console.log(`[orchestrator] Finished ${testCount} tests`);
         await Promise.all(runningTests);
     }
     async removePreviousReports() {
         await rm(`./${this.outputFolder}`, { recursive: true, force: true });
+        await mkdir(`./${this.outputFolder}`, { recursive: true });
     }
     async runTest(test, config) {
         const testPosition = `${test.file}:${test.position}`;
         const testName = `[${test.project}] > ${testPosition}`;
         const testHash = createHash('md5').update(testName).digest('hex');
+        const resultFile = `${this.outputFolder}/${testHash}.result.json`;
+        const args = [testPosition, ...this.buildParams(test, config, testHash).split(' ')];
+        const env = {
+            ...process.env,
+            PLAYWRIGHT_BLOB_OUTPUT_FILE: `${this.outputFolder}/${testHash}.zip`,
+            PLAYWRIGHT_ORCHESTRATOR_RESULT_FILE: resultFile,
+        };
+        const fullCommand = `npx playwright test ${args.join(' ')}`;
+        const exitCode = await spawnPassthrough(fullCommand, env);
+        let testResult;
         try {
-            const run = exec(`npx playwright test ${testPosition} ${this.buildParams(test, config, testHash)}`, {
-                env: {
-                    ...process.env,
-                    PLAYWRIGHT_BLOB_OUTPUT_FILE: `${this.outputFolder}/${testHash}.zip`,
-                },
-            });
-            this.reporter.addTest(test, run);
-            const { stdout } = await run;
+            const resultJson = await readFile(resultFile, 'utf-8');
+            testResult = JSON.parse(resultJson);
+            await rm(resultFile, { force: true });
+        }
+        catch (e) {
+            console.error(`[orchestrator] Failed to read test result for [${test.project}] ${test.file}:${test.position}`, e);
+            throw e;
+        }
+        if (exitCode === 0) {
+            console.log(`[orchestrator] Test passed: [${test.project}] ${test.file}:${test.position}`);
+            this.reporter.finishTest(test);
             await this.adapter.finishTest({
                 runId: this.runId,
                 test,
-                testResult: this.parseTestResult(stdout),
+                testResult,
                 config,
             });
         }
-        catch (error) {
-            if (!error.stdout)
-                throw error;
+        else {
+            console.log(`[orchestrator] Test failed: [${test.project}] ${test.file}:${test.position}`);
+            this.reporter.failTest(test);
             await this.adapter.failTest({
                 runId: this.runId,
                 test,
-                testResult: this.parseTestResult(error.stdout),
+                testResult,
                 config,
             });
         }
     }
-    parseTestResult(stdout) {
-        return JSON.parse(stdout);
-    }
     buildParams(test, config, testHash) {
         const args = [...config.args];
         args.push('--workers', '1');
-        args.push('--reporter', 'blob,@dionlarson/playwright-orchestrator-core/test-result-reporter');
+        args.push('--reporter', 'list,blob,@dionlarson/playwright-orchestrator-core/test-result-reporter');
         args.push('--project', `"${test.project}"`);
         args.push('--output', `"${this.outputFolder}/${testHash}"`);
         if (config.configFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dionlarson/playwright-orchestrator-core",
-    "version": "1.3.1",
+    "version": "1.3.3",
     "description": "Core lib and cli for Playwright test orchestration",
     "keywords": [
         "playwright",