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

package/dist/browsers/factory.js

@@ -1,9 +1,174 @@
-import { factory as puppeteerFactory } from './puppeteer.js';
+import { factory as puppeteerFactory, descriptor as puppeteerDescriptor } from './puppeteer.js';
+import { factory as playwrightFactory, descriptor as playwrightDescriptor } from './playwright.js';
+import { factory as webdriverioFactory, descriptor as webdriverioDescriptor } from './webdriverio.js';
+import { factory as seleniumWebdriverFactory, descriptor as seleniumWebdriverDescriptor } from './seleniumWebdriver.js';
+import { Exit, logger } from '../platform/index.js';
+import { RecoverableBrowserError } from './RecoverableBrowserError.js';
+const DRIVERS = ['puppeteer', 'playwright', 'webdriverio', 'selenium-webdriver'];
+export const isDriver = (value) => DRIVERS.includes(value);
 const factories = {
-    puppeteer: puppeteerFactory
+    puppeteer: puppeteerFactory,
+    playwright: playwrightFactory,
+    webdriverio: webdriverioFactory,
+    'selenium-webdriver': seleniumWebdriverFactory
+};
+const descriptors = {
+    puppeteer: puppeteerDescriptor,
+    playwright: playwrightDescriptor,
+    webdriverio: webdriverioDescriptor,
+    'selenium-webdriver': seleniumWebdriverDescriptor
+};
+export const getDescriptor = (driver) => descriptors[driver];
+let _instanceCount = 0;
+const _activeInstances = new Set();
+const shutdown = async (browser, inner) => {
+    logger.debug({ source: browser, message: 'shutdown' });
+    try {
+        await inner.shutdown();
+        logger.debug({ source: browser, message: 'shutdown completed' });
+    }
+    catch (error) {
+        logger.warn({
+            source: browser,
+            message: 'shutdown failed',
+            error
+        });
+    }
 };
 export const BrowserFactory = {
     async build(configuration, browser) {
-        return await factories[browser](configuration);
+        if (_activeInstances.has(browser)) {
+            logger.fatal({ source: browser, message: 'build failed: already has an active instance' });
+        }
+        _activeInstances.add(browser);
+        const abortController = new AbortController();
+        let inner;
+        try {
+            logger.debug({ source: browser, message: 'build' });
+            inner = await factories[browser](configuration, abortController.signal);
+            logger.debug({ source: browser, message: 'build completed' });
+        }
+        catch (error) {
+            _activeInstances.delete(browser);
+            logger.fatal({ source: browser, message: 'build failed', error });
+            throw error;
+        }
+        const _openWindows = new Set();
+        const closeAllWindows = async () => {
+            await Promise.all([..._openWindows].map(async (w) => {
+                try {
+                    await w.close();
+                }
+                catch {
+                }
+            }));
+        };
+        let task;
+        return {
+            async setup(settings) {
+                task = Exit.registerAsyncTask({
+                    name: `${browser}#${++_instanceCount}`,
+                    async stop() {
+                        abortController.abort();
+                        await closeAllWindows();
+                        await shutdown(browser, inner);
+                    }
+                });
+                logger.debug({ source: browser, message: 'setup', data: settings });
+                try {
+                    const capabilities = await inner.setup(settings);
+                    logger.debug({ source: browser, message: 'setup completed', data: capabilities });
+                    return capabilities;
+                }
+                catch (error) {
+                    task[Symbol.dispose]();
+                    _activeInstances.delete(browser);
+                    logger.fatal({
+                        source: browser,
+                        message: 'setup failed',
+                        error
+                    });
+                    throw error;
+                }
+            },
+            async newWindow(settings) {
+                const { pageId } = settings;
+                logger.debug({ source: browser, message: 'newWindow', pageId, data: settings });
+                try {
+                    const innerWindow = await inner.newWindow(settings);
+                    logger.debug({ source: browser, message: 'newWindow completed', pageId });
+                    const wrapped = wrapWindow(innerWindow, browser, pageId, () => _openWindows.delete(wrapped));
+                    _openWindows.add(wrapped);
+                    return wrapped;
+                }
+                catch (error) {
+                    const logMethod = error instanceof RecoverableBrowserError ? 'error' : 'fatal';
+                    logger[logMethod]({
+                        source: browser,
+                        message: 'newWindow failed',
+                        error
+                    });
+                    throw error;
+                }
+            },
+            async shutdown() {
+                await closeAllWindows();
+                await shutdown(browser, inner);
+                task?.[Symbol.dispose]();
+                _activeInstances.delete(browser);
+            }
+        };
     }
 };
+const wrapWindow = (innerWindow, source, pageId, onClosed) => {
+    let isClosed = false;
+    return {
+        async eval(script) {
+            logger.debug({ source, message: 'eval', pageId, data: { script } });
+            try {
+                if (isClosed) {
+                    throw new Error('window closed');
+                }
+                const result = await innerWindow.eval(script);
+                logger.debug({ source, message: 'eval completed', pageId, data: { result } });
+                return result;
+            }
+            catch (error) {
+                logger.error({ source, message: 'eval failed', pageId, error });
+                throw error;
+            }
+        },
+        async screenshot(path) {
+            logger.debug({ source, message: 'screenshot', pageId, data: { path } });
+            try {
+                if (isClosed) {
+                    throw new Error('window closed');
+                }
+                await innerWindow.screenshot(path);
+                logger.debug({ source, message: 'screenshot completed', pageId, data: { path } });
+            }
+            catch (error) {
+                logger.error({ source, message: 'screenshot failed', pageId, error, data: { path } });
+                throw error;
+            }
+        },
+        async close() {
+            if (isClosed) {
+                logger.warn({ source, message: 'closing an already closed window, ignored', pageId });
+                return;
+            }
+            isClosed = true;
+            logger.debug({ source, message: 'window close', pageId });
+            try {
+                await innerWindow.close();
+                logger.debug({ source, message: 'window closed', pageId });
+            }
+            catch (error) {
+                logger.error({ source, message: 'window close failed', error });
+            }
+            finally {
+                onClosed();
+            }
+        }
+    };
+};

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 (configuration) => {
+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;
+    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 (configuration) => {
                 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 (configuration) => {
                     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();
+        }
+    };
+};