ui5-test-runner 5.13.0 → 6.0.0-beta.1

package/README.md

@@ -1,4 +1,4 @@
-# UI5 Test runner
+# UI5 Test runner 6️⃣
 
 [![Node.js CI](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml/badge.svg)](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml)
 [![Package Quality](https://npm.packagequality.com/shield/ui5-test-runner.svg)](https://packagequality.com/#?package=ui5-test-runner)
@@ -19,7 +19,7 @@ A self-sufficient test runner for UI5 applications enabling parallel execution o
 
 ## 💿 How to install
 
-* Works with [Node.js](https://nodejs.org/en/download/) >= 18
+* Works with [Node.js](https://nodejs.org/en/download/) >= 24
 * Local installation
   * `npm install --save-dev ui5-test-runner`
   * Trigger either with `npx ui5-test-runner` or through an npm script invoking `ui5-test-runner`
@@ -36,6 +36,7 @@ A self-sufficient test runner for UI5 applications enabling parallel execution o
 
 | Version | Reason | 
 |-|-|
+| **6**.0.0 | • Drop support of Node.js < 24 |
 | **5**.0.0 | • Some coverage reports now includes **all** files, leading to a potential decrease of coverage |
 | **4**.0.0 | • Drop support of Node.js 16 |
 | **3**.0.0 | • Drop support of Node.js 14 |

package/dist/Npm.js

@@ -0,0 +1,80 @@
+import { logger, FileSystem, Http, Path, Process } from './platform/index.js';
+import { memoize } from './utils/shared/memoize.js';
+const getNpmCliPath = memoize(async () => {
+    const npmChildProcess = Process.spawn('npm', [], {
+        shell: true
+    });
+    await npmChildProcess.closed;
+    const error = new Error('Unable to initialize NPM');
+    const match = /^npm@([^ ]+) (.*)$/gm.exec(npmChildProcess.stdout);
+    if (!match) {
+        logger.fatal({ source: 'npm', message: 'Unable to match NPM output', error });
+        throw error;
+    }
+    const [, semver, path] = match;
+    if (!semver || !path) {
+        logger.fatal({ source: 'npm', message: 'Failed to parse NPM output', error, data: { semver, path } });
+        throw error;
+    }
+    logger.debug({ source: 'npm', message: `npm@${semver} ${path}` });
+    return Path.join(path, 'bin/npm-cli.js');
+});
+const npm = async (...arguments_) => {
+    const npmCliPath = await getNpmCliPath();
+    return Process.spawn('node', [npmCliPath, ...arguments_], {
+        detached: true
+    });
+};
+const getRoots = memoize(async () => {
+    const localRootProcess = await npm('root');
+    const globalRootProcess = await npm('root', '--global');
+    await Promise.all([localRootProcess.closed, globalRootProcess.closed]);
+    const local = localRootProcess.stdout.trim();
+    const global = globalRootProcess.stdout.trim();
+    logger.debug({ source: 'npm', message: 'Roots', data: { local, global } });
+    return {
+        local: localRootProcess.stdout.trim(),
+        global: globalRootProcess.stdout.trim()
+    };
+});
+export const Npm = {
+    async getLatestVersion(moduleName) {
+        try {
+            const response = await Http.get(`https://registry.npmjs.org/${moduleName}/latest`);
+            const { version } = JSON.parse(response);
+            return version;
+        }
+        catch (error) {
+            throw new Error(`Unable to fetch latest version of ${moduleName} from NPM registry`, {
+                cause: error
+            });
+        }
+    },
+    async checkIfLatestVersion(moduleName, isLocal) {
+        try {
+            const { local, global } = await getRoots();
+            const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(isLocal ? local : global, moduleName, 'package.json'), 'utf8'));
+            logger.info({ source: 'npm', message: `Installed version of ${moduleName} is ${installedVersion}` });
+            const latestVersion = await Npm.getLatestVersion(moduleName);
+            if (latestVersion !== installedVersion) {
+                logger.warn({ source: 'npm', message: `[PKGVRS] Latest version of ${moduleName} is ${latestVersion}` });
+            }
+        }
+        catch (error) {
+            logger.error({ source: 'npm', message: 'Failed in checkIfLatestVersion', error });
+        }
+    },
+    async import(moduleName) {
+        logger.debug({ source: 'npm', message: `Npm.import(${moduleName})` });
+        try {
+            const module = (await import(moduleName));
+            logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
+            void this.checkIfLatestVersion(moduleName, true);
+            return module;
+        }
+        catch {
+            logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
+        }
+        throw new Error('Not implemented');
+    }
+};

package/dist/browsers/IBrowser.js

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

package/dist/browsers/factory.js

@@ -0,0 +1,9 @@
+import { factory as puppeteerFactory } from './puppeteer.js';
+const factories = {
+    puppeteer: puppeteerFactory
+};
+export const BrowserFactory = {
+    async build(browser) {
+        return await factories[browser]();
+    }
+};

package/dist/browsers/puppeteer.js

@@ -0,0 +1,158 @@
+import { logger, Exit, Process } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+import { agentLogPrefix } from '../types/AgentState.js';
+export const factory = async () => {
+    const puppeteer = await Npm.import('puppeteer');
+    const { launch } = puppeteer;
+    let browser;
+    const abortController = new AbortController();
+    const { signal } = abortController;
+    const task = Exit.registerAsyncTask({
+        name: 'puppeteer',
+        async stop() {
+            abortController.abort();
+            await browser?.close();
+        }
+    });
+    let openedPages = 0;
+    const launchAndInstallIfNeeded = async (settings) => {
+        const launchOptions = {
+            headless: !settings.visible,
+            defaultViewport: null,
+            handleSIGINT: false,
+            signal,
+            args: ['--start-maximized']
+        };
+        try {
+            browser = await launch(launchOptions);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith('Could not find Chrome')) {
+                logger.info({
+                    source: 'progress',
+                    message: 'Installing chrome (puppeteer)',
+                    pageId: undefined,
+                    data: {
+                        value: 1,
+                        max: 0
+                    }
+                });
+                await Process.spawn('npx', 'puppeteer browsers install chrome'.split(' '), {
+                    shell: true,
+                    signal
+                }).closed;
+                browser = await launch(launchOptions);
+            }
+            else {
+                throw error;
+            }
+        }
+        logger.debug({ source: 'puppeteer', message: 'setup completed' });
+        return {
+            screenshotFormat: '.png'
+        };
+    };
+    return {
+        async setup(settings) {
+            logger.debug({ source: 'puppeteer', message: 'setup', data: settings });
+            try {
+                return await launchAndInstallIfNeeded(settings);
+            }
+            catch (error) {
+                logger.error({ source: 'puppeteer', message: 'setup failed', error });
+                task[Symbol.dispose]();
+                throw error;
+            }
+        },
+        async newWindow(settings) {
+            logger.debug({ source: 'puppeteer', message: 'newWindow', data: settings });
+            let page;
+            if (++openedPages === 1) {
+                const pages = await browser?.pages(true);
+                page = pages?.[0];
+            }
+            else {
+                page = await browser?.newPage({
+                    type: 'window'
+                });
+            }
+            for (const script of settings.scripts) {
+                await page?.evaluateOnNewDocument(script);
+            }
+            const { pageId } = settings;
+            page
+                ?.on('console', (message) => {
+                const LOG_TYPES = {
+                    error: 'error',
+                    warn: 'warn',
+                    debug: 'debug'
+                };
+                const logType = LOG_TYPES[message.type()] ?? 'info';
+                let source;
+                let messageText = message.text();
+                if (messageText.startsWith(agentLogPrefix)) {
+                    source = 'browser/agent';
+                    messageText = messageText.slice(agentLogPrefix.length);
+                }
+                else {
+                    source = 'browser/console';
+                }
+                logger[logType]({
+                    source,
+                    message: messageText,
+                    pageId,
+                    data: { type: message.type() }
+                });
+            })
+                ?.on('response', (response) => {
+                const request = response.request();
+                const statusType = Math.floor(response.status() / 100);
+                const LOG_TYPES = [null, null, null, null, 'warn', 'error'];
+                const logType = LOG_TYPES[statusType] ?? 'info';
+                logger[logType]({
+                    source: 'browser/network',
+                    message: request.url(),
+                    pageId,
+                    data: {
+                        request: {
+                            method: request.method(),
+                            headers: request.headers()
+                        },
+                        response: {
+                            status: response.status(),
+                            headers: response.headers()
+                        }
+                    }
+                });
+            });
+            await page?.goto(settings.url);
+            logger.debug({ source: 'puppeteer', message: 'newWindow completed', data: settings });
+            return {
+                async eval(script) {
+                    return await page?.evaluate(script);
+                },
+                screenshot() {
+                    throw new Error('Not implemented');
+                },
+                async close() {
+                    try {
+                        await page?.close();
+                    }
+                    catch (error) {
+                        logger.error({ source: 'puppeteer', message: 'page.close failed', error });
+                    }
+                }
+            };
+        },
+        async shutdown() {
+            logger.debug({ source: 'puppeteer', message: 'shutdown' });
+            try {
+                await browser?.close();
+            }
+            catch (error) {
+                logger.error({ source: 'puppeteer', message: 'browser.close failed', error });
+            }
+            task[Symbol.dispose]();
+        }
+    };
+};

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { Exit, Host } from './platform/index.js';
+import { CommandLine } from './configuration/CommandLine.js';
+import { execute } from './modes/execute.js';
+const main = async () => {
+    const indexOfCli = process.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value));
+    const configuration = await CommandLine.buildConfigurationFrom(Host.cwd(), process.argv.slice(indexOfCli + 1));
+    await execute(configuration);
+};
+main()
+    .catch((error) => {
+    console.error(error);
+    Exit.code = -1;
+})
+    .finally(async () => {
+    await Exit.shutdown();
+});

