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

package/dist/modes/batch/report.js

@@ -0,0 +1,45 @@
+import { initReportBuilder } from '../../reports/initReportBuilder.js';
+import { anonymize } from '../../utils/node/anonymize.js';
+const itemStatus = (item) => {
+    if (item.skipped) {
+        return 'skipped';
+    }
+    return item.timedOut || item.statusCode !== 0 ? 'failed' : 'passed';
+};
+export const buildBatchReport = async (items, configuration) => {
+    let start = Date.now();
+    for (const item of items) {
+        start = Math.min(item.start?.getTime() ?? start, start);
+    }
+    let stop = start;
+    for (const item of items) {
+        stop = Math.max(item.end?.getTime() ?? stop, stop);
+    }
+    const tests = items.map((item) => {
+        const itemStart = item.start?.getTime() ?? start;
+        const itemStop = item.end?.getTime() ?? stop;
+        const status = itemStatus(item);
+        return {
+            name: item.label,
+            status,
+            duration: itemStop - itemStart,
+            start: itemStart,
+            stop: itemStop,
+            filePath: anonymize(item).path,
+            ...(item.message !== undefined && { message: item.message })
+        };
+    });
+    const summary = {
+        tests: tests.length,
+        passed: tests.filter((test) => test.status === 'passed').length,
+        failed: tests.filter((test) => test.status === 'failed').length,
+        skipped: tests.filter((test) => test.status === 'skipped').length,
+        pending: 0,
+        other: 0,
+        start,
+        stop,
+        duration: stop - start
+    };
+    const builder = await initReportBuilder(configuration);
+    return { ...builder.report, results: { ...builder.report.results, summary, tests } };
+};

package/dist/modes/batch/resolve.js

