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

package/dist/platform/Exit.js

@@ -26,14 +26,14 @@ const socketHandleDescriptor = (handle) => {
     if (handle._handle) {
         const underlyingHandle = handle._handle;
         const underlyingClassName = underlyingHandle && underlyingHandle.constructor && underlyingHandle.constructor.name;
-        return `${underlyingClassName || 'handle unknown'}`;
+        return underlyingClassName || 'handle unknown';
     }
     return 'unknown';
 };
 const handleDescriptors = {
     ChildProcess: (handle) => {
         return (`pid: ${handle.pid}` +
-            (handle.spawnargs ? ` ${handle.spawnargs.map((value) => ('' + value).replaceAll(' ', '␣'))}` : ' unknown'));
+            (handle.spawnargs ? ` ${handle.spawnargs.map((value) => value.replaceAll(' ', '␣'))}` : ' unknown'));
     },
     ReadStream: (handle) => (handle.fd === 0 ? `stdin isTTY: ${handle.isTTY}` : `fd: ${handle.fd}`),
     Server: (handle) => `connections: ${handle._connections} events: ${handle._eventsCount}`,
@@ -44,10 +44,12 @@ const handleDescriptors = {
         : `fd: ${handle.fd}`
 };
 const isStdStream = (handle) => 'fd' in handle && handle.fd >= 0 && handle.fd < 3;
