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

package/dist/platform/Path.js

@@ -0,0 +1,5 @@
+import { join, isAbsolute } from 'node:path';
+export class Path {
+    static isAbsolute = isAbsolute;
+    static join = join;
+}

package/dist/platform/Process.js

@@ -0,0 +1,133 @@
+import { Host } from './Host.js';
+import { spawn } from 'node:child_process';
+import { logger } from './logger.js';
+import { Exit } from './Exit.js';
+class ProcessStopper {
+    _process;
+    set process(value) {
+        this._process = value;
+    }
+    async stop() {
+        await this._process?.kill();
+        return this._process?.closed;
+    }
+}
+export class Process {
+    static spawn = (command, arguments_, options = {}) => {
+        const finalCommand = command === 'node' ? process.argv[0] : command;
+        let asyncTask;
+        try {
+            const stopper = new ProcessStopper();
+            asyncTask = Exit.registerAsyncTask({
+                name: `Process.spawn(${command},${arguments_.join(',')})`,
+                stop: () => stopper.stop()
+            });
+            const childProcess = spawn(finalCommand, arguments_, options);
+            logger.debug({
+                source: 'process',
+                processId: childProcess.pid,
+                message: 'spawned',
+                data: { command, arguments: arguments_, options }
+            });
+            const process = new Process(childProcess, asyncTask);
+            stopper.process = process;
+            return process;
+        }
+        catch (error) {
+            logger.error({
+                source: 'process',
+                message: 'spawn failed',
+                data: { command, arguments: arguments_, options },
+                error
+            });
+            asyncTask?.[Symbol.dispose]();
+            throw error;
+        }
+    };
+    _stdout = [];
+    get stdout() {
+        return this._stdout.join('');
+    }
+    _stderr = [];
+    get stderr() {
+        return this._stderr.join('');
+    }
+    _code;
+    get code() {
+        return this._code;
+    }
+    _closed;
+    get closed() {
+        return this._closed;
+    }
+    _childProcess;
+    _asyncTask;
+    constructor(childProcess, asyncTask) {
+        this._childProcess = childProcess;
+        this._asyncTask = asyncTask;
+        const { promise, resolve } = Promise.withResolvers();
+        this._closed = promise;
+        this._childProcess.stdout?.on('data', (buffer) => {
+            const message = buffer.toString();
+            logger.debug({ source: 'process', processId: this.pid, message, data: { type: 'stdout' } });
+            this._stdout.push(message);
+        });
+        this._childProcess.stderr?.on('data', (buffer) => {
+            const message = buffer.toString();
+            logger.debug({ source: 'process', processId: this.pid, message, data: { type: 'stderr' } });
+            this._stderr.push(message);
+        });
+        this._childProcess.on('close', (code) => {
+            this._code = code ?? 0;
+            logger.debug({
+                source: 'process',
+                processId: this.pid,
+                message: 'closed',
+                data: { code: this._code }
+            });
+            this._asyncTask[Symbol.dispose]();
+            resolve();
+        });
+    }
+    get pid() {
+        return this._childProcess.pid;
+    }
+    async kill() {
+        logger.debug({
+            source: 'process',
+            processId: this.pid,
+            message: 'kill'
+        });
+        try {
+            if (Host.platform() === 'win32') {
+                const killProcess = spawn('taskkill', ['/F', '/T', '/PID', this.pid.toString()], {
+                    windowsHide: true
+                });
+                const { promise, resolve } = Promise.withResolvers();
+                killProcess.on('close', () => setTimeout(resolve, 0));
+                await promise;
+            }
+            else {
+                try {
+                    process.kill(-this.pid);
+                }
+                catch {
+                    process.kill(this.pid);
+                }
+            }
+            logger.debug({
+                source: 'process',
+                processId: this.pid,
+                message: 'killed'
+            });
+        }
+        catch (error) {
+            logger.debug({
+                source: 'process',
+                processId: this.pid,
+                message: 'unable to kill',
+                error
+            });
+        }
+    }
+}

