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

package/dist/modes/log/index.js

@@ -0,0 +1,58 @@
+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 { BrowserFactory } from '../../browsers/factory.js';
+import { getInitialLogMetrics } from './LogMetrics.js';
+export const log = async (configuration) => {
+    const logFileName = configuration.log;
+    let stopped = 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 stop = async () => {
+        stopped = true;
+        await server?.close();
+        resolve();
+    };
+    abortSignal.addEventListener('abort', () => {
+        void stop();
+    });
+    Exit.registerAsyncTask({
+        name: 'log',
+        stop: stop
+    });
+    const browser = await BrowserFactory.build('puppeteer');
+    const browserReady = browser.setup({
+        visible: true
+    });
+    server.on('ready', ({ url, port }) => {
+        console.log(url);
+        void browserReady
+            .then(() => browser.newWindow({
+            pageId: 0,
+            url: `http://localhost:${port}/`,
+            scripts: []
+        }))
+            .then(() => {
+            console.log('Use CTRL+C to exit');
+        });
+    });
+    for await (const item of LogReader.read(logFileName, abortSignal)) {
+        if (stopped) {
+            break;
+        }
+        const { type, ...attributes } = item;
+        if (type === 'log') {
+            storage.add(attributes);
+        }
+        else if (__developmentMode) {
+            Object.assign(metrics, attributes);
+        }
+    }
+    await promise;
+};

package/dist/modes/test/REserve.js

@@ -0,0 +1,31 @@
+import { logger } from '../../platform/index.js';
+export const buildREserveConfiguration = (configuration) => {
+    const match = /\/((?:test-)?resources\/.*)/;
+    let { ui5 } = configuration;
+    if (!ui5.endsWith('/')) {
+        ui5 += '/';
+    }
+    const mappingUrl = new URL('$1', ui5).toString();
+    return {
+        port: configuration.port ?? 0,
+        mappings: [
+            {
+                method: 'GET,HEAD',
+                match,
+                url: mappingUrl,
+                'ignore-unverifiable-certificate': true
+            },
+            {
+                match: /^\/(.*)/,
+                cwd: configuration.webapp,
+                file: '$1'
+            },
+            {
+                custom: (request) => logger.debug({ source: 'server', message: 'Unhandled request', data: { url: request.url } })
+            },
+            {
+                status: 404
+            }
+        ]
+    };
+};

package/dist/modes/test/agent.js

@@ -0,0 +1,8 @@
+import { __developmentMode, __sourcesRoot, Path, FileSystem } from '../../platform/index.js';
+import { memoize } from '../../utils/shared/memoize.js';
+export const getAgentSource = memoize(async () => {
+    const path = __developmentMode
+        ? Path.join(__sourcesRoot, '../dist/ui', 'agent.js')
+        : Path.join(__sourcesRoot, 'ui/agent.js');
+    return FileSystem.readFile(path, 'utf8');
+});

package/dist/modes/test/browser.js

@@ -0,0 +1,37 @@
+import { BrowserFactory } from '../../browsers/factory.js';
+import { Exit, assert, logger } from '../../platform/index.js';
+let browser;
+export const setupBrowser = async (configuration) => {
+    assert(configuration.browser === 'puppeteer');
+    browser = await BrowserFactory.build('puppeteer');
+    const { debugKeepBrowserOpen } = configuration;
+    const settings = {
+        visible: debugKeepBrowserOpen
+    };
+    try {
+        await browser.setup(settings);
+    }
+    catch (error) {
+        logger.fatal({ source: 'job', message: 'Unable to setup browser', error });
+        throw error;
+    }
+    if (debugKeepBrowserOpen) {
+        const { newWindow } = browser;
+        browser.newWindow = async (settings) => {
+            const window = await newWindow.call(browser, settings);
+            window.close = async () => { };
+            return window;
+        };
+        const { promise, resolve } = Promise.withResolvers();
+        Exit.registerAsyncTask({
+            name: 'debugKeepBrowserOpen',
+            stop: () => resolve()
+        });
+        browser.shutdown = () => {
+            logger.warn({ source: 'job', message: 'Browser will remain open, use CTRL+C to end command' });
+            return promise;
+        };
+    }
+    return browser;
+};
+export const getBrowser = () => browser;

package/dist/modes/test/index.js

