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

package/dist/runner.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightRunner = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const playwright_1 = require("playwright");
+const actions_1 = require("./actions");
+const runnerConfig_1 = require("./model/runnerConfig");
+const parser_1 = require("./lib/parser");
+const log4js_1 = require("log4js");
+const node_child_process_1 = require("node:child_process");
+const helper_1 = require("./lib/helper");
+const RESULT_FILE = "trace-model.json";
+class PlaywrightRunner {
+    constructor() {
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+        this.options = null;
+        this.logger = (0, log4js_1.getLogger)(PlaywrightRunner.name);
+    }
+    init(collectionPath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.logger.info("Initializing PlaywrightRunner...");
+            // Normalize resultDir
+            if (!options.resultDir || options.resultDir.trim() === "") {
+                options.resultDir = runnerConfig_1.ResultDir.BASE_DIR;
+                this.logger.debug("No resultDir specified. Defaulting to 'results'.");
+            }
+            this.options = options;
+            // Detect script type
+            this.options.scriptType = yield 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 === runnerConfig_1.ScriptType.PLAYWRIGHT_TEST) {
+                this.logger.info("Playwright Test detected. Skipping manual browser setup.");
+                return;
+            }
+            // Browser setup
+            const browserType = options.browser || runnerConfig_1.BrowserType.CHROMIUM;
+            const headless = options.headless;
+            this.logger.debug(`Browser type: ${browserType}, headless: ${headless}`);
+            this.browser = yield (browserType === runnerConfig_1.BrowserType.FIREFOX ? playwright_1.firefox :
+                browserType === runnerConfig_1.BrowserType.WEBKIT ? playwright_1.webkit :
+                    playwright_1.chromium).launch(Object.assign({ headless }, (options.chromiumPath && { executablePath: options.chromiumPath })));
+            this.logger.info("Browser launched successfully.");
+            let headers = {};
+            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 = yield this.browser.newContext(Object.assign(Object.assign({ ignoreHTTPSErrors: true }, (options.sslClientCert && {
+                clientCert: {
+                    cert: options.sslClientCert,
+                    key: options.sslClientKey,
+                    passphrase: options.sslClientPassphrase
+                }
+            })), { extraHTTPHeaders: headers }));
+            this.logger.info("Browser context created.");
+            yield this.context.tracing.start({ snapshots: true, screenshots: true, sources: true });
+            this.logger.info("Tracing started (snapshots, screenshots, sources enabled).");
+            this.page = yield this.context.newPage();
+            // @ts-ignore
+            if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.scriptType) != runnerConfig_1.ScriptType.PLAYWRIGHT_TEST && this.options.timeout != null) {
+                this.page.setDefaultTimeout(Number(this.options.timeout));
+            }
+            this.logger.info("New page created.");
+        });
+    }
+    run(collectionPath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.logger.info(`Running collection: ${collectionPath}`);
+            // Default trace path(s)
+            let tracePaths = [
+                options.resultDir
+                    ? path_1.default.join(options.resultDir, "trace.zip")
+                    : "trace.zip"
+            ];
+            switch ((_a = this.options) === null || _a === void 0 ? void 0 : _a.scriptType) {
+                case runnerConfig_1.ScriptType.JSON: {
+                    const flow = (0, helper_1.loadFlow)(collectionPath);
+                    this.logger.info(`Loaded flow: ${flow.name} with ${flow.steps.length} steps`);
+                    for (const [index, step] of flow.steps.entries()) {
+                        const handler = actions_1.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);
+                            }
+                            yield handler(this.page, step);
+                        }
+                        catch (err) {
+                            this.logger.error(`Step ${index} failed: ${err.message}`, err);
+                        }
+                    }
+                    break;
+                }
+                case runnerConfig_1.ScriptType.PLAYWRIGHT: {
+                    this.logger.info("Detected plain Playwright script with default export.");
+                    const mod = yield Promise.resolve(`${path_1.default.resolve(collectionPath)}`).then(s => __importStar(require(s)));
+                    const fn = mod.default;
+                    if (typeof fn !== "function") {
+                        throw new Error("Script does not export a default function");
+                    }
+                    try {
+                        yield fn(this.page);
+                        this.logger.info("Script execution finished.");
+                    }
+                    catch (err) {
+                        this.logger.error(`Script execution failed: ${err.message}`);
+                    }
+                    break;
+                }
+                case runnerConfig_1.ScriptType.PLAYWRIGHT_TEST: {
+                    this.logger.info("Detected Playwright Test file. Running via CLI...");
+                    const args = [
+                        "playwright",
+                        "test",
+                        collectionPath,
+                        "--browser", options.browser || runnerConfig_1.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(" ")}`);
+                    yield new Promise((resolve) => {
+                        const proc = (0, node_child_process_1.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 = (0, helper_1.collectTraceFiles)(options.resultDir || "results");
+                            resolve();
+                        });
+                    });
+                    break;
+                }
+                default:
+                    this.logger.error("Unsupported or invalid script type.");
+                    process.exit(9);
+            }
+            this.logger.info("Stopping tracing...");
+            yield this.traceProcess(tracePaths);
+        });
+    }
+    traceProcess(tracePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            if (!(tracePaths === null || tracePaths === void 0 ? void 0 : 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 && ((_a = this.options) === null || _a === void 0 ? void 0 : _a.scriptType) != runnerConfig_1.ScriptType.PLAYWRIGHT_TEST) {
+                yield this.context.tracing.stop({
+                    path: tracePaths[0]
+                });
+                this.logger.info(`Trace saved to ${tracePaths}`);
+            }
+            const models = {};
+            for (const tracePath of tracePaths) {
+                try {
+                    this.logger.info(`Parsing trace: ${tracePath}`);
+                    const traceModel = yield (0, parser_1.prepareTraceModel)(tracePath, (_b = this.options) === null || _b === void 0 ? void 0 : _b.logLevel);
+                    const runName = path_1.default.basename(path_1.default.dirname(tracePath));
+                    models[runName] = traceModel;
+                    const individualPath = path_1.default.join(path_1.default.dirname(tracePath), RESULT_FILE);
+                    fs_1.default.writeFileSync(individualPath, JSON.stringify({ "__self": traceModel }, null, 2), "utf-8");
+                    this.logger.debug(`Individual trace model written to ${individualPath}`);
+                }
+                catch (err) {
+                    this.logger.error(`Failed to process trace ${tracePath}: ${err.message}`, err);
+                }
+            }
+            // Write combined model if more than one trace
+            if (((_c = this.options) === null || _c === void 0 ? void 0 : _c.scriptType) == runnerConfig_1.ScriptType.PLAYWRIGHT_TEST) {
+                const combinedPath = ((_d = this.options) === null || _d === void 0 ? void 0 : _d.resultDir)
+                    ? path_1.default.join(this.options.resultDir, RESULT_FILE)
+                    : RESULT_FILE;
+                fs_1.default.writeFileSync(combinedPath, JSON.stringify(models, null, 2), "utf-8");
+                this.logger.info(`Combined trace model written to ${combinedPath}`);
+            }
+            const resourceDir = (_f = (_e = this.options) === null || _e === void 0 ? void 0 : _e.resultDir) !== null && _f !== void 0 ? _f : runnerConfig_1.ResultDir.BASE_DIR;
+            const finalZipPath = path_1.default.join(resourceDir, `artifacts.zip`);
+            yield (0, parser_1.zipResources)(finalZipPath, path_1.default.join(resourceDir, runnerConfig_1.ResultDir.SCREENSHOT), path_1.default.join(resourceDir, runnerConfig_1.ResultDir.SOURCE));
+            if ((_g = this.options) === null || _g === void 0 ? void 0 : _g.returnResult) {
+                console.log(JSON.stringify(models));
+            }
+        });
+    }
+    detectScriptType(collectionPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const mod = yield Promise.resolve(`${path_1.default.resolve(collectionPath)}`).then(s => __importStar(require(s)));
+                if (typeof mod.default === "function") {
+                    this.logger.debug("Detected plain Playwright script (default export).");
+                    return runnerConfig_1.ScriptType.PLAYWRIGHT;
+                }
+            }
+            catch (_a) {
+                this.logger.debug("Dynamic import failed, falling back to file content check.");
+            }
+            if (collectionPath.endsWith(".json")) {
+                this.logger.debug("Detected JSON flow.");
+                return runnerConfig_1.ScriptType.JSON;
+            }
+            const fileContent = fs_1.default.readFileSync(collectionPath, "utf-8");
+            if (fileContent.includes("test(")) {
+                this.logger.debug("Detected Playwright Test file.");
+                return runnerConfig_1.ScriptType.PLAYWRIGHT_TEST;
+            }
+            return undefined;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.logger.info("Closing browser...");
+            yield ((_a = this.browser) === null || _a === void 0 ? void 0 : _a.close());
+            this.logger.info("Browser closed.");
+        });
+    }
+}
+exports.PlaywrightRunner = PlaywrightRunner;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@apica-io/asm-playwright-runner",
+  "version": "1.0.0-dev.1",
+  "description": "CLI wrapper for Playwright collections or scripts with dynamic actions, config, and test result models.",
+  "main": "dist/cli.js",
+  "bin": {
+    "asm-playwright-runner": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/cli/ index.ts",
+    "dev": "ts-node-dev --respawn src/cli/index.ts",
+    "test:playwright-script": "ts-node src/cli samples/playwright-script.spec.ts --timeout 10000 --browser chromium --headless -v -r result1 -l debug",
+    "test:playwright/test-script": "ts-node src/cli samples/playwright-test-script.spec.ts --browser chromium --headless -r result2 -l debug",
+    "test:playwright-multi-script": "ts-node src/cli samples/playwright-multi-script.spec.ts --browser chromium --headless -v -r result3 -l debug",
+    "test:betsson-script": "ts-node src/cli samples/betsson.spec.ts --browser chromium -r result-betsson --headless false -l debug --extraHTTPHeaders {\\\"x-obg-bypass-fabric\\\":\\\"1\\\",\\\"x-obg-experiments\\\":\\\"b1ccAR1gW0f8\\\"}",
+    "test:playwright-json": "ts-node src/cli samples/example.json --browser chromium --headless -v -r results3",
+    "test:google": "ts-node src/cli samples/google.json --browser chromium --headless -v -r playwright-multi-script",
+    "test:google-firefox": "ts-node src/cli samples/google.json --browser firefox --headless -v -r playwright-multi-script"
+  },
+  "keywords": [
+    "playwright",
+    "cli",
+    "automation",
+    "testing",
+    "runner",
+    "Apica"
+  ],
+  "author": "Bhavik, Apica",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^11.0.0",
+    "playwright": "^1.60.0",
+    "playwright-core": "^1.59.1",
+    "log4js": "^6.3.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.59.1",
+    "@types/leaflet": "^1.9.15",
+    "@types/node": "^25.6.2",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.4.0",
+    "unzipper": "^0.12.3",
+    "archiver": "^5.3.2"
+  }
+}

package/samples/betsson.spec.ts

@@ -0,0 +1,86 @@
+import { expect, Page } from "@playwright/test";
+
+export default async function example(page: Page) {
+
+    // Open site
+    await page.goto(
+        "https://caba.betsson.bet.ar/?source=apica",
+        {
+            waitUntil: "networkidle"
+        }
+    );
+
+    // Wait for header
+    await page.waitForSelector(
+        "site-header-version-manager"
+    );
+
+    // Login button inside shadow dom
+    const loginButton = page.locator(`
+        router-link-v2[data-test-id="login-button"]
+        >> fds-button_control
+        >> fds-button
+        >> button[data-test-id="btn-1-button"]
+    `);
+
+    await loginButton.waitFor({
+        state: 'visible',
+        timeout: 60000
+    });
+
+    await expect(loginButton).toBeVisible();
+
+    await loginButton.click();
+
+    // Email input
+    const emailInput = page.locator(`
+        site-root_default
+        >> fds-dialog
+        >> account-login_fabric_wrapper
+        >> account-login-fabric
+        >> #email-input
+    `);
+
+    await emailInput.waitFor({
+        state: 'visible',
+        timeout: 60000
+    });
+
+    await expect(emailInput).toBeVisible();
+
+    await emailInput.fill(
+        "noc@betssongroup.com"
+    );
+
+    // Password input
+    const passwordInput = page.locator(`
+        site-root_default
+        >> fds-dialog
+        >> account-login_fabric_wrapper
+        >> account-login-fabric
+        >> #password-input
+    `);
+
+    await expect(passwordInput).toBeVisible();
+
+    await passwordInput.fill(
+        "n0cT35tAcc0unt!!"
+    );
+
+    // Submit login
+    const submitButton = page.locator(`
+        site-root_default
+        >> fds-dialog
+        >> account-login_fabric_wrapper
+        >> account-login-fabric
+        >> fds-button_control
+        >> fds-button
+    `).last();
+
+    await expect(submitButton).toBeVisible();
+
+    await submitButton.click();
+
+    // Wait after login
+    await page.waitForTimeout(10000);
+}

package/samples/example.json

@@ -0,0 +1,10 @@
+{
+  "name": "example",
+  "steps": [
+    { "action": "goto", "url": "https://playwright.dev/" },
+    { "action": "assertTitle", "expected": "Playwright" },
+    { "action": "click", "selector": "role=link[name='Get started']" },
+    { "action": "waitForSelector", "selector": "role=heading[name='Installation']" },
+    { "action": "assertVisible", "selector": "role=heading[name='Installation']" }
+  ]
+}

package/samples/google.json

@@ -0,0 +1,6 @@
+{
+    "name": "example",
+    "steps": [
+        { "action": "goto", "url": "https://nghttp2.org" }
+    ]
+}

package/samples/playwright-multi-script.spec.ts

@@ -0,0 +1,60 @@
+/**
+ * To learn more about Playwright Test visit:
+ * https://checklyhq.com/docs/browser-checks/playwright-test/
+ * https://playwright.dev/docs/writing-tests
+ */
+
+const { expect, test } = require('@playwright/test')
+
+// Configure the Playwright Test timeout to 210 seconds,
+// ensuring that longer tests conclude before Checkly's browser check timeout of 240 seconds.
+// The default Playwright Test timeout is set at 30 seconds.
+// For additional information on timeouts, visit: https://checklyhq.com/docs/browser-checks/timeouts/
+test.setTimeout(210000)
+
+// Set the action timeout to 10 seconds to quickly identify failing actions.
+// By default Playwright Test has no timeout for actions (e.g. clicking an element).
+test.use({ actionTimeout: 10000 })
+
+// You can use test.describe to declare a group of related test cases
+test.describe('Playwright home page', () => {
+    // The callback in test.beforeEach will be executed before each test.
+    test.beforeEach(async ({ page }) => {
+        // Each test will be given a new page instance navigated to the this URL
+        // For deployments Checkly will inject the deployment url as ENVIRONMENT_URL
+        await page.goto(process.env.ENVIRONMENT_URL || 'https://playwright.dev/')
+    })
+    // Other useful hooks: test.beforeAll, test.afterEach, test.afterAll
+
+    test('has a page title containing Playwright', async ({ page }) => {
+        // Expect a title "to contain" a substring.
+        await expect(page).toHaveTitle(/Playwright/)
+    })
+
+    test("has a 'get started' link linking to the intro page", async ({ page }) => {
+        // Create a locator based on a text selector.
+        const getStarted = page.getByText('Get Started')
+        // Use the locator for runtime 2022.02:
+        // const getStarted = page.locator('text=Get Started')
+
+        // Expect an attribute "to be strictly equal" to the value.
+        await expect(getStarted).toHaveAttribute('href', '/docs/intro')
+
+        // Click the get started link.
+        await getStarted.click()
+
+        // Expects the URL to contain intro.
+        await expect(page).toHaveURL(/.*intro/)
+    })
+
+    test.describe('has Open Graph tags', () => {
+        const tags = ['description', 'title', 'url']
+
+        // You can create tests from an array, by calling "test()" in a loop
+        tags.forEach((tag) => {
+            test(`has the Open Graph tag "${tag}"`, async ({ page }) => {
+                await expect(page.locator(`meta[property="og:${tag}"]`)).toHaveCount(1)
+            })
+        })
+    })
+})

package/samples/playwright-script.spec.ts

@@ -0,0 +1,9 @@
+import {expect, Page} from "playwright/test";
+
+export default async function example(page: Page) {
+    await page.goto("https://playwright.dev/");
+    await expect(page).toHaveTitle(/Playwright/);
+
+    await page.getByRole("link", { name: "Get started" }).click();
+    await expect(page.getByRole("heading", { name: "Installation" })).toBeVisible();
+}

package/samples/playwright-test-script.spec.ts

@@ -0,0 +1,18 @@
+import { test, expect } from '@playwright/test';
+
+test('has title', async ({ page }) => {
+    await page.goto('https://playwright.dev/');
+
+    // Expect a title "to contain" a substring.
+    await expect(page).toHaveTitle(/Playwright/);
+});
+
+test('get started link', async ({ page }) => {
+    await page.goto('https://playwright.dev/');
+
+    // Click the get started link.
+    await page.getByRole('link', { name: 'Get started' }).click();
+
+    // Expects page to have a heading with the name of Installation.
+    await expect(page.getByRole('heading', { name: 'Installation' })).toBeVisible();
+});