package/dist/platform/Terminal.js

@@ -0,0 +1,47 @@
+import { stripVTControlCharacters } from 'node:util';
+const ASCII_ESCAPE = '\u001B';
+const CSI = `${ASCII_ESCAPE}[`;
+export class Terminal {
+    static isTTY = process.stdout.isTTY;
+    static onResize(callback) {
+        process.stdout.on('resize', () => callback(Terminal.width));
+    }
+    static setRawMode(callback) {
+        if (callback === false) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+        else {
+            process.stdin.setRawMode(true);
+            process.stdin.on('data', callback);
+        }
+    }
+    static stripVTControlCharacters = stripVTControlCharacters;
+    static get width() {
+        return process.stdout.columns;
+    }
+    static write(text) {
+        process.stdout.write(text);
+    }
+    static hideCursor() {
+        Terminal.write(`${CSI}?25l`);
+    }
+    static showCursor() {
+        Terminal.write(`${CSI}?25h`);
+    }
+    static eraseToEnd(lines) {
+        if (lines === 0) {
+            Terminal.write(`${CSI}0G`);
+        }
+        else {
+            Terminal.write(`${CSI}0G${CSI}${lines}A${CSI}0J`);
+        }
+    }
+    static BLUE = `${CSI}34m`;
+    static CYAN = `${CSI}36m`;
+    static GREEN = `${CSI}32m`;
+    static MAGENTA = `${CSI}35m`;
+    static RED = `${CSI}31m`;
+    static WHITE = `${CSI}37m`;
+    static YELLOW = `${CSI}33m`;
+}

package/dist/platform/Thread.js

@@ -0,0 +1,43 @@
+import { extname } from 'node:path';
+import { Path } from './Path.js';
+import { BroadcastChannel, Worker, isMainThread, threadId } from 'node:worker_threads';
+import { __sourcesRoot } from './constants.js';
+import { logger } from './logger/proxy.js';
+export class Thread {
+    static threadCpuUsage = process.threadCpuUsage.bind(process);
+    static createBroadcastChannel = (name) => new BroadcastChannel(name);
+    static createWorker = (name, data) => {
+        const extension = extname(import.meta.url);
+        const workerPath = '../' + name + extension;
+        if (process.env['NO_WORKERS']) {
+            logger?.debug({ source: 'thread', message: `Creating fiber for ${name}`, data });
+            void (async () => {
+                const { workerMain } = (await import(workerPath));
+                workerMain(data);
+            })();
+            return {
+                on: (event, callback) => {
+                    if (event === 'exit') {
+                        callback(0);
+                    }
+                }
+            };
+        }
+        logger?.debug({ source: 'thread', message: `Creating worker for ${name}`, data });
+        const bootstrapPath = Path.join(__sourcesRoot, 'platform/workerBootstrap' + extension);
+        const js2tsUrl = new URL('js2ts.mjs', import.meta.url).toString();
+        const execArgv = extension === '.ts' ? ['--no-warnings', '--import', js2tsUrl] : [];
+        const worker = new Worker(bootstrapPath, {
+            execArgv,
+            workerData: {
+                path: workerPath,
+                data
+            }
+        });
+        worker.on('online', () => logger?.debug({ source: 'thread', message: `Worker for ${name} online`, data: { threadId: worker.threadId } }));
+        worker.on('exit', () => logger?.debug({ source: 'thread', message: `Worker for ${name} offline`, data: { threadId: worker.threadId } }));
+        return worker;
+    };
+    static isMainThread = isMainThread;
+    static threadId = threadId;
+}

package/dist/platform/ZLib.js

@@ -0,0 +1,7 @@
+import zlib from 'node:zlib';
+export class ZLib {
+    static constants = zlib.constants;
+    static gzipSync = zlib.gzipSync.bind(zlib);
+    static deflateRawSync = zlib.deflateRawSync.bind(zlib);
+    static inflateRawSync = zlib.inflateRawSync.bind(zlib);
+}

