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

package/dist/configuration/options.js

@@ -0,0 +1,191 @@
+export const options = [
+    {
+        name: 'cwd',
+        short: 'c',
+        type: 'fs-entry',
+        description: 'set working directory',
+        default: process.cwd()
+    },
+    {
+        name: 'webapp',
+        type: 'fs-entry',
+        typeModifiers: new Set(['safe-default']),
+        description: 'base folder of the UI5 application',
+        default: 'webapp'
+    },
+    {
+        name: 'testsuite',
+        type: 'string',
+        description: 'path of the testsuite file',
+        default: 'test/testsuite.qunit.html'
+    },
+    {
+        name: 'alternateNpmPath',
+        type: 'fs-entry',
+        description: 'alternate NPM package path'
+    },
+    {
+        name: 'browser',
+        short: 'b',
+        type: 'browser',
+        description: 'browser selection',
+        default: 'puppeteer'
+    },
+    {
+        name: 'capabilities',
+        type: 'boolean',
+        description: 'run browser tests'
+    },
+    {
+        name: 'ci',
+        type: 'boolean',
+        description: 'forces CI mode (no interactive output)',
+        default: !process.stdout.isTTY
+    },
+    {
+        name: 'config',
+        type: 'fs-entry',
+        typeModifiers: new Set(['file', 'safe-default']),
+        description: 'read options from a configuration file',
+        default: 'ui5-test-runner.json'
+    },
+    {
+        name: 'debugKeepBrowserOpen',
+        type: 'boolean',
+        description: 'keeps the browser open after the tests completed'
+    },
+    {
+        name: 'failFast',
+        short: 'f',
+        type: 'boolean',
+        description: 'stop the whole execution after the first failing page'
+    },
+    {
+        name: 'failOpaFast',
+        short: 'fo',
+        type: 'boolean',
+        description: 'stop the OPA page execution after the first failing test'
+    },
+    {
+        name: 'globalTimeout',
+        short: 't',
+        type: 'timeout',
+        description: 'limit the tests execution time, fail remaining pages if it takes longer than the timeout'
+    },
+    {
+        name: 'help',
+        type: 'boolean',
+        description: 'display help'
+    },
+    {
+        name: 'keepAlive',
+        short: 'k',
+        type: 'boolean',
+        description: 'keep the server alive'
+    },
+    {
+        name: 'localhost',
+        type: 'string',
+        description: 'hostname for legacy URL',
+        default: 'localhost'
+    },
+    {
+        name: 'log',
+        type: 'fs-entry',
+        typeModifiers: new Set(['file']),
+        description: 'read and dump log file using jsonl format'
+    },
+    {
+        name: 'logServer',
+        short: 'l',
+        type: 'boolean',
+        description: 'log inner server traces'
+    },
+    {
+        name: 'noNpmInstall',
+        type: 'boolean',
+        description: 'prevent any NPM install'
+    },
+    {
+        name: 'outputInterval',
+        short: 'oi',
+        type: 'timeout',
+        description: 'interval for reporting progress on non interactive output (CI/CD)',
+        default: 30_000
+    },
+    {
+        name: 'pageFilter',
+        short: 'pf',
+        type: 'regexp',
+        description: 'filter pages to execute'
+    },
+    {
+        name: 'pageParams',
+        short: 'pp',
+        type: 'string',
+        description: 'add parameters to page URL'
+    },
+    {
+        name: 'pageTimeout',
+        short: 'pt',
+        type: 'timeout',
+        description: 'fails a page if it takes longer than this timeout'
+    },
+    {
+        name: 'parallel',
+        short: 'p',
+        type: 'integer',
+        description: 'number of parallel executions',
+        default: 2
+    },
+    {
+        name: 'port',
+        type: 'integer',
+        description: 'port to use'
+    },
+    {
+        name: 'reportDir',
+        short: 'r',
+        type: 'fs-entry',
+        typeModifiers: new Set(['overwrite']),
+        description: 'directory to output test reports',
+        default: 'report'
+    },
+    {
+        name: 'serveOnly',
+        short: 's',
+        type: 'boolean',
+        description: 'serve only'
+    },
+    {
+        name: 'ui5',
+        type: 'url',
+        description: 'UI5 url',
+        default: 'https://ui5.sap.com'
+    },
+    {
+        name: 'url',
+        short: 'u',
+        type: 'url',
+        multiple: true,
+        description: 'URL of the page to test'
+    },
+    {
+        name: 'version',
+        type: 'boolean',
+        description: 'display version'
+    }
+];
+export const defaults = {
+    browser: 'puppeteer',
+    ci: !process.stdout.isTTY,
+    config: 'ui5-test-runner.json',
+    cwd: process.cwd(),
+    localhost: 'localhost',
+    outputInterval: 30_000,
+    parallel: 2,
+    reportDir: 'report',
+    testsuite: 'test/testsuite.qunit.html',
+    ui5: 'https://ui5.sap.com',
+    webapp: 'webapp'
+};