@@ -0,0 +1,105 @@
+import { FileSystem, Path, logger } from '../../platform/index.js';
+const folder = (items, folderPath) => {
+    const id = Path.basename(folderPath);
+    items.push({
+        path: folderPath,
+        id,
+        label: id,
+        args: ['--cwd', folderPath]
+    });
+};
+const configurationFile = async (items, configPath) => {
+    try {
+        const content = await FileSystem.readFile(configPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const id = parsed.batchId ?? Path.basename(configPath);
+        const label = parsed.batchLabel ?? Path.basename(configPath);
+        items.push({
+            path: configPath,
+            id,
+            label,
+            args: ['--config', configPath]
+        });
+    }
+    catch {
+        logger.warn({
+            source: 'job',
+            message: 'batch item failed',
+            data: { path: configPath, reason: 'invalid JSON configuration file' }
+        });
+    }
+};
+const scan = async (items, cwd, re, root = cwd) => {
+    const names = await FileSystem.readdir(cwd);
+    let count = 0;
+    for (const name of names) {
+        const path = Path.join(cwd, name);
+        if (name === 'node_modules' || name.startsWith('.')) {
+            logger.debug({
+                source: 'job',
+                message: `Ignored ${path} while scanning for batch items`
+            });
+            continue;
+        }
+        const relativePath = path.slice(root.length + 1).replaceAll('\\', '/');
+        const pathStat = await FileSystem.stat(path);
+        if (pathStat.isDirectory()) {
+            if (re.test(relativePath)) {
+                folder(items, path);
+                continue;
+            }
+            count += await scan(items, path, re, root);
+        }
+        else if (pathStat.isFile()) {
+            ++count;
+            if (re.test(relativePath)) {
+                await configurationFile(items, path);
+            }
+        }
+    }
+    return count;
+};
+export const resolve = async (configuration) => {
+    const items = [];
+    const specs = configuration.batch ?? [];
+    for (const spec of specs) {
+        try {
+            const path = Path.isAbsolute(spec) ? spec : Path.join(configuration.cwd, spec);
+            const pathStat = await FileSystem.stat(path);
+            if (pathStat.isDirectory()) {
+                folder(items, path);
+            }
+            else if (pathStat.isFile() && path.endsWith('.json')) {
+                await configurationFile(items, path);
+            }
+            else {
+                logger.warn({
+                    source: 'job',
+                    message: 'batch item failed',
+                    data: { path: spec, reason: 'only folders and JSON configuration files are supported' }
+                });
+            }
+            continue;
+        }
+        catch {
+        }
+        let re;
+        try {
+            re = new RegExp(spec);
+        }
+        catch {
+            logger.warn({
+                source: 'job',
+                message: 'batch item failed',
+                data: { path: spec, reason: 'invalid regular expression' }
+            });
+            continue;
+        }
+        const scanned = await scan(items, configuration.cwd, re);
+        logger.debug({
+            source: 'job',
+            message: `Scanned ${scanned} items`
+        });
+    }
+    return items;
+};

package/dist/modes/dumpConfig.js

@@ -0,0 +1,6 @@
+import { redactSecrets } from '../utils/node/anonymize.js';
+import { toPlainObject } from '../utils/shared/object.js';
+export const dumpConfig = (configuration) => {
+    const safe = redactSecrets(toPlainObject(configuration));
+    console.log(JSON.stringify(safe, null, 2));
+};

package/dist/modes/execute.js

@@ -1,18 +1,19 @@
+import { dumpConfig } from './dumpConfig.js';
 import { help } from './help.js';
 import { log } from './log/index.js';
+import { mcp } from './mcp/index.js';
 import { Modes } from './Modes.js';
 import { version } from './version.js';
 import { test } from './test/index.js';
+import { batch } from './batch/index.js';
 import { Exit } from '../platform/Exit.js';
-const notImplemented = () => {
-    throw new Error('Not implemented');
-};
 const modeFunctions = {
-    [Modes.batch]: notImplemented,
-    [Modes.capabilities]: notImplemented,
+    [Modes.batch]: batch,
+    [Modes.dumpConfig]: dumpConfig,
     [Modes.help]: help,
     [Modes.legacy]: test,
     [Modes.log]: log,
+    [Modes.mcp]: mcp,
     [Modes.remote]: test,
     [Modes.version]: version
 };

package/dist/modes/help.js

@@ -1,3 +1,88 @@
-export const help = () => {
-    console.log('Please check https://arnaudbuchholz.github.io/ui5-test-runner/');
+import { options } from '../configuration/options.js';
+import { Terminal } from '../platform/index.js';
+import { version } from '../platform/version.js';
+import { Npm } from '../Npm.js';
+import { toKebabCase } from '../utils/shared/string.js';
+const FALLBACK_WIDTH = 80;
+export const DOCUMENTATION_LINK = 'https://github.com/ArnaudBuchholz/ui5-test-runner/tree/main/docs#-documentation';
+const formatDefault = (value) => {
+    return Array.isArray(value) ? value.join(', ') : String(value);
+};
+const wrapText = (text, width, indent) => {
+    if (width <= 0) {
+        return text;
+    }
+    const words = text.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+        }
+        else if (current.length + 1 + word.length <= width) {
+            current += ` ${word}`;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current.length > 0) {
+        lines.push(current);
+    }
+    return lines.join(`\n${indent}`);
+};
+const optionFlags = (option) => {
+    const short = 'short' in option ? option.short : undefined;
+    const kebab = toKebabCase(option.name);
+    return short ? `--${kebab}, -${short}` : `--${kebab}`;
+};
+const TYPE_DISPLAY = {
+    'fs-entry': 'path',
+    'library-mapping': 'mapping'
+};
+const optionTypeLabel = (option) => {
+    const isMultiple = 'multiple' in option && option.multiple;
+    const display = TYPE_DISPLAY[option.type] ?? option.type;
+    return isMultiple ? `<${display}...>` : `<${display}>`;
+};
+const optionDescription = (option) => !('typeModifiers' in option) || !option.typeModifiers
+    ? option.description
+    : `${option.description} (${[...option.typeModifiers].join(', ')})`;
+export const help = async () => {
+    const { name, version: semver } = await version();
+    console.log(`${name}@${semver}`);
+    let latestVersion;
+    try {
+        latestVersion = await Npm.getLatestVersion(name);
+    }
+    catch {
+    }
+    if (latestVersion !== undefined && latestVersion !== semver) {
+        console.log(`Latest version of ${name} is ${latestVersion}`);
+    }
+    console.log('');
+    console.log('Usage: ui5-test-runner [options]\n');
+    console.log('Options:\n');
+    const col1Width = Math.max(...options.map((option) => optionFlags(option).length));
+    const col2Width = Math.max(...options.map((option) => optionTypeLabel(option).length));
+    const terminalWidth = Terminal.width || FALLBACK_WIDTH;
+    const descIndentWidth = 2 + col1Width + 2 + col2Width + 2;
+    const descWidth = terminalWidth - descIndentWidth;
+    const descIndent = ' '.repeat(descIndentWidth);
+    const getDefaultLabel = (option) => {
+        if ('defaultLabel' in option) {
+            return option.defaultLabel;
+        }
+        return 'default' in option ? formatDefault(option.default) : undefined;
+    };
+    for (const option of options) {
+        const flags = optionFlags(option);
+        const typeLabel = optionTypeLabel(option);
+        const defaultLabel = getDefaultLabel(option);
+        const defaultPart = defaultLabel === undefined ? '' : ` [default: ${defaultLabel}]`;
+        const desc = wrapText(`${optionDescription(option)}${defaultPart}`, descWidth, descIndent);
+        console.log(`  ${flags.padEnd(col1Width)}  ${typeLabel.padEnd(col2Width)}  ${desc}`);
+    }
+    console.log(`\nFor full documentation, visit ${DOCUMENTATION_LINK}`);
 };

package/dist/modes/log/LogReader.js

@@ -1,11 +1,12 @@
 import { ZLib } from '../../platform/index.js';
-import { createCompressionContext, uncompress } from '../../platform/logger/compress.js';
+import { CompressionContext } from '../../platform/logger/CompressionContext.js';
+import { uncompress } from '../../platform/logger/compress.js';
 import { FramedStreamReader } from '../../utils/node/FramedStreamReader.js';
 import { getInitialLogMetrics } from './LogMetrics.js';
 export const POLL_INTERVAL_MS = 500;
 export const LogReader = {
     async *read(logFileName, signal) {
-        const context = createCompressionContext();
+        const context = CompressionContext.create();
         const stream = FramedStreamReader.create(logFileName, POLL_INTERVAL_MS);
         const metrics = getInitialLogMetrics();
         for await (const chunk of stream.read(signal)) {

package/dist/modes/log/LogStorage.js

@@ -17,52 +17,56 @@ export class LogStorage {
         this._logsAdded = true;
     }
     _sortIfNeeded() {
-        if (this._logsAdded) {
-            this._logs.sort((a, b) => a.timestamp - b.timestamp);
-            this._logsAdded = false;
+        if (!this._logsAdded) {
+            return;
         }
+        this._logs.sort((a, b) => a.timestamp - b.timestamp);
+        this._logsAdded = false;
     }
     static buildFilterExpression(filter) {
-        if (!filter) {
-            return () => true;
-        }
         const expression = punyexpr(filter);
         return (log) => !!expression({
             ...log,
             level: LOG_LEVELS[log.level],
-            [punyexpr.propertyOf]: (value, property) => {
-                if (value === undefined) {
-                    return;
-                }
-                return value[property];
-            }
+            [punyexpr.propertyOf]: (value, property) => value && value[property]
         });
     }
-    fetch(query = {}) {
-        this._sortIfNeeded();
-        const { from = 0, to = Number.MAX_SAFE_INTEGER, filter = '' } = query;
-        let { skip = 0, limit = MAX_LIMIT } = query;
-        const filterExpression = LogStorage.buildFilterExpression(filter);
-        limit = Math.max(0, Math.min(limit, MAX_LIMIT));
+    #fetch(query) {
+        const { from, to, filter, skip, cappedLimit, hasRange, hasFilter } = query;
+        const filterExpression = hasFilter ? LogStorage.buildFilterExpression(filter) : null;
+        let startIndex = 0;
+        if (hasRange) {
+            startIndex = this._logs.findIndex((log) => log.timestamp >= from);
+            if (startIndex === -1) {
+                return [];
+            }
+        }
         const records = [];
-        for (let index = 0; limit > 0 && index < this._logs.length; ++index) {
+        let skipped = 0;
+        for (let index = startIndex; index < this._logs.length && records.length < cappedLimit; ++index) {
             const log = this._logs[index];
-            if (log.timestamp < from) {
-                continue;
-            }
-            if (log.timestamp > to) {
+            if (hasRange && log.timestamp > to) {
                 break;
             }
-            if (skip > 0) {
-                --skip;
+            if (filterExpression && !filterExpression(log)) {
                 continue;
             }
-            if (!filterExpression(log)) {
+            if (skipped < skip) {
+                ++skipped;
                 continue;
             }
             records.push(log);
-            --limit;
         }
         return records;
     }
+    fetch(query = {}) {
+        this._sortIfNeeded();
+        const { from = 0, to = Number.MAX_SAFE_INTEGER, filter = '', skip = 0, limit = MAX_LIMIT } = query;
+        const cappedLimit = Math.min(limit, MAX_LIMIT);
+        const hasRange = from !== 0 || to !== Number.MAX_SAFE_INTEGER;
+        const hasFilter = filter !== '';
+        return !hasRange && !hasFilter
+            ? this._logs.slice(skip, skip + Math.max(cappedLimit, 0))
+            : this.#fetch({ from, to, filter, skip, limit, cappedLimit, hasRange, hasFilter });
+    }
 }

package/dist/modes/log/index.js

@@ -2,20 +2,51 @@ import { __developmentMode, Exit } from '../../platform/index.js';
 import { LogReader } from './LogReader.js';
 import { serve } from 'reserve';
 import { LogStorage } from './LogStorage.js';
-import { buildREserveConfiguration } from './REserve.js';
+import { buildREserveConfiguration } from './reserve.js';
 import { BrowserFactory } from '../../browsers/factory.js';
 import { getInitialLogMetrics } from './LogMetrics.js';
+const dumpLogToStdout = async (configuration) => {
+    const logFileName = configuration.log;
+    const logFilter = configuration.logFilter;
+    const filterExpression = logFilter && logFilter.trim() !== '' ? LogStorage.buildFilterExpression(logFilter) : undefined;
+    process.stdout.write('[\n');
+    let isFirst = true;
+    for await (const item of LogReader.read(logFileName)) {
+        if (item.type !== 'log') {
+            continue;
+        }
+        const { type: _, ...logAttributes } = item;
+        if (filterExpression && !filterExpression(logAttributes)) {
+            continue;
+        }
+        if (!isFirst) {
+            process.stdout.write(',\n');
+        }
+        process.stdout.write('  ' + JSON.stringify(logAttributes));
+        isFirst = false;
+    }
+    process.stdout.write(isFirst ? ']\n' : '\n]\n');
+};
 export const log = async (configuration) => {
+    if (configuration.logDump) {
+        await dumpLogToStdout(configuration);
+        return;
+    }
     const logFileName = configuration.log;
-    let stopped = false;
+    let isStopped = false;
     const metrics = getInitialLogMetrics();
     const storage = LogStorage.create();
     const { promise, resolve } = Promise.withResolvers();
     const abortController = new AbortController();
     const abortSignal = abortController.signal;
-    const server = serve(buildREserveConfiguration(storage, metrics, abortController));
+    const server = serve(buildREserveConfiguration({
+        configuration,
+        storage,
+        metrics,
+        abortController
+    }));
     const stop = async () => {
-        stopped = true;
+        isStopped = true;
         await server?.close();
         resolve();
     };
@@ -43,12 +74,13 @@ export const log = async (configuration) => {
         });
     });
     for await (const item of LogReader.read(logFileName, abortSignal)) {
-        if (stopped) {
+        if (isStopped) {
             break;
         }
         const { type, ...attributes } = item;
         if (type === 'log') {
-            storage.add(attributes);
+            const { type: _, ...logAttributes } = item;
+            storage.add(logAttributes);
         }
         else if (__developmentMode) {
             Object.assign(metrics, attributes);

package/dist/modes/log/{REserve.js → reserve.js}

@@ -16,8 +16,8 @@ const getAsInt = (parameters, key) => {
     const value = parameters.get(key);
     return value ? Number.parseInt(value) : undefined;
 };
-export const buildREserveConfiguration = (storage, metrics, abortController) => ({
-    port: 0,
+export const buildREserveConfiguration = ({ configuration, storage, metrics, abortController }) => ({
+    port: configuration.port ?? 0,
     mappings: [
         {
             method: 'GET',
@@ -37,6 +37,29 @@ export const buildREserveConfiguration = (storage, metrics, abortController) =>
                 ];
             }
         },
+        {
+            method: 'GET',
+            match: '/all',
+            custom: async (request, response) => {
+                response.writeHead(200, {
+                    'content-type': 'application/json'
+                });
+                response.write('[\n');
+                const { length } = storage;
+                for (let index = 0; index < length; ++index) {
+                    const log = storage.fetch({
+                        skip: index,
+                        limit: 1
+                    })[0];
+                    const suffix = index < length - 1 ? ',\n' : '\n';
+                    const isDrainNeeded = !response.write('  ' + JSON.stringify(log) + suffix);
+                    if (isDrainNeeded) {
+                        await new Promise((resolve) => response.once('drain', resolve));
+                    }
+                }
+                response.end(']\n');
+            }
+        },
         {
             method: 'GET',
             match: '/lib.js',

package/dist/modes/mcp/IDocument.js

@@ -0,0 +1,2 @@
+const EXCLUDED_FOLDERS = ['adr', 'decks', 'prompts'];
+export const isExcludedPath = (documentationRelativePath) => EXCLUDED_FOLDERS.some((folder) => documentationRelativePath.startsWith(`${folder}/`));

package/dist/modes/mcp/frontmatter.js

@@ -0,0 +1,142 @@
+const FRONTMATTER_RE = /^---\n([\s\S]*?\n)---\n?([\s\S]*)$/;
+const KNOWN_SCALARS = new Set(['#type', 'id', 'title', 'summary']);
+const assignScalar = (frontmatter, key, value) => {
+    switch (key) {
+        case '#type': {
+            frontmatter['#type'] = value;
+            break;
+        }
+        case 'id': {
+            frontmatter.id = value;
+            break;
+        }
+        case 'title': {
+            frontmatter.title = value;
+            break;
+        }
+        case 'summary': {
+            frontmatter.summary = value;
+            break;
+        }
+    }
+};
+const stripQuotes = (value) => {
+    const trimmed = value.trim();
+    return trimmed.length >= 2 && (trimmed.startsWith('"') || trimmed.startsWith("'")) && trimmed.endsWith(trimmed[0])
+        ? trimmed.slice(1, -1)
+        : trimmed;
+};
+const parseInlineList = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
+        return null;
+    }
+    const inner = trimmed.slice(1, -1).trim();
+    return inner === '' ? [] : inner.split(',').map((item) => stripQuotes(item));
+};
+const measure = (line) => {
+    const trimmed = line.trimStart();
+    return { indent: line.length - trimmed.length, content: trimmed.trimEnd() };
+};
+const collectBlock = (lines, start, parentIndent) => {
+    const items = [];
+    let index = start;
+    while (index < lines.length) {
+        const { indent, content } = measure(lines[index]);
+        if (content === '') {
+            index += 1;
+            continue;
+        }
+        if (indent <= parentIndent || !content.startsWith('- ')) {
+            break;
+        }
+        items.push(stripQuotes(content.slice(2)));
+        index += 1;
+    }
+    return { items, next: index };
+};
+const readList = (lines, start, parentIndent, value) => {
+    if (value === '') {
+        const block = collectBlock(lines, start, parentIndent);
+        return { items: block.items, next: block.next };
+    }
+    return { items: parseInlineList(value), next: start };
+};
+const collectRelations = (lines, start, parentIndent) => {
+    const relations = {};
+    let index = start;
+    while (index < lines.length) {
+        const { indent, content } = measure(lines[index]);
+        if (content === '') {
+            index += 1;
+            continue;
+        }
+        if (indent <= parentIndent) {
+            break;
+        }
+        const colon = content.indexOf(':');
+        if (colon === -1) {
+            index += 1;
+            continue;
+        }
+        const key = content.slice(0, colon).trim();
+        const list = readList(lines, index + 1, indent, content.slice(colon + 1).trim());
+        index = list.next;
+        if (list.items !== null) {
+            relations[key] = list.items;
+        }
+    }
+    return { relations, next: index };
+};
+const skipIndentedBlock = (lines, start, parentIndent) => {
+    let index = start;
+    while (index < lines.length) {
+        const { indent, content } = measure(lines[index]);
+        if (content !== '' && indent <= parentIndent) {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+};
+const applyEntry = (frontmatter, lines, index, indent, key, value) => {
+    if (key === 'relations' && value === '') {
+        const result = collectRelations(lines, index, indent);
+        frontmatter.relations = result.relations;
+        return result.next;
+    }
+    if (key === 'keywords') {
+        const list = readList(lines, index, indent, value);
+        if (list.items !== null) {
+            frontmatter.keywords = list.items;
+        }
+        return list.next;
+    }
+    if (value !== '' && KNOWN_SCALARS.has(key)) {
+        assignScalar(frontmatter, key, stripQuotes(value));
+        return index;
+    }
+    if (value === '') {
+        return skipIndentedBlock(lines, index, indent);
+    }
+    return index;
+};
+const parseMetadata = (raw) => {
+    const frontmatter = {};
+    const lines = raw.split('\n');
+    let index = 0;
+    while (index < lines.length) {
+        const { indent, content } = measure(lines[index]);
+        const colon = content.indexOf(':');
+        if (colon === -1 || indent > 0) {
+            index += 1;
+            continue;
+        }
+        index = applyEntry(frontmatter, lines, index + 1, indent, stripQuotes(content.slice(0, colon)), content.slice(colon + 1).trim());
+    }
+    return frontmatter;
+};
+export const parseFrontmatter = (content) => {
+    const match = FRONTMATTER_RE.exec(content);
+    return match ? { frontmatter: parseMetadata(match[1]), body: match[2] } : { frontmatter: null, body: content };
+};