playwright-ng-schematics/lib/builders/playwright/index.js

Playwright Angular schematics

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getPackageManagerExecCommand = getPackageManagerExecCommand;
const node_child_process_1 = require("node:child_process");
const architect_1 = require("@angular-devkit/architect");
const core_1 = require("@angular-devkit/core");
/**
 * Converts the options object back to an argv string array.
 *
 * @example
 * buildArgs({"workers": 2}); // returns ["--workers", 2]
 */
function buildArgs(options) {
    var _a;
    // extract files
    const filesArgs = (_a = options.files) !== null && _a !== void 0 ? _a : [];
    options.files = null;
    // project alias
    if (options.testProject) {
        options.project = options.testProject;
        options.testProject = null;
    }
    return [
        ...filesArgs,
        ...Object.entries(options).flatMap(([key, value]) => {
            // Skip builder-internal options
            if (key === 'devServerTarget') {
                return [];
            }
            if (key === 'port') {
                return [];
            }
            // Skip objects, arrays, null, undefined (should already be validated by Angular though)
            if (typeof value === 'object' ||
                Array.isArray(value) ||
                value === null ||
                value === undefined) {
                return [];
            }
            // options automatically got converted to camelCase, so we have to convert them back to kebab-case for Playwright.
            const dashes = key.length === 1 ? '-' : '--';
            const argument = `${dashes}${core_1.strings.dasherize(key)}`;
            if (typeof value === 'boolean') {
                if (value) {
                    return argument;
                }
                return [];
            }
            return [argument, String(value)];
        }),
    ];
}
function startDevServer(context, devServerTarget, port) {
    return __awaiter(this, void 0, void 0, function* () {
        const target = (0, architect_1.targetFromTargetString)(devServerTarget);
        const defaultServerOptions = yield context.getTargetOptions(target);
        const overrides = { port: port !== null && port !== void 0 ? port : defaultServerOptions.port };
        const server = yield context.scheduleTarget(target, overrides);
        return server;
    });
}
function getPackageManagerExecCommand() {
    const env = process.env.npm_config_user_agent || '';
    if (env.includes('yarn')) {
        return 'yarn';
    }
    if (env.includes('pnpm')) {
        return 'pnpm exec';
    }
    return 'npx';
}
function startPlaywrightTest(options, baseURL) {
    return __awaiter(this, void 0, void 0, function* () {
        // PLAYWRIGHT_TEST_BASE_URL is actually a non-documented env variable used
        // by Playwright Test.
        // Its usage in playwright.config.ts is to clarify that it can be overriden.
        let env = process.env;
        if (baseURL) {
            env = Object.assign({ PLAYWRIGHT_TEST_BASE_URL: baseURL }, process.env);
        }
        return new Promise((resolve, reject) => {
            const childProcess = (0, node_child_process_1.spawn)(`${getPackageManagerExecCommand()} playwright test`, buildArgs(options), {
                cwd: process.cwd(),
                stdio: 'inherit',
                shell: true,
                env,
            });
            childProcess.on('exit', (exitCode) => {
                if (exitCode !== 0) {
                    reject(exitCode);
                }
                resolve(true);
            });
        });
    });
}
function runE2E(options, context) {
    return __awaiter(this, void 0, void 0, function* () {
        let server;
        let baseURL = '';
        try {
            if (options.devServerTarget) {
                server = yield startDevServer(context, options.devServerTarget, options.port);
                const result = yield server.result;
                baseURL = result.baseUrl;
            }
            yield startPlaywrightTest(options, baseURL);
            return { success: true };
        }
        catch (_error) {
            return { success: false };
        }
        finally {
            if (server) {
                server.stop();
            }
        }
    });
}
exports.default = (0, architect_1.createBuilder)(runE2E);