@dionlarson/playwright-orchestrator-core 1.3.0

package/dist/commands/init.js

@@ -0,0 +1,14 @@
+import { loadPlugins } from '../helpers/plugin.js';
+import { withErrorHandling } from './error-handler.js';
+import { program } from './program.js';
+export default async () => {
+    const command = program.command('init').description('Run initialize script for selected storage type.');
+    for await (const { factory, subCommand } of loadPlugins(command)) {
+        subCommand.action(withErrorHandling(async (options) => {
+            const adapter = await factory(options);
+            await adapter.initialize();
+            await adapter.dispose();
+            console.log('Storage initialized');
+        }));
+    }
+};

package/dist/commands/program.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@commander-js/extra-typings';
+export declare const program: Command<[], {}, {}>;

package/dist/commands/program.js

@@ -0,0 +1,17 @@
+import { Command } from '@commander-js/extra-typings';
+import init from './init.js';
+import run from './run.js';
+import create from './create.js';
+import createReport from './create-report.js';
+import { readFile } from 'node:fs/promises';
+export const program = new Command();
+const package_json = JSON.parse(await readFile('node_modules/@playwright-orchestrator/core/package.json', 'utf-8'));
+program
+    .name('playwright-orchestrator')
+    .description('CLI to orchestrate Playwright tests')
+    .version(package_json.version);
+await init();
+await run();
+await create();
+await createReport();
+program.parse();

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/dist/commands/run.js

@@ -0,0 +1,18 @@
+import { loadPlugins } from '../helpers/plugin.js';
+import { TestRunner } from '../test-runner.js';
+import { withErrorHandling } from './error-handler.js';
+import { program } from './program.js';
+export default async () => {
+    const command = program.command('run').description('Start test run shard');
+    for await (const { factory, subCommand } of loadPlugins(command)) {
+        subCommand
+            .requiredOption('--run-id <string>', 'Run id generated by create command')
+            .option('-o, --output <string>', 'Output folder for blob reports. Existing content is deleted before writing the new report.', 'blob-reports')
+            .action(withErrorHandling(async (options) => {
+            const adapter = await factory(options);
+            const runner = new TestRunner(options, adapter);
+            await runner.runTests();
+            console.log('Run completed');
+        }));
+    }
+};

package/dist/helpers/plugin.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@commander-js/extra-typings';
+import { STORAGES } from '../plugins-list.js';
+import { Adapter } from '../adapter.js';
+export type StorageType = (typeof STORAGES)[number];
+export declare function loadPluginModule(storage: string): Promise<{
+    factory: (options: any) => Promise<Adapter>;
+    createOptions: (command: Command) => void;
+    description?: string;
+} | undefined>;
+export declare function loadPlugins(command: Command<any>): AsyncGenerator<{
+    subCommand: Command<[], {}, {}>;
+    factory: (options: any) => Promise<Adapter>;
+}, void, unknown>;

package/dist/helpers/plugin.js

@@ -0,0 +1,23 @@
+import { STORAGES } from '../plugins-list.js';
+export async function loadPluginModule(storage) {
+    try {
+        const a = await import(`@playwright-orchestrator/${storage}`);
+        return a;
+    }
+    catch (error) {
+        return;
+    }
+}
+export async function* loadPlugins(command) {
+    for (const storage of STORAGES) {
+        const plugin = await loadPluginModule(storage);
+        if (plugin) {
+            const subCommand = command.command(storage);
+            if (plugin.description) {
+                subCommand.description(plugin.description);
+            }
+            plugin.createOptions(subCommand);
+            yield { subCommand, factory: plugin.factory };
+        }
+    }
+}

package/dist/helpers/reporter-tools.d.ts

@@ -0,0 +1,2 @@
+import { TestRunInfo } from '../types/test-info.js';
+export declare function loadRunInfo(args: string[]): Promise<TestRunInfo>;

package/dist/helpers/reporter-tools.js

