@dionlarson/playwright-orchestrator-core 1.3.0

package/dist/reporters/test-execution-reporter.js

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { cursorSavePosition, cursorRestorePosition, cursorLeft, cursorDown, eraseDown } from 'ansi-escapes';
+export class TestExecutionReporter {
+    failedTests = [];
+    succeedTests = [];
+    runningTests = [];
+    spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    spinnerIndex = 0;
+    spinnerInterval;
+    constructor() {
+        // disable spinner in CI
+        if (process.env.CI)
+            return;
+        process.stdout.write(cursorSavePosition);
+        this.spinnerInterval = setInterval(() => {
+            this.spinnerIndex = (this.spinnerIndex + 1) % this.spinner.length;
+            this.redrawRunning();
+        }, 80);
+    }
+    addTest(test, run) {
+        run.then(() => this.finishTest(test)).catch(() => this.failTest(test));
+        this.runningTests.push(test);
+        this.redrawRunning(true);
+    }
+    finishTest(test) {
+        this.succeedTests.push(test);
+        const message = `${chalk.green('✓')} ${this.getKey(test)}`;
+        this.printTestResult(test, message);
+    }
+    failTest(test) {
+        this.failedTests.push(test);
+        const message = `${chalk.red('✗')} ${this.getKey(test)}`;
+        this.printTestResult(test, message);
+    }
+    printTestResult(test, message) {
+        this.runningTests.splice(this.runningTests.indexOf(test), 1);
+        if (process.env.CI) {
+            console.log(message);
+        }
+        else {
+            process.stdout.write(cursorRestorePosition);
+            process.stdout.write(eraseDown);
+            process.stdout.write(message);
+            process.stdout.write('\n');
+            process.stdout.write(cursorSavePosition);
+            this.redrawRunning(true);
+        }
+    }
+    printSummary() {
+        clearTimeout(this.spinnerInterval);
+        process.stdout.write(cursorRestorePosition);
+        process.stdout.write(eraseDown);
+        const lines = [
+            chalk.green(`Succeed: ${this.succeedTests.length}`),
+            chalk.red(`Failed: ${this.failedTests.length}:`),
+            ...this.failedTests.map((test) => chalk.red(`  - ${this.getKey(test)}`)),
+        ];
+        console.log(boxen(lines.join('\n'), {
+            title: 'Test shard results',
+            titleAlignment: 'left',
+            borderColor: 'yellow',
+            padding: 1,
+        }));
+    }
+    redrawRunning(full = false) {
+        if (process.env.CI)
+            return;
+        process.stdout.write(cursorRestorePosition);
+        for (let i = 0; i < this.runningTests.length; i++) {
+            const spinner = chalk.yellow(process.env.CI ? '*' : this.spinner[this.spinnerIndex]);
+            if (full) {
+                process.stdout.write(`${spinner} ${this.getKey(this.runningTests[i])}\n`);
+            }
+            else {
+                process.stdout.write(spinner);
+                process.stdout.write(cursorLeft);
+                process.stdout.write(cursorDown());
+            }
+        }
+    }
+    getKey(test) {
+        return `[${test.project}] ${test.file}:${test.position}`;
+    }
+}

package/dist/test-runner.d.ts

@@ -0,0 +1,18 @@
+import { Adapter } from './adapter.js';
+export declare class TestRunner {
+    private readonly adapter;
+    private readonly runId;
+    private readonly outputFolder;
+    private readonly reporter;
+    constructor(options: {
+        runId: string;
+        output: string;
+    }, adapter: Adapter);
+    runTests(): Promise<void>;
+    private runTestsUntilAvailable;
+    private removePreviousReports;
+    private runTest;
+    private parseTestResult;
+    private buildParams;
+    private createTempConfig;
+}

