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

package/dist/modes/test/coverage/collect.js

@@ -0,0 +1,38 @@
+import { FileSystem, Path, assert, logger } from '../../../platform/index.js';
+const isCoverageData = (value) => {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const entries = Object.values(value);
+    return (entries.length > 0 &&
+        entries.every((entry) => entry !== null && typeof entry === 'object' && 'path' in entry && typeof entry['path'] === 'string'));
+};
+const remapPaths = (coverageData, sourceDirectory) => Object.fromEntries(Object.entries(coverageData).map(([key, entry]) => {
+    const absoluteKey = Path.join(sourceDirectory, key);
+    return [absoluteKey, { ...entry, path: absoluteKey }];
+}));
+export const collect = async (configuration, pageContext) => {
+    const { page, pageId, url, isSuite } = pageContext;
+    if (isSuite || !configuration.coverage) {
+        return;
+    }
+    const coverageData = await page.eval('window.__coverage__');
+    if (!coverageData) {
+        logger.warn({ source: 'coverage', pageId, message: 'no coverage data found for page', data: { url } });
+        return;
+    }
+    assert(isCoverageData(coverageData), `Invalid coverage data for page ${url}`);
+    let data = coverageData;
+    const firstFilePath = Object.keys(data)[0];
+    try {
+        await FileSystem.access(firstFilePath, FileSystem.constants.R_OK);
+    }
+    catch {
+        logger.debug({ source: 'coverage', pageId, message: 'coverage data requires mapping' });
+        data = remapPaths(coverageData, configuration.coverageSourceDir ?? configuration.webapp);
+    }
+    const fileName = `${pageId}.json`;
+    const filePath = Path.join(configuration.coverageTempDir, fileName);
+    await FileSystem.writeFile(filePath, JSON.stringify(data));
+    logger.debug({ source: 'coverage', pageId, message: `Coverage collected for ${url}`, data: { filePath } });
+};

package/dist/modes/test/coverage/index.js

@@ -0,0 +1,3 @@
+export { instrument } from './instrument.js';
+export { collect } from './collect.js';
+export { generateReport } from './report.js';

package/dist/modes/test/coverage/instrument.js

@@ -0,0 +1,70 @@
+import { FileSystem, Host, Path, Process, assert, logger } from '../../../platform/index.js';
+import { Folder } from '../../../utils/node/Folder.js';
+import { getNycBin } from './nyc.js';
+import { initSettings } from './settings.js';
+const MIN_BASELINE_FILE_SIZE = 5;
+export const instrument = async (configuration) => {
+    await Folder.recreate(configuration.coverageTempDir);
+    if (configuration.coverageSourceDir) {
+        logger.info({ source: 'coverage', message: 'coverageSourceDir is set, skipping local instrumentation' });
+        await generateBaseline(configuration);
+        return;
+    }
+    if (!configuration.webapp) {
+        logger.info({ source: 'coverage', message: 'no local webapp, skipping instrumentation' });
+        return;
+    }
+    if (configuration.coverageRemoteInstrument?.length) {
+        logger.warn({
+            source: 'coverage',
+            message: 'coverageRemoteInstrument has no effect with local instrumentation (legacy mode)'
+        });
+    }
+    logger.info({ source: 'coverage', message: 'instrumenting source files...' });
+    const { settings, settingsPath } = await initSettings(configuration);
+    const nycBin = await getNycBin(configuration);
+    const destinationDirectory = Path.join(configuration.coverageTempDir, 'instrumented');
+    const proc = Process.spawn('node', [
+        nycBin,
+        'instrument',
+        '--nycrc-path',
+        settingsPath,
+        '--cwd',
+        configuration.webapp,
+        configuration.webapp,
+        destinationDirectory
+    ], { detached: true });
+    await proc.closed;
+    assert(proc.code === 0, `nyc instrument failed with code ${proc.code}`);
+    if (settings.all !== false) {
+        await generateBaseline(configuration);
+    }
+    logger.info({ source: 'coverage', message: 'instrumentation complete' });
+};
+const generateBaseline = async (configuration) => {
+    const { settings, settingsPath } = await initSettings(configuration);
+    if (settings.all === false) {
+        return;
+    }
+    const nycBin = await getNycBin(configuration);
+    const baselineTemporaryDirectory = Path.join(configuration.coverageTempDir, 'baseline');
+    const baselineProc = Process.spawn('node', [nycBin, '--nycrc-path', settingsPath, '--temp-dir', baselineTemporaryDirectory, Host.nodePath, '-e', ''], { detached: true });
+    await baselineProc.closed;
+    assert(baselineProc.code === 0, `nyc baseline generation failed with code ${baselineProc.code}`);
+    const baselineFiles = await FileSystem.readdir(baselineTemporaryDirectory, { withFileTypes: true });
+    let baselineIndex = 0;
+    for (const entry of baselineFiles) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const sourcePath = Path.join(baselineTemporaryDirectory, entry.name);
+        const { size } = await FileSystem.stat(sourcePath);
+        if (size <= MIN_BASELINE_FILE_SIZE) {
+            continue;
+        }
+        const destinationName = baselineIndex === 0 ? 'baseline.json' : `baseline-${baselineIndex}.json`;
+        await FileSystem.rename(sourcePath, Path.join(configuration.coverageTempDir, destinationName));
+        ++baselineIndex;
+    }
+    await FileSystem.rm(baselineTemporaryDirectory, { recursive: true });
+};

