ui5-test-runner 6.0.0-beta.5 → 6.0.1

package/dist/browsers/webdriverio.js

@@ -0,0 +1,85 @@
+import { logger, Path } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+import { handleConsoleMessage } from './consoleMessage.js';
+import { handleNetworkResponse } from './networkResponse.js';
+import { buildChromeLaunchOptions } from './chromeOptions.js';
+export const descriptor = {
+    supportedBrowsers: ['chrome', 'firefox', 'edge', 'safari'],
+    defaultBrowser: 'chrome',
+    screenshotFormat: '.png'
+};
+const headerValue = (value) => typeof value === 'string' ? value : (value?.value ?? '');
+const headersToObject = (headers) => Object.fromEntries((headers ?? []).map(({ name, value }) => [name.toLowerCase(), headerValue(value)]));
+export const factory = async (configuration) => {
+    const webdriverio = await Npm.import(configuration, 'webdriverio');
+    const { remote } = webdriverio;
+    let browser;
+    const contextToPageId = new Map();
+    return {
+        async setup(settings) {
+            logger.debug({ source: 'webdriverio', message: 'launching browser' });
+            process.env['WDIO_LOG_PATH'] = Path.join(configuration.reportDir, 'wdio.log');
+            browser = await remote({
+                capabilities: {
+                    browserName: 'chrome',
+                    webSocketUrl: true,
+                    'goog:chromeOptions': buildChromeLaunchOptions(settings.options, [
+                        ...(settings.visible ? [] : ['--headless']),
+                        '--start-maximized',
+                        ...(settings.viewport ? [`--window-size=${settings.viewport.width},${settings.viewport.height}`] : [])
+                    ])
+                }
+            });
+            browser.on('log.entryAdded', (entry) => {
+                const event = entry;
+                if (event.type !== 'console') {
+                    return;
+                }
+                const pageId = (event.source?.context === undefined ? undefined : contextToPageId.get(event.source.context)) ?? -1;
+                handleConsoleMessage(event.method ?? 'log', event.text ?? '', pageId);
+            });
+            await browser.sessionSubscribe({ events: ['network.responseStarted'] });
+            browser.on('network.responseStarted', (entry) => {
+                const event = entry;
+                const pageId = (event.context === null ? undefined : contextToPageId.get(event.context)) ?? -1;
+                handleNetworkResponse(pageId, event.request.url, event.request.method, event.response.status, headersToObject(event.request.headers), headersToObject(event.response.headers));
+            });
+            return {
+                browserName: browser.capabilities.browserName ?? 'chrome',
+                browserVersion: browser.capabilities.browserVersion ?? ''
+            };
+        },
+        async newWindow(settings) {
+            const { pageId, scripts, url } = settings;
+            const { context } = await browser.browsingContextCreate({ type: 'tab', background: true });
+            contextToPageId.set(context, pageId);
+            for (const script of scripts) {
+                await browser.scriptAddPreloadScript({
+                    functionDeclaration: `() => { ${script} }`,
+                    contexts: [context]
+                });
+            }
+            await browser.browsingContextNavigate({ context, url, wait: 'interactive' });
+            const switchTo = () => browser.switchToWindow(context);
+            return {
+                async eval(script) {
+                    await switchTo();
+                    return browser.execute(`return (${script})`);
+                },
+                async screenshot(path) {
+                    await switchTo();
+                    await browser.saveScreenshot(path);
+                },
+                async close() {
+                    contextToPageId.delete(context);
+                    await browser.browsingContextClose({ context });
+                }
+            };
+        },
+        async shutdown() {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            await browser?.deleteSession();
+            delete process.env['WDIO_LOG_PATH'];
+        }
+    };
+};

package/dist/cli.js

@@ -3,18 +3,24 @@ import { Exit, Host } from './platform/index.js';
 import { version } from './platform/version.js';
 import { CommandLine } from './configuration/CommandLine.js';
 import { execute } from './modes/execute.js';