-const unknownHandleDescriptor = () => 'unknown';
+const unknownHandleDescriptor = (_handle) => 'unknown';
 const describeHandle = (handle) => {
-    const className = handle && handle.constructor && handle.constructor.name;
-    return { className, label: (handleDescriptors[className] ?? unknownHandleDescriptor)(handle) };
+    const className = (handle && handle.constructor && handle.constructor.name);
+    return className
+        ? { className, label: (handleDescriptors[className] ?? unknownHandleDescriptor)(handle) }
+        : { className: 'unknown', label: unknownHandleDescriptor(handle) };
 };
 export class Exit {
     static _asyncTaskId = 0;
@@ -55,38 +57,42 @@ export class Exit {
     static _checkForHandlesLeak() {
         const undocumentedProcess = process;
         if (!undocumentedProcess._getActiveHandles) {
-            logger?.warn({ source: 'exit/handle', message: 'Missing process._getActiveHandles' });
+            logger?.warn({ source: 'exit/handle', message: 'missing process._getActiveHandles' });
             return;
         }
         const activeHandles = undocumentedProcess._getActiveHandles();
-        let messagePortFound = false;
+        let isMessagePortFound = false;
         for (const handle of activeHandles) {
             const { className, label } = describeHandle(handle);
             if (isStdStream(handle)) {
                 logger?.debug({ source: 'exit/handle', message: `${className} ${label}` });
             }
-            else if (className === 'MessagePort' && !messagePortFound) {
-                messagePortFound = true;
+            else if (className === 'MessagePort' && !isMessagePortFound) {
+                isMessagePortFound = true;
                 logger?.debug({ source: 'exit/handle', message: `${className} ${label}` });
             }
+            else if (['TLSSocket', 'Socket'].includes(className)) {
+                logger?.debug({ source: 'exit/handle', message: `destroying leak ${className} ${label}` });
+                handle.destroy();
+            }
             else {
                 logger?.warn({ source: 'exit/handle', message: `possible leak ${className} ${label}` });
-                if (className === 'TLSSocket' || className === 'Socket') {
-                    handle.destroy();
-                }
             }
         }
     }
+    static get code() {
+        return (process.exitCode ?? 0);
+    }
     static set code(code) {
         assert(Thread.isMainThread, 'Exit.code can be set only on main thread');
         process.exitCode = code;
     }
     static registerAsyncTask(task) {
         assert(Thread.isMainThread, 'Exit.registerAsyncTask can be called only on main thread');
-        if (Exit._enteringShutdown) {
+        if (this._enteringShutdown) {
             throw new ExitShutdownError();
         }
-        const id = ++Exit._asyncTaskId;
+        const id = ++this._asyncTaskId;
         this._asyncTasks.push({
             id,
             ...task
@@ -95,7 +101,7 @@ export class Exit {
             [Symbol.dispose]() {
                 const index = Exit._asyncTasks.findIndex((task) => task.id === id);
                 try {
-                    assert(index !== -1, 'unable to find Exit async task to unregister');
+                    assert(Exit._enteringShutdown || index !== -1, `unable to find Exit async task "${task.name}" to unregister (shutdown=${Exit._enteringShutdown})`);
                     Exit._asyncTasks.splice(index, 1);
                 }
                 catch {
@@ -107,10 +113,13 @@ export class Exit {
     static _logLevel = 'debug';
     static async shutdown() {
         assert(Thread.isMainThread, 'Exit.shutdown can be called only on main thread');
-        Exit._enteringShutdown = true;
-        const logLevel = Exit._logLevel;
-        while (Exit._asyncTasks.length > 0) {
-            const task = Exit._asyncTasks.at(-1);
+        if (this._enteringShutdown) {
+            return;
+        }
+        this._enteringShutdown = true;
+        const logLevel = this._logLevel;
+        while (this._asyncTasks.length > 0) {
+            const task = this._asyncTasks.at(-1);
             try {
                 logger?.[logLevel]({ source: 'exit', message: `Stopping ${task.name}...` });
                 await task.stop();
@@ -120,20 +129,20 @@ export class Exit {
                 logger?.[logLevel]({ source: 'exit', message: `Failed while stopping ${task.name}...`, error });
             }
             finally {
-                if (task === Exit._asyncTasks.at(-1)) {
-                    Exit._asyncTasks.pop();
+                if (task === this._asyncTasks.at(-1)) {
+                    this._asyncTasks.pop();
                 }
             }
         }
-        Exit._checkForHandlesLeak();
+        this._checkForHandlesLeak();
         logger?.[logLevel]({ source: 'exit', message: `Stopping logger...` });
         await logger?.stop();
     }
     static sigInt() {
         Exit._logLevel = 'info';
-        void Exit.shutdown();
+        void this.shutdown();
     }
 }
 if (Thread.isMainThread) {
-    process.on('SIGINT', Exit.sigInt);
+    process.on('SIGINT', () => Exit.sigInt());
 }

package/dist/platform/FileSystem.js

@@ -1,13 +1,17 @@
-import { access, stat, constants, readFile, mkdir, rm } from 'node:fs/promises';
-import { createReadStream, createWriteStream, writeFileSync } from 'node:fs';
+import { access, stat, constants, readFile, readdir, mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { createReadStream, createWriteStream, watch, writeFileSync } from 'node:fs';
 export class FileSystem {
     static access = access;
     static constants = constants;
     static createReadStream = createReadStream;
     static createWriteStream = createWriteStream;
     static mkdir = mkdir;
+    static readdir = readdir;
     static readFile = readFile;
+    static rename = rename;
     static rm = rm;
     static stat = stat;
+    static writeFile = writeFile;
+    static watch = watch;
     static writeFileSync = writeFileSync;
 }

package/dist/platform/Host.js

@@ -1,10 +1,18 @@
-import { machine, cpus, platform } from 'node:os';
+import { machine, cpus, platform, release, version, homedir, tmpdir } from 'node:os';
 export class Host {
+    static argv = process.argv;
+    static nodePath = process.argv[0];
     static cpus = cpus;
     static cwd = process.cwd.bind(process);
+    static env = process.env;
+    static tmpdir = tmpdir;
+    static homedir = homedir;
     static machine = machine;
     static memoryUsage = process.memoryUsage.bind(process);
     static nodeVersion = process.version;
+    static osRelease = release;
+    static osVersion = version;
     static pid = process.pid;
     static platform = platform;
+    static version = process.version;
 }

package/dist/platform/Http.js

@@ -1,38 +1,63 @@
 import { logger } from './logger.js';
 import { Exit } from './Exit.js';
-let lastRequestId = 0;
+let _lastRequestId = 0;
+const _fetch = async (url, init) => {
+    const { requestId = ++_lastRequestId, controller = new AbortController(), ...fetchInit } = init ?? {};
+    let abortForwarder;
+    if (init?.signal) {
+        abortForwarder = () => controller.abort();
+        init.signal.addEventListener('abort', abortForwarder);
+    }
+    const loggedInit = Object.keys(fetchInit).length > 0 ? fetchInit : undefined;
+    using _ = Exit.registerAsyncTask({
+        name: `http.fetch#${requestId}`,
+        stop: () => controller.abort()
+    });
+    logger.debug({
+        source: 'http',
+        message: `${fetchInit?.method ?? 'GET'} ${url}`,
+        data: { requestId, init: loggedInit }
+    });
+    try {
+        const response = await fetch(url, {
+            ...fetchInit,
+            signal: controller.signal
+        });
+        const headers = Object.fromEntries(response.headers);
+        logger.debug({
+            source: 'http',
+            message: `${response.status} ${response.statusText}`,
+            data: { requestId, status: response.status, headers }
+        });
+        return response;
+    }
+    catch (error) {
+        logger.debug({ source: 'http', message: 'error caught', data: { requestId }, error });
+        throw error;
+    }
+    finally {
+        if (abortForwarder) {
+            init?.signal?.removeEventListener('abort', abortForwarder);
+        }
+    }
+};
 export const Http = {
-    async get(url) {
-        const requestId = ++lastRequestId;
+    async fetch(url, init) {
+        return _fetch(url, init);
+    },
+    async getAsText(url) {
+        const requestId = ++_lastRequestId;
         const controller = new AbortController();
+        const response = await _fetch(url, { method: 'GET', requestId, controller });
+        if (!response.ok) {
+            throw new Error('HTTP request failed');
+        }
         using _ = Exit.registerAsyncTask({
-            name: `http.get#${requestId}`,
+            name: `http.getAsText#${requestId}`,
             stop: () => controller.abort()
         });
-        logger.debug({ source: 'http', message: `GET ${url}`, data: { requestId } });
-        try {
-            const response = await fetch(url, {
-                signal: controller.signal
-            });
-            const headers = {};
-            for (const [name, value] of response.headers) {
-                headers[name] = value;
-            }
-            logger.debug({
-                source: 'http',
-                message: `${response.status} ${response.statusText}`,
-                data: { requestId, status: response.status, headers }
-            });
-            if (!response.ok) {
-                throw new Error('HTTP request failed');
-            }
-            const text = await response.text();
-            logger.debug({ source: 'http', message: text, data: { requestId } });
-            return text;
-        }
-        catch (error) {
-            logger.debug({ source: 'http', message: 'error caught', data: { requestId }, error });
-            throw error;
-        }
+        const text = await response.text();
+        logger.debug({ source: 'http', message: text, data: { requestId } });
+        return text;
     }
 };

package/dist/platform/Module.js

@@ -1,4 +1,5 @@
-import { createRequire } from 'node:module';
+import { createRequire, findPackageJSON } from 'node:module';
 export class Module {
     static createRequire = createRequire;
+    static findPackageJSON = findPackageJSON;
 }

package/dist/platform/Path.js

@@ -1,5 +1,9 @@
-import { join, isAbsolute } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative } from 'node:path';
 export class Path {
+    static basename = basename;
+    static dirname = dirname;
+    static extname = extname;
     static isAbsolute = isAbsolute;
     static join = join;
+    static relative = relative;
 }

package/dist/platform/Process.js

@@ -1,5 +1,6 @@
 import { Host } from './Host.js';
 import { spawn } from 'node:child_process';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
 import { logger } from './logger.js';
 import { Exit } from './Exit.js';
 class ProcessStopper {
@@ -12,9 +13,23 @@ class ProcessStopper {
         return this._process?.closed;
     }
 }
+export const splitLines = (string) => string.split(/\r?\n/).filter((line, index, array) => index < array.length - 1 || line.length > 0);
+function sanitizeSpawnOptions(options) {
+    if (!options.env)
+        return options;
+    const { env, ...rest } = options;
+    return { ...rest, env: Object.keys(env) };
+}
 export class Process {
+    static sendToParent = (message) => {
+        if (process.send === undefined) {
+            throw new Error('process.send is not defined: this process has not been created with IPC mappings');
+        }
+        process.send(message);
+    };
     static spawn = (command, arguments_, options = {}) => {
-        const finalCommand = command === 'node' ? process.argv[0] : command;
+        const { onMessage, forceRender: _forceRender, ...spawnOptions } = options;
+        const finalCommand = command === 'node' ? Host.nodePath : command;
         let asyncTask;
         try {
             const stopper = new ProcessStopper();
@@ -22,14 +37,21 @@ export class Process {
                 name: `Process.spawn(${command},${arguments_.join(',')})`,
                 stop: () => stopper.stop()
             });
-            const childProcess = spawn(finalCommand, arguments_, options);
-            logger.debug({
+            if (onMessage) {
+                const stdio = spawnOptions.stdio;
+                spawnOptions.stdio = Array.isArray(stdio)
+                    ? [...stdio, 'ipc']
+                    : [stdio ?? 'pipe', stdio ?? 'pipe', stdio ?? 'pipe', 'ipc'];
+            }
+            const childProcess = spawn(finalCommand, arguments_, spawnOptions);
+            const logMethod = childProcess.pid ? 'debug' : 'warn';
+            logger[logMethod]({
                 source: 'process',
                 processId: childProcess.pid,
                 message: 'spawned',
-                data: { command, arguments: arguments_, options }
+                data: { command, arguments: arguments_, options: sanitizeSpawnOptions(spawnOptions) }
             });
-            const process = new Process(childProcess, asyncTask);
+            const process = new Process(childProcess, asyncTask, options);
             stopper.process = process;
             return process;
         }
@@ -37,7 +59,11 @@ export class Process {
             logger.error({
                 source: 'process',
                 message: 'spawn failed',
-                data: { command, arguments: arguments_, options },
+                data: {
+                    command,
+                    arguments: arguments_,
+                    options: sanitizeSpawnOptions(spawnOptions)
+                },
                 error
             });
             asyncTask?.[Symbol.dispose]();
@@ -62,31 +88,49 @@ export class Process {
     }
     _childProcess;
     _asyncTask;
-    constructor(childProcess, asyncTask) {
+    constructor(childProcess, asyncTask, options) {
         this._childProcess = childProcess;
         this._asyncTask = asyncTask;
         const { promise, resolve } = Promise.withResolvers();
         this._closed = promise;
+        if (options.onMessage) {
+            this._childProcess.on('message', options.onMessage);
+        }
+        const { forceRender } = options;
         this._childProcess.stdout?.on('data', (buffer) => {
             const message = buffer.toString();
-            logger.debug({ source: 'process', processId: this.pid, message, data: { type: 'stdout' } });
+            for (const line of splitLines(message)) {
+                logger.info({ source: 'process/stdout', processId: this.pid, forceRender, message: line });
+            }
             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' } });
+            for (const line of splitLines(message)) {
+                logger.error({ source: 'process/stderr', processId: this.pid, forceRender, message: line });
+            }
             this._stderr.push(message);
         });
-        this._childProcess.on('close', (code) => {
+        this._childProcess
+            .on('error', (error) => {
+            logger.error({
+                source: 'process',
+                processId: childProcess.pid,
+                message: error.message,
+                error
+            });
+        })
+            .on('close', (code) => {
             this._code = code ?? 0;
-            logger.debug({
+            const logLevel = this._code === 0 ? 'debug' : 'warn';
+            logger[logLevel]({
                 source: 'process',
                 processId: this.pid,
                 message: 'closed',
                 data: { code: this._code }
             });
             this._asyncTask[Symbol.dispose]();
-            resolve();
+            setTimeout(resolve, 0);
         });
     }
     get pid() {
@@ -112,7 +156,16 @@ export class Process {
                     process.kill(-this.pid);
                 }
                 catch {
-                    process.kill(this.pid);
+                    logger.warn({
+                        source: 'process',
+                        processId: this.pid,
+                        message: 'group kill failed; killing pid only — if this process spawned children, they may be orphaned (was it spawned with detached:true?)'
+                    });
+                    try {
+                        process.kill(this.pid);
+                    }
+                    catch {
+                    }
                 }
             }
             logger.debug({
@@ -130,4 +183,5 @@ export class Process {
             });
         }
     }
+    static sleep = (ms) => setTimeoutPromise(ms);
 }

package/dist/platform/Terminal.js

@@ -1,17 +1,21 @@
 import { stripVTControlCharacters } from 'node:util';
-const ASCII_ESCAPE = '\u001B';
+const ASCII_ESCAPE = '\u{1B}';
 const CSI = `${ASCII_ESCAPE}[`;
+let isRawModeSet = false;
 export class Terminal {
     static isTTY = process.stdout.isTTY;
     static onResize(callback) {
-        process.stdout.on('resize', () => callback(Terminal.width));
+        process.stdout.on('resize', () => callback(this.width));
     }
     static setRawMode(callback) {
         if (callback === false) {
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
+            if (isRawModeSet) {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+            }
         }
         else {
+            isRawModeSet = true;
             process.stdin.setRawMode(true);
             process.stdin.on('data', callback);
         }
@@ -24,17 +28,17 @@ export class Terminal {
         process.stdout.write(text);
     }
     static hideCursor() {
-        Terminal.write(`${CSI}?25l`);
+        this.write(`${CSI}?25l`);
     }
     static showCursor() {
-        Terminal.write(`${CSI}?25h`);
+        this.write(`${CSI}?25h`);
     }
     static eraseToEnd(lines) {
         if (lines === 0) {
-            Terminal.write(`${CSI}0G`);
+            this.write(`${CSI}0G`);
         }
         else {
-            Terminal.write(`${CSI}0G${CSI}${lines}A${CSI}0J`);
+            this.write(`${CSI}0G${CSI}${lines}A${CSI}0J`);
         }
     }
     static BLUE = `${CSI}34m`;

package/dist/platform/Thread.js

@@ -25,7 +25,7 @@ export class Thread {
         }
         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 js2tsUrl = new URL('js2ts.mjs', import.meta.url).href;
         const execArgv = extension === '.ts' ? ['--no-warnings', '--import', js2tsUrl] : [];
         const worker = new Worker(bootstrapPath, {
             execArgv,

package/dist/platform/assert.js

@@ -1,17 +1,18 @@
 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;
+export const assert = (shouldBeTrue, messageIfNotTrue = 'Assertion failed') => {
+    if (shouldBeTrue) {
+        return;
     }
+    const error = new AssertionError({ message: messageIfNotTrue });
+    if (__developmentMode) {
+        let { stack } = error;
+        stack = stack ? stack.split('\n').slice(1).join('\n') : '';
+        logger?.fatal({ source: 'assert', message: messageIfNotTrue + stack, error });
+    }
+    else {
+        logger?.fatal({ source: 'assert', message: messageIfNotTrue, error });
+    }
+    throw error;
 };

package/dist/platform/environment.js

@@ -1,28 +1,19 @@
 import { Host } from './Host.js';
 import { logger } from './logger.js';
 import { version } from './version.js';
+import { countCpuModels } from '../utils/shared/host.js';
 export const logEnvironnement = async () => {
-    const runnerVersion = await version();
+    const { name, version: semver } = await version();
     const now = new Date();
     logger.info({
         source: 'job',
-        message: `${runnerVersion} / Node.js ${Host.nodeVersion} / ${now.toISOString()} (${now.getTimezoneOffset()})`
+        message: `${name}@${semver} / 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}` });
-        }
+    const machine = Host.machine();
+    for (const { model, count } of countCpuModels(Host.cpus())) {
+        logger.info({
+            source: 'job',
+            message: count === 1 ? `${machine} / ${model}` : `${machine} / ${count}x ${model}`
+        });
     }
 };

package/dist/platform/index.js

@@ -1,5 +1,6 @@
 export * from './assert.js';
 export * from './constants.js';
+export * from './Crypto.js';
 export * from './environment.js';
 export * from './logger.js';
 export * from './Exit.js';