@testim/testim-cli 3.212.0 → 3.216.0

package/agent/routers/cliJsCode/service.js

@@ -3,7 +3,7 @@
 const path = require('path');
 const findRoot = require('find-root');
 const dataUriToBuffer = require('data-uri-to-buffer');
-const {spawn: threadSpawn, config} = require('threads');
+const { spawn: threadSpawn, config } = require('threads');
 const Promise = require('bluebird');
 const fs = require('fs-extra');
 const utils = require('../../../utils');
@@ -11,7 +11,7 @@ const logger = require('../../../commons/logger').getLogger("cli-service");
 const { getS3Artifact } = require('../../../commons/testimServicesApi');
 const npmWrapper = require('../../../commons/npmWrapper');
 const featureFlags = require('../../../commons/featureFlags');
-const {NpmPackageError} = require('../../../errors');
+const { NpmPackageError } = require('../../../errors');
 
 config.set({
     basepath: {
@@ -210,10 +210,10 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
     const thread = threadSpawn(constructWithArguments(Function, ['input', 'done', 'progress', runFn]));
     return new Promise((resolve) => {
         thread
-            .send({incomingParams, context, code})
+            .send({ incomingParams, context, code })
             .on('message', message => {
-                const messageWithLogs = Object.assign({}, message, {tstConsoleLogs: testimConsoleLogDataAggregates})
-                logger.debug('Run code worker response', {messageWithLogs, transactionId});
+                const messageWithLogs = Object.assign({}, message, { tstConsoleLogs: testimConsoleLogDataAggregates })
+                logger.debug('Run code worker response', { messageWithLogs, transactionId });
                 resolve(messageWithLogs);
             })
             .on('progress', (logMessage) => {
@@ -221,11 +221,11 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
             })
             .on('error', (err) => {
                 if (err.message === "malformed data: URI") {
-                    logger.error('Run code worker error', {err, transactionId, fileDataUrl});
+                    logger.error('Run code worker error', { err, transactionId, fileDataUrl });
                 } else {
-                    logger.error('Run code worker error', {err, transactionId});
+                    logger.error('Run code worker error', { err, transactionId });
                 }
-                
+
                 resolve({
                     tstConsoleLogs: testimConsoleLogDataAggregates,
                     status: 'failed',
@@ -239,11 +239,11 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                 });
             })
             .on('exit', () => {
-                logger.debug('Run code worker has been terminated', {transactionId});
+                logger.debug('Run code worker has been terminated', { transactionId });
             });
     }).timeout(timeout)
         .catch(Promise.TimeoutError, err => {
-            logger.warn("timeout to run code", {transactionId, err});
+            logger.warn("timeout to run code", { transactionId, err });
             return Promise.resolve({
                 tstConsoleLogs: testimConsoleLogDataAggregates,
                 status: 'failed',
@@ -254,7 +254,7 @@ function runCode(transactionId, incomingParams, context, code, packageLocalLocat
                     exportsGlobal: {}
                 },
                 success: false
-            }); 
+            });
         })
         .finally(() => thread && thread.kill());
 }
@@ -264,7 +264,7 @@ function removeFolder(installFolder) {
         return fs.remove(installFolder)
             .then(resolve)
             .catch(err => {
-                logger.warn(`failed to remove install npm packages folder`, {err});
+                logger.warn(`failed to remove install npm packages folder`, { err });
                 return resolve();
             });
     });