package/dist/configuration/CommandLine.js

@@ -0,0 +1,112 @@
+import { indexedOptions } from './indexedOptions.js';
+import { ConfigurationValidator } from './ConfigurationValidator.js';
+import { OptionValidationError } from './OptionValidationError.js';
+import { looksLikeAnUrl } from './validators/url.js';
+const setOption = (configuration, option, value) => {
+    const name = option.name;
+    if (value === undefined) {
+        if (option.type === 'boolean') {
+            Object.assign(configuration, {
+                [name]: true
+            });
+        }
+        else if (option.multiple !== true) {
+            configuration.errors.push(new OptionValidationError(option, 'Missing value'));
+        }
+    }
+    else {
+        if (option.multiple) {
+            if (!(option.name in configuration)) {
+                Object.assign(configuration, {
+                    [name]: []
+                });
+            }
+            configuration[name].push(value);
+        }
+        else {
+            Object.assign(configuration, {
+                [name]: value
+            });
+        }
+    }
+};
+const switchOption = (configuration, currentOption, name) => {
+    if (currentOption) {
+        setOption(configuration, currentOption);
+    }
+    const option = indexedOptions[name];
+    if (!option) {
+        throw OptionValidationError.createUnknown(name);
+    }
+    return option;
+};
+const positionalOption = {
+    name: 'positional',
+    description: 'Any argument not prefixed with an option',
+    type: 'string'
+};
+const handlePositional = (configuration, value) => {
+    if (looksLikeAnUrl(value)) {
+        setOption(configuration, indexedOptions.url, value);
+        return;
+    }
+    const shortcuts = ['capabilities', 'version', 'help'];
+    for (const shortcut of shortcuts) {
+        if (value === shortcut) {
+            setOption(configuration, indexedOptions[shortcut]);
+            return;
+        }
+    }
+    configuration.errors.push(new OptionValidationError(positionalOption, `Unable to process: ${value}`));
+};
+const traverseArguments = (configuration, argv) => {
+    let currentOption;
+    for (const argument of argv) {
+        if (argument.startsWith('--')) {
+            currentOption = switchOption(configuration, currentOption, argument.slice(2));
+            continue;
+        }
+        if (argument.startsWith('-')) {
+            currentOption = switchOption(configuration, currentOption, argument.slice(1));
+            continue;
+        }
+        if (currentOption === undefined) {
+            handlePositional(configuration, argument);
+        }
+        else {
+            setOption(configuration, currentOption, argument);
+            if (currentOption.multiple !== true) {
+                currentOption = undefined;
+            }
+        }
+    }
+    if (currentOption) {
+        setOption(configuration, currentOption);
+    }
+};
+export const CommandLine = {
+    async buildConfigurationFrom(cwd, argv) {
+        const configuration = { cwd, errors: [] };
+        traverseArguments(configuration, argv);
+        const { errors, ...configWithoutErrors } = configuration;
+        let validatedConfiguration;
+        try {
+            validatedConfiguration = await ConfigurationValidator.validate(configWithoutErrors);
+        }
+        catch (error) {
+            if (errors.length > 0 && error instanceof AggregateError) {
+                errors.push(...error.errors);
+            }
+            else {
+                errors.push(error);
+            }
+        }
+        if (errors.length === 1) {
+            throw errors[0];
+        }
+        else if (errors.length > 0) {
+            throw new AggregateError(errors, 'Multiple errors occurred');
+        }
+        return validatedConfiguration;
+    }
+};