package/dist/modes/test/coverage/nyc.js

@@ -0,0 +1,15 @@
+import { Npm } from '../../../Npm.js';
+import { Path } from '../../../platform/index.js';
+const cache = new WeakMap();
+export const getNycBin = (configuration) => {
+    let promise = cache.get(configuration);
+    if (!promise) {
+        promise = (async () => {
+            await Npm.import(configuration, 'nyc');
+            const nycRoot = await Npm.resolvePackageDir(configuration, 'nyc');
+            return Path.join(nycRoot, 'bin', 'nyc.js');
+        })();
+        cache.set(configuration, promise);
+    }
+    return promise;
+};

package/dist/modes/test/coverage/report.js

@@ -0,0 +1,71 @@
+import { Host, Path, Process, logger } from '../../../platform/index.js';
+import { createEmptyTestResults } from '../../../types/CommonTestReportFormat.js';
+import { Folder } from '../../../utils/node/Folder.js';
+import { getNycBin } from './nyc.js';
+import { getSettingsPath } from './settings.js';
+export const generateReport = async (configuration) => {
+    logger.info({ source: 'coverage', message: 'generating coverage report...' });
+    await Folder.recreate(configuration.coverageReportDir);
+    const [nycBin, settingsPath] = await Promise.all([getNycBin(configuration), getSettingsPath(configuration)]);
+    const mergedDirectory = Path.join(configuration.coverageTempDir, 'merged');
+    await Folder.create(mergedDirectory);
+    const mergedPath = Path.join(mergedDirectory, 'coverage.json');
+    const mergeProc = Process.spawn('node', [nycBin, 'merge', configuration.coverageTempDir, mergedPath], {
+        detached: true
+    });
+    await mergeProc.closed;
+    if (mergeProc.code !== 0) {
+        throw new Error(`nyc merge failed with code ${mergeProc.code}`);
+    }
+    const checks = [
+        ['--branches', configuration.coverageCheckBranches],
+        ['--functions', configuration.coverageCheckFunctions],
+        ['--lines', configuration.coverageCheckLines],
+        ['--statements', configuration.coverageCheckStatements]
+    ];
+    const hasThresholds = checks.some(([, value]) => value > 0);
+    const thresholdArguments = checks.flatMap(([flag, value]) => [flag, String(value)]);
+    const checkCoverageArguments = hasThresholds ? ['--check-coverage', ...thresholdArguments] : [];
+    const reporters = [...configuration.coverageReporters];
+    if (!reporters.includes('text')) {
+        reporters.push('text');
+    }
+    const reporterArguments = reporters.flatMap((r) => ['--reporter', r]);
+    const proc = Process.spawn('node', [
+        nycBin,
+        'report',
+        '--nycrc-path',
+        settingsPath,
+        '--temp-dir',
+        mergedDirectory,
+        '--report-dir',
+        configuration.coverageReportDir,
+        ...reporterArguments,
+        ...checkCoverageArguments
+    ], { detached: true, forceRender: true, env: { ...Host.env, NODE_OPTIONS: '' } });
+    await proc.closed;
+    if (proc.code !== 0) {
+        if (checkCoverageArguments.length > 0) {
+            const thresholds = checks
+                .filter(([, value]) => value > 0)
+                .map(([flag, value]) => `${flag.replace('--', '')}=${value}%`)
+                .join(', ');
+            logger.error({ source: 'coverage', message: `Coverage thresholds not met (${thresholds})` });
+            logger.info({ source: 'coverage', message: 'coverage report complete' });
+            const results = createEmptyTestResults();
+            results.tool.name = 'nyc';
+            results.summary.tests = 1;
+            results.summary.failed = 1;
+            results.tests.push({
+                name: 'Global code coverage check',
+                status: 'failed',
+                duration: 0,
+                message: `Coverage thresholds not met (${thresholds})`
+            });
+            return results;
+        }
+        throw new Error(`nyc report failed with code ${proc.code}`);
+    }
+    logger.info({ source: 'coverage', message: 'coverage report complete' });
+    return undefined;
+};