@@ -0,0 +1,66 @@
+import { logger, logEnvironnement, Exit, FileSystem, Path, Http } from '../../platform/index.js';
+import { defaults } from '../../configuration/options.js';
+import { parallelize } from '../../utils/shared/parallelize.js';
+import { getAgentSource } from './agent.js';
+import { setupBrowser } from './browser.js';
+import { pageTask } from './pageTask.js';
+import { reportBuilder } from './report.js';
+import { generateHtmlReport } from '../../reports/html.js';
+import { Folder } from '../../utils/node/Folder.js';
+import { server } from './server.js';
+import { formatDuration } from '../../utils/shared/string.js';
+export const test = async (configuration) => {
+    await Folder.create(configuration.reportDir);
+    logger.start(configuration);
+    logger.debug({ source: 'job', message: 'Configuration', data: { defaults, configuration } });
+    await logEnvironnement();
+    await getAgentSource();
+    let browser;
+    try {
+        const port = await server.start(configuration);
+        const version = JSON.parse(await Http.get(`http://localhost:${port}/resources/sap-ui-version.json`));
+        const { version: coreVersion } = version.libraries.find(({ name }) => name === 'sap.ui.core') ?? {
+            version: 'unknown'
+        };
+        logger.info({ source: 'job', message: `UI5 version used by the local server: ${coreVersion}` });
+        if (!configuration.url) {
+            configuration.url = [new URL(configuration.testsuite, `http://localhost:0`).toString()];
+        }
+        const urls = [...configuration.url.map((url) => url.replace(':0/', `:${port}/`))];
+        browser = await setupBrowser(configuration);
+        logger.info({ source: 'progress', message: 'Executing pages', pageId: undefined, data: { value: 0, max: 0 } });
+        let completed = 0;
+        await parallelize(pageTask, urls, {
+            parallel: configuration.parallel,
+            on: (event) => {
+                if (event.type === 'failed') {
+                    logger.error({ source: 'job', message: 'page failed', error: event.error, data: { url: event.input } });
+                    Exit.code = -1;
+                }
+                if (event.type === 'completed') {
+                    ++completed;
+                }
+                logger.info({
+                    source: 'progress',
+                    message: 'Executing pages',
+                    pageId: undefined,
+                    data: { value: completed, max: urls.length }
+                });
+            }
+        });
+        reportBuilder.finalize();
+        FileSystem.writeFileSync(Path.join(configuration.reportDir, 'report.json'), JSON.stringify(reportBuilder.report, undefined, 2), 'utf8');
+        await generateHtmlReport(configuration, reportBuilder.report);
+        const { duration } = reportBuilder.report.results.summary;
+        if (duration) {
+            logger.info({ source: 'job', message: `Tests duration: ${formatDuration(duration)}` });
+        }
+    }
+    catch (error) {
+        logger.error({ source: 'job', message: 'An error occurred', error });
+    }
+    finally {
+        await browser?.shutdown();
+        await server.stop();
+    }
+};

package/dist/modes/test/pageTask.js