package/dist/configuration/validators/OptionValidator.js

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

package/dist/configuration/validators/boolean.js

@@ -0,0 +1,15 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+const BOOLEAN_TRUE = new Set(['true', 'on', 1]);
+const BOOLEAN_FALSE = new Set(['false', 'off', 0]);
+export const boolean = (option, value) => {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (BOOLEAN_TRUE.has(value)) {
+        return true;
+    }
+    if (BOOLEAN_FALSE.has(value)) {
+        return false;
+    }
+    throw new OptionValidationError(option);
+};

package/dist/configuration/validators/browser.js

@@ -0,0 +1,11 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+const KNOWN_BROWSERS = new Set(['puppeteer']);
+export const browser = (option, value) => {
+    if (typeof value === 'string') {
+        const name = value.startsWith('$/') && value.endsWith('.js') ? value.slice(2, -3) : value;
+        if (KNOWN_BROWSERS.has(name)) {
+            return name;
+        }
+    }
+    throw new OptionValidationError(option);
+};

package/dist/configuration/validators/fsEntry.js

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

package/dist/configuration/validators/index.js

@@ -0,0 +1,20 @@
+import { boolean } from './boolean.js';
+import { browser } from './browser.js';
+import { fsEntry } from './fsEntry.js';
+import { integer } from './integer.js';
+import { percent } from './percent.js';
+import { regexp } from './regexp.js';
+import { string } from './string.js';
+import { timeout } from './timeout.js';
+import { url } from './url.js';
+export const validators = {
+    boolean,
+    browser,
+    'fs-entry': fsEntry,
+    integer,
+    percent,
+    regexp,
+    string,
+    timeout,
+    url
+};

package/dist/configuration/validators/integer.js

@@ -0,0 +1,10 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+export const integer = (option, value) => {
+    if (typeof value === 'string') {
+        value = Number.parseInt(value);
+    }
+    if (typeof value !== 'number' || value % 1 !== 0) {
+        throw new OptionValidationError(option);
+    }
+    return value;
+};

package/dist/configuration/validators/percent.js

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

package/dist/configuration/validators/regexp.js

@@ -0,0 +1,20 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+export const regexp = (option, value) => {
+    if (typeof value === 'object' && value instanceof RegExp) {
+        return value;
+    }
+    if (typeof value !== 'string' || !value) {
+        throw new OptionValidationError(option);
+    }
+    try {
+        const match = /^\/(.+)\/(\w*)$/.exec(value);
+        if (match) {
+            const [, pattern = '', flags = ''] = match;
+            return new RegExp(pattern, flags);
+        }
+        return new RegExp(value);
+    }
+    catch (error) {
+        throw new OptionValidationError(option, 'Invalid regexp', error);
+    }
+};

package/dist/configuration/validators/string.js

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

package/dist/configuration/validators/timeout.js

