@apica-io/asm-playwright-runner 1.0.0-dev.1

package/src/runner.ts

@@ -0,0 +1,272 @@
+import fs from "fs";
+import path from "path";
+import {Browser, BrowserContext, chromium, firefox, Page, webkit} from "playwright";
+import {actionRegistry} from "./actions";
+import {BrowserType, ResultDir, RunnerConfig, ScriptType} from "./model/runnerConfig";
+import {prepareTraceModel, zipResources} from "./lib/parser";
+import {getLogger, Logger} from "log4js";
+import {spawn} from "node:child_process";
+import {collectTraceFiles, loadFlow} from "./lib/helper";
+
+const RESULT_FILE: string = "trace-model.json"
+
+export class PlaywrightRunner {
+    private logger: Logger;
+    private browser: Browser | null = null;
+    private context: BrowserContext | null = null;
+    private page: Page | null = null;
+    private options: RunnerConfig | null = null;
+
+    public constructor() {
+        this.logger = getLogger(PlaywrightRunner.name);
+    }
+
+    public async init(collectionPath: string, options: RunnerConfig): Promise<void> {
+        this.logger.info("Initializing PlaywrightRunner...");
+
+        // Normalize resultDir
+        if (!options.resultDir || options.resultDir.trim() === "") {
+            options.resultDir = ResultDir.BASE_DIR;
+            this.logger.debug("No resultDir specified. Defaulting to 'results'.");
+        }
+        this.options = options;
+
+        // Detect script type
+        this.options.scriptType = await this.detectScriptType(collectionPath);
+        this.options.isValidScript = this.options.scriptType !== undefined;
+
+        if (!this.options.isValidScript) {
+            this.logger.warn("Script is not valid.");
+            process.exit(9);
+        }
+
+        // Skip browser setup for Playwright Test files
+        if (this.options.scriptType === ScriptType.PLAYWRIGHT_TEST) {
+            this.logger.info("Playwright Test detected. Skipping manual browser setup.");
+            return;
+        }
+
+        // Browser setup
+        const browserType = options.browser || BrowserType.CHROMIUM;
+        const headless = options.headless;
+        this.logger.debug(`Browser type: ${browserType}, headless: ${headless}`);
+
+        this.browser = await (
+            browserType === BrowserType.FIREFOX ? firefox :
+                browserType === BrowserType.WEBKIT ? webkit :
+                    chromium
+        ).launch({
+            headless,
+            ...(options.chromiumPath && {executablePath: options.chromiumPath})
+        });
+        this.logger.info("Browser launched successfully.");
+
+        let headers: Record<string, string> = {};
+        if (options.extraHTTPHeaders) {
+            try {
+                headers = JSON.parse(options.extraHTTPHeaders);
+            } catch (err) {
+                this.logger.warn("Invalid JSON for extraHTTPHeaders, ignoring:", options.extraHTTPHeaders);
+                headers = {}; // fallback to empty headers
+            }
+        }
+
+        this.context = await this.browser.newContext({
+            ignoreHTTPSErrors: true,
+            ...(options.sslClientCert && {
+                clientCert: {
+                    cert: options.sslClientCert,
+                    key: options.sslClientKey,
+                    passphrase: options.sslClientPassphrase
+                }
+            }),
+            extraHTTPHeaders: headers,
+        });
+        this.logger.info("Browser context created.");
+
+        await this.context.tracing.start({snapshots: true, screenshots: true, sources: true});
+        this.logger.info("Tracing started (snapshots, screenshots, sources enabled).");
+
+        this.page = await this.context.newPage();
+
+        // @ts-ignore
+        if (this.options?.scriptType != ScriptType.PLAYWRIGHT_TEST && this.options.timeout != null) {
+            this.page.setDefaultTimeout(Number(this.options.timeout));
+        }
+
+        this.logger.info("New page created.");
+    }
+
+    public async run(collectionPath: string, options: RunnerConfig): Promise<void> {
+        this.logger.info(`Running collection: ${collectionPath}`);
+
+        // Default trace path(s)
+        let tracePaths: string[] = [
+            options.resultDir
+                ? path.join(options.resultDir, "trace.zip")
+                : "trace.zip"
+        ];
+
+        switch (this.options?.scriptType) {
+            case ScriptType.JSON: {
+                const flow = loadFlow(collectionPath);
+                this.logger.info(`Loaded flow: ${flow.name} with ${flow.steps.length} steps`);
+
+                for (const [index, step] of flow.steps.entries()) {
+                    const handler = actionRegistry[step.action];
+                    this.logger.debug(`Executing step ${index}: action=${step.action}`);
+
+                    try {
+                        if (!handler) this.logger.error(`Unknown action: ${step.action}`);
+                        if (!this.page) {
+                            this.logger.error("Page not initialized. Did you call init()?");
+                            process.exit(9);
+                        }
+                        await handler(this.page, step);
+                    } catch (err: any) {
+                        this.logger.error(`Step ${index} failed: ${err.message}`, err);
+                    }
+                }
+                break;
+            }
+
+            case ScriptType.PLAYWRIGHT: {
+                this.logger.info("Detected plain Playwright script with default export.");
+                const mod = await import(path.resolve(collectionPath));
+                const fn = mod.default;
+                if (typeof fn !== "function") {
+                    throw new Error("Script does not export a default function");
+                }
+                try {
+                    await fn(this.page!);
+                    this.logger.info("Script execution finished.");
+                } catch (err: any) {
+                    this.logger.error(`Script execution failed: ${err.message}`);
+                }
+                break;
+            }
+
+            case ScriptType.PLAYWRIGHT_TEST: {
+                this.logger.info("Detected Playwright Test file. Running via CLI...");
+
+                const args: any[] = [
+                    "playwright",
+                    "test",
+                    collectionPath,
+                    "--browser", options.browser || BrowserType.CHROMIUM,
+                    "--output", options.resultDir || "results",
+                    "--trace", "on"
+                ];
+                if (options.timeout != null) args.push("--timeout", options.timeout);
+                if (!options.headless) args.push("--headed");
+                // if (options.verbose) args.push("--verbose");
+
+                this.logger.debug(`Spawning Playwright CLI: npx ${args.join(" ")}`);
+
+                await new Promise<void>((resolve) => {
+                    const proc = spawn("npx", args, {stdio: "inherit", shell: true});
+                    proc.on("close", (code) => {
+                        if (code === 0) {
+                            this.logger.info("Playwright Test finished successfully.");
+                        } else {
+                            this.logger.error(`Playwright Test exited with code ${code}`);
+                        }
+
+                        tracePaths = collectTraceFiles(options.resultDir || "results");
+                        resolve();
+                    });
+                });
+                break;
+            }
+
+            default:
+                this.logger.error("Unsupported or invalid script type.");
+                process.exit(9);
+        }
+
+        this.logger.info("Stopping tracing...");
+        await this.traceProcess(tracePaths);
+    }
+
+    private async traceProcess(tracePaths: string[]): Promise<void> {
+        if (!tracePaths?.length) {
+            this.logger.warn("No trace paths provided.");
+            return;
+        }
+
+        // Only stop tracing if this.context is active and we’re handling a live run
+        if (this.context && this.options?.scriptType != ScriptType.PLAYWRIGHT_TEST) {
+            await this.context.tracing.stop({
+                path: tracePaths[0]
+            });
+            this.logger.info(`Trace saved to ${tracePaths}`);
+        }
+
+        const models: Record<string, any> = {};
+
+        for (const tracePath of tracePaths) {
+            try {
+                this.logger.info(`Parsing trace: ${tracePath}`);
+                const traceModel = await prepareTraceModel(tracePath, this.options?.logLevel);
+                const runName = path.basename(path.dirname(tracePath));
+                models[runName] = traceModel;
+
+                const individualPath = path.join(path.dirname(tracePath), RESULT_FILE);
+
+                fs.writeFileSync(individualPath, JSON.stringify({"__self": traceModel}, null, 2), "utf-8");
+                this.logger.debug(`Individual trace model written to ${individualPath}`);
+            } catch (err: any) {
+                this.logger.error(`Failed to process trace ${tracePath}: ${err.message}`, err);
+            }
+        }
+
+        // Write combined model if more than one trace
+        if (this.options?.scriptType == ScriptType.PLAYWRIGHT_TEST) {
+            const combinedPath = this.options?.resultDir
+                ? path.join(this.options.resultDir, RESULT_FILE)
+                : RESULT_FILE;
+
+            fs.writeFileSync(combinedPath, JSON.stringify(models, null, 2), "utf-8");
+            this.logger.info(`Combined trace model written to ${combinedPath}`);
+        }
+
+        const resourceDir = this.options?.resultDir ?? ResultDir.BASE_DIR;
+        const finalZipPath = path.join(resourceDir, `artifacts.zip`);
+        await zipResources(finalZipPath, path.join(resourceDir, ResultDir.SCREENSHOT), path.join(resourceDir, ResultDir.SOURCE));
+
+        if(this.options?.returnResult){
+            console.log(JSON.stringify(models));
+        }
+    }
+
+    private async detectScriptType(collectionPath: string): Promise<ScriptType | undefined> {
+        try {
+            const mod = await import(path.resolve(collectionPath));
+            if (typeof mod.default === "function") {
+                this.logger.debug("Detected plain Playwright script (default export).");
+                return ScriptType.PLAYWRIGHT;
+            }
+        } catch {
+            this.logger.debug("Dynamic import failed, falling back to file content check.");
+        }
+
+        if (collectionPath.endsWith(".json")) {
+            this.logger.debug("Detected JSON flow.");
+            return ScriptType.JSON;
+        }
+
+        const fileContent = fs.readFileSync(collectionPath, "utf-8");
+        if (fileContent.includes("test(")) {
+            this.logger.debug("Detected Playwright Test file.");
+            return ScriptType.PLAYWRIGHT_TEST;
+        }
+
+        return undefined;
+    }
+
+    public async close(): Promise<void> {
+        this.logger.info("Closing browser...");
+        await this.browser?.close();
+        this.logger.info("Browser closed.");
+    }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "rootDir": "src",
+    "strict": true,
+    "noImplicitAny": false,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": false,
+    "jsx": "react-jsx",
+    "isolatedModules": true,
+//    "noEmit": true,
+    "noImplicitOverride": true,
+    "useUnknownInCatchVariables": false,
+    "useDefineForClassFields": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "results"]
+}