package/dist/platform/assert.js

@@ -0,0 +1,17 @@
+import { AssertionError } from 'node:assert/strict';
+import { __developmentMode } from './constants.js';
+import { logger } from './logger/proxy.js';
+export const assert = (condition, message = 'Assertion failed') => {
+    if (!condition) {
+        const error = new AssertionError({ message });
+        if (__developmentMode) {
+            let { stack } = error;
+            stack = stack ? stack.split('\n').slice(1).join('\n') : '';
+            logger?.fatal({ source: 'assert', message: (message ?? 'Assertion failed') + stack, error });
+        }
+        else {
+            logger?.fatal({ source: 'assert', message: message ?? 'Assertion failed', error });
+        }
+        throw error;
+    }
+};

package/dist/platform/constants.js

@@ -0,0 +1,5 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+export const __sourcesRoot = dirname(dirname(__filename));
+export const __developmentMode = __filename.endsWith('.ts');

package/dist/platform/environment.js

@@ -0,0 +1,28 @@
+import { Host } from './Host.js';
+import { logger } from './logger.js';
+import { version } from './version.js';
+export const logEnvironnement = async () => {
+    const runnerVersion = await version();
+    const now = new Date();
+    logger.info({
+        source: 'job',
+        message: `${runnerVersion} / Node.js ${Host.nodeVersion} / ${now.toISOString()} (${now.getTimezoneOffset()})`
+    });
+    const cpus = {};
+    for (const { model } of Host.cpus()) {
+        if (cpus[model]) {
+            ++cpus[model];
+        }
+        else {
+            cpus[model] = 1;
+        }
+    }
+    for (const [model, count] of Object.entries(cpus)) {
+        if (count === 1) {
+            logger.info({ source: 'job', message: `${Host.machine()} / ${model}` });
+        }
+        else {
+            logger.info({ source: 'job', message: `${Host.machine()} / ${count}x ${model}` });
+        }
+    }
+};

package/dist/platform/index.js

@@ -0,0 +1,13 @@
+export * from './assert.js';
+export * from './constants.js';
+export * from './environment.js';
+export * from './logger.js';
+export * from './Exit.js';
+export * from './FileSystem.js';
+export * from './Host.js';
+export * from './Http.js';
+export * from './Path.js';
+export * from './Process.js';
+export * from './Terminal.js';
+export * from './Thread.js';
+export * from './ZLib.js';

package/dist/platform/logger/ILogger.js

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

package/dist/platform/logger/allCompressed.js

@@ -0,0 +1,54 @@
+import { Path, Thread, ZLib } from '../index.js';
+import { LogLevel } from './types.js';
+import { toInternalLogAttributes } from './toInternalLogAttributes.js';
+import { createCompressionContext, compress } from './compress.js';
+import { FramedStreamWriter } from '../../utils/node/FramedStreamWriter.js';
+export const MAX_BUFFER_COUNT = 50;
+const FLUSH_INTERVAL_MS = 200;
+const compressionContext = createCompressionContext();
+export const workerMain = ({ configuration }) => {
+    const LOG_FILE_NAME = `traces-${new Date().toISOString().slice(0, 19).replaceAll(/[-:]/g, '').replace('T', '-')}.logz`;
+    const stream = FramedStreamWriter.create(Path.join(configuration.reportDir, LOG_FILE_NAME));
+    const buffer = [];
+    let flushTimeout;
+    let writePromise = Promise.resolve();
+    const flushBuffer = () => {
+        if (buffer.length === 0) {
+            return;
+        }
+        const chunk = buffer.join('\n');
+        buffer.length = 0;
+        clearTimeout(flushTimeout);
+        flushTimeout = undefined;
+        const compressed = ZLib.deflateRawSync(chunk, { level: ZLib.constants.Z_BEST_COMPRESSION });
+        writePromise = writePromise.then(() => stream.write(compressed));
+    };
+    const log = (attributes) => {
+        buffer.push(compress(compressionContext, attributes));
+        if (buffer.length >= MAX_BUFFER_COUNT) {
+            flushBuffer();
+        }
+        else if (!flushTimeout) {
+            flushTimeout = setTimeout(flushBuffer, FLUSH_INTERVAL_MS);
+        }
+    };
+    const _log = (attributes) => log(toInternalLogAttributes(attributes, LogLevel.info));
+    const channel = Thread.createBroadcastChannel('logger');
+    channel.onmessage = (event) => {
+        const { data: message } = event;
+        if (message.command === 'terminate') {
+            _log({ source: 'logger', message: 'Logger terminating' });
+            channel.close();
+            flushBuffer();
+            void writePromise.then(() => stream.end());
+        }
+        else if (message.command === 'log') {
+            log(message);
+        }
+    };
+    _log({ source: 'logger', message: 'Logger ready' });
+    channel.postMessage({
+        command: 'ready',
+        source: 'allCompressed'
+    });
+};

