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

package/dist/Npm.js

@@ -1,6 +1,6 @@
-import { logger, FileSystem, Http, Path, Process } from './platform/index.js';
+import { logger, FileSystem, Http, Module, Path, Process, Url } from './platform/index.js';
 import { memoize } from './utils/shared/memoize.js';
-const getNpmCliPath = memoize(async () => {
+export const getNpmCliPath = async () => {
     const npmChildProcess = Process.spawn('npm', [], {
         shell: true
     });
@@ -18,9 +18,10 @@ const getNpmCliPath = memoize(async () => {
     }
     logger.debug({ source: 'npm', message: `npm@${semver} ${path}` });
     return Path.join(path, 'bin/npm-cli.js');
-});
+};
+const memoizedNpmCliPath = memoize(getNpmCliPath);
 const npm = async (...arguments_) => {
-    const npmCliPath = await getNpmCliPath();
+    const npmCliPath = await memoizedNpmCliPath();
     return Process.spawn('node', [npmCliPath, ...arguments_], {
         detached: true
     });
@@ -37,8 +38,33 @@ const getRoots = memoize(async () => {
         global: globalRootProcess.stdout.trim()
     };
 });
-export const Npm = {
-    async getLatestVersion(moduleName) {
+const buildInstallPlan = (strategy, moduleName, globalRoot, prefix) => {
+    if (strategy === 'global') {
+        return { installArguments: ['install', '-g', moduleName], reimportPath: globalRoot };
+    }
+    if (strategy === 'prefix') {
+        return {
+            installArguments: ['install', '--prefix', prefix, '--no-save', moduleName],
+            reimportPath: Path.join(prefix, 'node_modules')
+        };
+    }
+    return { installArguments: ['install', '--no-save', moduleName], reimportPath: undefined };
+};
+export class Npm {
+    static dynamicImport(specifier) {
+        return import(specifier);
+    }
+    static async tryImportFromPath(configuration, moduleName, nodeModulesPath) {
+        try {
+            const require = Module.createRequire(Url.pathToFileURL(Path.join(configuration.cwd, 'package.json')).href);
+            const resolved = require.resolve(moduleName, { paths: [nodeModulesPath] });
+            return await this.dynamicImport(Url.pathToFileURL(resolved).href);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static async getLatestVersion(moduleName) {
         try {
             const response = await Http.get(`https://registry.npmjs.org/${moduleName}/latest`);
             const { version } = JSON.parse(response);
@@ -49,8 +75,8 @@ export const Npm = {
                 cause: error
             });
         }
-    },
-    async checkIfLatestVersion(moduleName, isLocal) {
+    }
+    static async checkIfLatestVersion(moduleName, isLocal) {
         try {
             const { local, global } = await getRoots();
             const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(isLocal ? local : global, moduleName, 'package.json'), 'utf8'));
@@ -63,18 +89,62 @@ export const Npm = {
         catch (error) {
             logger.error({ source: 'npm', message: 'Failed in checkIfLatestVersion', error });
         }
-    },
-    async import(moduleName) {
+    }
+    static async import(configuration, moduleName) {
         logger.debug({ source: 'npm', message: `Npm.import(${moduleName})` });
         try {
-            const module = (await import(moduleName));
+            const module = await this.dynamicImport(moduleName);
             logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
-            void this.checkIfLatestVersion(moduleName, true);
+            void Npm.checkIfLatestVersion(moduleName, true);
             return module;
         }
-        catch {
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') {
+                throw error;
+            }
             logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
         }
-        throw new Error('Not implemented');
+        const { global: globalRoot } = await getRoots();
+        const fromGlobal = await this.tryImportFromPath(configuration, moduleName, globalRoot);
+        if (fromGlobal !== undefined) {
+            logger.debug({ source: 'npm', message: `Module ${moduleName} found globally` });
+            void Npm.checkIfLatestVersion(moduleName, false);
+            return fromGlobal;
+        }
+        if (configuration.alternateNpmPath) {
+            const fromAlternate = await this.tryImportFromPath(configuration, moduleName, configuration.alternateNpmPath);
+            if (fromAlternate !== undefined) {
+                logger.debug({ source: 'npm', message: `Module ${moduleName} found in alternateNpmPath` });
+                return fromAlternate;
+            }
+        }
+        if (configuration.npmInstallPrefix) {
+            const fromPrefix = await this.tryImportFromPath(configuration, moduleName, Path.join(configuration.npmInstallPrefix, 'node_modules'));
+            if (fromPrefix !== undefined) {
+                logger.debug({ source: 'npm', message: `Module ${moduleName} found in npmInstallPrefix` });
+                return fromPrefix;
+            }
+        }
+        if (configuration.noNpmInstall) {
+            const message = `Module ${moduleName} not found and noNpmInstall is set`;
+            logger.fatal({ source: 'npm', message });
+            throw new Error(message);
+        }
+        const strategy = configuration.npmInstall;
+        logger.info({ source: 'npm', message: `Installing ${moduleName} (strategy: ${strategy})` });
+        const { installArguments, reimportPath } = buildInstallPlan(strategy, moduleName, globalRoot, configuration.npmInstallPrefix ?? '');
+        const installProcess = await npm(...installArguments);
+        await installProcess.closed;
+        if (reimportPath !== undefined) {
+            const result = await this.tryImportFromPath(configuration, moduleName, reimportPath);
+            if (result === undefined) {
+                const message = `Module ${moduleName} could not be loaded after install`;
+                logger.fatal({ source: 'npm', message });
+                throw new Error(message);
+            }
+            return result;
+        }
+        return await this.dynamicImport(moduleName);
     }
-};
+}

package/dist/browsers/factory.js

@@ -3,7 +3,7 @@ const factories = {
     puppeteer: puppeteerFactory
 };
 export const BrowserFactory = {
-    async build(browser) {
-        return await factories[browser]();
+    async build(configuration, browser) {
+        return await factories[browser](configuration);
     }
 };

package/dist/browsers/puppeteer.js

@@ -1,8 +1,8 @@
 import { logger, Exit, 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');
+export const factory = async (configuration) => {
+    const puppeteer = await Npm.import(configuration, 'puppeteer');
     const { launch } = puppeteer;
     let browser;
     const abortController = new AbortController();

package/dist/cli.js

@@ -5,8 +5,8 @@ import { CommandLine } from './configuration/CommandLine.js';
 import { execute } from './modes/execute.js';
 const main = async () => {
     const cliVersion = await version();
-    const cliName = cliVersion.split('@')[0];
-    const indexOfCli = process.argv.findIndex((value) => /[\\/]cli(\.[tj]s)?$/.exec(value) || value === cliName);
+    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);
 };

package/dist/configuration/options.js

@@ -106,6 +106,17 @@ export const options = [
         type: 'boolean',
         description: 'prevent any NPM install'
     },
+    {
+        name: 'npmInstall',
+        type: 'string',
+        description: 'npm install strategy for missing packages',
+        default: 'global'
+    },
+    {
+        name: 'npmInstallPrefix',
+        type: 'fs-entry',
+        description: 'path used as --prefix when npmInstall is set to prefix'
+    },
     {
         name: 'outputInterval',
         short: 'oi',
@@ -182,6 +193,7 @@ export const defaults = {
     config: 'ui5-test-runner.json',
     cwd: process.cwd(),
     localhost: 'localhost',
+    npmInstall: 'global',
     outputInterval: 30_000,
     parallel: 2,
     reportDir: 'report',

package/dist/modes/log/index.js

@@ -26,7 +26,7 @@ export const log = async (configuration) => {
         name: 'log',
         stop: stop
     });
-    const browser = await BrowserFactory.build('puppeteer');
+    const browser = await BrowserFactory.build(configuration, 'puppeteer');
     const browserReady = browser.setup({
         visible: true
     });

package/dist/modes/test/browser.js

@@ -3,7 +3,7 @@ import { Exit, assert, logger } from '../../platform/index.js';
 let browser;
 export const setupBrowser = async (configuration) => {
     assert(configuration.browser === 'puppeteer');
-    browser = await BrowserFactory.build('puppeteer');
+    browser = await BrowserFactory.build(configuration, 'puppeteer');
     const { debugKeepBrowserOpen } = configuration;
     const settings = {
         visible: debugKeepBrowserOpen

package/dist/platform/Module.js

@@ -0,0 +1,4 @@
+import { createRequire } from 'node:module';
+export class Module {
+    static createRequire = createRequire;
+}

package/dist/platform/Url.js

@@ -0,0 +1,4 @@
+import { pathToFileURL } from 'node:url';
+export class Url {
+    static pathToFileURL = pathToFileURL;
+}

package/dist/platform/index.js

@@ -6,8 +6,10 @@ export * from './Exit.js';
 export * from './FileSystem.js';
 export * from './Host.js';
 export * from './Http.js';
+export * from './Module.js';
 export * from './Path.js';
 export * from './Process.js';
 export * from './Terminal.js';
 export * from './Thread.js';
+export * from './Url.js';
 export * from './ZLib.js';

package/dist/platform/mock.js

@@ -1,17 +1,21 @@
 import { vi } from 'vitest';
 import { join } from 'node:path';
-const mockStaticMethodsOfExportedClasses = (actual) => {
+const mockMethods = (object, members) => {
+    for (const member of members) {
+        if (typeof object[member] === 'function') {
+            object[member] = vi.fn();
+        }
+    }
+};
+const mockStaticMethodsOfExports = (actual) => {
     const mocked = { ...actual };
     for (const exportName in mocked) {
         const exportValue = mocked[exportName];
         if (typeof exportValue === 'function') {
-            const exportClass = exportValue;
-            for (const staticName of Object.getOwnPropertyNames(exportValue)) {
-                const staticValue = exportClass[staticName];
-                if (typeof staticValue === 'function') {
-                    exportClass[staticName] = vi.fn();
-                }
-            }
+            mockMethods(exportValue, Object.getOwnPropertyNames(exportValue));
+        }
+        else if (typeof exportValue === 'object' && exportValue !== null) {
+            mockMethods(exportValue, Object.keys(exportValue));
         }
     }
     return mocked;
@@ -26,7 +30,7 @@ vi.mock(import('./constants.js'), async (importActual) => {
 export const __unregisterExitAsyncTask = vi.fn();
 export let __lastRegisteredExitAsyncTask;
 vi.mock(import('./Exit.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const mocked = mockStaticMethodsOfExports(await importActual());
     const { Exit } = mocked;
     vi.mocked(Exit.registerAsyncTask).mockImplementation((task) => {
         __lastRegisteredExitAsyncTask = task;
@@ -35,7 +39,7 @@ vi.mock(import('./Exit.js'), async (importActual) => {
     return mocked;
 });
 vi.mock(import('./FileSystem.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const mocked = mockStaticMethodsOfExports(await importActual());
     const { FileSystem } = mocked;
     const writeStream = {
         write: vi.fn().mockImplementation((_, callback) => callback()),
@@ -46,8 +50,9 @@ vi.mock(import('./FileSystem.js'), async (importActual) => {
     vi.mocked(FileSystem.createReadStream).mockReturnValue(readStream);
     return mocked;
 });
-vi.mock(import('./Host.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
-vi.mock(import('./Http.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+vi.mock(import('./Host.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));
+vi.mock(import('./Http.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));
+vi.mock(import('./Module.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));
 const logger = {
     start: vi.fn(),
     debug: vi.fn(),
@@ -59,18 +64,18 @@ const logger = {
 };
 vi.mock(import('./logger.js'), () => ({ logger }));
 vi.mock(import('./Path.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const mocked = mockStaticMethodsOfExports(await importActual());
     const { Path } = mocked;
     vi.mocked(Path.isAbsolute).mockImplementation((path) => path.startsWith('/'));
     vi.mocked(Path.join).mockImplementation((...arguments_) => join(...arguments_).replaceAll('\\', '/'));
     return mocked;
 });
-vi.mock(import('./Process.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+vi.mock(import('./Process.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));
 export let __lastTerminalRawModeCallback = false;
 vi.mock(import('./Terminal.js'), async (importActual) => {
     const actual = await importActual();
     const originalstripVTControlCharacters = actual.Terminal.stripVTControlCharacters;
-    const mocked = mockStaticMethodsOfExportedClasses(actual);
+    const mocked = mockStaticMethodsOfExports(actual);
     const { Terminal } = mocked;
     vi.mocked(Terminal.setRawMode).mockImplementation((callback) => {
         __lastTerminalRawModeCallback = callback;
@@ -79,7 +84,7 @@ vi.mock(import('./Terminal.js'), async (importActual) => {
     return mocked;
 });
 vi.mock(import('./Thread.js'), async (importActual) => {
-    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const mocked = mockStaticMethodsOfExports(await importActual());
     const { Thread } = mocked;
     const channel = {
         postMessage: vi.fn().mockImplementation((data) => {
@@ -101,4 +106,5 @@ vi.mock(import('./Thread.js'), async (importActual) => {
 vi.mock(import('./version.js'), () => ({
     version: vi.fn().mockResolvedValue('ui5-test-runner@1.2.3')
 }));
-vi.mock(import('./ZLib.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+vi.mock(import('./ZLib.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));
+vi.mock(import('./Url.js'), async (importActual) => mockStaticMethodsOfExports(await importActual()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ui5-test-runner",
-  "version": "6.0.0-beta.2",
+  "version": "6.0.0-beta.5",
   "description": "Standalone test runner for UI5",
   "main": "dist/cli.js",
   "type": "module",
@@ -101,7 +101,7 @@
     "globals": "^17.6.0",
     "jsdom": "^29.1.1",
     "markdownlint-cli": "^0.48.0",
-    "npm-check-updates": "^22.2.1",
+    "npm-check-updates": "^22.2.2",
     "puppeteer": "^25.1.0",
     "qunit": "^2.26.0",
     "rimraf": "^6.1.3",
@@ -110,7 +110,7 @@
     "stylelint-config-standard": "^40.0.0",
     "terser": "^5.48.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.0",
+    "typescript-eslint": "^8.60.1",
     "ui5-tooling-transpile": "^3.11.2",
     "vite": "^8.0.16",
     "vite-plugin-css-injected-by-js": "^5.0.1",