@testim/testim-cli 3.253.0 → 3.255.0

package/agent/routers/playground/router.js

@@ -1,16 +1,17 @@
-"use strict";
+'use strict';
 
 const express = require('express');
+
 const router = express.Router();
 const logger = require('../../../commons/logger').getLogger('playground-router');
-const {ClientError, PlaygroundCodeError} = require('../../../errors');
-const {runPlaygroundTest, stopPlaygroundTest, CODE_TYPES} = require('./service');
-const {DISABLE_AGENT_ORIGIN_CHECK} = require('../../../commons/config');
+const { ClientError, PlaygroundCodeError } = require('../../../errors');
+const { runPlaygroundTest, stopPlaygroundTest, CODE_TYPES } = require('./service');
+const { DISABLE_AGENT_ORIGIN_CHECK } = require('../../../commons/config');
 
 const VALID_HOSTS = ['localhost', 'app.testim.io', 'playground.testim.io', 'staging.testim.io', 'app.staging.testim.cc', 'tta-crm.tricentis.com'];
 
 const parseUrl = (url) => {
-    if(!url) {
+    if (!url) {
         return {};
     }
     try {
@@ -21,17 +22,17 @@ const parseUrl = (url) => {
 };
 
 const checkReferer = (req, res, next) => {
-    if(DISABLE_AGENT_ORIGIN_CHECK) {
+    if (DISABLE_AGENT_ORIGIN_CHECK) {
         return next();
     }
     const referer = req.headers.referer;
     const origin = req.headers.origin;
-    if(!referer && !origin) {
+    if (!referer && !origin) {
         return res.status(400).send();
     }
     const refererUrl = parseUrl(referer);
     const originUrl = parseUrl(origin);
-    if(!VALID_HOSTS.includes(refererUrl.hostname) && !VALID_HOSTS.includes(originUrl.hostname)) {
+    if (!VALID_HOSTS.includes(refererUrl.hostname) && !VALID_HOSTS.includes(originUrl.hostname)) {
         return res.status(400).send();
     }
     return next();
@@ -50,11 +51,11 @@ router.post('/run', [checkReferer], async (req, res) => {
         await runPlaygroundTest(body);
         res.send({ success: true });
     } catch (e) {
-        if(e instanceof ClientError) {
+        if (e instanceof ClientError) {
             res.status(404).send({ success: false });
             return undefined;
         }
-        if(e instanceof PlaygroundCodeError) {
+        if (e instanceof PlaygroundCodeError) {
             res.json({ success: false, type: 'playground-error', stack: e.innerStack });
             return undefined;
         }

package/agent/routers/playground/service.js

@@ -1,48 +1,47 @@
-"use strict";
+'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 {ClientError, PlaygroundCodeError} = require('../../../errors');
+const { fork } = require('child_process');
+const { ClientError, PlaygroundCodeError } = require('../../../errors');
+
 const CODE_TYPES = ['playwright', 'selenium', 'puppeteer'];
 
 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' ]});
+    const child = fork(fileFullPath, { stdio: ['inherit', 'inherit', 'inherit', 'ipc'] });
     promise.child = child;
     child.on('message', (message) => {
-        if(!message) {
+        if (!message) {
             return;
         }
-        const {type, error} = message;
-        if(error && ['uncaughtException', 'unhandledRejection'].includes(type)) {
-            return gotResolved({error: Object.assign(new PlaygroundCodeError(), {innerStack: message.error.stack})})
+        const { type, error } = message;
+        if (error && ['uncaughtException', 'unhandledRejection'].includes(type)) {
+            gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
         }
     });
     child.on('error', (error) => {
-        gotResolved({error});
+        gotResolved({ error });
     });
     child.on('exit', (exitCode) => {
-        gotResolved({exitCode});
+        gotResolved({ exitCode });
     });
 
     return promise;
 };
 
-async function runCodeLocally({code}) {
+async function runCodeLocally({ code }) {
     const forkId = Date.now();
     try {
         const codeWithExtra = `
@@ -60,25 +59,25 @@ async function runCodeLocally({code}) {
         const fileFullPath = await createTempFile(`tst-playground-${Date.now()}.js`, codeWithExtra);
         const promiseExec = forkAsync(fileFullPath);
         runForks[forkId] = promiseExec.child;
-        const {error, exitCode} = await promiseExec;
-        if(error) {
+        const { error, exitCode } = await promiseExec;
+        if (error) {
             throw error;
         }
-        if(exitCode !== 0) {
+        if (exitCode !== 0) {
             throw new Error(`Process exited with exit code: ${exitCode}`);
         }
         return undefined;
     } finally {
-        if(runForks[forkId]) {
+        if (runForks[forkId]) {
             runForks[forkId].kill();
             delete runForks[forkId];
         }
     }
 }
 
-async function runPlaygroundTest({code, type}) {
-    if(['playwright', 'puppeteer', 'selenium'].includes(type)) {
-        return runCodeLocally({code});
+async function runPlaygroundTest({ code, type }) {
+    if (['playwright', 'puppeteer', 'selenium'].includes(type)) {
+        return runCodeLocally({ code });
     }
     throw new ClientError();
 }

package/agent/routers/standalone-browser/registerRoutes.js

@@ -1,11 +1,12 @@
 // @ts-check
-"use strict";
+
+'use strict';
 
 const express = require('express');
 
 module.exports = {
-    standaloneBrowserRoutes
-}
+    standaloneBrowserRoutes,
+};
 
 /**
  * @param {{
@@ -13,33 +14,32 @@ module.exports = {
 }} [testimStandaloneBrowser]
  */
 function standaloneBrowserRoutes(testimStandaloneBrowser) {
-
     const router = express.Router();
 
-    router.get("/cdp-url", (req, res) => {
+    router.get('/cdp-url', (req, res) => {
         if (!testimStandaloneBrowser) {
             res.status(503).send({
-                error: "Testim standalone browser is not running"
+                error: 'Testim standalone browser is not running',
             });
 
             return;
         }
 
         res.status(200).send({
-            url: testimStandaloneBrowser.webdriverApi.cdpUrl
+            url: testimStandaloneBrowser.webdriverApi.cdpUrl,
         });
     });
 
-    router.get("/status", (req, res) => {
+    router.get('/status', (req, res) => {
         if (!testimStandaloneBrowser) {
             res.status(503).send({
-                ok: false
+                ok: false,
             });
             return;
         }
 
         res.status(200).send({
-            ok: true
+            ok: true,
         });
     });
 

package/cdpTestRunner.js

@@ -1,5 +1,6 @@
 const WebSocket = require('ws');
 const Promise = require('bluebird');
+const { promiseFromCallback } = require('./utils');
 
 
 class CDPTestRunner {
@@ -20,11 +21,11 @@ class CDPTestRunner {
         }
         const websocket = new WebSocket(this._cdpUrl, { timeout });
 
-        const openPromise = Promise.fromCallback((cb) => {
+        const openPromise = promiseFromCallback((cb) => {
             websocket.once('open', cb);
         });
 
-        const errorPromise = Promise.fromCallback((cb) => {
+        const errorPromise = promiseFromCallback((cb) => {
             websocket.once('error', cb);
         }).catch(() => {
             websocket.close();
@@ -46,7 +47,7 @@ class CDPTestRunner {
         this._cdpCallbacks.delete(object.id);
         if (object.error) {
             callback.reject(new Error(object.error));
-        } else if (object.result.exceptionDetails && object.result.exceptionDetails.exception) {
+        } else if (object.result.exceptionDetails?.exception) {
             callback.reject(new Error(object.result.exceptionDetails.exception.description));
         } else {
             callback.resolve(object.result);

package/chromiumInstaller.js

@@ -2,8 +2,7 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs-extra');
 const { ArgError } = require('./errors');
-const { unzipFile } = require('./utils');
-const { downloadAndSave, TESTIM_BROWSER_DIR } = require('./utils');
+const { downloadAndSave, unzipFile, TESTIM_BROWSER_DIR } = require('./utils');
 const ora = require('ora');
 
 
@@ -30,7 +29,7 @@ async function downloadAndInstallChromium() {
     const platformFolder = {
         linux: 'Linux_x64',
         mac: 'Mac',
-        mac_arm: 'Mac_Arm',
+        mac_arm: 'Mac_Arm', // eslint-disable-line camelcase
         win32: 'Win',
         win64: 'Win_x64',
     };
@@ -42,14 +41,14 @@ async function downloadAndInstallChromium() {
     const platformArchiveName = {
         linux: 'chrome-linux',
         mac: 'chrome-mac',
-        mac_arm: 'chrome-mac',
+        mac_arm: 'chrome-mac', // eslint-disable-line camelcase
         win32: winArchiveName,
         win64: winArchiveName,
     };
     const binaryPaths = {
         linux: 'chrome',
         mac: 'Chromium.app/Contents/MacOS/Chromium',
-        mac_arm: 'Chromium.app/Contents/MacOS/Chromium',
+        mac_arm: 'Chromium.app/Contents/MacOS/Chromium', // eslint-disable-line camelcase
         win32: 'chrome.exe',
         win64: 'chrome.exe',
     };

package/cli/onExit.js

@@ -48,12 +48,12 @@ module.exports.ignoreFailingTestsInExitCode = function () {
 
 
 module.exports.onExit = async function onExit(exitValue) {
-    if (exitValue && exitValue.stack) {
+    if (exitValue?.stack) {
         if (!isCi) {
             writeStackTrace(exitValue);
         } else {
             // eslint-disable-next-line no-console
-            console.error(exitValue, exitValue && exitValue.stack);
+            console.error(exitValue, exitValue.stack);
         }
     }
 

package/cli.js

@@ -35,15 +35,16 @@ async function checkNodeVersion() {
         throw new ArgError(`Required node version ${version} not satisfied with current version ${process.version}`);
     }
 
-    const majorVersion = Number(process.version.replace('v', '').split('.')[0]);
-    const dateHasPassed = new Date('2022-08-01T00:00:00.000Z') <= new Date();
+    const minimalNodeVersion = 16;
+    const majorVersion = Number(process.versions.node.split('.')[0]);
+    const dateHasPassed = new Date('2023-04-30T00:00:00.000Z') <= new Date();
 
-    if (majorVersion < 14 && dateHasPassed) {
-        throw new ArgError('Testim.io CLI supports Node.js 14 and above, please upgrade to a newer Node.js version');
+    if (majorVersion < minimalNodeVersion && dateHasPassed) {
+        throw new ArgError(`Testim.io CLI supports Node.js ${minimalNodeVersion} and above, please upgrade to a newer Node.js version`);
     }
 
-    if (majorVersion < 14) {
-        console.log('\x1b[33m%s\x1b[0m', 'Testim.io CLI will stop supporting Node.js < 14 on August 1st 2022, please upgrade to a newer Node.js version');
+    if (majorVersion < minimalNodeVersion) {
+        console.log('\x1b[33m%s\x1b[0m', `Testim.io CLI will stop supporting Node.js < ${minimalNodeVersion} on April 30 2023, please upgrade to a newer Node.js version`);
     }
 }
 
@@ -67,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);
@@ -91,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

@@ -7,13 +7,12 @@ const path = require('path');
 const fs = require('fs-extra');
 const ms = require('ms');
 const WebSocket = require('ws');
-const Bluebird = require('bluebird');
 const ChromeLauncher = require('chrome-launcher');
 const config = require('./commons/config');
 const { ArgError } = require('./errors');
 const lazyRequire = require('./commons/lazyRequire');
 const prepareUtils = require('./commons/prepareRunnerAndTestimStartUtils');
-const { downloadAndSave, unzipFile, getCdpAddressForHost, TESTIM_BROWSER_DIR } = require('./utils');
+const { downloadAndSave, unzipFile, getCdpAddressForHost, TESTIM_BROWSER_DIR, promiseFromCallback } = require('./utils');
 const ora = require('ora');
 const { downloadAndInstallChromium, CHROMIUM_VERSION } = require('./chromiumInstaller');
 
@@ -33,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;
 }
 
@@ -54,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;
@@ -63,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;
@@ -361,7 +361,7 @@ async function readAndValidateChromedriverDevToolsActivePortFile() {
 async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100) {
     const websocketConnection = await wsConnectAndOpen(webSocketDebuggerUrl, timeout);
 
-    return Bluebird.fromCallback(cb => {
+    return promiseFromCallback(cb => {
         websocketConnection.send(JSON.stringify({
             id: 0,
             method: 'Browser.close',
@@ -376,13 +376,13 @@ async function tryToCloseBrowserWithCDPUrl(webSocketDebuggerUrl, timeout = 100)
 async function wsConnectAndOpen(webSocketDebuggerUrl, timeout = 100) {
     const websocket = new WebSocket(webSocketDebuggerUrl, { timeout });
 
-    const openPromise = Bluebird.fromCallback((cb) => {
+    const openPromise = promiseFromCallback((cb) => {
         websocket.once('open', cb);
     }).then(() => {
         websocket.removeAllListeners();
     });
 
-    const errorPromise = Bluebird.fromCallback((cb) => {
+    const errorPromise = promiseFromCallback((cb) => {
         websocket.once('error', cb);
     }).catch(() => {
         websocket.close();

package/codim/codim-cli.js

@@ -1,11 +1,15 @@
-"use strict";
+/* eslint-disable no-console */
 
-const { promisifyAll } = require('bluebird');
-const fse = require('fs-extra');
-const exec = promisifyAll(require('child_process')).execAsync;
+'use strict';
+
+const fs = require('fs');
+const childProcess = require('child_process');
 const path = require('path');
-const validateNpmPackageName = require("validate-npm-package-name");
+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');
@@ -16,19 +20,19 @@ module.exports.init = async function init(name) {
             type: 'text',
             name: 'project',
             message: 'Please enter Project name',
-            validate: value => String(value).length > 3
+            validate: value => String(value).length > 3,
         });
         name = response.project;
     }
 
-    const fullpath = path.resolve(name);
+    const fullPath = path.resolve(name);
 
-    if (fse.existsSync(fullpath) && fse.readdirSync(fullpath).length !== 0) {
-        console.log(`${fullpath} is not empty. Quiting...`);
+    if (fs.existsSync(fullPath) && fs.readdirSync(fullPath).length !== 0) {
+        console.log(`${fullPath} is not empty. Quitting...`);
         process.exit(1);
     }
 
-    const packageName = fullpath.substr(Math.max(fullpath.lastIndexOf('/'), fullpath.lastIndexOf('\\')) + 1);
+    const packageName = fullPath.substr(Math.max(fullPath.lastIndexOf('/'), fullPath.lastIndexOf('\\')) + 1);
 
     const nameValidity = validateNpmPackageName(packageName);
 
@@ -36,7 +40,7 @@ module.exports.init = async function init(name) {
         if (nameValidity.errors) nameValidity.errors.forEach((e) => console.log(e));
         if (nameValidity.warnings) nameValidity.warnings.forEach((e) => console.log(e));
 
-        throw new ArgError("Package name is not valid");
+        throw new ArgError('Package name is not valid');
     }
 
     const response = await prompts({
@@ -45,7 +49,7 @@ module.exports.init = async function init(name) {
         message: 'Add support for TypeScript?',
         initial: true,
         active: 'no',
-        inactive: 'yes'
+        inactive: 'yes',
     });
 
     const sourceFolder = response.isJs ? 'template.js' : 'template.ts';
@@ -55,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();
@@ -77,5 +81,4 @@ module.exports.init = async function init(name) {
     spinner.succeed();
 
     console.log(`Testim Dev Kit project folder successfully created in ${dest}.`);
-
 };

package/codim/hybrid-utils.js

@@ -4,7 +4,7 @@ module.exports.getArgumentsFromContext = async function getArgumentsFromContext(
     step,
     context,
     locatorStrategy
-)  {
+) {
     const argsInCorrectOrder = fixArgsOrdering(step.parameterNames.map(p => p.displayName), context.incomingParams.as);
 
     return await Promise.all(argsInCorrectOrder.map(arg => {

package/codim/measure-perf.js

@@ -1,8 +1,9 @@
+/* eslint-disable no-console */
 const startTime = Date.now();
 let last = 0;
 global.log = function time(message) {
-    let time = Date.now() - startTime;
-    console.log(time, time - last ,message);
+    const time = Date.now() - startTime;
+    console.log(time, time - last, message);
     last = time;
 };
 global.perf = function perf(fn) {
@@ -12,22 +13,24 @@ global.perf = function perf(fn) {
     } finally {
         console.log(fn.name, 'took', Date.now() - start);
     }
-}
+};
 
 require('bluebird').prototype.log = function log(message) {
     return this.tap(() => global.log(message));
-}
+};
 
 global.measureRequireTimes = () => {
     'use strict';
+
     const {
         performance,
-        PerformanceObserver
+        PerformanceObserver,
     } = require('perf_hooks');
     const mod = require('module');
 
     // Monkey patch the require function
     mod.Module.prototype.require = performance.timerify(mod.Module.prototype.require);
+    // eslint-disable-next-line no-global-assign
     require = performance.timerify(require);
 
     // Activate the observer
@@ -39,4 +42,4 @@ global.measureRequireTimes = () => {
         obs.disconnect();
     });
     obs.observe({ entryTypes: ['function'], buffered: true });
-}
+};

package/codim/template.js/tests/examples/01-simple-text-validation.test.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 // Import Testim Dev Kit methods
 const { go, text, test, l, Locator } = require('testim');
@@ -10,12 +10,12 @@ const { expect } = require('chai');
 Locator.set(require('./locators/locators.js'));
 
 test('Simple text validation', async () => {
-  await go("http://demo.testim.io");
+    await go('http://demo.testim.io');
 
-  // Grab the title text and store it in a const
-  const title = await text(l("SPACE_&_BEYOND"));
+    // Grab the title text and store it in a const
+    const title = await text(l('SPACE_&_BEYOND'));
 
-  // Use Chai to assert the title text is correct
-  expect(title).to.eq('Space & Beyond');
+    // Use Chai to assert the title text is correct
+    expect(title).to.eq('Space & Beyond');
 }); // end of test
 

package/codim/template.js/tests/examples/02-using-locators.test.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 // Import Testim Dev Kit methods
 const { go, waitForText, scrollToElement, click, test, l, Locator } = require('testim');
@@ -7,24 +7,22 @@ const { go, waitForText, scrollToElement, click, test, l, Locator } = require('t
 Locator.set(require('./locators/locators.js'));
 
 test('Using locators', async () => {
+    await go('http://demo.testim.io');
 
-  await go("http://demo.testim.io");
+    // Load the SELECT DESTINATION button smart locator. This locator
+    // can now be used by any method that accepts a smart locator as
+    // as argument.
+    //
+    // You can read more about the advantages of working with smart
+    // locators in the Testim documentation:
+    // https://help.testim.io/docs/working-with-locators
+    const selectDestButton = l('SELECT_DESTINATION');
 
-  // Load the SELECT DESTINATION button smart locator. This locator
-  // can now be used by any method that accepts a smart locator as
-  // as argument.
-  //
-  // You can read more about the advantages of working with smart
-  // locators in the Testim documentation:
-  // https://help.testim.io/docs/working-with-locators
-  const selectDestButton = l("SELECT_DESTINATION");
+    await waitForText(selectDestButton, 'Select Destination');
 
-  await waitForText(selectDestButton, 'Select Destination');
-
-  await scrollToElement(selectDestButton);
-
-  await click(selectDestButton);
+    await scrollToElement(selectDestButton);
 
+    await click(selectDestButton);
 }); // end of test