@@ -0,0 +1,24 @@
+import { OptionValidationError } from '../OptionValidationError.js';
+export const timeout = (option, value) => {
+    if (typeof value === 'string') {
+        if (value === 'none') {
+            return 0;
+        }
+        const match = /^(\d+)(ms|s|sec|m|min)?$/.exec(value);
+        if (match) {
+            const [, digits = '0', specifier = ''] = match;
+            let int = Number.parseInt(digits);
+            if (['s', 'sec'].includes(specifier)) {
+                int = int * 1000;
+            }
+            if (['m', 'min'].includes(specifier)) {
+                int = int * 60 * 1000;
+            }
+            value = int;
+        }
+    }
+    if (typeof value === 'number' && !Number.isNaN(value) && value >= 0 && value < Number.POSITIVE_INFINITY) {
+        return value;
+    }
+    throw new OptionValidationError(option);
+};

package/dist/configuration/validators/url.js

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

package/dist/modes/ModeFunction.js

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

package/dist/modes/Modes.js

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

package/dist/modes/execute.js

@@ -0,0 +1,27 @@
+import { help } from './help.js';
+import { log } from './log/index.js';
+import { Modes } from './Modes.js';
+import { version } from './version.js';
+import { test } from './test/index.js';
+import { Exit } from '../platform/Exit.js';
+const notImplemented = () => {
+    throw new Error('Not implemented');
+};
+const modeFunctions = {
+    [Modes.batch]: notImplemented,
+    [Modes.capabilities]: notImplemented,
+    [Modes.help]: help,
+    [Modes.legacy]: test,
+    [Modes.log]: log,
+    [Modes.remote]: test,
+    [Modes.version]: version
+};
+export const execute = async (configuration) => {
+    try {
+        const modeFunction = modeFunctions[configuration.mode];
+        await modeFunction(configuration);
+    }
+    finally {
+        await Exit.shutdown();
+    }
+};

package/dist/modes/help.js

@@ -0,0 +1,3 @@
+export const help = () => {
+    console.log('Please check https://arnaudbuchholz.github.io/ui5-test-runner/');
+};

package/dist/modes/log/ILogStorage.js

@@ -0,0 +1 @@
+export const MAX_LIMIT = 1000;

package/dist/modes/log/LogMetrics.js

@@ -0,0 +1,9 @@
+export const getInitialLogMetrics = () => ({
+    inputSize: 0,
+    chunksCount: 0,
+    outputSize: 0,
+    minTimestamp: Number.MAX_SAFE_INTEGER,
+    maxTimestamp: 0,
+    logCount: 0,
+    reading: true
+});

package/dist/modes/log/LogReader.js

@@ -0,0 +1,37 @@
+import { ZLib } from '../../platform/index.js';
+import { createCompressionContext, 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 stream = FramedStreamReader.create(logFileName, POLL_INTERVAL_MS);
+        const metrics = getInitialLogMetrics();
+        for await (const chunk of stream.read(signal)) {
+            metrics.inputSize += 4 + chunk.length;
+            ++metrics.chunksCount;
+            const lines = ZLib.inflateRawSync(chunk).toString();
+            const jsons = uncompress(context, lines);
+            for (const json of jsons) {
+                ++metrics.logCount;
+                metrics.minTimestamp = Math.min(metrics.minTimestamp, json.timestamp);
+                metrics.maxTimestamp = Math.max(metrics.maxTimestamp, json.timestamp);
+                metrics.outputSize += JSON.stringify(json).length + 1;
+                yield {
+                    type: 'log',
+                    ...json
+                };
+            }
+            yield {
+                type: 'metrics',
+                ...metrics
+            };
+        }
+        metrics.reading = false;
+        yield {
+            type: 'metrics',
+            ...metrics
+        };
+    }
+};

package/dist/modes/log/LogStorage.js