@@ -272,7 +272,7 @@ function removeFolder(installFolder) {
 
 function cleanPackages(transactionId) {
     function cleanInstallFolder() {
-        const {installFolder} = transactions[transactionId];
+        const { installFolder } = transactions[transactionId];
         if (!installFolder) {
             return Promise.resolve();
         }
@@ -310,16 +310,10 @@ function mapNpmInstallDataToInstallData(npmInstallData, packageData) {
 function installPackage(stepId, testResultId, retryIndex, packageData, stepResultId, timeout) {
     const transactionId = getTransactionId(stepResultId, testResultId, stepId, retryIndex);
     return runNpmInstall(transactionId, packageData, timeout)
-        .then(({data, installFolder}) => {
+        .then(({ data, installFolder }) => {
             transactions[transactionId] = transactions[transactionId] || {};
             transactions[transactionId].installFolder = installFolder;
             return Promise.resolve(data);
-        }).then(npmInstallData => {
-            if (!featureFlags.flags.enableNpmPackageInstallUsingNpmCli.isEnabled()) {
-                return mapNpmInstallDataToInstallData(npmInstallData, packageData)
-            } else {
-                return npmInstallData;
-            }
         });
 
 }
@@ -339,80 +333,47 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
         if (s3fileDataUrl) {
             fileDataUrl = s3fileDataUrl;
         }
-    })
-    .then(() => runCode(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl))
-    .then(res => Object.assign({}, res, {nodeVersion: process.version}))
-    .finally(() => cleanPackages(transactionId));
+    }).then(() => runCode(transactionId, incomingParams, context, code, packageLocalLocations, timeout, fileDataUrl))
+        .then(res => Object.assign({}, res, { nodeVersion: process.version }))
+        .finally(() => cleanPackages(transactionId));
 }
 
 function runNpmInstall(transactionId, packageData, timeout) {
-
-    if (featureFlags.flags.enableNpmPackageInstallUsingNpmCli.isEnabled()) {
-        const packages = packageData.map(data => `${data.packageName}@${data.packageVersion}`);
-
-        const localPackageInstallFolder = getLocalPackageInstallFolder();
-        const installFolder = path.join(localPackageInstallFolder, `/${transactionId}`);
-        const proxyUri = global.proxyUri;
-        return new Promise(async (resolve, reject) => {
-            let output = '';
-            try {
-                output = await npmWrapper.installPackages(installFolder, packages, proxyUri, timeout);
-                logger.info('npm package install finished', {transactionId ,output, timeout});
-
-                const packageLines = output.match(/\+ (\w|-)+@(\d|.)+/g);
-                const fullnames = packageLines.map(l => l.substr(2));
-
-                const packageDataWithVersions = packageData.map(pData => {
-                    const packageFullName = fullnames.find(name => {
-                        const strudelIndex = name.lastIndexOf('@');
-                        const npmInstalledPackageName = name.substr(0, strudelIndex);
-                        return npmInstalledPackageName === pData.packageName;
-                    });
-                    const packageLocalLocation = path.resolve(installFolder, 'node_modules', pData.packageName);
-                    const packageWithVersion = Object.assign(pData, { packageFullName, packageLocalLocation});
-                    return packageWithVersion;
-                });
-
-                resolve({data:packageDataWithVersions, installFolder});
-            } catch (err) {
-                logger.warn('npm package install failed', {transactionId, err});
-                reject(err);
+    const packages = packageData.map(data => `${data.packageName}@${data.packageVersion}`);
+    const localPackageInstallFolder = getLocalPackageInstallFolder();
+    const installFolder = path.join(localPackageInstallFolder, `/${transactionId}`);
+    const proxyUri = global.proxyUri;
+    return new Promise(async (resolve, reject) => {
+        let output = '';
+        try {
+            output = await npmWrapper.installPackages(installFolder, packages, proxyUri, timeout);
+            logger.info('npm package install finished', { transactionId, output, timeout });
+            if (Number(output.trim().split(' ')[1]) < packages.length) {
+                reject('npm package install failed, couldn\'t install all packages');
+                return;
             }
+            const packageDataWithVersions = packageData.map(pData => {
+                const version = npmWrapper.getLocallyInstalledPackageVersion(installFolder, pData.packageName);
+                const packageFullName = `${pData.packageName}@${version}`;
+                const packageLocalLocation = path.resolve(installFolder, 'node_modules', pData.packageName);
+                return Object.assign({}, pData, {
+                    packageFullName,
+                    packageLocalLocation
+                })
+            });
 
-        })
+            resolve({ data: packageDataWithVersions, installFolder });
+        } catch (err) {
+            logger.warn('npm package install failed', { transactionId, err });
+            reject(err);
+        }
+
+    })
         .timeout(timeout)
         .catch(Promise.TimeoutError, err => {
-            logger.warn("timeout to install package", {packages, transactionId, err, timeout});
+            logger.warn("timeout to install package", { packages, transactionId, err, timeout });
             throw err;
         });
-    } else {
-        const thread = threadSpawn('runNpmWorker.js');
-        const localPackageInstallFolder = getLocalPackageInstallFolder();
-        const packages = packageData.map(data => `${data.packageName}@${data.packageVersion}`);
-        return new Promise((resolve, reject) => {
-            thread
-                .send({transactionId, packages, command: "install", localPackageInstallFolder, proxyUri: global.proxyUri})
-                .on('message', message => {
-                    resolve(message);
-                    logger.debug("Npm worker response", {message, transactionId});
-                })
-                .on('error', err => {
-                    if (err.stack.includes("NpmPackageError")) {
-                        return reject(new NpmPackageError(err.message));
-                    }
-                    return reject(err);
-                });
-        })
-        .timeout(timeout)
-    .catch(Promise.TimeoutError, err => {
-            logger.warn("timeout to install package", {packageData, transactionId, err});
-            throw err;
-        })
-        .finally(() => thread && thread.kill());
-
-    }
-
-
 }
 
 function getLocalPackageInstallFolder() {

package/agent/routers/codim/service.js

@@ -107,7 +107,6 @@ async function saveTest({
     await fs.writeFileAsync(filename, body);
     await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
     for (const { id, body } of locators) {
-        // eslint-disable-next-line no-await-in-loop
         await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
@@ -129,7 +128,6 @@ async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExistin
     await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
 
     for (const { name, id, elementLocator } of locators) {
-        // eslint-disable-next-line no-await-in-loop
         await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));

package/cliAgentMode.js

@@ -81,7 +81,6 @@ async function runAgentMode(options) {
             ];
 
             for (const packageToInstall of packages) {
-                // eslint-disable-next-line no-await-in-loop
                 await lazyRequire(packageToInstall, { silent: true }).catch(() => {});
             }
         }, LOAD_PLAYER_DELAY);

package/codim/template.js/package.json

@@ -5,8 +5,8 @@
     "dependencies": {
         "testim": "latest",
         "@testim/testim-cli": "latest",
-        "@types/chai": "4.2.2",
-        "chai": "4.2.0",
+        "@types/chai": "4.3.0",
+        "chai": "4.3.4",
         "cross-env": "5.2.1"
     },
     "scripts": {

package/codim/template.ts/package.json

@@ -6,8 +6,8 @@
         "testim": "latest",
         "@testim/testim-cli": "latest",
         "@types/node": "12.7.1",
-        "@types/chai": "4.2.2",
-        "chai": "4.2.0",
+        "@types/chai": "4.3.0",
+        "chai": "4.3.4",
         "ts-loader": "6.0.4",
         "typescript": "3.5.3",
         "cross-env": "5.2.1"

package/commons/featureFlags.js

@@ -38,7 +38,6 @@ class FeatureFlagsService {
             useClickimVisibilityChecks: new Rox.Flag(),
             useIEWebdriverVisibilityChecks: new Rox.Flag(),
             runGetElementCodeInAut: new Rox.Flag(),
-            enableNpmPackageInstallUsingNpmCli: new Rox.Flag(),
             enableFrameSwitchOptimization: new Rox.Flag(),
             maximumJsResultSize: new Rox.Configuration(2000 * 1024),
             skipFileInputClicks: new Rox.Flag(),
@@ -56,6 +55,7 @@ class FeatureFlagsService {
             usePortedHtml5DragDrop: new Rox.Flag(),
             applitoolsNewIntegration: new Rox.Flag(),
             testNamesToBeforeSuiteHook: new Rox.Flag(),
+            addCustomCapabilities: new Rox.Variant('{}'),
         };
         Rox.register('default', this.flags);
     }

package/commons/httpRequest.js

@@ -32,6 +32,11 @@ function getProxy() {
     return global.proxyUri;
 }
 
+const logErrorAndRethrow = (logMsg, data) => err => {
+    logger.error(logMsg, { ...data, error: err });
+    throw err;
+};
+
 function deleteMethod(url, headers, timeout) {
     return deleteFullRes(url, headers, timeout)
         .then(res => {
@@ -40,7 +45,7 @@ function deleteMethod(url, headers, timeout) {
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to delete request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to delete request', { url }));
 }
 
 function deleteFullRes(url, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
@@ -70,7 +75,7 @@ function post({
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to post request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
 function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry) {
@@ -128,7 +133,7 @@ function postForm(url, fields, files, headers = {}, timeout = DEFAULT_REQUEST_TI
             }
             return res.body;
         })
-        .tapCatch((err) => logger.error('failed to post request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
 function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isBinary = false, skipProxy = false } = {}) {
@@ -156,13 +161,16 @@ function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isB
 function getText(url, query, headers) {
     return _get(url, query, headers)
         .then((res) => res.text)
-        .tapCatch((err) => logger.error('failed to getText request', { url, query, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to getText request', { url, query }));
 }
 
 function get(url, query, headers, timeout, options) {
     return _get(url, query, headers, timeout, options)
         .then((res) => res.body)
-        .tapCatch((err) => logger.warn('failed to get request', { url, query, error: { message: err.message, stack: err.stack } }));
+        .catch(err => {
+            logger.warn('failed to get request', { url, query, error: err });
+            throw err;
+        });
 }
 
 function getFullRes(url, query, headers, timeout) {
@@ -183,7 +191,7 @@ function head(url) {
     }
 
     return Promise.fromCallback((callback) => request.end(callback))
-        .tapCatch((err) => logger.error('failed to head request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to head request', { url }));
 }
 
 function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
@@ -203,7 +211,7 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
 
     return Promise.fromCallback((callback) => request.end(callback))
         .then((res) => res.body)
-        .tapCatch((err) => logger.error('failed to put request', { url, error: { message: err.message, stack: err.stack } }));
+        .catch(logErrorAndRethrow('failed to put request', { url }));
 }
 
 function download(url) {
@@ -224,8 +232,11 @@ function download(url) {
     }
 
     return Promise.fromCallback((callback) => request.end(callback))
-        .tap(() => logger.info('finished to download', { url }))
-        .tapCatch((err) => logger.error('failed to download', { error: { message: err.message, stack: err.stack } }));
+        .then(response => {
+            logger.info('finished to download', { url });
+            return response;
+        })
+        .catch(logErrorAndRethrow('failed to download', { url }));
 }
 
 module.exports = {
@@ -241,4 +252,5 @@ module.exports = {
     head: wrapWithMonitoring(head),
     download: wrapWithMonitoring(download),
     isNetworkHealthy: wrapWithMonitoring.isNetworkHealthy,
+    didNetworkConnectivityTestFail: wrapWithMonitoring.didNetworkConnectivityTestFail,
 };

package/commons/httpRequestCounters.js

@@ -1,7 +1,36 @@
 'use strit';
 
 const { sum } = require('lodash');
-const { method } = require('bluebird');
+const Bluebird = require('bluebird');
+const dns = require('dns');
+const _ = require('lodash');
+const config = require('./config');
+
+const logger = require('./logger').getLogger('http-request-counters');
+
+let networkConnectivityTestFailed = false;
+
+/** Tests network connectivity with DNS resolution (a basic test for a 7 later stack parallel but essential to most HTTP requests) */
+const testNetworkConnectivity = async () => {
+    if (config.IS_ON_PREM) {
+        return true;
+    }
+    const hostnames = ['www.google.com', 'www.facebook.com', 'www.microsoft.com', 'testim.io'];
+    try {
+        // If any of these domains resolve we consider the connectivity to be ok
+        const result = Boolean(await Bluebird.any(hostnames.map(host => dns.promises.lookup(host))));
+        if (!result) {
+            networkConnectivityTestFailed = true;
+        }
+        return result;
+    } catch (e) {
+        logger.error('network connectivity test failed');
+        networkConnectivityTestFailed = true;
+        return false;
+    }
+};
+const throttledTestNetworkConnectivity = _.throttle(testNetworkConnectivity, 10 * 1000);
+
 // we remove entries after 15 minutes, note that this isn't accurate because
 // we remove the "fail"/"success" 10 minutes after we add them (and not the "call")
 // this is fine since these values are an estimation and not an accurate representation
@@ -24,7 +53,7 @@ module.exports.makeCounters = () => {
         }, ttl);
     }
     function wrapWithMonitoring(fn, name = fn.name) {
-        return method(async function (...args) {
+        return Bluebird.method(async function (...args) {
             update(counters.call, name);
             try {
                 const result = await fn.call(this, ...args);
@@ -32,24 +61,26 @@ module.exports.makeCounters = () => {
                 return result;
             } catch (e) {
                 update(counters.fail, name);
+                if (!networkConnectivityTestFailed) {
+                    throttledTestNetworkConnectivity();
+                }
                 throw e;
             }
         });
     }
-    wrapWithMonitoring.isNetworkHealthy = function isNetworkHealthy() {
+    wrapWithMonitoring.isNetworkHealthy = async function isNetworkHealthy() {
+        if (networkConnectivityTestFailed || !(await testNetworkConnectivity())) {
+            return false;
+        }
         const allFailed = sum([...counters.fail.values()]);
-        const allSuccess = sum([...counters.success.values()]);
         const allCalls = sum([...counters.call.values()]);
         // we declare a test unhealthy network wise if
-        // 1. more than 10 requests failed and there are fewer than 100 requests
-        // 2. more than 10% of requests (out of finished requests) failed
+        // 10% or more of requests (out of finished requests) failed
         // note that the network can be unhealthy but the test would still pass
-        if (allCalls < 100) {
-            return allFailed < 10;
-        }
-        return (allSuccess + allFailed) > allFailed * 10;
+        return allFailed < allCalls * 0.1;
     };
     wrapWithMonitoring.counters = counters; // expose the counters used to the outside
     wrapWithMonitoring.isNetworkHealthy.counters = wrapWithMonitoring.counters;
+    wrapWithMonitoring.didNetworkConnectivityTestFail = () => networkConnectivityTestFailed;
     return wrapWithMonitoring;
 };

package/commons/httpRequestCounters.test.js

@@ -9,30 +9,30 @@ describe('the http request counters', () => {
     });
 
     it('Marks an always failing network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         await rejects(fn);
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), false);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
     it('Marks an unstable network as unhealthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         const fn2 = runWithRetries(wrapWithMonitoring(() => 'hello'), 20, 1);
         await rejects(fn);
         await doesNotReject(fn2);
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), false);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
     });
 
-    it('Marks a recovering network as healthy', async () => {
-        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 20, 1);
+    it('Marks a trivial amount of failed requests as healthy', async () => {
+        const fn = runWithRetries(wrapWithMonitoring(() => { throw new Error('bad network'); }), 30, 1);
         await rejects(fn);
         const fn2 = wrapWithMonitoring(() => 'hello');
-        await Promise.all(Array(200).fill().map(fn2));
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), true);
+        await Promise.all(Array(290).fill().map(fn2));
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
     });
 
     it('Marks a healthy network as healthy', async () => {
         const fn2 = wrapWithMonitoring(() => 'hello');
         await Promise.all(Array(200).fill().map(fn2));
-        strictEqual(wrapWithMonitoring.isNetworkHealthy(), true);
+        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
     });
 });

package/commons/npmWrapper.js

@@ -60,6 +60,11 @@ async function installPackageLocally(rootPath, packageName, execOptions) {
         return regexResult[1];
     }
 
+    // https://github.com/npm/arborist/pull/362
+    function npmSevenAndEightMissingPermissions(error) {
+        return /The "to" argument must be of type string./.exec(error.stderr);
+    }
+
     // this is here because our shrinkwrap blocks our lazy deps for some reason
     const oldShrinkwrap = path.join(rootPath, 'npm-shrinkwrap.json');
     const newShrinkwrap = path.join(rootPath, 'npm-shrinkwrap-dummy.json');
@@ -73,23 +78,24 @@ async function installPackageLocally(rootPath, packageName, execOptions) {
         } catch (err) {
             // ignore error
         }
-        return await exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
+        return await exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
             const pathWithMissingPermissions = getPathWithMissingPermissions(err);
-            if (pathWithMissingPermissions) {
+            const npmEightMissingPermissions = npmSevenAndEightMissingPermissions(err);
+            if (pathWithMissingPermissions || npmEightMissingPermissions) {
                 logger.info('Failed to install package due to insufficient write access', {
                     ...additionalLogDetails(),
                     package: packageName,
-                    path: pathWithMissingPermissions,
+                    path: pathWithMissingPermissions || rootPath,
                 });
                 // eslint-disable-next-line no-console
                 console.error(`
 
 Testim failed installing the package ${packageName} due to insufficient permissions.
 This is probably due to an installation of @testim/testim-cli with sudo, and running it without sudo.
-Testim had missing write access to ${pathWithMissingPermissions}
+Testim had missing write access to ${pathWithMissingPermissions || rootPath}
 
 `);
-                throw new NpmPermissionsError(pathWithMissingPermissions);
+                throw new NpmPermissionsError(pathWithMissingPermissions || rootPath);
             }
             throw err;
         });
@@ -104,7 +110,7 @@ Testim had missing write access to ${pathWithMissingPermissions}
     }
 }
 
-const localNpmLocation = path.resolve(require.resolve('npm'), '../../bin/npm-cli.js');
+const localNpmLocation = path.resolve(require.resolve('npm').replace('index.js',''), 'bin','npm-cli.js');
 
 function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -115,7 +121,8 @@ function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
         let stdout = '';
         let stderr = '';
 
-        const npmInstall = spawn('node', [localNpmLocation, 'i', '--prefix', prefix, '--prefer-offline', '--no-audit', ...packageNames, ...proxyFlag], envVars);
+        const ops = '--no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false'.split(' ');
+        const npmInstall = spawn('node', [localNpmLocation, 'i', '--prefix', prefix, ...ops, ...packageNames, ...proxyFlag], envVars);
         npmInstall.stderr.pipe(process.stderr);
         npmInstall.stdout.pipe(process.stdout);
 

package/commons/npmWrapper.test.js

@@ -54,7 +54,7 @@ describe('npmWrapper', () => {
                 fakeChildProcess.exec.yields(undefined, []); //resolve without errors
                 const cwd = '/some/dir';
                 const pkg = 'some-package';
-                const expectedCmd = 'npm i some-package --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false';
+                const expectedCmd = 'npm i some-package --no-save --no-package-lock --no-prune --prefer-offline --no-audit --legacy-peer-deps --progress=false';
                 const expectedExecParams = { cwd };
 
                 await npmWrapper.installPackageLocally(cwd, pkg);

package/commons/testimDesiredCapabilitiesBuilder.js

@@ -567,6 +567,27 @@ function buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo,
 
     _.merge(opts.desiredCapabilities, browserOptions.seleniumCapsFileContent);
 
+    try {
+        /**
+         * Targeted custom capabilities can be added to the desired capabilities object via the addCustomCapabilities FF.
+         * No targeting: { selenium_version: '3.141.59' }
+         * One level targeting (either grid provider, host, browser name or browser version): { "devicefarm": { selenium_version: '3.141.59' } }
+         * Two level targeting: { "internet explorer": { "11": { selenium_version: '3.141.59' } } }
+         */
+        const hostToProvider = { 'hub.lambdatest.com': 'lambdatest', 'public-grid.testim.io': 'testim', 'testgrid-devicefarm.us-west-2.amazonaws.com': 'devicefarm' };
+        const byGrid = (capabilities) => capabilities[gridInfo.provider] || capabilities[opts.host] || capabilities[hostToProvider[opts.host]];
+        const getTargetingGroup = (capabilities) => byGrid(capabilities) || capabilities[opts.desiredCapabilities.browserName] || capabilities[opts.desiredCapabilities.version] || capabilities || {};
+        const capabilities = JSON.parse(featureFlags.flags.addCustomCapabilities.getValue() || '{}');
+        const customCapabilities = getTargetingGroup(getTargetingGroup(capabilities));
+
+        if (Object.keys(customCapabilities).length) {
+            logger.info(`Adding custom capabilities: ${JSON.stringify(customCapabilities)}`);
+            Object.assign(opts.desiredCapabilities, customCapabilities);
+        }
+    } catch (e) {
+        logger.error(`Failed to load custom capabilities: ${e.message}`, { customCapabilities: featureFlags.flags.addCustomCapabilities.getValue() });
+    }
+
     if (isDFGrid(gridInfo) && opts.desiredCapabilities && !opts.capabilities) {
         convertToNewCapabilitiesFormat(opts.desiredCapabilities);
         opts.capabilities = { alwaysMatch: opts.desiredCapabilities, firstMatch: [{}] };