@@ -0,0 +1,21 @@
+import child_process from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(child_process.exec);
+export async function loadRunInfo(args) {
+    const { stdout, stderr } = await exec(buildCommand(args), {
+        env: { ...process.env, NO_COLOR: '1' },
+    });
+    if (stderr) {
+        throw new Error(stderr);
+    }
+    // Extract JSON from stdout - skip any non-JSON lines (e.g., dotenvx logs)
+    const jsonMatch = stdout.match(/(\{[\s\S]*\})\s*$/);
+    if (!jsonMatch) {
+        throw new Error(`Failed to parse test run info. Output was: ${stdout}`);
+    }
+    return JSON.parse(jsonMatch[1]);
+}
+function buildCommand(args) {
+    // last param wins, so we need to put our reporter at the end
+    return `npx playwright test --list ${args.join(' ')} --reporter "@playwright-orchestrator/core/tests-info-reporter"`;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types/adapters.js';
+export * from './types/reporter.js';
+export * from './types/test-info.js';
+export * from './adapter.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types/adapters.js';
+export * from './types/reporter.js';
+export * from './types/test-info.js';
+export * from './adapter.js';

package/dist/playwright-tools/annotations.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ID_TYPE = void 0;
+exports.id = id;
+exports.ID_TYPE = '@playwright-orchestrator/id';
+function id(value) {
+    return { type: exports.ID_TYPE, description: value };
+}

package/dist/playwright-tools/annotations.d.cts

@@ -0,0 +1,3 @@
+import { TestDetailsAnnotation } from '@playwright/test';
+export declare const ID_TYPE = "@playwright-orchestrator/id";
+export declare function id(value: string): TestDetailsAnnotation;

package/dist/playwright-tools/run-builder.d.ts

@@ -0,0 +1,15 @@
+import { FullConfig, Suite, TestCase } from '@playwright/test/reporter';
+import { TestRunInfo } from '../types/test-info.js';
+export declare class RunBuilder {
+    private readonly testRun;
+    private config;
+    parseEntry(entry: TestCase | Suite): this;
+    parseConfig(config: FullConfig): this;
+    build(): TestRunInfo;
+    private parseSuitesHelper;
+    private tryParseEntry;
+    private isSerialSuite;
+    private getSuiteTimeout;
+    private getAnnotations;
+    private getFileTests;
+}

package/dist/playwright-tools/run-builder.js

@@ -0,0 +1,81 @@
+export class RunBuilder {
+    testRun = {};
+    config = undefined;
+    parseEntry(entry) {
+        this.parseSuitesHelper(entry);
+        return this;
+    }
+    parseConfig(config) {
+        this.config = {
+            workers: config.workers,
+            configFile: config.configFile,
+            projects: config.projects.map((project) => ({
+                name: project.name,
+                outputDir: project.outputDir,
+            })),
+        };
+        return this;
+    }
+    build() {
+        return structuredClone({
+            config: this.config,
+            testRun: this.testRun,
+        });
+    }
+    parseSuitesHelper(entry) {
+        if (this.tryParseEntry(entry)) {
+            return;
+        }
+        for (const item of entry.entries()) {
+            this.parseSuitesHelper(item);
+        }
+    }
+    tryParseEntry(entry) {
+        const [_, project, file] = entry.titlePath();
+        if (!file)
+            return false;
+        const fileTests = this.getFileTests(file);
+        const position = `${entry.location?.line}:${entry.location?.column}`;
+        // Use position:title as key to support parameterized tests at same location
+        const key = `${position}:${entry.title}`;
+        if (fileTests[key]) {
+            fileTests[key].projects.push(project);
+            return true;
+        }
+        // Check for serial mode using Playwright's internal _parallelMode property
+        const isSerial = entry.type !== 'test' && this.isSerialSuite(entry);
+        if (entry.type === 'test' || isSerial) {
+            if (!fileTests[key]) {
+                // For serial suites, sum up all test timeouts
+                const timeout = entry.type === 'test'
+                    ? entry.timeout
+                    : this.getSuiteTimeout(entry);
+                fileTests[key] = {
+                    timeout,
+                    projects: [project],
+                    annotations: this.getAnnotations(entry),
+                    title: entry.title,
+                };
+            }
+            return true;
+        }
+        return false;
+    }
+    isSerialSuite(suite) {
+        return suite._parallelMode === 'serial';
+    }
+    getSuiteTimeout(suite) {
+        return suite.allTests().reduce((sum, test) => sum + test.timeout, 0);
+    }
+    getAnnotations(entry) {
+        if (entry.type === 'test') {
+            return entry.annotations;
+        }
+        return entry.allTests()[0]?.annotations;
+    }
+    getFileTests(file) {
+        if (!this.testRun[file])
+            this.testRun[file] = {};
+        return this.testRun[file];
+    }
+}

package/dist/playwright-tools/run-info-reporter.d.ts

@@ -0,0 +1,4 @@
+import { FullConfig, Reporter, Suite } from '@playwright/test/reporter';
+export default class RunInfoReporter implements Reporter {
+    onBegin(config: FullConfig, suite: Suite): void;
+}

package/dist/playwright-tools/run-info-reporter.js

@@ -0,0 +1,7 @@
+import { RunBuilder } from './run-builder.js';
+export default class RunInfoReporter {
+    onBegin(config, suite) {
+        const testRunInfo = new RunBuilder().parseConfig(config).parseEntry(suite).build();
+        console.log(JSON.stringify(testRunInfo, null, 2));
+    }
+}

package/dist/playwright-tools/test-ats-analyzer.d.ts

@@ -0,0 +1,21 @@
+import { Suite, TestCase } from '@playwright/test/reporter';
+export declare class TestASTAnalyzer {
+    private readonly program;
+    private readonly typeChecker;
+    private readonly sourceFile;
+    private constructor();
+    static create(file?: string): TestASTAnalyzer | undefined;
+    suiteIsSerial(suite: Suite): boolean;
+    getTimeout(entry: TestCase | Suite): number;
+    private checkFileSerialStatement;
+    private isSerialStatement;
+    private getFunctionBodyStatements;
+    private extractCallStatementsTestFunc;
+    private extractTestCallStatements;
+    private isTestStatement;
+    private isSlowStatement;
+    private getTimeoutFromStatement;
+    private getNumberIdentifierValue;
+    private findTestTimeout;
+    private findNodeAtLocation;
+}

package/dist/playwright-tools/test-ats-analyzer.js

@@ -0,0 +1,173 @@
+import ts from 'typescript';
+const FILTER_PROPERTIES = ['setTimeout', 'slow', 'configure'];
+export class TestASTAnalyzer {
+    program;
+    typeChecker;
+    sourceFile;
+    constructor(file) {
+        this.program = ts.createProgram([file], {
+            allowJs: true,
+            noResolve: true, // Don't resolve imports - much faster
+        });
+        this.typeChecker = this.program.getTypeChecker();
+        this.sourceFile = this.program.getSourceFile(file);
+    }
+    static create(file) {
+        if (!file)
+            return;
+        return new TestASTAnalyzer(file);
+    }
+    suiteIsSerial(suite) {
+        if (!suite.location || (suite.location.line === 0 && suite.location.column == 0)) {
+            return this.checkFileSerialStatement();
+        }
+        const suiteNode = this.findNodeAtLocation(suite.location);
+        if (!suiteNode ||
+            !ts.isPropertyAccessExpression(suiteNode) ||
+            !ts.isIdentifier(suiteNode.expression) ||
+            !ts.isCallExpression(suiteNode.parent))
+            return false;
+        const testNodeText = suiteNode.expression.text;
+        var testStatements = this.extractTestCallStatements(this.extractCallStatementsTestFunc(suiteNode.parent), testNodeText);
+        // last statement wins
+        for (let i = testStatements.length - 1; i >= 0; i--) {
+            if (this.isSerialStatement(testStatements[i]))
+                return true;
+        }
+        return false;
+    }
+    getTimeout(entry) {
+        if (entry.type === 'test')
+            return this.findTestTimeout(entry);
+        return entry.entries().reduce((timeout, entry) => this.getTimeout(entry) + timeout, 0);
+    }
+    checkFileSerialStatement() {
+        return this.sourceFile.statements
+            .filter((statement) => ts.isExpressionStatement(statement))
+            .map((statement) => statement.expression)
+            .some((statement) => this.isSerialStatement(statement));
+    }
+    isSerialStatement(statement) {
+        const expression = statement.expression;
+        if (!ts.isPropertyAccessExpression(expression) ||
+            expression.name.text !== 'configure' ||
+            !ts.isPropertyAccessExpression(expression.expression) ||
+            expression.expression.name.text !== 'describe' ||
+            statement.arguments.length === 0)
+            return false;
+        const arg = statement.arguments[0];
+        return (ts.isObjectLiteralExpression(arg) &&
+            arg.properties.some((prop) => {
+                return (prop.name?.getText() === 'mode' &&
+                    ts.isPropertyAssignment(prop) &&
+                    ts.isStringLiteral(prop.initializer) &&
+                    prop.initializer.text === 'serial');
+            }));
+    }
+    getFunctionBodyStatements(node) {
+        if (ts.isFunctionLike(node)) {
+            const body = node.body;
+            // Handle block body (FunctionDeclaration, FunctionExpression, MethodDeclaration)
+            if (ts.isBlock(body)) {
+                return [...body.statements];
+            }
+            // Handle expression body (ArrowFunction)
+            if (ts.isExpression(body)) {
+                return [ts.factory.createExpressionStatement(body)];
+            }
+        }
+        // Handle function expressions in variable declarations
+        if (ts.isVariableDeclaration(node) && node.initializer) {
+            if (ts.isFunctionExpression(node.initializer) || ts.isArrowFunction(node.initializer)) {
+                return this.getFunctionBodyStatements(node.initializer);
+            }
+        }
+        return [];
+    }
+    extractCallStatementsTestFunc(node) {
+        return this.getFunctionBodyStatements(node.arguments.find((arg) => ts.isFunctionLike(arg)));
+    }
+    extractTestCallStatements(nodes, testNodeText) {
+        return nodes
+            .filter((statement) => ts.isExpressionStatement(statement) && this.isTestStatement(statement, testNodeText))
+            .map((statement) => statement.expression);
+    }
+    isTestStatement(statement, testNodeText) {
+        if (!ts.isCallExpression(statement.expression))
+            return false;
+        let node = statement.expression.getChildAt(0);
+        if (!ts.isPropertyAccessExpression(node) || !FILTER_PROPERTIES.includes(node.name.text))
+            return false;
+        while (!ts.isIdentifier(node) && node.getChildCount() > 0)
+            node = node.getChildAt(0);
+        return node.getText() === testNodeText;
+    }
+    isSlowStatement(statement) {
+        const expression = statement.expression;
+        const functionName = expression.getChildAt(expression.getChildCount() - 1);
+        return functionName.getText() === 'slow';
+    }
+    getTimeoutFromStatement(statement) {
+        const expression = statement.expression;
+        if (!ts.isCallExpression(statement) ||
+            statement.arguments.length === 0 ||
+            !ts.isPropertyAccessExpression(expression) ||
+            expression.name.text !== 'setTimeout')
+            return 0;
+        return this.getNumberIdentifierValue(statement.arguments[0]);
+    }
+    getNumberIdentifierValue(node) {
+        if (ts.isNumericLiteral(node))
+            return parseInt(node.text, 10);
+        if (ts.isIdentifier(node)) {
+            const symbol = this.typeChecker.getSymbolAtLocation(node);
+            if (!symbol)
+                return 0;
+            const declarations = symbol.declarations;
+            if (!declarations || declarations.length === 0)
+                return 0;
+            const declaration = declarations[0];
+            if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+                if (ts.isNumericLiteral(declaration.initializer)) {
+                    return parseInt(declaration.initializer.text, 10);
+                }
+            }
+        }
+        return 0;
+    }
+    findTestTimeout(test) {
+        const { location, timeout } = test;
+        const testNode = this.findNodeAtLocation(location);
+        if (!testNode || !ts.isIdentifier(testNode))
+            return timeout;
+        const testNodeText = testNode.text;
+        if (!ts.isCallExpression(testNode.parent))
+            return timeout;
+        var testStatements = this.extractTestCallStatements(this.extractCallStatementsTestFunc(testNode.parent), testNodeText);
+        // last statement wins
+        for (let i = testStatements.length - 1; i >= 0; i--) {
+            const statement = testStatements[i];
+            if (this.isSlowStatement(statement))
+                return timeout * 3;
+            const localTimeout = this.getTimeoutFromStatement(statement);
+            if (localTimeout)
+                return localTimeout;
+        }
+        return timeout;
+    }
+    findNodeAtLocation(location) {
+        let position = ts.getPositionOfLineAndCharacter(this.sourceFile, Math.max(0, location.line - 1), // ts using 0-based index location
+        Math.max(0, location.column - 1));
+        if (position > 0)
+            position -= 1;
+        const findSmallestContainingNode = (node) => {
+            for (const child of node.getChildren()) {
+                if (child.getStart() < position && position < child.getEnd()) {
+                    return findSmallestContainingNode(child);
+                }
+            }
+            return node;
+        };
+        return findSmallestContainingNode(this.sourceFile);
+    }
+}