package/dist/configuration/Configuration.js

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

package/dist/configuration/ConfigurationValidator.js

@@ -0,0 +1,79 @@
+import { options, defaults } from './options.js';
+import { indexedOptions } from './indexedOptions.js';
+import { validators } from './validators/index.js';
+import { OptionValidationError } from './OptionValidationError.js';
+import { Modes } from '../modes/Modes.js';
+const assertIfConfiguration = (value) => {
+    const errors = [];
+    for (const key of Object.keys(value)) {
+        const option = indexedOptions[key];
+        if (option) {
+            if (key === option.short) {
+                errors.push(new OptionValidationError(option, 'Do not use short name'));
+            }
+            else if (key !== option.name) {
+                errors.push(new OptionValidationError(option, 'Do not use kebab-case'));
+            }
+        }
+        else {
+            errors.push(OptionValidationError.createUnknown(key));
+        }
+    }
+    if (errors.length > 1) {
+        throw new AggregateError(errors, 'Unknown keys');
+    }
+    const [error] = errors;
+    if (error) {
+        throw error;
+    }
+};
+const validateValue = async (option, configuration) => {
+    const value = configuration[option.name];
+    if ('multiple' in option) {
+        const validatedValues = [];
+        if (Array.isArray(value)) {
+            for (const valueItem of value) {
+                validatedValues.push(await validators[option.type](option, valueItem, configuration));
+            }
+        }
+        else {
+            validatedValues.push(await validators[option.type](option, value, configuration));
+        }
+        return validatedValues;
+    }
+    return await validators[option.type](option, value, configuration);
+};
+export const ConfigurationValidator = {
+    merge(configuration) {
+        return Promise.resolve(configuration);
+    },
+    computeMode(configuration) {
+        if (configuration.help) {
+            return Modes.help;
+        }
+        if (configuration.version) {
+            return Modes.version;
+        }
+        if (configuration.log) {
+            return Modes.log;
+        }
+        if (configuration.url) {
+            return Modes.remote;
+        }
+        return Modes.legacy;
+    },
+    async validate(configuration) {
+        const withDefaults = Object.assign(Object.create(defaults), configuration);
+        assertIfConfiguration(withDefaults);
+        const merged = await this.merge(withDefaults);
+        merged.mode = this.computeMode(merged);
+        for (const option of options) {
+            if (Object.hasOwnProperty.call(merged, option.name) || (merged[option.name] && option.type === 'fs-entry')) {
+                Object.assign(merged, {
+                    [option.name]: await validateValue(option, merged)
+                });
+            }
+        }
+        return merged;
+    }
+};

package/dist/configuration/Option.js

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

package/dist/configuration/OptionValidationError.js

@@ -0,0 +1,15 @@
+export class OptionValidationError extends Error {
+    static createUnknown(name) {
+        return new OptionValidationError({ name, type: 'string', description: 'unknown' }, 'Unknown option');
+    }
+    _option;
+    constructor(option, message = 'Invalid value', cause) {
+        super(message);
+        this._option = option;
+        this.name = 'OptionValidationError';
+        this.cause = cause;
+    }
+    get option() {
+        return this._option;
+    }
+}

package/dist/configuration/indexedOptions.js

@@ -0,0 +1,13 @@
+import { options } from './options.js';
+export const indexedOptions = {};
+for (const option of options) {
+    const { name } = option;
+    indexedOptions[name] = option;
+    if ('short' in option) {
+        indexedOptions[option.short] = option;
+    }
+    const kebabCase = name.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLocaleLowerCase()}`);
+    if (name !== kebabCase) {
+        indexedOptions[kebabCase] = option;
+    }
+}