@testim/testim-cli 3.254.0 → 3.255.0

package/agent/routers/codim/router.test.js

@@ -1,20 +1,16 @@
 'use strict';
 
 const router = require('./router');
-
 const path = require('path');
 const os = require('os');
 const compression = require('compression');
 const express = require('express');
-
-const app = express();
 const bodyParser = require('body-parser');
-const Promise = require('bluebird');
-const { promiseFromCallback } = require('../../../utils');
 const superagent = require('superagent');
+const fs = require('fs');
 const { expect } = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
 
-const fs = Promise.promisifyAll(require('fs'));
+const app = express();
 
 app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
 app.use(compression());
@@ -25,25 +21,26 @@ app.use('/files', router.router);
 describe('codim router', () => {
     let listener;
     async function saveLocators(locatorsObject) {
-        const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`)
-            .send(locatorsObject);
-        await promiseFromCallback((callback) => request.end(callback));
+        const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`).send(locatorsObject);
+        await request;
     }
 
     async function loadLocators() {
         const request = superagent.get(`http://localhost:${listener.address().port}/files/locators`);
-        return await promiseFromCallback((callback) => request.end(callback)).then(x => x.text).then(JSON.parse);
+        const response = await request;
+        return JSON.parse(response.text);
     }
 
     let tmpDir;
+
     before((done) => {
         tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdk-test-'));
         process.chdir(tmpDir);
-        listener = app.listen(0, done);
+        listener = app.listen(0, () => done());
     });
 
     after(async () => {
-        await fs.unlinkAsync(tmpDir).catch(() => {});
+        await fs.promises.unlink(tmpDir).catch(() => {});
     });
 
     it('saves locators', async () => {

package/agent/routers/codim/service.js

@@ -2,17 +2,16 @@
 
 const _ = require('lodash');
 const path = require('path');
-const Promise = require('bluebird');
-const fs = Promise.promisifyAll(require('fs'));
+const fsPromises = require('fs/promises');
 const { fromPairs } = require('lodash');
 const { buildCodeTests } = require('../../../runners/buildCodeTests');
 const { AbortError } = require('../../../commons/AbortError');
 
 const findTestFolder = _.memoize(async (fromFolder) => {
-    const files = await fs.readdirAsync(fromFolder);
+    const files = await fsPromises.readdir(fromFolder);
     // this is either invoked by running the Testim CLI from inside the tests folder or from inside the `init` folder
     // so deal with the case we're inside tests.
-    const isInProjectFolder = files.includes('tests') && (await fs.statAsync(path.join(fromFolder, 'tests'))).isDirectory();
+    const isInProjectFolder = files.includes('tests') && (await fsPromises.stat(path.join(fromFolder, 'tests'))).isDirectory();
     if (isInProjectFolder) {
         return path.join(fromFolder, 'tests');
     }
@@ -27,7 +26,7 @@ async function getLocalLocators() {
         // eslint-disable-next-line no-eval
         return eval(buffer.toString().replace(/require/g, '(x => /locator\.(.*)\.json/.exec(x)[1])'));
     }
-    const locators = await fs.readFileAsync(locatorsFilePath).then(parseLocators, () => ({}));
+    const locators = await fsPromises.readFile(locatorsFilePath).then(parseLocators, () => ({}));
     return _(Object.keys(locators)).map((id) => {
         const escapedId = id.replace(/"/g, '\\"');
         return [escapedId, locators[id]];
@@ -36,7 +35,7 @@ async function getLocalLocators() {
 
 async function findTests(folder = process.cwd()) {
     const testFolder = await findTestFolder(folder);
-    const filesWithStat = await fs.promises.readdir(testFolder, { withFileTypes: true });
+    const filesWithStat = await fsPromises.readdir(testFolder, { withFileTypes: true });
 
     // things we know are not tests but end in js
     const excluded = ['webpack.config.js', 'tsconfig.js', '.DS_Store', 'functions.js'];
@@ -70,13 +69,14 @@ async function getLocalLocatorContents(locators, full = false, originFolder = pr
     if (full) {
         const folder = await findTestFolder(originFolder);
         for (const key of Object.values(locators)) {
-            props[key] = fs.promises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
+            props[key] = fsPromises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
         }
     }
     try {
         const contents = await promiseFromProps(props);
         return contents;
     } catch (e) {
+        // eslint-disable-next-line no-console
         console.error(e);
         return {};
     }
@@ -104,10 +104,10 @@ async function saveTest({
     if (filename.endsWith('locators/locators.js')) {
         throw new Error('Cannot override locators file from the internet as it is evaluated by the runner');
     }
-    await fs.writeFileAsync(filename, body);
-    await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
+    await fsPromises.writeFile(filename, body);
+    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
     for (const { id, body } of locators) {
-        await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
+        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
     const localLocatorMap = await getLocalLocators();
@@ -120,15 +120,15 @@ async function writeLocators(locatorsFilePath, locatorMap) {
         content += `  "${key}": require('./locator.${value}.json'),\n`;
     }
     content += '};';
-    await fs.writeFileAsync(locatorsFilePath, content);
+    await fsPromises.writeFile(locatorsFilePath, content);
 }
 async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExisting: false }) {
     const folder = await findTestFolder(process.cwd());
     const locatorsFilePath = path.join(folder, 'locators', 'locators.js');
-    await fs.mkdirAsync(path.join(folder, 'locators')).catch(() => {});
+    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
 
     for (const { name, id, elementLocator } of locators) {
-        await fs.writeFileAsync(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
+        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
     }
     const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
     if (mergeIntoExisting) {
@@ -139,14 +139,14 @@ async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExistin
     await writeLocators(locatorsFilePath, locatorMap);
 }
 
-async function compileFunctionsLibrary({ fileSystem, bypassWebpack } = {}, optionalAbortSignal) {
+async function compileFunctionsLibrary({ fileSystem, bypassWebpack } = {}, optionalAbortSignal = undefined) {
     const folder = await findTestFolder(process.cwd());
-    if (optionalAbortSignal && optionalAbortSignal.aborted) {
+    if (optionalAbortSignal?.aborted) {
         throw new AbortError();
     }
 
     const functionsFile = path.join(folder, 'functions.js');
-    if (bypassWebpack && bypassWebpack.testim) {
+    if (bypassWebpack?.testim) {
         const Module = require('module');
         // attempt to require without webpack compile - useful for puppeteer/selenium hybrid
         const originalRequire = Module.prototype.require;

package/agent/routers/playground/service.js

@@ -1,11 +1,9 @@
 'use strict';
 
-const Promise = require('bluebird');
-const util = require('util');
-const writeFileAsync = util.promisify(require('fs').writeFile);
+const fs = require('fs');
 const path = require('path');
-const { fork } = require('child_process');
 const os = require('os');
+const { fork } = require('child_process');
 const { ClientError, PlaygroundCodeError } = require('../../../errors');
 
 const CODE_TYPES = ['playwright', 'selenium', 'puppeteer'];
@@ -14,13 +12,13 @@ const runForks = {};
 
 async function createTempFile(fileName, data, encoding = 'utf8') {
     const fullPath = path.join(os.tmpdir(), fileName);
-    await writeFileAsync(fullPath, data, encoding);
+    await fs.promises.writeFile(fullPath, data, encoding);
     return fullPath;
 }
 
 const forkAsync = (fileFullPath) => {
     let gotResolved;
-    const promise = new Promise(resolve => gotResolved = resolve);
+    const promise = new Promise(resolve => { gotResolved = resolve; });
 
     const child = fork(fileFullPath, { stdio: ['inherit', 'inherit', 'inherit', 'ipc'] });
     promise.child = child;
@@ -30,7 +28,7 @@ const forkAsync = (fileFullPath) => {
         }
         const { type, error } = message;
         if (error && ['uncaughtException', 'unhandledRejection'].includes(type)) {
-            return gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
+            gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
         }
     });
     child.on('error', (error) => {

package/cli.js

@@ -68,14 +68,14 @@ async function main() {
         require('./commons/logger').setProjectId(processedOptions.project);
         require('./commons/runnerFileCache').setEncryptKey(typeof processedOptions.token === 'string' ? processedOptions.token : 'anonymous_encrypt_key');
 
-        if (processedOptions.initCodimMode) {
+        if (utils.isInitCodimMode(processedOptions)) {
             const codimCli = require('./codim/codim-cli');
             return codimCli.init(processedOptions.initTestProject);
         }
-        if (processedOptions.loginMode) {
+        if (utils.isLoginMode(processedOptions)) {
             return undefined;
         }
-        if (processedOptions.createPrefechedData) {
+        if (utils.isCreatePrefetchedDataMode(processedOptions)) {
             const runnerFileCache = require('./commons/runnerFileCache');
             await runnerFileCache.clear();
             await prepareRunner.initializeUserWithAuth(processedOptions);
@@ -92,7 +92,7 @@ async function main() {
             return undefined;
         }
 
-        if (processedOptions.tunnelOnlyMode) {
+        if (utils.isTunnelOnlyMode(processedOptions)) {
             await testRunner.init(processedOptions);
             await require('./commons/testimTunnel').serveTunneling(processedOptions);
             return undefined;

package/cliAgentMode.js

@@ -32,9 +32,10 @@ module.exports = {
 };
 
 /**
- * @param {{ agentMode: boolean; }} options
+ * @type {(options: import('./runOptions').Options) => options is import('./runOptions').AgentModeOptions}
  */
 function shouldStartAgentMode(options) {
+    // @ts-ignore should be `as any`
     return options.agentMode;
 }
 
@@ -53,7 +54,7 @@ async function runAgentMode(options) {
             // Consider moving that into the agent server and add endpoint to start browser?
             testimStandaloneBrowser = await startTestimStandaloneBrowser(options);
         } catch (e) {
-            if (e && e.message && e.message.includes('user data directory is already in use')) {
+            if (e?.message?.includes('user data directory is already in use')) {
                 throw new ArgError('Please close all chrome browsers that were opened with "testim start" and try again');
             }
             throw e;
@@ -62,7 +63,7 @@ async function runAgentMode(options) {
 
     const agentServer = require('./agent/server');
 
-    if (testimStandaloneBrowser && testimStandaloneBrowser.webdriverApi) {
+    if (testimStandaloneBrowser?.webdriverApi) {
         // if we're starting the agent here, pre-load the sessionPlayer so it loads faster
         // on first play
         const LOAD_PLAYER_DELAY = 6000;

package/codim/codim-cli.js

@@ -2,12 +2,14 @@
 
 'use strict';
 
-const { promisifyAll } = require('bluebird');
-const fse = require('fs-extra');
-const exec = promisifyAll(require('child_process')).execAsync;
+const fs = require('fs');
+const childProcess = require('child_process');
 const path = require('path');
 const validateNpmPackageName = require('validate-npm-package-name');
 const ArgError = require('../errors.js').ArgError;
+const { promisify } = require('util');
+
+const exec = promisify(childProcess.exec);
 
 module.exports.init = async function init(name) {
     const ora = require('ora');
@@ -25,7 +27,7 @@ module.exports.init = async function init(name) {
 
     const fullPath = path.resolve(name);
 
-    if (fse.existsSync(fullPath) && fse.readdirSync(fullPath).length !== 0) {
+    if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length !== 0) {
         console.log(`${fullPath} is not empty. Quitting...`);
         process.exit(1);
     }
@@ -57,20 +59,20 @@ module.exports.init = async function init(name) {
 
     let spinner = ora(`Creating new test project in ${dest}`).start();
 
-    await fse.copy(source, dest);
+    await fs.promises.copyFile(source, dest);
 
     const sourcePackageJson = path.join(__dirname, sourceFolder, 'package.json');
     const destPackageJson = path.join(process.cwd(), name, 'package.json');
 
-    const packageContents = await fse.readFile(sourcePackageJson);
+    const packageContents = await fs.promises.readFile(sourcePackageJson);
 
     const newPackageJson = packageContents.toString().replace('~testim-codeful-test-project~', packageName);
 
-    await fse.writeFile(destPackageJson, newPackageJson);
+    await fs.promises.writeFile(destPackageJson, newPackageJson);
 
     const gitIgnore = 'node_modules';
     const gitIgnoreFilePath = path.join(process.cwd(), name, '.gitignore');
-    await fse.writeFile(gitIgnoreFilePath, gitIgnore);
+    await fs.promises.writeFile(gitIgnoreFilePath, gitIgnore);
 
     spinner.succeed();
     spinner = ora('Installing dependencies').start();

package/commons/featureFlags.js

@@ -67,6 +67,14 @@ class FeatureFlagsService {
         Rox.setCustomStringProperty('projectId', projectId);
     }
 
+    setProjectType(projectType) {
+        Rox.setCustomStringProperty('projectType', projectType);
+    }
+
+    setCompanyProductType(productType) {
+        Rox.setCustomStringProperty('productType', productType);
+    }
+
     setCompanyId(companyId) {
         Rox.setCustomStringProperty('companyId', companyId);
     }

package/commons/httpRequest.js

@@ -79,7 +79,7 @@ function post({
         .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
-function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry) {
+function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry = 0) {
     const request = superagent
         .post(url)
         .send(body)
@@ -215,6 +215,10 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
         .catch(logErrorAndRethrow('failed to put request', { url }));
 }
 
+/**
+ * @param {string} url
+ * @returns {Promise<superagent.Response>}
+ */
 function download(url) {
     logger.info('start to download', { url });
 

package/commons/httpRequestCounters.js

@@ -1,10 +1,11 @@
-'use strit';
+'use strict';
 
-const { sum } = require('lodash');
-const Bluebird = require('bluebird');
-const dns = require('dns');
 const _ = require('lodash');
 const config = require('./config');
+const dns = require('dns').promises;
+const Bluebird = require('bluebird');
+const { sum } = require('lodash');
+const { promiseMap } = require('../utils/promiseUtils');
 
 const logger = require('./logger').getLogger('http-request-counters');
 
@@ -18,7 +19,7 @@ const testNetworkConnectivity = async () => {
     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))));
+        const result = Boolean(await promiseMap(hostnames, host => dns.lookup(host)));
         if (!result) {
             networkConnectivityTestFailed = true;
         }
@@ -40,18 +41,28 @@ const ttl = 60 * 1000 * 15;
 
 module.exports.makeCounters = () => {
     const counters = {
-        call: new Map(),
-        success: new Map(),
-        fail: new Map(),
+        /** @type {Map<string, number>} */ call: new Map(),
+        /** @type {Map<string, number>} */ success: new Map(),
+        /** @type {Map<string, number>} */ fail: new Map(),
     };
+    /**
+     * @param {counters[keyof counters]} counter
+     * @param {string} key
+     */
     function update(counter, key) {
         const result = counter.get(key) || 0;
         counter.set(key, result + 1);
         setTimeout(() => {
-            const result = counter.get(key) || 1;
-            counter.set(key, result - 1);
+            const _result = counter.get(key) || 1;
+            counter.set(key, _result - 1);
         }, ttl);
     }
+    /**
+     * @template T, TArgs
+     * @param {(...args: TArgs) => T} fn
+     * @param {string=} name
+     * @return {(...args: TArgs) => Bluebird<Awaited<T>>}
+     */
     function wrapWithMonitoring(fn, name = fn.name) {
         return Bluebird.method(async function (...args) {
             update(counters.call, name);

package/commons/lazyRequire.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Bluebird = require('bluebird');
 const npmWrapper = require('./npmWrapper');
 const ora = require('ora');
 const path = require('path');
@@ -76,10 +75,12 @@ async function lazyRequireImpl(dependency) {
     return requireWithFallback(dependency);
 }
 
-function installAllLazyDependencies() {
+async function installAllLazyDependencies() {
     const allLazyDependencies = Object.keys(packageJson.lazyDependencies);
 
-    return Bluebird.each(allLazyDependencies, dep => lazyRequireImpl(dep));
+    for (const dep of allLazyDependencies) {
+        await lazyRequireImpl(dep);
+    }
 }
 
 if (require.main === module) {

package/commons/preloadTests.js

@@ -1,5 +1,5 @@
-const Promise = require('bluebird');
 const _ = require('lodash');
+const { promiseMap } = require('../utils');
 const localRunnerCache = require('./runnerFileCache');
 const servicesApi = require('./testimServicesApi.js');
 
@@ -15,7 +15,7 @@ async function preloadTests(options) {
         projectId: options.project,
     };
     return await localRunnerCache.memoize(async () => {
-        const results = await Promise.map(options.testId, testId => servicesApi.loadTest({ ...opts, testId }), { concurrency: 2 });
+        const results = await promiseMap(options.testId, testId => servicesApi.loadTest({ ...opts, testId }), { concurrency: 2 });
         return _.keyBy(results, 'testData.id');
     }, 'loadTests', TEN_HOURS, [opts, options.testId])();
 }

package/commons/prepareRunner.js

@@ -24,7 +24,7 @@ Promise.resolve().then(() => {
 
 async function prepare(options) {
     /**
-     * @type {Promise}
+     * @type {globalThis.Promise<void>}
      */
     let chromedriverPromise = Promise.resolve();
 
@@ -35,7 +35,7 @@ async function prepare(options) {
         chromedriverPromise = prepareRunnerAndTestimStartUtils.prepareChromeDriver(
             { projectId: options.project, userId: options.user },
             { chromeBinaryLocation: options.chromeBinaryLocation },
-            Boolean(options.lightweightMode && options.lightweightMode.general)
+            Boolean(options.lightweightMode?.general)
         );
         options.useLocalChromeDriver = true;
     }
@@ -61,6 +61,8 @@ async function prepare(options) {
 
 async function prepareMockNetwork(location) {
     logger.info('prepare MockNetwork', { location });
+    /** @type {Buffer} */
+    // @ts-expect-error There seems to be an actual bug in case the location is a URL.
     const rulesJsonBuf = await utils.getSourceAsBuffer(location);
     if (rulesJsonBuf.byteLength > MAX_RULE_FILE_SIZE_IN_MB * 1000000) {
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} exceeded ${MAX_RULE_FILE_SIZE_IN_MB}MB`);

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -1,9 +1,7 @@
 // @ts-check
 
-// @ts-ignore
-const Promise = require('bluebird');
 const path = require('path');
-const fs = Promise.promisifyAll(require('fs'));
+const fs = require('fs');
 const ms = require('ms');
 const { serializeError } = require('serialize-error');
 const { additionalLogDetails } = require('./logUtils');
@@ -11,7 +9,15 @@ const { additionalLogDetails } = require('./logUtils');
 const config = require('./config');
 const { ArgError, NpmPermissionsError } = require('../errors');
 const {
-    getCliLocation, isURL, downloadAndSave, getSource, getLocalFileSizeInMB, download, unzipFile, getSourcePath,
+    getCliLocation,
+    isURL,
+    downloadAndSave,
+    getSource,
+    getLocalFileSizeInMB,
+    download,
+    unzipFile,
+    getSourcePath,
+    promiseMap,
 } = require('../utils');
 const localRunnerCache = require('./runnerFileCache');
 const logger = require('./logger').getLogger('prepare runner and testim start');
@@ -31,63 +37,58 @@ module.exports = {
 /**
  * @param {string} location
  */
-function prepareCustomExtension(location, unlimitedSize = false) {
+async function prepareCustomExtension(location, unlimitedSize = false) {
     if (!location) {
-        return Promise.resolve();
+        return undefined;
     }
 
     if (isURL(location)) {
         const destFile = path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
-        return getRemoteFileSizeInMB(location)
-            .then(contentLength => {
-                if (contentLength > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-                    throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
-                }
-                return downloadAndSave(location, destFile);
-            })
-            .then(() => destFile);
+        const contentLength = await getRemoteFileSizeInMB(location);
+        if (contentLength > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
+            throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
+        }
+        await downloadAndSave(location, destFile);
+        return destFile;
     }
 
     const destFile = path.resolve(location);
     if (!fs.existsSync(destFile)) {
-        return Promise.reject(new ArgError(`Failed to find custom extension in location: ${destFile}`));
+        throw new ArgError(`Failed to find custom extension in location: ${destFile}`);
     }
     const fileSize = getLocalFileSizeInMB(destFile);
     if (fileSize > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-        return Promise.reject(new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG));
+        throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
     }
-    return Promise.resolve(destFile);
+    return destFile;
 }
 
 
 /**
  * @param {string} url
  */
-function getRemoteFileSizeInMB(url) {
+async function getRemoteFileSizeInMB(url) {
     const httpRequest = require('./httpRequest');
-    return httpRequest.head(url)
-        .then(res => {
-            const contentLengthHeader = res.headers['content-length'];
-            const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
-            return contentLengthBytes / 1000000;
-        })
-        .catch(err => {
-            logger.warn('failed to download custom extension', { err });
-            throw new ArgError(`Failed to download custom extension from location: ${url}`);
-        });
+    try {
+        const res = await httpRequest.head(url);
+        const contentLengthHeader = res.headers['content-length'];
+        const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+        return contentLengthBytes / 1000000;
+    } catch (err) {
+        logger.warn('failed to download custom extension', { err });
+        throw new ArgError(`Failed to download custom extension from location: ${url}`);
+    }
 }
 
 /**
- *
  * @param {string[]} locations
- *
  */
 function prepareExtension(locations) {
     logger.info('prepare extension', { locations });
 
     const fullLocations = locations.map(location => ({ location, path: getSourcePath(location) }));
     return localRunnerCache.memoize(
-        () => Promise.map(fullLocations, ({ location, path }) => getSource(location, path)),
+        () => promiseMap(fullLocations, ({ location, path }) => getSource(location, path)),
         'prepareExtension',
         MSEC_IN_HALF_DAY,
         fullLocations
@@ -131,25 +132,23 @@ async function prepareChromeDriver(userDetails = {}, driverOptions = {}, skipIsR
     }
 }
 
-function getPlayerVersion() {
+async function getPlayerVersion() {
     const url = `${config.BLOB_URL}/extension/sessionPlayer_LATEST_RELEASE`;
-    return download(url)
-        .then(res => res.body.toString('utf8'));
+    const res = await download(url);
+    return res.body.toString('utf8');
 }
 
 /**
  * @param {string} location
  * @param {string | undefined} canary
- *
- * @returns {Promise<string>}
  */
-function getPlayerLocation(location, canary) {
+async function getPlayerLocation(location, canary) {
     if (!isURL(location) || (isURL(location) && canary) || config.IS_ON_PREM) {
-        return Promise.resolve(location);
+        return location;
     }
 
-    return getPlayerVersion()
-        .then(ver => `${location}-${ver}`);
+    const ver = await getPlayerVersion();
+    return `${location}-${ver}`;
 }
 
 function getSessionPlayerFolder() {
@@ -178,7 +177,7 @@ async function downloadAndUnzip(loc, playerFileName, isRetry = false) {
     }
 }
 
-function preparePlayer(location, canary) {
+async function preparePlayer(location, canary) {
     logger.info('prepare player', { location, canary });
     const playerFileName = getPlayerDestination();
     return localRunnerCache.memoize(

package/commons/runnerFileCache.js

@@ -96,7 +96,7 @@ function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
         }
         logger.debug('cache miss:', { fnName });
         if (!cacheMissAllowed) {
-            throw new Error(`Attemped to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
+            throw new Error(`Attempted to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
         }
         const value = await fn();
         if (value) {

package/commons/testimTunnel.test.js

@@ -66,7 +66,8 @@ describe('testimTunnel', () => {
 
         it('should handle connect errors', async () => {
             ltConnectStub.rejects('error');
-            await expect(testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } })).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
+            const connectPromise = testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } });
+            await expect(connectPromise).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
         });
     });
 

package/coverage/SummaryToObjectReport.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { ReportBase } = require('istanbul-lib-report');
-const _ = require('lodash');
 
 class SummaryToObjectReport extends ReportBase {
     constructor(opts) {