ui5-test-runner 6.0.3 → 6.0.5

package/dist/Npm.js

@@ -19,7 +19,7 @@ const npm = async (...arguments_) => {
         detached: true
     });
 };
-const validateRoot = async (proc, label) => {
+const validateRoot = async (proc, label, requiresExistence) => {
     if (proc.code !== 0) {
         logger.fatal({ source: 'npm', message: `npm root ${label} failed with code ${proc.code}` });
     }
@@ -30,8 +30,11 @@ const validateRoot = async (proc, label) => {
     try {
         await FileSystem.access(value, FileSystem.constants.R_OK);
     }
-    catch {
-        logger.fatal({ source: 'npm', message: `npm root ${label} directory is not accessible: "${value}"` });
+    catch (error) {
+        const code = error.code;
+        if (requiresExistence || code !== 'ENOENT') {
+            logger.fatal({ source: 'npm', message: `npm root ${label} directory is not accessible: "${value}"` });
+        }
     }
     return value;
 };
@@ -39,8 +42,8 @@ const getRoots = memoize(async () => {
     const localRootProcess = await npm('root');
     const globalRootProcess = await npm('root', '--global');
     await Promise.all([localRootProcess.closed, globalRootProcess.closed]);
-    const local = await validateRoot(localRootProcess, '(local)');
-    const global = await validateRoot(globalRootProcess, '(global)');
+    const local = await validateRoot(localRootProcess, '(local)', false);
+    const global = await validateRoot(globalRootProcess, '(global)', true);
     logger.debug({ source: 'npm', message: 'roots', data: { local, global } });
     return { local, global };
 });
@@ -63,6 +66,17 @@ export class Npm {
     static dynamicImport(specifier) {
         return import(specifier);
     }
+    static resolveSpecifier(specifier) {
+        return import.meta.resolve(specifier);
+    }
+    static tryResolveSpecifier(specifier) {
+        try {
+            return this.resolveSpecifier(specifier);
+        }
+        catch {
+            return 'unknown location';
+        }
+    }
     static tryResolvePackageDir(moduleName, nodeModulesPath) {
         try {
             const packageJsonPath = Module.findPackageJSON(moduleName, `${nodeModulesPath}/`);
@@ -73,10 +87,13 @@ export class Npm {
         }
     }
     static async tryImportFromPath(configuration, moduleName, nodeModulesPath) {
+        if (this.tryResolvePackageDir(this.packageNameOf(moduleName), nodeModulesPath) === undefined) {
+            return undefined;
+        }
         try {
             const require = Module.createRequire(`${Url.pathToFileURL(configuration.cwd).href}/`);
             const resolved = require.resolve(moduleName, { paths: [nodeModulesPath] });
-            return await this.dynamicImport(Url.pathToFileURL(resolved).href);
+            return { module: await this.dynamicImport(Url.pathToFileURL(resolved).href), resolved };
         }
         catch {
             return undefined;
@@ -86,19 +103,24 @@ export class Npm {
         for (const { path, label, checkVersion } of roots) {
             const result = await this.tryImportFromPath(configuration, moduleName, path);
             if (result !== undefined) {
-                logger.debug({ source: 'npm', message: `Module ${moduleName} ${label}` });
+                logger.debug({ source: 'npm', message: `Module ${moduleName} ${label} (${result.resolved})` });
                 if (checkVersion)
                     void this.checkIfLatestVersion(configuration, moduleName);
-                return result;
+                return result.module;
             }
         }
         return undefined;
     }
-    static async import(configuration, moduleName) {
-        logger.debug({ source: 'npm', message: `Importing module: ${moduleName}` });
+    static async tryImportLocally(configuration, moduleName) {
+        if (configuration.debugNpmNoLocal) {
+            return undefined;
+        }
         try {
             const module = await this.dynamicImport(moduleName);
-            logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
+            logger.debug({
+                source: 'npm',
+                message: `Module ${moduleName} found locally (${this.tryResolveSpecifier(moduleName)})`
+            });
             void this.checkIfLatestVersion(configuration, moduleName);
             return module;
         }
@@ -110,7 +132,14 @@ export class Npm {
             if (moduleName === this.packageNameOf(moduleName)) {
                 logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
             }
+            return undefined;
         }
+    }
+    static async import(configuration, moduleName) {
+        logger.debug({ source: 'npm', message: `Importing module: ${moduleName}` });
+        const local = await this.tryImportLocally(configuration, moduleName);
+        if (local !== undefined)
+            return local;
         const { local: localRoot, global: globalRoot } = await getRoots();
         const extraRoots = [
             ...(configuration.alternateNpmPath
@@ -121,7 +150,9 @@ export class Npm {
                 : [])
         ];
         const found = await this.tryImportFromRoots(configuration, moduleName, [
-            { path: localRoot, label: 'found in local node_modules', checkVersion: true },
+            ...(configuration.debugNpmNoLocal
+                ? []
+                : [{ path: localRoot, label: 'found in local node_modules', checkVersion: true }]),
             { path: globalRoot, label: 'found globally', checkVersion: true },
             ...extraRoots
         ]);
@@ -144,18 +175,20 @@ export class Npm {
         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 });
+                return logger.fatal({ source: 'npm', message: `Module ${moduleName} could not be loaded after install` });
             }
-            return result;
+            logger.debug({ source: 'npm', message: `Module ${moduleName} loaded after install (${result.resolved})` });
+            return result.module;
         }
         return await this.dynamicImport(moduleName);
     }
     static async resolvePackageDir(configuration, moduleName) {
         const { local, global: globalRoot } = await getRoots();
-        const fromLocal = this.tryResolvePackageDir(moduleName, local);
-        if (fromLocal)
-            return fromLocal;
+        if (!configuration.debugNpmNoLocal) {
+            const fromLocal = this.tryResolvePackageDir(moduleName, local);
+            if (fromLocal)
+                return fromLocal;
+        }
         const fromGlobal = this.tryResolvePackageDir(moduleName, globalRoot);
         if (fromGlobal)
             return fromGlobal;
@@ -171,6 +204,17 @@ export class Npm {
         }
         throw new Error(`Cannot locate package directory for ${moduleName}`);
     }
+    static async resolvePackageBinCommand(configuration, moduleName, command) {
+        const packageDirectory = await this.resolvePackageDir(configuration, moduleName);
+        const { bin } = JSON.parse(await FileSystem.readFile(Path.join(packageDirectory, 'package.json'), 'utf8'));
+        const binRelativePath = typeof bin === 'string' ? bin : bin?.[command];
+        return binRelativePath
+            ? Path.join(packageDirectory, binRelativePath)
+            : logger.fatal({
+                source: 'npm',
+                message: `Unable to locate command "${command}" in ${moduleName} package.json "bin"`
+            });
+    }
     static packageNameOf(moduleName) {
         if (moduleName.startsWith('@')) {
             const [scope, package_] = moduleName.split('/', 2);

package/dist/browsers/playwright.js

@@ -35,8 +35,8 @@ export const factory = async (configuration, signal) => {
                         max: 0
                     }
                 });
-                await Process.spawn('npx', 'playwright install chromium'.split(' '), {
-                    shell: true,
+                const cliPath = await Npm.resolvePackageBinCommand(configuration, 'playwright', 'playwright');
+                await Process.spawn('node', [cliPath, 'install', 'chromium'], {
                     signal
                 }).closed;
                 browser = await chromium.launch(launchOptions);

package/dist/browsers/puppeteer.js

@@ -45,8 +45,8 @@ export const factory = async (configuration, signal) => {
                         max: 0
                     }
                 });
-                await Process.spawn('npx', `puppeteer browsers install ${target}`.split(' '), {
-                    shell: true,
+                const cliPath = await Npm.resolvePackageBinCommand(configuration, 'puppeteer', 'puppeteer');
+                await Process.spawn('node', [cliPath, 'browsers', 'install', target], {
                     signal
                 }).closed;
                 browser = await launch(launchOptions);

package/dist/configuration/ConfigurationValidator.js

@@ -91,6 +91,17 @@ const extractConfigEntries = (parsed, configDirectory) => {
     }
     return { forcedKeys, configFileKeys, configFileObject };
 };
+const substitutePlaceholder = async (merged, searchToken, valueToReplace) => {
+    for (const option of options) {
+        if (!(option.type === 'fs-entry' &&
+            typeof merged[option.name] === 'string' &&
+            merged[option.name].includes(searchToken))) {
+            continue;
+        }
+        const substituted = Path.join(valueToReplace, merged[option.name].split(searchToken, 2)[1]);
+        Object.assign(merged, { [option.name]: await validateValue(option, { ...merged, [option.name]: substituted }) });
+    }
+};
 const finalizeConfiguration = async (merged) => {
     const hasExplicitReportDirectory = Object.hasOwn(merged, 'reportDir');
     for (const option of options) {
@@ -108,15 +119,8 @@ const finalizeConfiguration = async (merged) => {
             reportDir: await validateValue(reportDirectoryOption, { ...merged, reportDir: batchReportDirectory })
         });
     }
-    for (const option of options) {
-        if (!(option.type === 'fs-entry' &&
-            typeof merged[option.name] === 'string' &&
-            merged[option.name].includes('{{reportDir}}'))) {
-            continue;
-        }
-        const substituted = Path.join(merged.reportDir, merged[option.name].split('{{reportDir}}', 2)[1]);
-        Object.assign(merged, { [option.name]: await validateValue(option, { ...merged, [option.name]: substituted }) });
-    }
+    await substitutePlaceholder(merged, '{{reportDir}}', merged.reportDir);
+    await substitutePlaceholder(merged, '{{tmpDir}}', Host.tmpdir());
     for (const derive of derivations) {
         derive(merged);
     }

package/dist/configuration/options.js

@@ -249,6 +249,11 @@ export const options = [
         type: 'boolean',
         description: 'use local docs/ directory instead of fetching from GitHub (development only)'
     },
+    {
+        name: 'debugNpmNoLocal',
+        type: 'boolean',
+        description: 'Simulates a locally-absent package so the runner falls back to global or prefix resolution (development/testing only)'
+    },
     {
         name: 'driver',
         short: 'd',
@@ -378,7 +383,8 @@ export const options = [
     {
         name: 'npmInstallPrefix',
         type: 'fs-entry',
-        description: 'path used as --prefix when npmInstall is set to prefix'
+        typeModifiers: new Set(['overwrite']),
+        description: 'Directory used as the npm --prefix install target when --npm-install is set to prefix'
     },
     {
         name: 'outputInterval',