-const main = async () => {
-    const cliVersion = await version();
-    const cliName = cliVersion.split('@')[0] ?? 'ui5-test-runner';
-    const indexOfCli = process.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value) || value.endsWith(cliName));
-    const configuration = await CommandLine.buildConfigurationFrom(Host.cwd(), process.argv.slice(indexOfCli + 1));
-    await execute(configuration);
-};
-main()
-    .catch((error) => {
+import { isIfEvaluatedAsTrue } from './if.js';
+import { sendToParentProcess } from './sendToParentProcess.js';
+try {
+    const { name: cliName } = await version();
+    const indexOfCli = Host.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value) || value.endsWith(cliName));
+    const configuration = await CommandLine.buildConfigurationFrom(Host.cwd(), indexOfCli === -1 ? [] : Host.argv.slice(indexOfCli + 1));
+    if (await isIfEvaluatedAsTrue(configuration)) {
+        await execute(configuration);
+    }
+    else {
+        console.log(String.raw `/!\ Skipping execution (--if)`);
+        sendToParentProcess({ type: 'skip' });
+    }
+}
+catch (error) {
     console.error(error);
     Exit.code = -1;
-})
-    .finally(async () => {
+}
+finally {
     await Exit.shutdown();
-});
+}

package/dist/configuration/CommandLine.js

@@ -1,7 +1,8 @@
 import { indexedOptions } from './indexedOptions.js';
 import { ConfigurationValidator } from './ConfigurationValidator.js';
 import { OptionValidationError } from './OptionValidationError.js';
