ui5-test-runner 6.0.0-beta.4 → 6.0.0

package/dist/browsers/networkResponse.js

@@ -0,0 +1,15 @@
+import { logger } from '../platform/index.js';
+const LOG_TYPES = [null, null, null, null, 'warn', 'error'];
+export const handleNetworkResponse = (pageId, url, method, status, requestHeaders, responseHeaders) => {
+    const statusType = Math.floor(status / 100);
+    const logType = LOG_TYPES[statusType] ?? 'info';
+    logger[logType]({
+        source: 'browser/network',
+        message: url,
+        pageId,
+        data: {
+            request: { method, headers: requestHeaders },
+            response: { status, headers: responseHeaders }
+        }
+    });
+};

package/dist/browsers/playwright.js

@@ -0,0 +1,104 @@
+import { logger, Process, assert } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+import { handleConsoleMessage } from './consoleMessage.js';
+import { handleNetworkResponse } from './networkResponse.js';
+import { buildChromeLaunchOptions } from './chromeOptions.js';
+export const descriptor = {
+    supportedBrowsers: ['chromium', 'firefox', 'webkit'],
+    defaultBrowser: 'chromium',
+    screenshotFormat: '.png'
+};
+export const factory = async (configuration, signal) => {
+    const playwright = await Npm.import(configuration, 'playwright');
+    const { chromium } = playwright;
+    let browser;
+    let context;
+    let isFirstWindow = true;
+    const launchAndInstallIfNeeded = async (settings) => {
+        const launchOptions = {
+            headless: !settings.visible,
+            handleSIGINT: false,
+            ...buildChromeLaunchOptions(settings.options)
+        };
+        logger.debug({ source: 'playwright', message: 'launching browser' });
+        try {
+            browser = await chromium.launch(launchOptions);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Executable doesn')) {
+                logger.info({
+                    source: 'progress',
+                    message: 'installing chromium (playwright)',
+                    pageId: undefined,
+                    data: {
+                        value: 1,
+                        max: 0
+                    }
+                });
+                await Process.spawn('npx', 'playwright install chromium'.split(' '), {
+                    shell: true,
+                    signal
+                }).closed;
+                browser = await chromium.launch(launchOptions);
+            }
+            else {
+                throw error;
+            }
+        }
+        context = await browser.newContext({
+            viewport: settings.viewport ?? null,
+            httpCredentials: settings.basicAuthentication
+                ? { username: settings.basicAuthentication.username, password: settings.basicAuthentication.password.reveal() }
+                : undefined
+        });
+        return {
+            browserName: browser.browserType().name(),
+            browserVersion: browser.version()
+        };
+    };
+    return {
+        async setup(settings) {
+            return await launchAndInstallIfNeeded(settings);
+        },
+        async newWindow(settings) {
+            let page;
+            if (isFirstWindow) {
+                isFirstWindow = false;
+                const existingPages = context?.pages();
+                page = existingPages?.[0] ?? (await context?.newPage());
+            }
+            else {
+                page = await context?.newPage();
+            }
+            assert(page !== undefined);
+            for (const script of settings.scripts) {
+                await page.addInitScript(script);
+            }
+            const { pageId } = settings;
+            page
+                .on('console', (message) => {
+                handleConsoleMessage(message.type(), message.text(), pageId);
+            })
+                .on('response', (response) => {
+                const request = response.request();
+                handleNetworkResponse(pageId, request.url(), request.method(), response.status(), request.headers(), response.headers());
+            });
+            await page.goto(settings.url);
+            return {
+                async eval(script) {
+                    return await page?.evaluate(script);
+                },
+                async screenshot(path) {
+                    await page.screenshot({ path });
+                },
+                async close() {
+                    await page.goto('about:blank');
+                    await page.close();
+                }
+            };
+        },
+        async shutdown() {
+            await browser?.close();
+        }
+    };
+};

package/dist/browsers/puppeteer.js

@@ -1,43 +1,51 @@
-import { logger, Exit, Process } from '../platform/index.js';
+import { logger, Process } from '../platform/index.js';
 import { Npm } from '../Npm.js';