package/dist/modes/test/coverage/settings.js

@@ -0,0 +1,53 @@
+import { FileSystem, Path, logger } from '../../../platform/index.js';
+const cache = new WeakMap();
+export const getSettingsPath = async (configuration) => {
+    const { settingsPath } = await initSettings(configuration);
+    return settingsPath;
+};
+export const getSettings = async (configuration) => {
+    const { settings } = await initSettings(configuration);
+    return settings;
+};
+export const initSettings = (configuration) => {
+    let promise = cache.get(configuration);
+    if (!promise) {
+        promise = _initSettings(configuration);
+        cache.set(configuration, promise);
+    }
+    return promise;
+};
+const _initSettings = async (configuration) => {
+    let base = {};
+    try {
+        await FileSystem.access(configuration.coverageSettings, FileSystem.constants.R_OK);
+        const raw = await FileSystem.readFile(configuration.coverageSettings, 'utf8');
+        base = JSON.parse(raw);
+        logger.debug({ source: 'coverage', message: `Loaded coverage settings from ${configuration.coverageSettings}` });
+    }
+    catch {
+        logger.debug({ source: 'coverage', message: 'no coverage settings file found, using defaults' });
+    }
+    const exclude = [...(Array.isArray(base.exclude) ? base.exclude : [])];
+    const sourceDirectory = configuration.coverageSourceDir || configuration.webapp;
+    if (sourceDirectory) {
+        const temporaryDirectoryRelative = Path.relative(sourceDirectory, configuration.coverageTempDir);
+        const reportDirectoryRelative = Path.relative(sourceDirectory, configuration.coverageReportDir);
+        const testReportDirectoryRelative = Path.relative(sourceDirectory, configuration.reportDir);
+        exclude.push(`${temporaryDirectoryRelative}/**`, `${reportDirectoryRelative}/**`, `${testReportDirectoryRelative}/**`);
+    }
+    const settings = {
+        ...base,
+        all: base.all !== false,
+        sourceMap: false,
+        coverageGlobalScope: 'window.top',
+        coverageGlobalScopeFunc: false,
+        ...(sourceDirectory && { cwd: sourceDirectory }),
+        exclude
+    };
+    const settingsDirectory = Path.join(configuration.coverageTempDir, 'settings');
+    const settingsPath = Path.join(settingsDirectory, '.nycrc.json');
+    await FileSystem.mkdir(settingsDirectory, { recursive: true });
+    await FileSystem.writeFile(settingsPath, JSON.stringify(settings, undefined, 2));
+    logger.debug({ source: 'coverage', message: `Coverage settings written to ${settingsPath}` });
+    return { settings, settingsPath };
+};

package/dist/modes/test/index.js

@@ -1,66 +1,126 @@
-import { logger, logEnvironnement, Exit, FileSystem, Path, Http } from '../../platform/index.js';
+import { logger, logEnvironnement, Exit } from '../../platform/index.js';
 import { defaults } from '../../configuration/options.js';
+import { redactSecrets } from '../../utils/node/anonymize.js';
+import { toPlainObject } from '../../utils/shared/object.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 { setupBrowser, getBrowser } from './browser.js';
+import { makePageTask, reportError } from './pageTask.js';
+import { initBrowserConfig } from './browserConfig.js';
+import { initReportBuilder, getReportBuilder, setReportBrowserInfo } from './report.js';
+import { saveReport } from '../../reports/saveReport.js';
 import { Folder } from '../../utils/node/Folder.js';
-import { server } from './server.js';
+import { Server } from './Server.js';
 import { formatDuration } from '../../utils/shared/string.js';