-import { looksLikeAnUrl } from './validators/url.js';
+import { isLikeAnUrl } from './validators/url.js';
+import { assert, Host } from '../platform/index.js';
 const setOption = (configuration, option, value) => {
     const name = option.name;
     if (value === undefined) {
@@ -11,12 +12,12 @@ const setOption = (configuration, option, value) => {
             });
         }
         else if (option.multiple !== true) {
-            configuration.errors.push(new OptionValidationError(option, 'Missing value'));
+            configuration.errors.push(OptionValidationError.createMissingValue(option));
         }
     }
     else {
         if (option.multiple) {
-            if (!(option.name in configuration)) {
+            if (!Object.hasOwn(configuration, option.name)) {
                 Object.assign(configuration, {
                     [name]: []
                 });
@@ -35,10 +36,13 @@ const switchOption = (configuration, currentOption, name) => {
         setOption(configuration, currentOption);
     }
     const option = indexedOptions[name];
-    if (!option) {
-        throw OptionValidationError.createUnknown(name);
+    if (option) {
+        return option;
     }
-    return option;
+    if (Host.env['IGNORE_UNKNOWN_OPTION']) {
+        return undefined;
+    }
+    throw OptionValidationError.createUnknown(name);
 };
 const positionalOption = {
     name: 'positional',
@@ -46,29 +50,38 @@ const positionalOption = {
     type: 'string'
 };
 const handlePositional = (configuration, value) => {
-    if (looksLikeAnUrl(value)) {
+    if (isLikeAnUrl(value)) {
         setOption(configuration, indexedOptions.url, value);
         return;
     }
-    const shortcuts = ['capabilities', 'version', 'help'];
+    const shortcuts = ['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}`));
+    configuration.errors.push(OptionValidationError.createUnprocessable(positionalOption, value));
+};
+const NEGATIVE_NUMBER = /^-\d+$|^-\d*\.\d+$/;
+const switchOptionFromToken = (configuration, currentOption, argument) => {
+    if (argument.startsWith('--')) {
+        return { option: switchOption(configuration, currentOption, argument.slice(2)) };
+    }
+    return argument.startsWith('-')
+        ? { option: switchOption(configuration, currentOption, argument.slice(1)) }
+        : undefined;
 };
 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;
+        const isValueForCurrentOption = currentOption !== undefined && NEGATIVE_NUMBER.test(argument);
+        if (!isValueForCurrentOption) {
+            const switched = switchOptionFromToken(configuration, currentOption, argument);
+            if (switched) {
+                currentOption = switched.option;
+                continue;
+            }
         }
         if (currentOption === undefined) {
             handlePositional(configuration, argument);
@@ -86,26 +99,33 @@ const traverseArguments = (configuration, argv) => {
 };
 export const CommandLine = {
     async buildConfigurationFrom(cwd, argv) {
-        const configuration = { cwd, errors: [] };
+        const configuration = Object.create({ cwd, errors: [] });
         traverseArguments(configuration, argv);
-        const { errors, ...configWithoutErrors } = configuration;
+        const cliKeys = new Set(Object.keys(configuration));
         let validatedConfiguration;
         try {
-            validatedConfiguration = await ConfigurationValidator.validate(configWithoutErrors);
+            validatedConfiguration = await ConfigurationValidator.validate(configuration);
         }
         catch (error) {
-            if (errors.length > 0 && error instanceof AggregateError) {
-                errors.push(...error.errors);
+            if (configuration.errors.length > 0 && error instanceof AggregateError) {
+                configuration.errors.push(...error.errors);
             }
             else {
-                errors.push(error);
+                configuration.errors.push(error);
             }
         }
-        if (errors.length === 1) {
-            throw errors[0];
+        if (configuration.errors.length === 1) {
+            throw configuration.errors[0];
+        }
+        if (configuration.errors.length > 0) {
+            throw new AggregateError(configuration.errors, 'Multiple errors occurred');
         }
-        else if (errors.length > 0) {
-            throw new AggregateError(errors, 'Multiple errors occurred');
+        assert(validatedConfiguration !== undefined);
+        validatedConfiguration.sources = {
+            ...validatedConfiguration.sources
+        };
+        for (const key of cliKeys) {
+            validatedConfiguration.sources[key] = 'cli';
         }
         return validatedConfiguration;
     }

package/dist/configuration/ConfigurationValidator.js

@@ -2,20 +2,24 @@ import { options, defaults } from './options.js';
 import { indexedOptions } from './indexedOptions.js';
 import { validators } from './validators/index.js';
 import { OptionValidationError } from './OptionValidationError.js';
+import { validations } from './validations.js';
+import { derivations } from './derivations.js';
 import { Modes } from '../modes/Modes.js';
+import { assert, FileSystem, Host, Path } from '../platform/index.js';
+const MAX_CONFIG_DEPTH = 10;
 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'));
+                errors.push(OptionValidationError.createShortName(option));
             }
             else if (key !== option.name) {
-                errors.push(new OptionValidationError(option, 'Do not use kebab-case'));
+                errors.push(OptionValidationError.createKebabCase(option));
             }
         }
-        else {
+        else if (!Host.env['IGNORE_UNKNOWN_OPTION']) {
             errors.push(OptionValidationError.createUnknown(key));
         }
     }
@@ -27,25 +31,123 @@ const assertIfConfiguration = (value) => {
         throw error;
     }
 };
+const callValidator = (option, value, configuration) => validators[option.type](option, value, configuration);
 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));
+                validatedValues.push(await callValidator(option, valueItem, configuration));
             }
         }
         else {
-            validatedValues.push(await validators[option.type](option, value, configuration));
+            validatedValues.push(await callValidator(option, value, configuration));
         }
         return validatedValues;
     }
-    return await validators[option.type](option, value, configuration);
+    return await callValidator(option, value, configuration);
+};
+const loadConfigFile = async (configPath) => {
+    let content;
+    try {
+        content = await FileSystem.readFile(configPath, 'utf8');
+    }
+    catch (error) {
+        throw OptionValidationError.createConfigReadError(indexedOptions.config, configPath, error);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        throw OptionValidationError.createConfigInvalidJson(indexedOptions.config, configPath, error);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw OptionValidationError.createConfigNotObject(indexedOptions.config, configPath);
+    }
+    return parsed;
+};
+const extractConfigEntries = (parsed, configDirectory) => {
+    const forcedKeys = new Set();
+    const configFileKeys = new Set();
+    const configFileObject = {};
+    for (const [rawKey, value] of Object.entries(parsed)) {
+        const key = rawKey.startsWith('!') ? rawKey.slice(1) : rawKey;
+        if (rawKey.startsWith('!')) {
+            forcedKeys.add(key);
+        }
+        configFileObject[key] = value;
+        configFileKeys.add(key);
+    }
+    if (configFileKeys.has('cwd') && typeof configFileObject['cwd'] === 'string') {
+        const rawCwd = configFileObject['cwd'];
+        if (!Path.isAbsolute(rawCwd)) {
+            configFileObject['cwd'] = Path.join(configDirectory, rawCwd);
+        }
+    }
+    else {
+        configFileObject['cwd'] = configDirectory;
+    }
+    return { forcedKeys, configFileKeys, configFileObject };
+};
+const finalizeConfiguration = async (merged) => {
+    const hasExplicitReportDirectory = Object.hasOwn(merged, 'reportDir');
+    for (const option of options) {
+        if (!Object.hasOwn(merged, option.name) && merged[option.name] && option.type === 'fs-entry') {
+            Object.assign(merged, {
+                [option.name]: await validateValue(option, merged)
+            });
+        }
+    }
+    const batchReportDirectory = Host.env['UI5TR_BATCH_REPORT_DIR'];
+    if (batchReportDirectory && !hasExplicitReportDirectory) {
+        const reportDirectoryOption = options.find((option) => option.name === 'reportDir');
+        assert(reportDirectoryOption !== undefined);
+        Object.assign(merged, {
+            reportDir: await validateValue(reportDirectoryOption, { ...merged, reportDir: batchReportDirectory })
+        });
+    }
+    for (const option of options) {
+        if (!(option.type === 'fs-entry' &&
+            typeof merged[option.name] === 'string' &&
+            merged[option.name].includes('{{reportDir}}'))) {
+            continue;
+        }
+        const substituted = Path.join(merged.reportDir, merged[option.name].split('{{reportDir}}', 2)[1]);
+        Object.assign(merged, { [option.name]: await validateValue(option, { ...merged, [option.name]: substituted }) });
+    }
+    for (const derive of derivations) {
+        derive(merged);
+    }
+    merged.mode = ConfigurationValidator.computeMode(merged);
+    for (const validate of validations) {
+        validate(merged);
+    }
 };
 export const ConfigurationValidator = {
-    merge(configuration) {
-        return Promise.resolve(configuration);
+    async merge(configuration, explicitKeys, depth) {
+        if (!configuration.config || !Path.isAbsolute(configuration.config)) {
+            return configuration;
+        }
+        if (depth >= MAX_CONFIG_DEPTH) {
+            throw OptionValidationError.createConfigNestingDepth(indexedOptions.config, MAX_CONFIG_DEPTH);
+        }
+        const parsed = await loadConfigFile(configuration.config);
+        const configDirectory = Path.dirname(configuration.config);
+        const { forcedKeys, configFileKeys, configFileObject } = extractConfigEntries(parsed, configDirectory);
+        const fileConfig = await this.validate(configFileObject, depth + 1);
+        for (const [key, value] of Object.entries(fileConfig)) {
+            if (key === 'mode' ||
+                key === 'config' ||
+                (key === 'cwd' && !configFileKeys.has('cwd')) ||
+                (!forcedKeys.has(key) && explicitKeys.has(key))) {
+                continue;
+            }
+            Object.assign(configuration, { [key]: value });
+            configuration.sources[key] = 'config';
+        }
+        return configuration;
     },
     computeMode(configuration) {
         if (configuration.help) {
@@ -54,26 +156,38 @@ export const ConfigurationValidator = {
         if (configuration.version) {
             return Modes.version;
         }
+        if (configuration.dumpConfig) {
+            return Modes.dumpConfig;
+        }
+        if (configuration.mcp) {
+            return Modes.mcp;
+        }
+        if (configuration.batch) {
+            return Modes.batch;
+        }
         if (configuration.log) {
             return Modes.log;
         }
-        if (configuration.url) {
-            return Modes.remote;
-        }
-        return Modes.legacy;
+        return configuration.url ? Modes.remote : Modes.legacy;
     },
-    async validate(configuration) {
+    async validate(configuration, depth = 0) {
         const withDefaults = Object.assign(Object.create(defaults), configuration);
         assertIfConfiguration(withDefaults);
-        const merged = await this.merge(withDefaults);
-        merged.mode = this.computeMode(merged);
+        const explicitKeys = new Set(Object.keys(withDefaults));
         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)
+            if (Object.hasOwn(withDefaults, option.name)) {
+                Object.assign(withDefaults, {
+                    [option.name]: await validateValue(option, withDefaults)
                 });
             }
         }
+        if (!Object.hasOwn(withDefaults, 'sources')) {
+            Object.assign(withDefaults, { sources: {} });
+        }
+        const merged = await this.merge(withDefaults, explicitKeys, depth);
+        if (depth === 0) {
+            await finalizeConfiguration(merged);
+        }
         return merged;
     }
 };

package/dist/configuration/OptionValidationError.js

@@ -1,9 +1,57 @@
 export class OptionValidationError extends Error {
+    static createInvalidValue(option) {
+        return new OptionValidationError(option, `Invalid value for ${option.name}`);
+    }
     static createUnknown(name) {
-        return new OptionValidationError({ name, type: 'string', description: 'unknown' }, 'Unknown option');
+        return new OptionValidationError({ name, type: 'string', description: 'unknown' }, `Unknown option ${name}`);
+    }
+    static createShortName(option) {
+        return new OptionValidationError(option, 'Do not use short name');
+    }
+    static createKebabCase(option) {
+        return new OptionValidationError(option, 'Do not use kebab-case');
+    }
+    static createMissingValue(option) {
+        return new OptionValidationError(option, `Missing value for ${option.name}`);
+    }
+    static createUnprocessable(option, value) {
+        return new OptionValidationError(option, `Unable to process: ${value}`);
+    }
+    static createInvalidRegexp(option, cause) {
+        return new OptionValidationError(option, `Invalid regexp set to ${option.name}`, cause);
+    }
+    static createFsAccessError(option, cause) {
+        return new OptionValidationError(option, 'Unable to access file system entry', cause);
+    }
+    static createFsNotFolder(option) {
+        return new OptionValidationError(option, 'Not a folder');
+    }
+    static createFsNotFile(option) {
+        return new OptionValidationError(option, 'Not a file');
+    }
+    static createFsCheckTypeError(option, cause) {
+        return new OptionValidationError(option, 'Unable to check type', cause);
+    }
+    static createFsExpectedString(option) {
+        return new OptionValidationError(option, 'Expected string');
+    }
+    static createConfigNestingDepth(option, maxDepth) {
+        return new OptionValidationError(option, `config file nesting exceeded maximum depth of ${maxDepth}`);
+    }
+    static createConfigReadError(option, path, cause) {
+        return new OptionValidationError(option, `cannot read config file ${path}`, cause);
+    }
+    static createConfigInvalidJson(option, path, cause) {
+        return new OptionValidationError(option, `config file ${path} is not valid JSON`, cause);
+    }
+    static createConfigNotObject(option, path) {
+        return new OptionValidationError(option, `config file ${path} must be a JSON object`);
+    }
+    static createValidationError(option, message) {
+        return new OptionValidationError(option, `invalid use of ${option.name}: ${message}`);
     }
     _option;
-    constructor(option, message = 'Invalid value', cause) {
+    constructor(option, message, cause) {
         super(message);
         this._option = option;
         this.name = 'OptionValidationError';

package/dist/configuration/derivations.js

@@ -0,0 +1,8 @@
+import { punyexpr } from 'punyexpr';
+export const derivations = [
+    (configuration) => {
+        if (punyexpr('llm')(configuration)) {
+            Object.assign(configuration, { ci: true, noBanner: true });
+        }
+    }
+];