@@ -0,0 +1,145 @@
+import { assert, logger } from '../../platform/index.js';
+import { getAgentSource } from './agent.js';
+import { getBrowser } from './browser.js';
+import { Exit, ExitShutdownError } from '../../platform/Exit.js';
+import { setTimeout } from 'node:timers/promises';
+import { reportBuilder } from './report.js';
+let lastPageId = 0;
+const reportQunitProgress = (context, agentState) => {
+    if (agentState.isOpa) {
+        context.loopDelay = 1000;
+    }
+    if (agentState.total > 0) {
+        const { executed, total, errors } = agentState;
+        if (executed !== context.lastExecuted || total !== context.lastTotal) {
+            const type = agentState.isOpa ? 'opa' : 'qunit';
+            context.lastExecuted = executed;
+            context.lastTotal = total;
+            context.errors = errors;
+            context.type = type;
+            logger.info({
+                source: 'progress',
+                message: context.url,
+                pageId: context.pageId,
+                data: { max: agentState.total, value: agentState.executed, type, errors }
+            });
+        }
+    }
+};
+const queryAgentState = async (context) => {
+    const agentState = (await context.page.eval("window['ui5-test-runner'].state"));
+    logger.debug({ source: 'page', message: 'agent state', data: { state: agentState }, pageId: context.pageId });
+    if (agentState.done) {
+        if (agentState.type === 'suite') {
+            for (const page of agentState.pages) {
+                const pageUrl = new URL(page, context.url).toString();
+                context.urls.push(pageUrl);
+            }
+        }
+        else if (agentState.type === 'unknown') {
+            logger.fatal({
+                source: 'page',
+                message: 'Unable to detect page type',
+                pageId: context.pageId,
+                data: { state: agentState }
+            });
+            throw new Error('Unable to detect page type');
+        }
+        else {
+            assert(agentState.type === 'QUnit');
+            reportQunitProgress(context, agentState);
+        }
+        return true;
+    }
+    if (agentState.type === 'QUnit') {
+        reportQunitProgress(context, agentState);
+        if (agentState.uncaughtErrors?.length) {
+            return true;
+        }
+    }
+    return false;
+};
+export const pageTask = async function (url, index, urls) {
+    const pageId = ++lastPageId;
+    logger.debug({ source: 'page', message: 'new page task', pageId, data: { url } });
+    logger.info({
+        source: 'progress',
+        message: url,
+        pageId,
+        data: { max: 0, value: 1, type: 'unknown', errors: 0 }
+    });
+    const { promise: taskStopped, resolve: setTaskAsStopped } = Promise.withResolvers();
+    using _ = Exit.registerAsyncTask({
+        name: url,
+        stop: async () => {
+            try {
+                this.stop(new ExitShutdownError());
+            }
+            catch {
+            }
+            finally {
+                await taskStopped;
+            }
+        }
+    });
+    let page;
+    let context;
+    try {
+        const agentSource = await getAgentSource();
+        const browser = getBrowser();
+        page = await browser.newWindow({
+            pageId,
+            scripts: [agentSource],
+            url
+        });
+        context = {
+            pageId,
+            urls,
+            url,
+            page,
+            loopDelay: 250,
+            type: 'unknown',
+            lastExecuted: 0,
+            errors: 0,
+            lastTotal: 0
+        };
+        while (!this.stopRequested) {
+            try {
+                await setTimeout(context.loopDelay);
+                if (await queryAgentState(context)) {
+                    break;
+                }
+            }
+            catch (error) {
+                logger.error({ source: 'page', message: 'An error occurred', error, pageId, data: {} });
+                break;
+            }
+        }
+        const testResults = (await page.eval("window['ui5-test-runner'].results"));
+        logger.debug({ source: 'page', message: 'test results', pageId, data: { results: testResults } });
+        reportBuilder.merge(url, testResults);
+    }
+    finally {
+        if (context !== undefined) {
+            logger.info({
+                source: 'progress',
+                message: url,
+                pageId,
+                data: {
+                    max: context.lastTotal,
+                    value: context.lastExecuted,
+                    type: context.type,
+                    errors: context.errors,
+                    remove: true
+                }
+            });
+        }
+        try {
+            await page?.close();
+        }
+        catch (error) {
+            logger.error({ source: 'page', message: 'page.close failed', error, pageId, data: {} });
+        }
+        setTaskAsStopped();
+    }
+};

package/dist/modes/test/report.js

@@ -0,0 +1,3 @@
+import { TestReportBuilder } from '../../utils/shared/TestReportBuilder.js';
+import { version } from '../../platform/version.js';
+export const reportBuilder = new TestReportBuilder(crypto.randomUUID(), await version());

package/dist/modes/test/server.js