@@ -0,0 +1,68 @@
+import { LogLevel } from '../../platform/logger/types.js';
+import { MAX_LIMIT } from './ILogStorage.js';
+import { punyexpr } from 'punyexpr';
+const LOG_LEVELS = Object.fromEntries(Object.entries(LogLevel).map(([name, value]) => [value, name]));
+export class LogStorage {
+    static create() {
+        return new this();
+    }
+    _logs = [];
+    _logsAdded = false;
+    constructor() { }
+    get length() {
+        return this._logs.length;
+    }
+    add(log) {
+        this._logs.push(log);
+        this._logsAdded = true;
+    }
+    _sortIfNeeded() {
+        if (this._logsAdded) {
+            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];
+            }
+        });
+    }
+    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));
+        const records = [];
+        for (let index = 0; limit > 0 && index < this._logs.length; ++index) {
+            const log = this._logs[index];
+            if (log.timestamp < from) {
+                continue;
+            }
+            if (log.timestamp > to) {
+                break;
+            }
+            if (skip > 0) {
+                --skip;
+                continue;
+            }
+            if (!filterExpression(log)) {
+                continue;
+            }
+            records.push(log);
+            --limit;
+        }
+        return records;
+    }
+}

package/dist/modes/log/REserve.js

@@ -0,0 +1,101 @@
+import { __developmentMode, __sourcesRoot, Path, FileSystem } from '../../platform/index.js';
+import { memoize } from '../../utils/shared/memoize.js';
+const getLibrarySource = memoize(async () => {
+    const path = __developmentMode
+        ? Path.join(__sourcesRoot, '../dist/ui', 'lib.js')
+        : Path.join(__sourcesRoot, 'ui/lib.js');
+    return FileSystem.readFile(path, 'utf8');
+});
+const getLogViewerSource = memoize(async () => {
+    const path = __developmentMode
+        ? Path.join(__sourcesRoot, '../dist/ui', 'log-viewer.js')
+        : Path.join(__sourcesRoot, 'ui/log-viewer.js');
+    return FileSystem.readFile(path, 'utf8');
+});
+const getAsInt = (parameters, key) => {
+    const value = parameters.get(key);
+    return value ? Number.parseInt(value) : undefined;
+};
+export const buildREserveConfiguration = (storage, metrics, abortController) => ({
+    port: 0,
+    mappings: [
+        {
+            method: 'GET',
+            match: '/query',
+            custom: ({ url }) => {
+                const searchParameters = new URLSearchParams(new URL(url, 'http://localhost').search);
+                const from = getAsInt(searchParameters, 'from');
+                const to = getAsInt(searchParameters, 'to');
+                const skip = getAsInt(searchParameters, 'skip');
+                const limit = getAsInt(searchParameters, 'limit');
+                const filter = searchParameters.get('filter') ?? undefined;
+                return [
+                    {
+                        metrics,
+                        logs: storage.fetch({ from, to, skip, limit, filter })
+                    }
+                ];
+            }
+        },
+        {
+            method: 'GET',
+            match: '/lib.js',
+            custom: async () => [
+                await getLibrarySource(),
+                {
+                    headers: {
+                        'Content-Type': 'application/javascript'
+                    }
+                }
+            ]
+        },
+        {
+            method: 'GET',
+            match: '/log-viewer.js',
+            custom: async () => [
+                await getLogViewerSource(),
+                {
+                    headers: {
+                        'Content-Type': 'application/javascript'
+                    }
+                }
+            ]
+        },
+        {
+            match: '/close',
+            custom: () => {
+                abortController.abort();
+                return 200;
+            }
+        },
+        {
+            method: 'GET',
+            custom: () => [
+                `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>UI5 Test Runner Log Viewer</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/lib.js"></script>
+    <script type="module" src="/log-viewer.js"></script>
+    <script>
+const close = () => navigator.sendBeacon('/close');
+document.addEventListener('visibilitychange', () => (document.visibilityState === 'hidden') && close());
+window.addEventListener('pagehide', (event) => (!event.persisted) && close());
+    </script>
+  </body>
+</html>
+`,
+                {
+                    headers: {
+                        'Content-Type': 'text/html'
+                    }
+                }
+            ]
+        }
+    ]
+});