+import { start } from '../../start.js';
+import { end } from '../../end.js';
+import { sendToParentProcess } from '../../sendToParentProcess.js';
+import { instrument, generateReport } from './coverage/index.js';
 export const test = async (configuration) => {
+    await initReportBuilder(configuration);
     await Folder.create(configuration.reportDir);
-    logger.start(configuration);
-    logger.debug({ source: 'job', message: 'Configuration', data: { defaults, configuration } });
-    await logEnvironnement();
+    await logger.start(configuration);
+    sendToParentProcess({ type: 'report-dir', reportDir: configuration.reportDir });
+    logger.debug({
+        source: 'job',
+        message: 'configuration',
+        data: { defaults, configuration: redactSecrets(toPlainObject(configuration)) }
+    });
+    if (!configuration.noBanner) {
+        await logEnvironnement();
+    }
     await getAgentSource();
-    let browser;
+    let isBrowserStarted = false;
     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}` });
+        await start(configuration);
+        if (configuration.coverage) {
+            await instrument(configuration);
+        }
+        const port = await Server.start(configuration);
+        if (configuration.serveOnly) {
+            const { promise, resolve } = Promise.withResolvers();
+            Exit.registerAsyncTask({
+                name: 'serveOnly',
+                stop: () => resolve()
+            });
+            logger.warn({ source: 'job', message: 'serving only, use CTRL+C to end command' });
+            await promise;
+            return;
+        }
         if (!configuration.url) {
-            configuration.url = [new URL(configuration.testsuite, `http://localhost:0`).toString()];
+            configuration.url = [new URL(configuration.testsuite, `http://localhost:0`).href];
         }
-        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 } });
+        const urls = configuration.url.map((url) => url.replace(':0/', () => `:${port}/`));
+        const capabilities = await setupBrowser(configuration);
+        setReportBrowserInfo(capabilities);
+        isBrowserStarted = true;
+        initBrowserConfig(configuration);
+        logger.info({ source: 'progress', message: 'executing pages', pageId: undefined, data: { value: 0, max: 0 } });
+        sendToParentProcess({ type: 'progress', count: 0, total: 0 });
         let completed = 0;
-        await parallelize(pageTask, urls, {
+        let lastLoggedCompleted;
+        let lastLoggedMax;
+        const startedIndices = new Set();
+        await parallelize(makePageTask(configuration), urls, {
             parallel: configuration.parallel,
             on: (event) => {
-                if (event.type === 'failed') {
+                if (event.type === 'started') {
+                    startedIndices.add(event.index);
+                }
+                else if (event.type === 'failed') {
                     logger.error({ source: 'job', message: 'page failed', error: event.error, data: { url: event.input } });
-                    Exit.code = -1;
+                    ++completed;
                 }
-                if (event.type === 'completed') {
+                else if (event.type === 'completed') {
                     ++completed;
                 }
+                if (lastLoggedCompleted === completed && lastLoggedMax === urls.length) {
+                    return;
+                }
+                lastLoggedCompleted = completed;
+                lastLoggedMax = urls.length;
                 logger.info({
                     source: 'progress',
-                    message: 'Executing pages',
+                    message: 'executing pages',
                     pageId: undefined,
                     data: { value: completed, max: urls.length }
                 });
+                sendToParentProcess({ type: 'progress', count: completed, total: 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)}` });
+        for (const [index, url] of urls.entries()) {
+            if (!startedIndices.has(index)) {
+                reportError(url, 'not executed (process was interrupted)');
+            }
+        }
+        getReportBuilder().finalize();
+        if (configuration.coverage) {
+            const coverageFailure = await generateReport(configuration);
+            if (coverageFailure) {
+                getReportBuilder().merge('coverage', coverageFailure);
+            }
         }
+        const { report } = getReportBuilder();
+        await saveReport(configuration, report);
+        const { passed, failed, tests, duration } = report.results.summary;
+        const durationString = duration ? ` (${formatDuration(duration)})` : '';
+        logger.info({
+            source: 'job',
+            message: `Tests completed: passed=${passed} failed=${failed} tests=${tests}${durationString}`
+        });
+        if (failed) {
+            Exit.code = -1;
+        }
+        sendToParentProcess({ type: 'done', passed, failed, tests });
+        await end(configuration);
     }
     catch (error) {
-        logger.error({ source: 'job', message: 'An error occurred', error });
+        logger.error({ source: 'job', message: 'an error occurred', error });
     }
     finally {
-        await browser?.shutdown();
-        await server.stop();
+        if (isBrowserStarted) {
+            await getBrowser().shutdown();
+        }
+        await Server.stop();
     }
 };