@@ -0,0 +1,109 @@
+import { assert, Exit, logger, Thread } from '../../platform/index.js';
+import { serve } from 'reserve';
+import { toPlainObject } from '../../utils/shared/object.js';
+import { buildREserveConfiguration } from './REserve.js';
+let channel;
+let serverWorker;
+let stopping = false;
+export const server = {
+    async start(configuration) {
+        assert(serverWorker === undefined);
+        channel = Thread.createBroadcastChannel('server');
+        Exit.registerAsyncTask({
+            name: 'server',
+            stop: () => server.stop()
+        });
+        logger.debug({ source: 'server', message: 'Starting server' });
+        serverWorker = Thread.createWorker('modes/test/server', toPlainObject(configuration));
+        const { promise, resolve, reject } = Promise.withResolvers();
+        channel.onmessage = ({ data: message }) => {
+            if (message.command === 'ready') {
+                resolve(message.port);
+            }
+            else if (message.command === 'error') {
+                reject(new Error('failed to start'));
+            }
+            else {
+                assert(false, 'unexpected');
+            }
+        };
+        return promise;
+    },
+    async stop() {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        try {
+            assert(serverWorker !== undefined);
+            logger.debug({ source: 'server', message: 'Stopping server' });
+            channel.postMessage({
+                command: 'terminate'
+            });
+            const { promise, resolve } = Promise.withResolvers();
+            channel.onmessage = ({ data: message }) => {
+                if (message.command === 'terminated') {
+                    channel.close();
+                    resolve();
+                }
+            };
+            await promise;
+        }
+        finally {
+            channel.close();
+        }
+    }
+};
+export const workerMain = (configuration) => {
+    logger.debug({ source: 'server', message: 'Starting server...' });
+    channel = Thread.createBroadcastChannel('server');
+    channel.onmessage = ({ data: message }) => {
+        if (message.command === 'terminate') {
+            logger.debug({ source: 'server', message: 'Stopping server...' });
+            void server.close().finally(() => {
+                logger.debug({ source: 'server', message: 'Server stopped.' });
+                channel.postMessage({
+                    command: 'terminated'
+                });
+                channel.close();
+            });
+        }
+    };
+    let server;
+    try {
+        server = serve(buildREserveConfiguration(configuration));
+    }
+    catch (error) {
+        logger.error({ source: 'server', message: 'An error occurred while configuring', error });
+        channel.postMessage({
+            command: 'error'
+        });
+        return;
+    }
+    server.on('created', () => {
+        logger.debug({ source: 'reserve', message: 'created', data: {} });
+    });
+    for (const eventName of ['incoming', 'redirecting', 'redirected', 'aborted', 'closed']) {
+        server.on(eventName, (event) => {
+            const { eventName: message, ...data } = event;
+            logger.debug({ source: 'reserve', message, data });
+        });
+    }
+    server
+        .on('ready', (event) => {
+        const { eventName: message, ...data } = event;
+        logger.debug({ source: 'reserve', message, data });
+        logger.info({ source: 'server', message: `Server listening on: ${event.url}` });
+        channel.postMessage({
+            command: 'ready',
+            port: event.port
+        });
+    })
+        .on('error', (event) => {
+        const { eventName: message, reason: error, ...data } = event;
+        logger.debug({ source: 'reserve', message, data, error });
+        channel.postMessage({
+            command: 'error'
+        });
+    });
+};

package/dist/modes/version.js

@@ -0,0 +1,11 @@
+import { FileSystem } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+export const version = async () => {
+    const packageFile = await FileSystem.readFile('package.json', 'utf8');
+    const { name, version: installedVersion } = JSON.parse(packageFile);
+    console.log(`${name}@${installedVersion}`);
+    const latestVersion = await Npm.getLatestVersion(name);
+    if (latestVersion !== installedVersion) {
+        console.log(`Latest version of ${name} is ${latestVersion}`);
+    }
+};

package/dist/platform/Exit.js