package/dist/playwright-tools/test-result-reporter.d.ts

@@ -0,0 +1,11 @@
+import { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+export default class TestResultReporter implements Reporter {
+    private testResults;
+    private testCases;
+    private commonParent;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<{
+        status?: FullResult['status'];
+    } | undefined | void> | void;
+}

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

@@ -0,0 +1,63 @@
+export default class TestResultReporter {
+    testResults = [];
+    testCases = [];
+    commonParent;
+    onBegin(config, suite) {
+        const tests = suite.allTests();
+        if (tests.length > 1) {
+            const path = [];
+            let current = tests[0].parent;
+            while (current) {
+                path.push(current);
+                current = current.parent;
+            }
+            let lastCommonParent = path.length - 1;
+            for (const test of tests.slice(1)) {
+                current = test.parent;
+                while (test.parent !== this.commonParent) {
+                    const index = path.indexOf(current);
+                    if (index !== -1 && index < lastCommonParent) {
+                        lastCommonParent = index;
+                        break;
+                    }
+                    current = current?.parent;
+                }
+            }
+            this.commonParent = path[lastCommonParent];
+        }
+    }
+    onTestEnd(test, result) {
+        this.testResults.push(result);
+        this.testCases.push(test);
+    }
+    onEnd(result) {
+        const { status, error, retry } = this.testResults.at(-1);
+        const duration = this.testResults.reduce((acc, { duration }) => acc + duration, 0);
+        const existingAnnotations = new Set();
+        const annotations = this.testCases
+            .flatMap((test) => test.annotations)
+            .filter(({ type, description }) => {
+            if (existingAnnotations.has(type + (description ?? '')))
+                return false;
+            existingAnnotations.add(type + (description ?? ''));
+            return true;
+        });
+        const { title } = this.commonParent ?? this.testCases.at(-1);
+        const output = {
+            status,
+            duration,
+            error,
+            title,
+            annotations,
+            tests: this.testResults.map(({ status, duration, error }, i) => ({
+                status,
+                duration,
+                error,
+                annotations: this.testCases[i].annotations,
+                title: this.testCases[i].title,
+                retry,
+            })),
+        };
+        console.log(JSON.stringify(output));
+    }
+}

package/dist/plugins-list.d.ts

@@ -0,0 +1 @@
+export declare const STORAGES: readonly ["file", "dynamo-db", "pg", "mysql", "mongo"];

package/dist/plugins-list.js

@@ -0,0 +1,2 @@
+// before renaming this file fix GHA workflow
+export const STORAGES = ['file', 'dynamo-db', 'pg', 'mysql', 'mongo'];

package/dist/reporters/gha-reporter.d.ts

@@ -0,0 +1,2 @@
+import { TestRunReport } from '../types/reporter.js';
+export declare function ghaReporter(data: TestRunReport): Promise<void>;

package/dist/reporters/gha-reporter.js

@@ -0,0 +1,42 @@
+import * as core from '@actions/core';
+import { TestStatus } from '../types/test-info.js';
+import { calculateTrend, formatDuration } from './helpers.js';
+export async function ghaReporter(data) {
+    const { config, runId, tests } = data;
+    await core.summary
+        .addHeading(`🏃 Test run summary`)
+        .addDetails('Run config', buildConfigData(data))
+        .addTable([
+        [
+            { data: '', header: true },
+            { data: '📁 Project', header: true },
+            { data: '📝 Title', header: true },
+            { data: '⏱️ Duration', header: true },
+            { data: '📊 Trend', header: true },
+            { data: '✨ Last successful run', header: true },
+            { data: '❌ Fails', header: true },
+        ],
+        ...tests.map((test) => {
+            const { percentage, trendIcon } = calculateTrend(test);
+            return [
+                test.status === TestStatus.Passed ? '✅' : '❌',
+                test.project,
+                test.title,
+                formatDuration(test.duration),
+                `${trendIcon} ${percentage}%`,
+                test.lastSuccessfulRunTimestamp
+                    ? new Date(test.lastSuccessfulRunTimestamp).toLocaleString()
+                    : 'N/A',
+                test.fails.toString(),
+            ];
+        }),
+    ])
+        .write();
+}
+function buildConfigData({ config, runId }) {
+    return `
+<table>
+<tr><td>Run Id</td><td>${runId}</td></tr>    
+<tr><td>History Window</td><td>${config.historyWindow}</td></tr>    
+</table>`;
+}

package/dist/reporters/helpers.d.ts

@@ -0,0 +1,7 @@
+import { TestReport } from '../types/reporter.js';
+export declare function calculateTrend(test: TestReport): {
+    trend: number;
+    trendIcon: string;
+    percentage: string;
+};
+export declare function formatDuration(ms: number): string;

package/dist/reporters/helpers.js

@@ -0,0 +1,21 @@
+export function calculateTrend(test) {
+    const trend = test.averageDuration - test.duration;
+    return {
+        trend,
+        trendIcon: trend > 0 ? '📈' : '📉',
+        percentage: ((trend / test.averageDuration) * 100).toFixed(1),
+    };
+}
+export function formatDuration(ms) {
+    const seconds = Math.floor((ms / 1000) % 60);
+    const minutes = Math.floor((ms / (1000 * 60)) % 60);
+    const hours = Math.floor((ms / (1000 * 60 * 60)) % 24);
+    const parts = [];
+    if (hours)
+        parts.push(`${hours} ${hours === 1 ? 'h' : 'hs'}`);
+    if (minutes)
+        parts.push(`${minutes} ${minutes === 1 ? 'min' : 'mins'}`);
+    if (parts.length === 0 || seconds)
+        parts.push(`${seconds} ${seconds === 1 ? 'sec' : 'secs'}`);
+    return parts.join(', ');
+}

package/dist/reporters/reporter-factory.d.ts

@@ -0,0 +1,4 @@
+import { TestRunReport } from '../types/reporter.js';
+export declare const REPORTERS: readonly ["json", "gha"];
+export type ReporterType = (typeof REPORTERS)[number];
+export declare function generateReport(data: TestRunReport, type: ReporterType): Promise<void>;

package/dist/reporters/reporter-factory.js

@@ -0,0 +1,14 @@
+import { ghaReporter } from './gha-reporter.js';
+export const REPORTERS = ['json', 'gha'];
+export async function generateReport(data, type) {
+    switch (type) {
+        case 'json':
+            console.log(JSON.stringify(data));
+            break;
+        case 'gha':
+            await ghaReporter(data);
+            break;
+        default:
+            console.error('Unknown reporter type');
+    }
+}

package/dist/reporters/test-execution-reporter.d.ts

@@ -0,0 +1,17 @@
+import { TestItem } from '../types/adapters.js';
+export declare class TestExecutionReporter {
+    private readonly failedTests;
+    private readonly succeedTests;
+    private readonly runningTests;
+    private readonly spinner;
+    private spinnerIndex;
+    private spinnerInterval?;
+    constructor();
+    addTest(test: TestItem, run: Promise<any>): void;
+    finishTest(test: TestItem): void;
+    failTest(test: TestItem): void;
+    private printTestResult;
+    printSummary(): void;
+    private redrawRunning;
+    private getKey;
+}