@dionlarson/playwright-orchestrator-file 1.3.0

package/README.md

@@ -0,0 +1,3 @@
+# Playwright Orchestrator local file plugin
+
+For more details visit @[playwright-orchestrator/core](https://www.npmjs.com/package/@playwright-orchestrator/core) page

package/dist/create-args.d.ts

@@ -0,0 +1,3 @@
+export interface CreateArgs {
+    directory: string;
+}

package/dist/create-args.js

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

package/dist/file-adapter.d.ts

@@ -0,0 +1,22 @@
+import { TestItem, Adapter, TestRunConfig, TestRunReport, ResultTestParams, SaveTestRunParams } from '@playwright-orchestrator/core';
+import { CreateArgs } from './create-args.js';
+export declare class FileAdapter extends Adapter {
+    private readonly dir;
+    constructor(createArgs: CreateArgs);
+    startShard(runId: string): Promise<TestRunConfig>;
+    finishShard(runId: string): Promise<void>;
+    getNextTest(runId: string, config: TestRunConfig): Promise<TestItem | undefined>;
+    failTest(params: ResultTestParams): Promise<void>;
+    finishTest(params: ResultTestParams): Promise<void>;
+    saveTestRun({ runId, testRun, args, historyWindow }: SaveTestRunParams): Promise<void>;
+    initialize(): Promise<void>;
+    dispose(): Promise<void>;
+    getReportData(runId: string): Promise<TestRunReport>;
+    private loadTestInfos;
+    private addResult;
+    private updateHistory;
+    private getRunIdFilePath;
+    private getRunConfigPath;
+    private getHistoryRunPath;
+    private getResultsRunPath;
+}

package/dist/file-adapter.js

@@ -0,0 +1,176 @@
+import { Adapter, RunStatus, TestStatus, } from '@playwright-orchestrator/core';
+import { lock } from 'proper-lockfile';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+export class FileAdapter extends Adapter {
+    dir;
+    constructor(createArgs) {
+        super();
+        this.dir = createArgs.directory;
+    }
+    async startShard(runId) {
+        const file = this.getRunConfigPath(runId);
+        const release = await lock(file, { retries: 100 });
+        const config = JSON.parse(await readFile(file, 'utf-8'));
+        if (config.status === RunStatus.Created || config.status === RunStatus.Finished) {
+            config.status = config.status === RunStatus.Created ? RunStatus.Run : RunStatus.RepeatRun;
+            config.updated = Date.now();
+            await writeFile(file, JSON.stringify(config));
+            if (config.status === RunStatus.RepeatRun) {
+                const results = JSON.parse(await readFile(this.getResultsRunPath(runId), 'utf-8'));
+                const failed = results
+                    .filter((r) => r.status === TestStatus.Failed)
+                    .map(({ file, testId, order, position, project, timeout }) => ({
+                    file,
+                    testId,
+                    order,
+                    position,
+                    project,
+                    timeout,
+                }));
+                const rest = results.filter((r) => r.status !== TestStatus.Failed);
+                await writeFile(this.getRunIdFilePath(runId), JSON.stringify(failed, null, 2));
+                await writeFile(this.getResultsRunPath(runId), JSON.stringify(rest, null, 2), 'utf-8');
+            }
+        }
+        await release();
+        return config;
+    }
+    async finishShard(runId) {
+        const file = this.getRunConfigPath(runId);
+        const release = await lock(file, { retries: 100 });
+        const config = JSON.parse(await readFile(file, 'utf-8'));
+        config.status = RunStatus.Finished;
+        config.updated = Date.now();
+        await writeFile(file, JSON.stringify(config));
+        await release();
+    }
+    async getNextTest(runId, config) {
+        const file = this.getRunIdFilePath(runId);
+        const release = await lock(file, { retries: 100 });
+        const tests = JSON.parse(await readFile(file, 'utf-8'));
+        const test = tests.pop();
+        await writeFile(file, JSON.stringify(tests, null, 2));
+        await release();
+        return test;
+    }
+    async failTest(params) {
+        await this.addResult(TestStatus.Failed, params);
+    }
+    async finishTest(params) {
+        await this.addResult(TestStatus.Passed, params);
+    }
+    async saveTestRun({ runId, testRun, args, historyWindow }) {
+        const file = this.getRunConfigPath(runId);
+        await mkdir(this.dir, { recursive: true });
+        const testConfig = {
+            ...testRun.config,
+            args: args,
+            status: 0,
+            updated: Date.now(),
+            historyWindow,
+        };
+        await writeFile(file, JSON.stringify(testConfig, null, 2));
+        let tests = this.transformTestRunToItems(testRun.testRun);
+        const testInfos = await this.loadTestInfos(tests);
+        tests = this.sortTests(tests, testInfos, { historyWindow, reverse: true });
+        await writeFile(this.getRunIdFilePath(runId), JSON.stringify(tests, null, 2));
+        await writeFile(this.getResultsRunPath(runId), '[]');
+    }
+    async initialize() {
+        return;
+    }
+    async dispose() { }
+    async getReportData(runId) {
+        const config = JSON.parse(await readFile(this.getRunConfigPath(runId), 'utf-8'));
+        const tests = JSON.parse(await readFile(this.getResultsRunPath(runId), 'utf-8'));
+        return {
+            runId,
+            config,
+            tests: tests.map(({ file, status, project, position, report }) => ({
+                averageDuration: report.ema,
+                duration: report.duration,
+                fails: report.fails,
+                title: report.title,
+                file,
+                position,
+                project,
+                status,
+                lastSuccessfulRunTimestamp: report.lastSuccessfulRunTimestamp,
+            })),
+        };
+    }
+    async loadTestInfos(test) {
+        const history = !existsSync(this.getHistoryRunPath())
+            ? {}
+            : JSON.parse(await readFile(this.getHistoryRunPath(), 'utf-8'));
+        for (const t of test) {
+            if (!history[t.testId]) {
+                history[t.testId] = {
+                    ema: 0,
+                    created: Date.now(),
+                    history: [],
+                };
+            }
+        }
+        await writeFile(this.getHistoryRunPath(), JSON.stringify(history, null, 2));
+        return new Map(Object.entries(history).map(([testId, { ema, history }]) => [
+            testId,
+            { ema, fails: history.filter((h) => h.status === TestStatus.Failed).length },
+        ]));
+    }
+    async addResult(status, params) {
+        const { runId, test, testResult } = params;
+        const file = this.getResultsRunPath(runId);
+        const release = await lock(file, { retries: 100 });
+        const results = JSON.parse(await readFile(file, 'utf-8'));
+        const testId = this.getTestId({ ...test, ...testResult });
+        const stats = await this.updateHistory(status, params);
+        results.push({
+            testId,
+            ...test,
+            status,
+            report: {
+                duration: testResult.duration,
+                ema: stats.ema,
+                fails: stats.history.filter((h) => h.status === TestStatus.Failed).length,
+                title: testResult.title,
+                lastSuccessfulRunTimestamp: stats.history.findLast((h) => h.status === TestStatus.Passed)?.updated,
+            },
+        });
+        await writeFile(file, JSON.stringify(results, null, 2));
+        await release();
+    }
+    async updateHistory(status, { test, testResult, config }) {
+        const file = this.getHistoryRunPath();
+        const release = await lock(file, { retries: 100 });
+        const history = JSON.parse(await readFile(file, 'utf-8'));
+        const id = this.getTestId({ ...test, ...testResult });
+        const item = history[id];
+        const itemCopy = structuredClone(item);
+        item.history.push({
+            duration: testResult.duration,
+            status,
+            updated: Date.now(),
+        });
+        if (item.history.length > config.historyWindow) {
+            item.history.splice(0, item.history.length - config.historyWindow);
+        }
+        item.ema = this.calculateEMA(testResult.duration, item.ema, config.historyWindow);
+        await writeFile(file, JSON.stringify(history, null, 2));
+        await release();
+        return itemCopy;
+    }
+    getRunIdFilePath(runId) {
+        return `${this.dir}/${runId}.queue.json`;
+    }
+    getRunConfigPath(runId) {
+        return `${this.dir}/${runId}.config.json`;
+    }
+    getHistoryRunPath() {
+        return `${this.dir}/tests.history.json`;
+    }
+    getResultsRunPath(runId) {
+        return `${this.dir}/${runId}.results.json`;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@commander-js/extra-typings';
+import { CreateArgs } from './create-args.js';
+import { FileAdapter } from './file-adapter.js';
+export declare function factory(args: CreateArgs): Promise<FileAdapter>;
+export declare function createOptions(command: Command): void;
+export declare const description = "Local file storage adapter";

package/dist/index.js

@@ -0,0 +1,9 @@
+import { Option } from '@commander-js/extra-typings';
+import { FileAdapter } from './file-adapter.js';
+export async function factory(args) {
+    return new FileAdapter(args);
+}
+export function createOptions(command) {
+    command.addOption(new Option('--directory <string>', 'Directory to store test run data').default('test-runs').env('DIRECTORY'));
+}
+export const description = 'Local file storage adapter';

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@dionlarson/playwright-orchestrator-file",
+    "version": "1.3.0",
+    "keywords": [],
+    "author": "Rostyslav Kudrevatykh",
+    "license": "Apache-2.0",
+    "description": "Playwright orchestrator local file plugin",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dionlarson/playwright-orchestrator-private.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@commander-js/extra-typings": "^13.0.0",
+        "@dionlarson/playwright-orchestrator-core": "^1.3.0",
+        "commander": "^13.0.0",
+        "proper-lockfile": "4.1.2"
+    },
+    "devDependencies": {
+        "@types/proper-lockfile": "^4.1.2"
+    },
+    "main": "dist/index.js",
+    "type": "module",
+    "exports": {
+        ".": {
+            "default": "./dist/index.js"
+        }
+    }
+}