@@ -0,0 +1,139 @@
+import { ServerResponse, ClientRequest } from 'node:http';
+import { Thread } from './Thread.js';
+import { assert } from './assert.js';
+import { logger } from './logger/proxy.js';
+export class ExitShutdownError extends Error {
+    constructor() {
+        super('Exiting application');
+        this.name = 'ExitShutdownError';
+    }
+}
+const socketHandleDescriptor = (handle) => {
+    if (handle._httpMessage instanceof ServerResponse) {
+        const { method, url } = handle._httpMessage.req;
+        return `IncomingRequest ${method} ${url}`;
+    }
+    if (handle._httpMessage instanceof ClientRequest) {
+        const { path, method, host, protocol } = handle._httpMessage;
+        return `ClientRequest ${method} ${protocol}//${host}${path}`;
+    }
+    if (handle.localAddress) {
+        const { localAddress, localPort, remoteAddress, remotePort } = handle;
+        return remoteAddress === undefined
+            ? `local ${localAddress}:${localPort}`
+            : `local ${localAddress}:${localPort} <-> remote ${remoteAddress}:${remotePort}`;
+    }
+    if (handle._handle) {
+        const underlyingHandle = handle._handle;
+        const underlyingClassName = underlyingHandle && underlyingHandle.constructor && underlyingHandle.constructor.name;
+        return `${underlyingClassName || 'handle unknown'}`;
+    }
+    return 'unknown';
+};
+const handleDescriptors = {
+    ChildProcess: (handle) => {
+        return (`pid: ${handle.pid}` +
+            (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}`,
+    Socket: socketHandleDescriptor,
+    TLSSocket: socketHandleDescriptor,
+    WriteStream: (handle) => handle.fd < 3
+        ? `${[0, 'stdout', 'stderr'][handle.fd]} ${handle.columns}x${handle.rows} isTTY: ${handle.isTTY}`
+        : `fd: ${handle.fd}`
+};
+const isStdStream = (handle) => 'fd' in handle && handle.fd >= 0 && handle.fd < 3;
+const unknownHandleDescriptor = () => 'unknown';
+const describeHandle = (handle) => {
+    const className = handle && handle.constructor && handle.constructor.name;
+    return { className, label: (handleDescriptors[className] ?? unknownHandleDescriptor)(handle) };
+};
+export class Exit {
+    static _asyncTaskId = 0;
+    static _asyncTasks = [];
+    static _checkForHandlesLeak() {
+        const undocumentedProcess = process;
+        if (!undocumentedProcess._getActiveHandles) {
+            logger?.warn({ source: 'exit/handle', message: 'Missing process._getActiveHandles' });
+            return;
+        }
+        const activeHandles = undocumentedProcess._getActiveHandles();
+        let messagePortFound = 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;
+                logger?.debug({ source: 'exit/handle', message: `${className} ${label}` });
+            }
+            else {
+                logger?.warn({ source: 'exit/handle', message: `possible leak ${className} ${label}` });
+                if (className === 'TLSSocket' || className === 'Socket') {
+                    handle.destroy();
+                }
+            }
+        }
+    }
+    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) {
+            throw new ExitShutdownError();
+        }
+        const id = ++Exit._asyncTaskId;
+        this._asyncTasks.push({
+            id,
+            ...task
+        });
+        return {
+            [Symbol.dispose]() {
+                const index = Exit._asyncTasks.findIndex((task) => task.id === id);
+                try {
+                    assert(index !== -1, 'unable to find Exit async task to unregister');
+                    Exit._asyncTasks.splice(index, 1);
+                }
+                catch {
+                }
+            }
+        };
+    }
+    static _enteringShutdown = false;
+    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);
+            try {
+                logger?.[logLevel]({ source: 'exit', message: `Stopping ${task.name}...` });
+                await task.stop();
+                logger?.[logLevel]({ source: 'exit', message: `${task.name} stopped.` });
+            }
+            catch (error) {
+                logger?.[logLevel]({ source: 'exit', message: `Failed while stopping ${task.name}...`, error });
+            }
+            finally {
+                if (task === Exit._asyncTasks.at(-1)) {
+                    Exit._asyncTasks.pop();
+                }
+            }
+        }
+        Exit._checkForHandlesLeak();
+        logger?.[logLevel]({ source: 'exit', message: `Stopping logger...` });
+        await logger?.stop();
+    }
+    static sigInt() {
+        Exit._logLevel = 'info';
+        void Exit.shutdown();
+    }
+}
+if (Thread.isMainThread) {
+    process.on('SIGINT', Exit.sigInt);
+}

package/dist/platform/FileSystem.js

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

package/dist/platform/Host.js

@@ -0,0 +1,10 @@
+import { machine, cpus, platform } from 'node:os';
+export class Host {
+    static cpus = cpus;
+    static cwd = process.cwd.bind(process);
+    static machine = machine;
+    static memoryUsage = process.memoryUsage.bind(process);
+    static nodeVersion = process.version;
+    static pid = process.pid;
+    static platform = platform;
+}

package/dist/platform/Http.js

@@ -0,0 +1,38 @@
+import { logger } from './logger.js';
+import { Exit } from './Exit.js';
+let lastRequestId = 0;
+export const Http = {
+    async get(url) {
+        const requestId = ++lastRequestId;
+        const controller = new AbortController();
+        using _ = Exit.registerAsyncTask({
+            name: `http.get#${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;
+        }
+    }
+};