package/dist/test-runner.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+import child_process from 'node:child_process';
+import { promisify } from 'node:util';
+import { 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);
+export class TestRunner {
+    adapter;
+    runId;
+    outputFolder;
+    reporter = new TestExecutionReporter();
+    constructor(options, adapter) {
+        this.adapter = adapter;
+        this.runId = options.runId;
+        this.outputFolder = options.output;
+    }
+    async runTests() {
+        await this.removePreviousReports();
+        const config = await this.adapter.startShard(this.runId);
+        config.configFile = await this.createTempConfig(config.configFile);
+        try {
+            await this.runTestsUntilAvailable(config);
+            await this.adapter.finishShard(this.runId);
+            await this.adapter.dispose();
+            this.reporter.printSummary();
+        }
+        finally {
+            if (config.configFile)
+                await rm(config.configFile);
+        }
+    }
+    async runTestsUntilAvailable(config) {
+        const runningTests = new Set();
+        let next = await this.adapter.getNextTest(this.runId, config);
+        while (next || runningTests.size > 0) {
+            if (next && runningTests.size < config.workers) {
+                const testPromise = this.runTest(next, config).then(() => {
+                    runningTests.delete(testPromise);
+                });
+                runningTests.add(testPromise);
+                next = await this.adapter.getNextTest(this.runId, config);
+            }
+            else {
+                await Promise.race(runningTests);
+            }
+        }
+        await Promise.all(runningTests);
+    }
+    async removePreviousReports() {
+        await rm(`./${this.outputFolder}`, { recursive: true, force: true });
+    }
+    async runTest(test, config) {
+        const testPosition = `${test.file}:${test.position}`;
+        const testName = `[${test.project}] > ${testPosition}`;
+        const testHash = createHash('md5').update(testName).digest('hex');
+        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;
+            await this.adapter.finishTest({
+                runId: this.runId,
+                test,
+                testResult: this.parseTestResult(stdout),
+                config,
+            });
+        }
+        catch (error) {
+            if (!error.stdout)
+                throw error;
+            await this.adapter.failTest({
+                runId: this.runId,
+                test,
+                testResult: this.parseTestResult(error.stdout),
+                config,
+            });
+        }
+    }
+    parseTestResult(stdout) {
+        return JSON.parse(stdout);
+    }
+    buildParams(test, config, testHash) {
+        const args = [...config.args];
+        args.push('--workers', '1');
+        args.push('--reporter', 'blob,@playwright-orchestrator/core/test-result-reporter');
+        args.push('--project', `"${test.project}"`);
+        args.push('--output', `"${this.outputFolder}/${testHash}"`);
+        if (config.configFile) {
+            args.push('--config', `"${config.configFile}"`);
+        }
+        return args.join(' ');
+    }
+    async createTempConfig(file) {
+        if (!file)
+            return;
+        // Remove webServer from the config. Not supported in the orchestrator
+        const content = `
+        import config from '${path.resolve(file)}';
+        delete config.webServer;
+        export default config;`;
+        const tempFile = `.playwright-${uuid.v7()}.config.tmp.ts`;
+        await writeFile(tempFile, content);
+        return tempFile;
+    }
+}

package/dist/types/adapters.d.ts

@@ -0,0 +1,39 @@
+import { TestReportResult } from './reporter.js';
+import { TestRunConfig, TestRunInfo } from './test-info.js';
+import { TestDetailsAnnotation } from '@playwright/test';
+export interface TestItem {
+    file: string;
+    position: string;
+    project: string;
+    order: number;
+    timeout: number;
+}
+export interface ReporterTestItem extends TestItem {
+    testId: string;
+}
+export interface ResultTestParams {
+    runId: string;
+    test: TestItem;
+    testResult: TestReportResult;
+    config: TestRunConfig;
+}
+export interface SaveTestRunParams {
+    runId: string;
+    testRun: TestRunInfo;
+    args: string[];
+    historyWindow: number;
+}
+export interface GetTestIdParams {
+    project: string;
+    file: string;
+    title: string;
+    annotations: TestDetailsAnnotation[];
+}
+export interface SortTestsOptions {
+    historyWindow: number;
+    reverse?: boolean;
+}
+export interface TestSortItem {
+    ema: number;
+    fails: number;
+}

package/dist/types/adapters.js

@@ -0,0 +1 @@
+export {};

package/dist/types/reporter.d.ts

@@ -0,0 +1,32 @@
+import { TestResult } from '@playwright/test/reporter';
+import { TestDetailsAnnotation } from '@playwright/test';
+import { TestRunConfig, TestStatus } from './test-info.js';
+export interface TestReport {
+    file: string;
+    position: string;
+    project: string;
+    status: TestStatus;
+    duration: number;
+    averageDuration: number;
+    title: string;
+    fails: number;
+    lastSuccessfulRunTimestamp?: number;
+}
+export interface TestRunReport {
+    runId: string;
+    config: TestRunConfig;
+    tests: TestReport[];
+}
+export interface BaseTestResult {
+    annotations: TestDetailsAnnotation[];
+    duration: number;
+    title: string;
+    status: TestResult['status'];
+}
+export interface TestReportResult extends BaseTestResult {
+    error: TestResult['error'];
+    tests: TestInfoResult[];
+}
+export interface TestInfoResult extends BaseTestResult {
+    retry: number;
+}