-import { agentLogPrefix } from '../types/AgentState.js';
-export const factory = async () => {
-    const puppeteer = await Npm.import('puppeteer');
-    const { launch } = puppeteer;
+import { handleConsoleMessage } from './consoleMessage.js';
+import { handleNetworkResponse } from './networkResponse.js';
+import { buildChromeLaunchOptions } from './chromeOptions.js';
+import { RecoverableBrowserError } from './RecoverableBrowserError.js';
+export const descriptor = {
+    supportedBrowsers: ['chrome', 'firefox'],
+    defaultBrowser: 'chrome',
+    screenshotFormat: '.png'
+};
+export const factory = async (configuration, signal) => {
+    const puppeteer = await Npm.import(configuration, 'puppeteer');
+    const launch = puppeteer.launch;
     let browser;
-    const abortController = new AbortController();
-    const { signal } = abortController;
-    const task = Exit.registerAsyncTask({
-        name: 'puppeteer',
-        async stop() {
-            abortController.abort();
-            await browser?.close();
-        }
-    });
-    let openedPages = 0;
+    let isFirstWindow = true;
+    let basicAuthentication;
+    let deviceName;
     const launchAndInstallIfNeeded = async (settings) => {
+        const target = settings.browser ?? 'chrome';
+        const arguments_ = [
+            settings.viewport ? `--window-size=${settings.viewport.width},${settings.viewport.height}` : '--start-maximized'
+        ];
+        const chromeLaunchOptions = buildChromeLaunchOptions(settings.options, arguments_, target === 'chrome');
         const launchOptions = {
+            browser: target,
             headless: !settings.visible,
             defaultViewport: null,
             handleSIGINT: false,
             signal,
-            args: ['--start-maximized']
+            ...chromeLaunchOptions
         };
+        logger.debug({ source: 'puppeteer', message: 'launching browser' });
         try {
             browser = await launch(launchOptions);
         }
         catch (error) {
-            if (error instanceof Error && error.message.startsWith('Could not find Chrome')) {
+            if (error instanceof Error && error.message.startsWith('Could not find')) {
                 logger.info({
                     source: 'progress',
-                    message: 'Installing chrome (puppeteer)',
+                    message: `Installing ${target} (puppeteer)`,
                     pageId: undefined,
                     data: {
                         value: 1,
                         max: 0
                     }
                 });
-                await Process.spawn('npx', 'puppeteer browsers install chrome'.split(' '), {
+                await Process.spawn('npx', `puppeteer browsers install ${target}`.split(' '), {
                     shell: true,
                     signal
                 }).closed;
@@ -47,27 +55,22 @@ export const factory = async () => {
                 throw error;
             }
         }
-        logger.debug({ source: 'puppeteer', message: 'setup completed' });
         return {
-            screenshotFormat: '.png'
+            browserName: target,
+            browserVersion: await browser.version()
         };
     };
     return {
         async setup(settings) {
-            logger.debug({ source: 'puppeteer', message: 'setup', data: settings });
-            try {
-                return await launchAndInstallIfNeeded(settings);
-            }
-            catch (error) {
-                logger.error({ source: 'puppeteer', message: 'setup failed', error });
-                task[Symbol.dispose]();
-                throw error;
-            }
+            basicAuthentication = settings.basicAuthentication;
+            deviceName = settings.device;
+            return await launchAndInstallIfNeeded(settings);
         },
         async newWindow(settings) {
-            logger.debug({ source: 'puppeteer', message: 'newWindow', data: settings });
+            const { pageId } = settings;
             let page;
-            if (++openedPages === 1) {
+            if (isFirstWindow) {
+                isFirstWindow = false;
                 const pages = await browser?.pages(true);
                 page = pages?.[0];
             }
@@ -76,83 +79,46 @@ export const factory = async () => {
                     type: 'window'
                 });
             }
+            if (deviceName) {
+                const knownDevices = puppeteer.KnownDevices ?? {};
+                const device = knownDevices[deviceName];
+                if (!device) {
+                    throw new RecoverableBrowserError(`Unknown device "${deviceName}", available devices: ${Object.keys(knownDevices).join(', ')}`);
+                }
+                await page?.emulate(device);
+            }
             for (const script of settings.scripts) {
                 await page?.evaluateOnNewDocument(script);
             }
-            const { pageId } = settings;
             page
                 ?.on('console', (message) => {
-                const LOG_TYPES = {
-                    error: 'error',
-                    warn: 'warn',
-                    debug: 'debug'
-                };
-                const logType = LOG_TYPES[message.type()] ?? 'info';
-                let source;
-                let messageText = message.text();
-                if (messageText.startsWith(agentLogPrefix)) {
-                    source = 'browser/agent';
-                    messageText = messageText.slice(agentLogPrefix.length);
-                }
-                else {
-                    source = 'browser/console';
-                }
-                logger[logType]({
-                    source,
-                    message: messageText,
-                    pageId,
-                    data: { type: message.type() }
-                });
+                handleConsoleMessage(message.type(), message.text(), pageId);
             })
                 ?.on('response', (response) => {
                 const request = response.request();
-                const statusType = Math.floor(response.status() / 100);
-                const LOG_TYPES = [null, null, null, null, 'warn', 'error'];
-                const logType = LOG_TYPES[statusType] ?? 'info';
-                logger[logType]({
-                    source: 'browser/network',
-                    message: request.url(),
-                    pageId,
-                    data: {
-                        request: {
-                            method: request.method(),
-                            headers: request.headers()
-                        },
-                        response: {
-                            status: response.status(),
-                            headers: response.headers()
-                        }
-                    }
-                });
+                handleNetworkResponse(pageId, request.url(), request.method(), response.status(), request.headers(), response.headers());
             });
+            if (basicAuthentication) {
+                await page?.authenticate({
+                    username: basicAuthentication.username,
+                    password: basicAuthentication.password.reveal()
+                });
+            }
             await page?.goto(settings.url);
-            logger.debug({ source: 'puppeteer', message: 'newWindow completed', data: settings });
             return {
                 async eval(script) {
                     return await page?.evaluate(script);
                 },
-                screenshot() {
-                    throw new Error('Not implemented');
+                async screenshot(path) {
+                    await page?.screenshot({ path });
                 },
                 async close() {
-                    try {
-                        await page?.close();
-                    }
-                    catch (error) {
-                        logger.error({ source: 'puppeteer', message: 'page.close failed', error });
-                    }
+                    await page?.close();
                 }
             };
         },
         async shutdown() {
-            logger.debug({ source: 'puppeteer', message: 'shutdown' });
-            try {
-                await browser?.close();
-            }
-            catch (error) {
-                logger.error({ source: 'puppeteer', message: 'browser.close failed', error });
-            }
-            task[Symbol.dispose]();
+            await browser?.close();
         }
     };
 };

package/dist/browsers/seleniumWebdriver.js

@@ -0,0 +1,124 @@
+import { logger } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+import { handleConsoleMessage } from './consoleMessage.js';
+import { handleNetworkResponse } from './networkResponse.js';
+import { buildChromeLaunchOptions } from './chromeOptions.js';
+import { writeFile } from 'node:fs/promises';
+import { RecoverableBrowserError } from './RecoverableBrowserError.js';
+export const descriptor = {
+    supportedBrowsers: ['chrome', 'firefox', 'edge', 'safari'],
+    defaultBrowser: 'chrome',
+    screenshotFormat: '.png'
+};
+const headersToObject = (headers) => Object.fromEntries(headers.map(({ name, value }) => [name.toLowerCase(), value.value ?? '']));
+const withApiTimeout = async (ms, promise) => {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new RecoverableBrowserError(`Selenium WebDriver API call did not respond within ${ms}ms — the session may have expired`)), ms);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+export const factory = async (configuration) => {
+    const selenium = await Npm.import(configuration, 'selenium-webdriver');
+    const { Builder: SeleniumBuilder, Browser } = selenium;
+    const { Options: ChromeOptions } = (await Npm.import(configuration, 'selenium-webdriver/chrome'));
+    const LogInspector = (await Npm.import(configuration, 'selenium-webdriver/bidi/logInspector')).default;
+    const BrowsingContext = (await Npm.import(configuration, 'selenium-webdriver/bidi/browsingContext')).default;
+    const ScriptManager = (await Npm.import(configuration, 'selenium-webdriver/bidi/scriptManager')).default;
+    const { CreateContextParameters: CreateContextParametersClass } = (await Npm.import(configuration, 'selenium-webdriver/bidi/createContextParameters'));
+    const { Network } = (await Npm.import(configuration, 'selenium-webdriver/bidi/network'));
+    let driver;
+    const contextToPageId = new Map();
+    let isFirstWindow = true;
+    return {
+        async setup(settings) {
+            logger.debug({ source: 'selenium-webdriver', message: 'launching browser' });
+            const options = new ChromeOptions();
+            const { args } = buildChromeLaunchOptions(settings.options, [
+                ...(settings.visible ? [] : ['--headless']),
+                '--start-maximized',
+                ...(settings.viewport ? [`--window-size=${settings.viewport.width},${settings.viewport.height}`] : [])
+            ]);
+            options.addArguments(...args);
+            options.enableBidi();
+            driver = new SeleniumBuilder().forBrowser(Browser.CHROME).setChromeOptions(options).build();
+            const caps = await driver.getCapabilities();
+            const logInspector = await LogInspector(driver);
+            await logInspector.onConsoleEntry((entry) => {
+                const pageId = (entry.source.browsingContextId === null ? undefined : contextToPageId.get(entry.source.browsingContextId)) ??
+                    -1;
+                handleConsoleMessage(entry.method, entry.text, pageId);
+            });
+            const network = await Network(driver);
+            await network.responseStarted((event) => {
+                if (event === null || !('response' in event))
+                    return;
+                const pageId = (event.id === null ? undefined : contextToPageId.get(event.id)) ?? -1;
+                handleNetworkResponse(pageId, event.request.url, event.request.method, event.response.status, headersToObject(event.request.headers), headersToObject(event.response.headers));
+            });
+            return {
+                browserName: caps.get('browserName') ?? 'chrome',
+                browserVersion: caps.get('browserVersion') ?? ''
+            };
+        },
+        async newWindow(settings) {
+            const { pageId, scripts, url } = settings;
+            const isFirst = isFirstWindow;
+            isFirstWindow = false;
+            let context;
+            if (isFirst) {
+                context = await driver.getWindowHandle();
+                contextToPageId.set(context, pageId);
+                for (const script of scripts) {
+                    const sm = await ScriptManager(context, driver);
+                    await sm.addPreloadScript(`() => { ${script} }`);
+                }
+                await driver.get(url);
+            }
+            else {
+                const tabParameters = new CreateContextParametersClass().background(true);
+                const bc = await BrowsingContext(driver, { type: 'tab', createParameters: tabParameters });
+                context = bc.id;
+                contextToPageId.set(context, pageId);
+                for (const script of scripts) {
+                    const sm = await ScriptManager(context, driver);
+                    await sm.addPreloadScript(`() => { ${script} }`);
+                }
+                await bc.navigate(url, 'interactive');
+            }
+            const { seleniumApiTimeout } = configuration;
+            return {
+                async eval(script) {
+                    return withApiTimeout(seleniumApiTimeout, (async () => {
+                        await driver.switchTo().window(context);
+                        return driver.executeScript(`return (${script})`);
+                    })());
+                },
+                async screenshot(path) {
+                    await withApiTimeout(seleniumApiTimeout, (async () => {
+                        await driver.switchTo().window(context);
+                        const data = await driver.takeScreenshot();
+                        await writeFile(path, Buffer.from(data, 'base64'));
+                    })());
+                },
+                async close() {
+                    contextToPageId.delete(context);
+                    if (contextToPageId.size === 0) {
+                        await BrowsingContext(driver, { type: 'tab' });
+                    }
+                    const bc = await BrowsingContext(driver, { browsingContextId: context });
+                    await bc.close();
+                }
+            };
+        },
+        async shutdown() {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            await driver?.quit();
+        }
+    };
+};

package/dist/browsers/webdriverio.js

@@ -0,0 +1,85 @@
+import { logger, Path } from '../platform/index.js';
+import { Npm } from '../Npm.js';
+import { handleConsoleMessage } from './consoleMessage.js';
+import { handleNetworkResponse } from './networkResponse.js';
+import { buildChromeLaunchOptions } from './chromeOptions.js';
+export const descriptor = {
+    supportedBrowsers: ['chrome', 'firefox', 'edge', 'safari'],
+    defaultBrowser: 'chrome',
+    screenshotFormat: '.png'
+};
+const headerValue = (value) => typeof value === 'string' ? value : (value?.value ?? '');
+const headersToObject = (headers) => Object.fromEntries((headers ?? []).map(({ name, value }) => [name.toLowerCase(), headerValue(value)]));
+export const factory = async (configuration) => {
+    const webdriverio = await Npm.import(configuration, 'webdriverio');
+    const { remote } = webdriverio;
+    let browser;
+    const contextToPageId = new Map();
+    return {
+        async setup(settings) {
+            logger.debug({ source: 'webdriverio', message: 'launching browser' });
+            process.env['WDIO_LOG_PATH'] = Path.join(configuration.reportDir, 'wdio.log');
+            browser = await remote({
+                capabilities: {
+                    browserName: 'chrome',
+                    webSocketUrl: true,
+                    'goog:chromeOptions': buildChromeLaunchOptions(settings.options, [
+                        ...(settings.visible ? [] : ['--headless']),
+                        '--start-maximized',
+                        ...(settings.viewport ? [`--window-size=${settings.viewport.width},${settings.viewport.height}`] : [])
+                    ])
+                }
+            });
+            browser.on('log.entryAdded', (entry) => {
+                const event = entry;
+                if (event.type !== 'console') {
+                    return;
+                }
+                const pageId = (event.source?.context === undefined ? undefined : contextToPageId.get(event.source.context)) ?? -1;
+                handleConsoleMessage(event.method ?? 'log', event.text ?? '', pageId);
+            });
+            await browser.sessionSubscribe({ events: ['network.responseStarted'] });
+            browser.on('network.responseStarted', (entry) => {
+                const event = entry;
+                const pageId = (event.context === null ? undefined : contextToPageId.get(event.context)) ?? -1;
+                handleNetworkResponse(pageId, event.request.url, event.request.method, event.response.status, headersToObject(event.request.headers), headersToObject(event.response.headers));
+            });
+            return {
+                browserName: browser.capabilities.browserName ?? 'chrome',
+                browserVersion: browser.capabilities.browserVersion ?? ''
+            };
+        },
+        async newWindow(settings) {
+            const { pageId, scripts, url } = settings;
+            const { context } = await browser.browsingContextCreate({ type: 'tab', background: true });
+            contextToPageId.set(context, pageId);
+            for (const script of scripts) {
+                await browser.scriptAddPreloadScript({
+                    functionDeclaration: `() => { ${script} }`,
+                    contexts: [context]
+                });
+            }
+            await browser.browsingContextNavigate({ context, url, wait: 'interactive' });
+            const switchTo = () => browser.switchToWindow(context);
+            return {
+                async eval(script) {
+                    await switchTo();
+                    return browser.execute(`return (${script})`);
+                },
+                async screenshot(path) {
+                    await switchTo();
+                    await browser.saveScreenshot(path);
+                },
+                async close() {
+                    contextToPageId.delete(context);
+                    await browser.browsingContextClose({ context });
+                }
+            };
+        },
+        async shutdown() {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            await browser?.deleteSession();
+            delete process.env['WDIO_LOG_PATH'];
+        }
+    };
+};

package/dist/cli.js

@@ -3,18 +3,24 @@ import { Exit, Host } from './platform/index.js';
 import { version } from './platform/version.js';
 import { CommandLine } from './configuration/CommandLine.js';
 import { execute } from './modes/execute.js';
-const main = async () => {
-    const cliVersion = await version();
-    const cliName = cliVersion.split('@')[0] ?? 'ui5-test-runner';
-    const indexOfCli = process.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value) || value.endsWith(cliName));
-    const configuration = await CommandLine.buildConfigurationFrom(Host.cwd(), process.argv.slice(indexOfCli + 1));
-    await execute(configuration);
-};
-main()
-    .catch((error) => {
+import { isIfEvaluatedAsTrue } from './if.js';
+import { sendToParentProcess } from './sendToParentProcess.js';
+try {
+    const { name: cliName } = await version();
+    const indexOfCli = Host.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value) || value.endsWith(cliName));
+    const configuration = await CommandLine.buildConfigurationFrom(Host.cwd(), indexOfCli === -1 ? [] : Host.argv.slice(indexOfCli + 1));
+    if (await isIfEvaluatedAsTrue(configuration)) {
+        await execute(configuration);
+    }
+    else {
+        console.log(String.raw `/!\ Skipping execution (--if)`);
+        sendToParentProcess({ type: 'skip' });
+    }
+}
+catch (error) {
     console.error(error);
     Exit.code = -1;
-})
-    .finally(async () => {
+}
+finally {
     await Exit.shutdown();
-});
+}