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

package/dist/configuration/validators/boolean.js

@@ -11,5 +11,5 @@ export const boolean = (option, value) => {
     if (BOOLEAN_FALSE.has(value)) {
         return false;
     }
-    throw new OptionValidationError(option);
+    throw OptionValidationError.createInvalidValue(option);
 };

package/dist/configuration/validators/enumeration.js

@@ -0,0 +1,7 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+export const enumeration = (option, value) => {
+    if (typeof value !== 'string' || !option.typeModifiers?.has(value)) {
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    return value;
+};

package/dist/configuration/validators/fsEntry.js

@@ -1,45 +1,45 @@
 import { FileSystem, Host, Path } from '../../platform/index.js';
 import { OptionValidationError } from '../OptionValidationError.js';
 const fsCheckAccess = async (option, path) => {
-    const overwrite = option.typeModifiers?.has('overwrite') ?? false;
+    const isOverwrite = option.typeModifiers?.has('overwrite') ?? false;
     try {
-        const mode = FileSystem.constants.R_OK | (overwrite ? FileSystem.constants.W_OK : 0);
+        const mode = FileSystem.constants.R_OK | (isOverwrite ? FileSystem.constants.W_OK : 0);
         await FileSystem.access(path, mode);
     }
     catch (error) {
-        if (overwrite) {
+        if (isOverwrite) {
             const code = typeof error === 'object' && error && 'code' in error && error.code;
             if (code === 'EACCES') {
-                throw new OptionValidationError(option, 'Unable to access file system entry', error);
+                throw OptionValidationError.createFsAccessError(option, error);
             }
             if (code === 'ENOENT') {
                 return path;
             }
         }
         else {
-            throw new OptionValidationError(option, `Unable to access file system entry`, error);
+            throw OptionValidationError.createFsAccessError(option, error);
         }
     }
     return undefined;
 };
 const fsCheckStat = async (option, path) => {
-    const file = option.typeModifiers?.has('file') ?? false;
+    const isFile = option.typeModifiers?.has('file') ?? false;
     try {
         const stat = await FileSystem.stat(path);
-        if (!file && !stat.isDirectory()) {
-            throw new OptionValidationError(option, 'Not a folder');
+        if (!isFile && !stat.isDirectory()) {
+            throw OptionValidationError.createFsNotFolder(option);
         }
-        if (file && !stat.isFile()) {
-            throw new OptionValidationError(option, 'Not a file');
+        if (isFile && !stat.isFile()) {
+            throw OptionValidationError.createFsNotFile(option);
         }
     }
     catch (error) {
-        throw new OptionValidationError(option, 'Unable to check type', error);
+        throw OptionValidationError.createFsCheckTypeError(option, error);
     }
 };
 export const fsOption = async (option, value, configuration) => {
     if (typeof value !== 'string') {
-        throw new OptionValidationError(option, 'Expected string');
+        throw OptionValidationError.createFsExpectedString(option);
     }
     let path;
     if (Path.isAbsolute(value)) {

package/dist/configuration/validators/index.js

@@ -1,19 +1,25 @@
 import { boolean } from './boolean.js';
-import { browser } from './browser.js';
+import { enumeration } from './enumeration.js';
 import { fsEntry } from './fsEntry.js';
 import { integer } from './integer.js';
+import { json } from './json.js';
+import { lib } from './libraryMapping.js';
 import { percent } from './percent.js';
 import { regexp } from './regexp.js';
+import { secret } from './secret.js';
 import { string } from './string.js';
 import { timeout } from './timeout.js';
 import { url } from './url.js';
 export const validators = {
     boolean,
-    browser,
+    enumeration,
     'fs-entry': fsEntry,
     integer,
+    json,
+    'library-mapping': lib,
     percent,
     regexp,
+    secret,
     string,
     timeout,
     url

package/dist/configuration/validators/integer.js

@@ -4,7 +4,13 @@ export const integer = (option, value) => {
         value = Number.parseInt(value);
     }
     if (typeof value !== 'number' || value % 1 !== 0) {
-        throw new OptionValidationError(option);
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    if (value < 0 && option.typeModifiers?.has('positive')) {
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    if (value === 0 && option.typeModifiers?.has('non-zero')) {
+        throw OptionValidationError.createInvalidValue(option);
     }
     return value;
 };

package/dist/configuration/validators/json.js

@@ -0,0 +1,23 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+const isJsonObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const json = (option, value) => {
+    if (isJsonObject(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!isJsonObject(parsed)) {
+            throw OptionValidationError.createInvalidValue(option);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof OptionValidationError) {
+            throw error;
+        }
+        throw OptionValidationError.createConfigInvalidJson(option, value, error);
+    }
+};

package/dist/configuration/validators/libraryMapping.js

@@ -0,0 +1,28 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+import { validate } from '../../utils/shared/schema.js';
+import { fsOption } from './fsEntry.js';
+const libraryMappingSchema = {
+    resourcesSubFolder: 'string',
+    sourceFolder: 'string'
+};
+export const lib = async (option, value, configuration) => {
+    if (typeof value === 'string') {
+        const [resourcesSubFolder, sourceFolder, extra] = value.split('=', 3);
+        if (extra) {
+            throw OptionValidationError.createInvalidValue(option);
+        }
+        value = {
+            resourcesSubFolder,
+            sourceFolder: sourceFolder ?? resourcesSubFolder
+        };
+    }
+    try {
+        validate(value, libraryMappingSchema);
+    }
+    catch {
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    const { resourcesSubFolder, sourceFolder } = value;
+    const validatedSourceFolder = await fsOption(option, sourceFolder, configuration);
+    return { resourcesSubFolder, sourceFolder: validatedSourceFolder };
+};

package/dist/configuration/validators/percent.js

@@ -4,7 +4,7 @@ export const percent = (option, value) => {
         const match = /^(\d{0,3}(:?\.\d{0,3})?)%$/.exec(value);
         if (match) {
             const [, digits = '0'] = match;
-            const float = Number.parseFloat(digits);
+            const float = Number(digits);
             if (float >= 0 && float <= 100) {
                 value = float;
             }
@@ -13,5 +13,5 @@ export const percent = (option, value) => {
     if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value <= 100) {
         return value;
     }
-    throw new OptionValidationError(option);
+    throw OptionValidationError.createInvalidValue(option);
 };

package/dist/configuration/validators/regexp.js

@@ -4,7 +4,7 @@ export const regexp = (option, value) => {
         return value;
     }
     if (typeof value !== 'string' || !value) {
-        throw new OptionValidationError(option);
+        throw OptionValidationError.createInvalidValue(option);
     }
     try {
         const match = /^\/(.+)\/(\w*)$/.exec(value);
@@ -15,6 +15,6 @@ export const regexp = (option, value) => {
         return new RegExp(value);
     }
     catch (error) {
-        throw new OptionValidationError(option, 'Invalid regexp', error);
+        throw OptionValidationError.createInvalidRegexp(option, error);
     }
 };

package/dist/configuration/validators/secret.js

@@ -0,0 +1,8 @@
+import { SecretValue } from '../../types/SecretValue.js';
+import { OptionValidationError } from '../OptionValidationError.js';
+export const secret = (option, value) => {
+    if (typeof value !== 'string' || !value) {
+        throw OptionValidationError.createInvalidValue(option);
+    }
+    return new SecretValue(value);
+};

package/dist/configuration/validators/string.js

@@ -1,7 +1,7 @@
 import { OptionValidationError } from '../OptionValidationError.js';
 export const string = (option, value) => {
     if (typeof value !== 'string' || !value) {
-        throw new OptionValidationError(option);
+        throw OptionValidationError.createInvalidValue(option);
     }
     return value;
 };

package/dist/configuration/validators/timeout.js

@@ -9,7 +9,7 @@ export const timeout = (option, value) => {
             const [, digits = '0', specifier = ''] = match;
             let int = Number.parseInt(digits);
             if (['s', 'sec'].includes(specifier)) {
-                int = int * 1000;
+                int *= 1000;
             }
             if (['m', 'min'].includes(specifier)) {
                 int = int * 60 * 1000;
@@ -20,5 +20,5 @@ export const timeout = (option, value) => {
     if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value < Number.POSITIVE_INFINITY) {
         return value;
     }
-    throw new OptionValidationError(option);
+    throw OptionValidationError.createInvalidValue(option);
 };

package/dist/configuration/validators/url.js

@@ -1,8 +1,8 @@
 import { OptionValidationError } from '../OptionValidationError.js';
-export const looksLikeAnUrl = (value) => !!/^https?:\/\/[^ "]+$/.test(value);
+export const isLikeAnUrl = (value) => !!/^https?:\/\/[^ "]+$/.test(value);
 export const url = (option, value) => {
-    if (typeof value === 'string' && looksLikeAnUrl(value)) {
+    if (typeof value === 'string' && isLikeAnUrl(value)) {
         return value;
     }
-    throw new OptionValidationError(option);
+    throw OptionValidationError.createInvalidValue(option);
 };

package/dist/end.js

@@ -0,0 +1,58 @@
+import { logger, Exit, Process, Host } from './platform/index.js';
+import { Command } from './Command.js';
+import { formatDuration } from './utils/shared/string.js';
+export const end = async (configuration) => {
+    if (!configuration.end) {
+        return;
+    }
+    const start = Date.now();
+    logger.info({ source: 'job', message: 'executing end command...' });
+    logger.info({ source: 'progress', message: 'executing end command', pageId: undefined, data: { value: 0, max: 0 } });
+    const [command, arguments_, environment] = await Command.parse(configuration, configuration.end, {
+        exitCode: String(Exit.code)
+    });
+    const process = Process.spawn(command, arguments_, {
+        cwd: configuration.cwd,
+        env: { ...Host.env, ...environment },
+        forceRender: true
+    });
+    let code;
+    if (configuration.endTimeout) {
+        let didTimeout = false;
+        const timeout = new Promise((resolve) => setTimeout(() => {
+            didTimeout = true;
+            resolve();
+        }, configuration.endTimeout));
+        await Promise.race([process.closed, timeout]);
+        if (didTimeout) {
+            logger.error({ source: 'job', message: 'end command timed out, killing' });
+            await process.kill();
+            code = -1;
+        }
+        else {
+            code = process.code;
+        }
+    }
+    else {
+        await process.closed;
+        code = process.code;
+    }
+    if (code !== undefined) {
+        const before = Exit.code;
+        if (before === 0 && code !== 0) {
+            logger.warn({
+                source: 'job',
+                message: 'status changed to error by end command'
+            });
+        }
+        else if (before !== 0 && code === 0) {
+            logger.warn({
+                source: 'job',
+                message: 'status changed to success by end command'
+            });
+        }
+        Exit.code = code;
+    }
+    const duration = formatDuration(Date.now() - start);
+    logger.info({ source: 'job', message: `End command executed (${duration})` });
+};

package/dist/if.js

@@ -0,0 +1,22 @@
+import { punyexpr } from 'punyexpr';
+import { Host } from './platform/index.js';
+import { version } from './platform/version.js';
+import { compareVersions } from './utils/shared/version.js';
+import { options } from './configuration/options.js';
+export const isImplemented = (option) => Object.values(options).some(({ name }) => name === option);
+export const isIfEvaluatedAsTrue = async ({ if: condition }) => {
+    if (!condition) {
+        return true;
+    }
+    const [nodeMajorVersion] = Host.version.slice(1).split('.', 1);
+    const { name: runnerName, version: runnerVersion } = await version();
+    return !!punyexpr(condition)({
+        ...Host.env,
+        UI5TR_NAME: runnerName,
+        UI5TR_VERSION: runnerVersion,
+        NODE_VERSION: Host.version,
+        NODE_MAJOR_VERSION: Number(nodeMajorVersion),
+        compareVersions,
+        implemented: isImplemented
+    });
+};

package/dist/modes/Modes.js

@@ -1,9 +1,10 @@
 export const Modes = {
     batch: 'batch',
-    capabilities: 'capabilities',
+    dumpConfig: 'dumpConfig',
     help: 'help',
     legacy: 'legacy',
     log: 'log',
+    mcp: 'mcp',
     remote: 'remote',
     version: 'version'
 };

package/dist/modes/batch/BatchItem.js

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

package/dist/modes/batch/batchTask.js

@@ -0,0 +1,159 @@
+import { logger, Path, Process, Host, __sourcesRoot, FileSystem } from '../../platform/index.js';
+import { options } from '../../configuration/options.js';
+import { toKebabCase, formatDuration } from '../../utils/shared/string.js';
+import { getEffectiveTimeout, isGloballyTimedOut } from '../../utils/node/timeout.js';
+const getBatchTimeout = (configuration, startTime) => getEffectiveTimeout(configuration.batchTimeout, configuration.globalTimeout, startTime);
+const buildRunnerCommand = () => {
+    const extension = Path.extname(import.meta.url);
+    const cliPath = Path.join(__sourcesRoot, 'cli' + extension);
+    const js2tsUrl = Path.join(__sourcesRoot, 'platform/js2ts.mjs');
+    return extension === '.ts' ? ['--no-warnings', '--import', js2tsUrl, cliPath] : [cliPath];
+};
+const forwardedOptions = options.filter((o) => 'batchForwarded' in o && o.batchForwarded);
+const buildForwardedParameters = (configuration) => {
+    const parameters = [];
+    for (const option of forwardedOptions) {
+        const name = option.name;
+        if (configuration.sources[name] !== 'cli') {
+            continue;
+        }
+        const flag = `--${toKebabCase(option.name)}`;
+        const value = configuration[name];
+        if (option.type === 'boolean') {
+            parameters.push(flag, String(value));
+        }
+        else if (option.type === 'json') {
+            parameters.push(flag, JSON.stringify(value));
+        }
+        else if ('multiple' in option && option.multiple) {
+            for (const item of value) {
+                parameters.push(flag, item);
+            }
+        }
+        else {
+            parameters.push(flag, `${value}`);
+        }
+    }
+    return parameters;
+};
+const MAX_MESSAGE_LENGTH = 120;
+const buildFailureMessage = async (reportDirectory) => {
+    try {
+        const raw = await FileSystem.readFile(Path.join(reportDirectory, 'report.json'), 'utf8');
+        const report = JSON.parse(raw);
+        const failed = report.results.tests.filter((t) => t.status === 'failed');
+        if (failed.length === 0) {
+            return undefined;
+        }
+        const prefix = `${failed.length} test${failed.length > 1 ? 's' : ''} failed: `;
+        let names = failed.map((t) => t.name).join(', ');
+        if (prefix.length + names.length > MAX_MESSAGE_LENGTH) {
+            names = names.slice(0, MAX_MESSAGE_LENGTH - prefix.length - 1) + '…';
+        }
+        return prefix + names;
+    }
+    catch {
+        return undefined;
+    }
+};
+let lastPageId = 0;
+export const batchTask = async (configuration, batchItem, startTime) => {
+    const pageId = ++lastPageId;
+    const label = `${batchItem.label} (${batchItem.id})`;
+    logger.info({
+        source: 'progress',
+        message: label,
+        pageId,
+        data: { max: 0, value: 1, type: 'unknown', errors: 0 }
+    });
+    if (isGloballyTimedOut(configuration.globalTimeout, startTime)) {
+        logger.warn({ source: 'page', message: 'global timeout reached, skipping batch item', pageId, data: { label } });
+        batchItem.skipped = true;
+        batchItem.message = 'batch item not executed (process was interrupted)';
+        return batchItem;
+    }
+    batchItem.start = new Date();
+    const reportDirectory = Path.join(configuration.reportDir, batchItem.id);
+    batchItem.reportDir = reportDirectory;
+    const parameters = [
+        ...buildRunnerCommand(),
+        '--no-banner',
+        ...batchItem.args,
+        ...buildForwardedParameters(configuration)
+    ];
+    const childProcess = Process.spawn('node', parameters, {
+        env: { ...Host.env, UI5TR_BATCH_MODE: '1', UI5TR_BATCH_REPORT_DIR: reportDirectory },
+        windowsHide: true,
+        onMessage: (data) => {
+            const message = data;
+            if (message?.type === 'progress') {
+                logger.info({
+                    source: 'progress',
+                    message: label,
+                    pageId,
+                    data: { value: message.count, max: message.total, errors: 0, type: 'unknown' }
+                });
+            }
+            else if (message?.type === 'skip') {
+                batchItem.skipped = true;
+            }
+            else if (message?.type === 'report-dir') {
+                batchItem.reportDir = message.reportDir;
+            }
+        }
+    });
+    logger.debug({
+        source: 'page',
+        message: 'new batch task',
+        pageId,
+        data: { ...batchItem, processId: childProcess.pid }
+    });
+    const batchTimeoutMs = getBatchTimeout(configuration, startTime);
+    if (batchTimeoutMs > 0) {
+        const timeoutHandle = setTimeout(() => {
+            logger.warn({ source: 'page', message: 'batch item timed out', pageId, data: { label } });
+            batchItem.timedOut = true;
+            batchItem.message = 'batch item timed out, check the logs';
+            void childProcess.kill();
+        }, batchTimeoutMs);
+        await childProcess.closed;
+        clearTimeout(timeoutHandle);
+    }
+    else {
+        await childProcess.closed;
+    }
+    batchItem.end = new Date();
+    batchItem.statusCode = childProcess.code;
+    const duration = formatDuration(batchItem.end.getTime() - batchItem.start.getTime());
+    if (batchItem.skipped) {
+        logger.warn({ source: 'page', pageId, message: `skipped ${label} (${duration})` });
+    }
+    else if (batchItem.statusCode === 0 && !batchItem.timedOut) {
+        logger.info({
+            source: 'page',
+            pageId,
+            message: `succeeded ${label} (${duration})`
+        });
+    }
+    else {
+        logger.error({
+            source: 'page',
+            pageId,
+            message: `failed ${label} (${duration})`
+        });
+        batchItem.message = await buildFailureMessage(batchItem.reportDir ?? reportDirectory);
+    }
+    logger.debug({
+        source: 'page',
+        message: 'batch task closed',
+        pageId,
+        data: { ...batchItem, processId: childProcess.pid }
+    });
+    logger.info({
+        source: 'progress',
+        message: label,
+        pageId,
+        data: { max: 0, value: 0, type: 'unknown', errors: 0, remove: true }
+    });
+    return batchItem;
+};

package/dist/modes/batch/index.js

@@ -0,0 +1,98 @@
+import { logger, Exit, logEnvironnement } from '../../platform/index.js';
+import { parallelize } from '../../utils/shared/parallelize.js';
+import { start } from '../../start.js';
+import { resolve } from './resolve.js';
+import { batchTask } from './batchTask.js';
+import { buildBatchReport } from './report.js';
+import { defaults } from '../../configuration/options.js';
+import { redactSecrets } from '../../utils/node/anonymize.js';
+import { toPlainObject } from '../../utils/shared/object.js';
+import { Folder } from '../../utils/node/Folder.js';
+import { saveReport } from '../../reports/saveReport.js';
+import { formatDuration } from '../../utils/shared/string.js';
+import { end } from '../../end.js';
+import { printBatchOutput } from './output.js';
+export const batch = async (configuration) => {
+    const batchStart = Date.now();
+    await Folder.create(configuration.reportDir);
+    await logger.start(configuration);
+    logger.debug({
+        source: 'job',
+        message: 'configuration',
+        data: { defaults, configuration: redactSecrets(toPlainObject(configuration)) }
+    });
+    if (!configuration.noBanner) {
+        await logEnvironnement();
+    }
+    logger.info({ source: 'progress', message: 'resolving batch items', pageId: undefined, data: { value: 0, max: 0 } });
+    const items = await resolve(configuration);
+    if (items.length === 0) {
+        logger.warn({ source: 'job', message: 'no batch items found' });
+        return;
+    }
+    logger.info({ source: 'job', message: `Found ${items.length} batch items` });
+    const startProcess = await start(configuration);
+    let failed = 0;
+    logger.info({ source: 'progress', message: 'executing batch items', pageId: undefined, data: { value: 0, max: 0 } });
+    let completed = 0;
+    let lastLoggedCompleted;
+    const started = new Set();
+    try {
+        await parallelize(async function (item) {
+            const result = await batchTask(configuration, item, batchStart);
+            if (configuration.failFast && (result.statusCode !== 0 || result.timedOut)) {
+                for (const [queuedIndex, queuedItem] of items.entries()) {
+                    if (started.has(queuedIndex)) {
+                        continue;
+                    }
+                    queuedItem.skipped = true;
+                    queuedItem.message = 'batch item not executed (fail-fast)';
+                }
+                this.stop(new Error(`batch item failed: ${result.id}`));
+            }
+            return result;
+        }, items, {
+            parallel: configuration.parallel,
+            on: (event) => {
+                if (event.type === 'started') {
+                    started.add(event.index);
+                }
+                else if (event.type === 'completed') {
+                    ++completed;
+                    if (event.input.statusCode !== 0 || event.input.timedOut) {
+                        ++failed;
+                    }
+                }
+                else if (event.type === 'failed') {
+                    ++failed;
+                    ++completed;
+                }
+                if (lastLoggedCompleted === completed) {
+                    return;
+                }
+                lastLoggedCompleted = completed;
+                logger.info({
+                    source: 'progress',
+                    message: 'executing batch items',
+                    pageId: undefined,
+                    data: { value: completed, max: items.length }
+                });
+            }
+        });
+    }
+    finally {
+        await startProcess?.kill();
+    }
+    await saveReport(configuration, await buildBatchReport(items, configuration));
+    if (configuration.batchOutput) {
+        await printBatchOutput(items);
+    }
+    logger.info({
+        source: 'job',
+        message: `Batch items completed: passed=${completed - failed} failed=${failed} count=${completed} (${formatDuration(Date.now() - batchStart)})`
+    });
+    if (failed > 0) {
+        Exit.code = -1;
+    }
+    await end(configuration);
+};

package/dist/modes/batch/output.js

@@ -0,0 +1,22 @@
+import { FileSystem, Path, logger } from '../../platform/index.js';
+export const printBatchOutput = async (items) => {
+    const sortedItems = [...items].toSorted((left, right) => left.id.localeCompare(right.id));
+    for (const item of sortedItems) {
+        try {
+            if (!item.reportDir) {
+                continue;
+            }
+            const output = await FileSystem.readFile(Path.join(item.reportDir, 'output.txt'), 'utf8');
+            logger.info({
+                source: 'job',
+                message: `Batch output: ${item.label} (${item.id})\n${output}`
+            });
+        }
+        catch {
+            logger.warn({
+                source: 'job',
+                message: `No batch output: ${item.label} (${item.id})`
+            });
+        }
+    }
+};