package/dist/types/reporter.js

@@ -0,0 +1 @@
+export {};

package/dist/types/test-info.d.ts

@@ -0,0 +1,42 @@
+import { TestDetailsAnnotation } from '@playwright/test';
+export interface Project {
+    name: string;
+    outputDir: string;
+}
+export interface TestConfig {
+    workers: number;
+    configFile?: string;
+    projects: Project[];
+}
+export interface TestRunConfig extends TestConfig {
+    historyWindow: number;
+    args: string[];
+    status: RunStatus;
+    updated: number;
+}
+export interface TestRunInfo {
+    testRun: TestRun;
+    config: TestConfig;
+}
+export interface TestRun {
+    [file: string]: {
+        [position: string]: {
+            timeout: number;
+            projects: string[];
+            title: string;
+            annotations: TestDetailsAnnotation[];
+        };
+    };
+}
+export declare enum RunStatus {
+    Created = 0,
+    Run = 10,
+    RepeatRun = 20,
+    Finished = 30
+}
+export declare enum TestStatus {
+    Ready = 0,
+    Ongoing = 10,
+    Failed = 20,
+    Passed = 30
+}

package/dist/types/test-info.js

@@ -0,0 +1,14 @@
+export var RunStatus;
+(function (RunStatus) {
+    RunStatus[RunStatus["Created"] = 0] = "Created";
+    RunStatus[RunStatus["Run"] = 10] = "Run";
+    RunStatus[RunStatus["RepeatRun"] = 20] = "RepeatRun";
+    RunStatus[RunStatus["Finished"] = 30] = "Finished";
+})(RunStatus || (RunStatus = {}));
+export var TestStatus;
+(function (TestStatus) {
+    TestStatus[TestStatus["Ready"] = 0] = "Ready";
+    TestStatus[TestStatus["Ongoing"] = 10] = "Ongoing";
+    TestStatus[TestStatus["Failed"] = 20] = "Failed";
+    TestStatus[TestStatus["Passed"] = 30] = "Passed";
+})(TestStatus || (TestStatus = {}));

package/package.json

@@ -0,0 +1,81 @@
+{
+    "name": "@dionlarson/playwright-orchestrator-core",
+    "version": "1.3.0",
+    "description": "Core lib and cli for Playwright test orchestration",
+    "keywords": [
+        "playwright",
+        "testing",
+        "automation",
+        "orchestration",
+        "e2e"
+    ],
+    "author": "Rostyslav Kudrevatykh",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dionlarson/playwright-orchestrator-private.git"
+    },
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "bin": {
+        "playwright-orchestrator": "./dist/cli.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@actions/core": "^1.11.1",
+        "@commander-js/extra-typings": "^13.0.0",
+        "ansi-escapes": "^7.0.0",
+        "chalk": "^5.4.1",
+        "commander": "^13.0.0",
+        "boxen": "^8.0.1",
+        "typescript": "^5.0.0",
+        "uuid": "^11.0.3"
+    },
+    "devDependencies": {},
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "type": "module",
+    "main": "dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./cli": "./dist/cli.js",
+        "./package.json": "./package.json",
+        "./tests-info-reporter": "./dist/playwright-tools/run-info-reporter.js",
+        "./test-result-reporter": "./dist/playwright-tools/test-result-reporter.js",
+        "./annotations": "./dist/playwright-tools/annotations.cjs"
+    },
+    "peerDependencies": {
+        "@playwright/test": "^1.44.0",
+        "@dionlarson/playwright-orchestrator-file": "^1.0.0",
+        "@dionlarson/playwright-orchestrator-dynamo-db": "^1.0.0",
+        "@dionlarson/playwright-orchestrator-pg": "^1.0.0",
+        "@dionlarson/playwright-orchestrator-mysql": "^1.0.0",
+        "@dionlarson/playwright-orchestrator-mongo": "^1.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@dionlarson/playwright-orchestrator-file": {
+            "optional": true
+        },
+        "@dionlarson/playwright-orchestrator-dynamo-db": {
+            "optional": true
+        },
+        "@dionlarson/playwright-orchestrator-pg": {
+            "optional": true
+        },
+        "@dionlarson/playwright-orchestrator-mysql": {
+            "optional": true
+        },
+        "@dionlarson/playwright-orchestrator-mongo": {
+            "optional": true
+        }
+    },
+    "scripts": {
+        "prepare": "cp ../../README.md ./ && cp ../../LICENSE.md ./"
+    }
+}