package/dist/platform/logger/compress.js

@@ -0,0 +1,277 @@
+import { LogLevel } from './types.js';
+import { isDeepStrictEqual } from 'node:util';
+import assert from 'node:assert/strict';
+import { split } from '../../utils/shared/string.js';
+const ASCII_RECORD_SEPARATOR = '\u001E';
+export const DIGITS = Array.from({ length: 127 - 32 })
+    .fill(0)
+    .map((_, index) => String.fromCodePoint(32 + index))
+    .join('');
+const JSON_VALUE_SEP = ASCII_RECORD_SEPARATOR;
+const MAX_INDEX_DIGITS = 2;
+const CONTEXT_PROCESS_ID = 'p';
+const CONTEXT_SOURCE_ID = 's';
+export const MAX_TIMESTAMP_DIGITS = 7;
+export const MAX_DWORD_DIGITS = 5;
+class Context {
+    static compressNumber(value, maxLength) {
+        const digits = [];
+        while (value > 0) {
+            const digit = value % DIGITS.length;
+            digits.push(DIGITS[digit]);
+            value = (value - digit) / DIGITS.length;
+        }
+        return digits.join('').padEnd(maxLength, DIGITS[0]);
+    }
+    static uncompressNumber(value) {
+        let result = 0;
+        let factor = 1;
+        for (const digit of value) {
+            const index = DIGITS.indexOf(digit);
+            result += index * factor;
+            factor *= DIGITS.length;
+        }
+        return result;
+    }
+    fail(message) {
+        throw new Error(message);
+    }
+    _compressWithList({ array, value, compress }) {
+        const index = array.findIndex((candidate) => isDeepStrictEqual(candidate, value));
+        if (index !== -1) {
+            const compressed = Context.compressNumber(index, MAX_INDEX_DIGITS);
+            return {
+                context: '',
+                compressed
+            };
+        }
+        const lastIndex = array.length;
+        array.push(value);
+        return {
+            context: compress(value).join(''),
+            compressed: Context.compressNumber(lastIndex, MAX_INDEX_DIGITS)
+        };
+    }
+    _uncompressFromList({ type, array, compressed }) {
+        const index = Context.uncompressNumber(compressed);
+        return array[index] ?? this.fail(`Invalid ${type} index ${index} (length: ${array.length})`);
+    }
+    _processes = [];
+    compressProcess(value) {
+        return this._compressWithList({
+            array: this._processes,
+            value,
+            compress: ({ processId, threadId, isMainThread }) => {
+                if (threadId === -1) {
+                    return [CONTEXT_PROCESS_ID, Context.compressNumber(processId, MAX_DWORD_DIGITS)];
+                }
+                return [
+                    CONTEXT_PROCESS_ID,
+                    Context.compressNumber(processId, MAX_DWORD_DIGITS),
+                    Context.compressNumber(threadId, MAX_DWORD_DIGITS),
+                    isMainThread ? '!' : ''
+                ];
+            }
+        });
+    }
+    addProcess(compressed) {
+        const [, cProcessId, cThreadId, cIsMainThread] = split(compressed, 1, MAX_DWORD_DIGITS, MAX_DWORD_DIGITS, 1);
+        if (cThreadId) {
+            this._processes.push({
+                processId: Context.uncompressNumber(cProcessId),
+                threadId: Context.uncompressNumber(cThreadId),
+                isMainThread: cIsMainThread === '!'
+            });
+        }
+        else {
+            this._processes.push({
+                processId: Context.uncompressNumber(cProcessId),
+                threadId: -1,
+                isMainThread: false
+            });
+        }
+    }
+    uncompressProcess(compressed) {
+        return this._uncompressFromList({
+            type: 'process',
+            array: this._processes,
+            compressed
+        });
+    }
+    _sources = [];
+    compressSource(value) {
+        return this._compressWithList({
+            array: this._sources,
+            value,
+            compress: (value) => [CONTEXT_SOURCE_ID, value]
+        });
+    }
+    addSource(compressed) {
+        this._sources.push(compressed.slice(1));
+    }
+    uncompressSource(compressed) {
+        return this._uncompressFromList({
+            type: 'source',
+            array: this._sources,
+            compressed
+        });
+    }
+}
+export const createCompressionContext = () => new Context();
+const LEVEL_MAPPING = {
+    [LogLevel.debug]: 'D',
+    [LogLevel.info]: 'I',
+    [LogLevel.warn]: 'W',
+    [LogLevel.error]: 'E',
+    [LogLevel.fatal]: 'F'
+};
+const LEVELS = Object.values(LEVEL_MAPPING).join('');
+const levelSlot = {
+    width: 1,
+    compress(_, { level }) {
+        return { compressed: LEVEL_MAPPING[level] };
+    },
+    uncompress(_, compressed) {
+        return { level: LEVELS.indexOf(compressed) };
+    }
+};
+const timestampSlot = {
+    width: MAX_TIMESTAMP_DIGITS,
+    compress(_, { timestamp }) {
+        return { compressed: Context.compressNumber(timestamp, MAX_TIMESTAMP_DIGITS) };
+    },
+    uncompress(_, compressed) {
+        return { timestamp: Context.uncompressNumber(compressed) };
+    }
+};
+const processSlot = {
+    width: MAX_INDEX_DIGITS,
+    compress(context, { processId, threadId, isMainThread }) {
+        const { context: contextLine, compressed } = context.compressProcess({ processId, threadId, isMainThread });
+        return { contextLine: contextLine || undefined, compressed };
+    },
+    uncompress(context, compressed) {
+        return context.uncompressProcess(compressed);
+    }
+};
+const sourceSlot = {
+    width: MAX_INDEX_DIGITS,
+    compress(context, { source }) {
+        const { context: contextLine, compressed } = context.compressSource(source);
+        return { contextLine: contextLine || undefined, compressed };
+    },
+    uncompress(context, compressed) {
+        return { source: context.uncompressSource(compressed) };
+    }
+};
+const pageIdSlot = {
+    width: MAX_INDEX_DIGITS,
+    compress(_, { pageId }) {
+        return { compressed: Context.compressNumber(pageId === undefined ? 0 : pageId + 1, MAX_INDEX_DIGITS) };
+    },
+    uncompress(_, compressed) {
+        const value = Context.uncompressNumber(compressed);
+        return value > 0 ? { pageId: value - 1 } : {};
+    }
+};
+const messageAndExtraSlot = {
+    width: 0,
+    compress(_, { message, data, error }) {
+        const parts = [message.replaceAll(/\r?\n/g, '\r')];
+        if (data || error) {
+            parts.push(JSON_VALUE_SEP, JSON.stringify([data ?? 0, error ?? 0]).replaceAll(/"(\w+)":/g, (_, name) => `${name}${JSON_VALUE_SEP}`));
+        }
+        return { compressed: parts.join('') };
+    },
+    uncompress(_, compressed) {
+        const startOfJson = compressed.indexOf(JSON_VALUE_SEP);
+        if (startOfJson === -1) {
+            return { message: compressed.replaceAll('\r', '\n') };
+        }
+        const message = compressed.slice(0, startOfJson).replaceAll('\r', '\n');
+        const json = compressed
+            .slice(startOfJson + 1)
+            .replaceAll(new RegExp(String.raw `(\w+)${JSON_VALUE_SEP}`, 'g'), (_, name) => `"${name}":`);
+        const [data, error] = JSON.parse(json);
+        return {
+            message,
+            ...(data ? { data } : {}),
+            ...(error ? { error } : {})
+        };
+    }
+};
+const DATA_LINE_SLOTS = [
+    levelSlot,
+    timestampSlot,
+    processSlot,
+    sourceSlot,
+    pageIdSlot,
+    messageAndExtraSlot
+];
+const FIXED_SLOTS = DATA_LINE_SLOTS.filter((s) => s.width > 0);
+const FIXED_SLOT_WIDTHS = FIXED_SLOTS.map((s) => s.width);
+const VARIABLE_SLOTS = DATA_LINE_SLOTS.filter((s) => s.width === 0);
+assert.ok(VARIABLE_SLOTS.length === 1, 'DATA_LINE_SLOTS must contain exactly one variable-width slot');
+const VARIABLE_SLOT = VARIABLE_SLOTS[0];
+export const _ALL_LOG_ATTRIBUTES_ARE_HANDLED = {
+    level: levelSlot,
+    timestamp: timestampSlot,
+    processId: processSlot,
+    threadId: processSlot,
+    isMainThread: processSlot,
+    source: sourceSlot,
+    pageId: pageIdSlot,
+    message: messageAndExtraSlot,
+    data: messageAndExtraSlot,
+    error: messageAndExtraSlot
+};
+export const compress = (context, attributes) => {
+    assert.ok(context instanceof Context);
+    const contextLines = [];
+    const parts = [];
+    for (const slot of DATA_LINE_SLOTS) {
+        const { contextLine, compressed } = slot.compress(context, attributes);
+        if (contextLine)
+            contextLines.push(contextLine);
+        parts.push(compressed);
+    }
+    return [...contextLines, parts.join('')].join('\n') + '\n';
+};
+const augmentContext = (context, line) => {
+    const firstChar = line.charAt(0);
+    if (firstChar === CONTEXT_PROCESS_ID) {
+        context.addProcess(line);
+    }
+    else {
+        assert.ok(firstChar === CONTEXT_SOURCE_ID, `unexpected context operator ${firstChar}`);
+        context.addSource(line);
+    }
+};
+const uncompressLine = (context, line) => {
+    const firstChar = line.charAt(0);
+    if (!LEVELS.includes(firstChar)) {
+        augmentContext(context, line);
+        return;
+    }
+    const parts = split(line, ...FIXED_SLOT_WIDTHS);
+    const attributes = {};
+    for (const [index, fixedSlot] of FIXED_SLOTS.entries()) {
+        Object.assign(attributes, fixedSlot.uncompress(context, parts[index]));
+    }
+    Object.assign(attributes, VARIABLE_SLOT.uncompress(context, parts[FIXED_SLOTS.length]));
+    return attributes;
+};
+export const uncompress = (context, compressed) => {
+    assert.ok(context instanceof Context);
+    const result = [];
+    for (const line of compressed.split('\n')) {
+        if (!line) {
+            continue;
+        }
+        const attributes = uncompressLine(context, line);
+        if (attributes) {
+            result.push(attributes);
+        }
+    }
+    return result;
+};