@testim/testim-cli 3.253.0 → 3.254.0

package/OverrideTestDataBuilder.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const utils = require('./utils.js');
+const utils = require('./utils');
 const _ = require('lodash');
 const logger = require('./commons/logger').getLogger('override-test-data-builder');
 

package/agent/routers/cliJsCode/index.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
 const router = require('./router');
 const service = require('./service');
-const logger = require('../../../commons/logger').getLogger("cli-service");
+const logger = require('../../../commons/logger').getLogger('cli-service');
 
 // clean local
 service.cleanLocalPackageInstallFolder()
-    .catch(err => logger.warn("failed to clean local package folder", {err}));
+    .catch(err => logger.warn('failed to clean local package folder', { err }));
 
 module.exports = {
-    router: router
+    router,
 };

package/agent/routers/cliJsCode/router.js

@@ -1,60 +1,64 @@
-"use strict";
+/* eslint-disable no-console */
 
-const Promise = require('bluebird');
+'use strict';
+
+const { TimeoutError } = require('bluebird');
 const express = require('express');
 const service = require('./service');
-const {NpmPackageError} = require('../../../errors');
-const logger = require('../../../commons/logger').getLogger("cli-router");
+const { NpmPackageError } = require('../../../errors');
+const logger = require('../../../commons/logger').getLogger('cli-router');
 const chalk = require('chalk');
 
 const router = express.Router();
 
-router.post('/run', (req, res) => {
-    const {code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl} = req.body;
+router.post('/run', async (req, res) => {
+    const { code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl } = req.body;
 
-    if (typeof code !== "string" || !stepId || !incomingParams || !context || !testResultId || typeof retryIndex !== "number" || !stepResultId || typeof timeout !== "number") {
-        return res.status(400).json({success: false, code: "invalid-params"});
+    if (typeof code !== 'string' || !stepId || !incomingParams || !context || !testResultId || typeof retryIndex !== 'number' || !stepResultId || typeof timeout !== 'number') {
+        res.status(400).json({ success: false, code: 'invalid-params' });
+        return;
     }
 
-    return service.runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl)
-        .then(data => {
-            if(!data.success) {
-                console.log(chalk.red(data.result.resultValue));
-                logger.error('CLI Action Failure', {message: data.result.resultValue });
-            }
-            res.status(200).json({success: true, data});
-        })
-        .catch(err => {
-            logger.error("failed to run cli code", {err});
-            console.log(chalk.red("failed to run cli code", err));
-            res.status(500).json({success: false, code: "internal-error"});
-        });
+    try {
+        const data = await service.runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, timeout, fileDataUrl);
+        if (!data.success) {
+            console.log(chalk.red(data.result.resultValue));
+            logger.error('CLI Action Failure', { message: data.result.resultValue });
+        }
+        res.status(200).json({ success: true, data });
+    } catch (err) {
+        logger.error('failed to run cli code', { err });
+        console.log(chalk.red('failed to run cli code', err));
+        res.status(500).json({ success: false, code: 'internal-error' });
+    }
 });
 
-router.post('/install', (req, res) => {
-    const {stepId, testResultId, retryIndex, packageData, stepResultId, timeout} = req.body;
+router.post('/install', async (req, res) => {
+    const { stepId, testResultId, retryIndex, packageData, stepResultId, timeout } = req.body;
 
-    if (!stepId || typeof packageData !== "object" || !testResultId || typeof retryIndex !== "number" || !stepResultId || typeof timeout !== "number") {
-        return res.status(400).json({success: false, code: "invalid-params"});
+    if (!stepId || typeof packageData !== 'object' || !testResultId || typeof retryIndex !== 'number' || !stepResultId || typeof timeout !== 'number') {
+        res.status(400).json({ success: false, code: 'invalid-params' });
+        return;
     }
 
-    return service.installPackage(stepId, testResultId, retryIndex, packageData, stepResultId, timeout)
-        .then(data => {
-            logger.info("installed packages successfully");
-            res.status(200).json({success: true, data});
-        })
-        .catch(NpmPackageError, err => {
-            logger.error("failed to install node packages", {err});
-            res.status(200).json({success: false, code: "invalid-node-package", message: err.message});
-        })
-        .catch(Promise.TimeoutError, () => {
-            logger.error("timeout installing node package");
-            return res.status(200).json({success: false, code: "timeout"});
-        })
-        .catch(err => {
-            logger.error("failed to install node packages", {err});
-            res.status(500).json({success: false, code: "internal-error"});
-        });
+    try {
+        const data = await service.installPackage(stepId, testResultId, retryIndex, packageData, stepResultId, timeout);
+        logger.info('installed packages successfully');
+        res.status(200).json({ success: true, data });
+    } catch (err) {
+        if (err instanceof NpmPackageError) {
+            logger.error('failed to install node packages', { err });
+            res.status(200).json({ success: false, code: 'invalid-node-package', message: err.message });
+            return;
+        }
+        if (err instanceof TimeoutError) {
+            logger.error('timeout installing node package');
+            res.status(200).json({ success: false, code: 'timeout' });
+            return;
+        }
+        logger.error('failed to install node packages', { err });
+        res.status(500).json({ success: false, code: 'internal-error' });
+    }
 });
 
 module.exports = router;

package/agent/routers/cliJsCode/service.js

@@ -11,6 +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 { TimeoutError } = require('../../../errors');
 
 let workerThreads;
 
@@ -587,22 +588,22 @@ function runCodeWithPackages(code, stepId, incomingParams, context, testResultId
     }).then(res => Object.assign({}, res, { nodeVersion: process.version }));
 }
 
-function runNpmInstall(transactionId, packageData, timeout) {
+async function runNpmInstall(transactionId, packageData, timeout) {
     const packages = packageData.map(data => `${data.packageName}@${data.packageVersion}`);
     const localPackageInstallFolder = getLocalPackageInstallFolder();
     const installFolder = path.join(localPackageInstallFolder, `/${transactionId}`);
     const proxyUri = global.proxyUri;
 
-    // while correct, everything is in a try/catch so it should be fine.
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve, reject) => {
+
+    async function npmInstallation() {
         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;
+                // TODO: I am not sure changing this to an error would be safe.
+                // eslint-disable-next-line no-throw-literal
+                throw 'npm package install failed, couldn\'t install all packages';
             }
             const packageDataWithVersions = packageData.map(pData => {
                 const version = npmWrapper.getLocallyInstalledPackageVersion(installFolder, pData.packageName);
@@ -614,17 +615,21 @@ function runNpmInstall(transactionId, packageData, timeout) {
                 });
             });
 
-            resolve({ data: packageDataWithVersions, installFolder });
+            return { data: packageDataWithVersions, installFolder };
         } catch (err) {
             logger.warn('npm package install failed', { transactionId, err });
-            reject(err);
+            throw err;
         }
-    })
-        .timeout(timeout)
-        .catch(Promise.TimeoutError, err => {
+    }
+
+    try {
+        return await utils.promiseTimeout(npmInstallation(), timeout);
+    } catch (err) {
+        if (err instanceof TimeoutError) {
             logger.warn('timeout to install package', { packages, transactionId, err, timeout });
-            throw err;
-        });
+        }
+        throw err;
+    }
 }
 
 function getLocalPackageInstallFolder() {

package/agent/routers/codim/router.js

@@ -1,8 +1,9 @@
-"use strict";
+'use strict';
 
 const express = require('express');
+
 const router = express.Router();
-const logger = require('../../../commons/logger').getLogger("codim-router");
+const logger = require('../../../commons/logger').getLogger('codim-router');
 
 const {
     findTests,
@@ -10,40 +11,39 @@ const {
     getLocalLocatorContents,
     saveTest,
     saveLocators,
-    compileFunctionsLibrary
+    compileFunctionsLibrary,
 } = require('./service');
 
 
 router.get('/tests', async (req, res) => {
     const tests = await findTests();
-    res.json({tests, success: true });
+    res.json({ tests, success: true });
 });
 router.get('/locators', async (req, res) => {
     const locators = await getLocalLocators();
     const contents = await getLocalLocatorContents(locators, req.query.full);
-    res.json({locators, contents, success: true });
+    res.json({ locators, contents, success: true });
 });
 router.post('/locators', async (req, res) => {
-
     if (!req.body) {
-        res.status(400).send({success: false, reason: 'missing body' });
+        res.status(400).send({ success: false, reason: 'missing body' });
         return;
     }
     if (!req.body.locators) {
-        res.status(400).send({success: false, reason: 'missing locators' });
+        res.status(400).send({ success: false, reason: 'missing locators' });
         return;
     }
 
     const { locators, mergeIntoExisting } = req.body;
 
     await saveLocators(locators, { mergeIntoExisting: mergeIntoExisting || false });
-    res.status(200).send({ success: true })
+    res.status(200).send({ success: true });
 });
 
 router.get('/compile', async (req, res) => {
     try {
         const code = await compileFunctionsLibrary(req.body.name);
-        res.send({ success: true, code })
+        res.send({ success: true, code });
     } catch (e) {
         logger.error(e);
         res.json({ success: false, reason: e.message });
@@ -51,20 +51,17 @@ router.get('/compile', async (req, res) => {
 });
 
 router.post('/saveTest', async (req, res) => {
-
     if (!req.body) {
-        res.status(400).send({success: false, reason: 'missing body' });
+        res.status(400).send({ success: false, reason: 'missing body' });
         return;
     }
     try {
-       await saveTest(req.body);
-       res.send({ success: true });
+        await saveTest(req.body);
+        res.send({ success: true });
     } catch (e) {
-        res.json({success: false, reason: e.message });
+        res.json({ success: false, reason: e.message });
         logger.error(e);
-        return;
     }
-
 });
 
 

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

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const router = require('./router');
 
@@ -6,17 +6,19 @@ 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 { expect } = require('chai');
+const { expect } = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
 
 const fs = Promise.promisifyAll(require('fs'));
 
-app.use(bodyParser.urlencoded({extended: false, limit: '50mb'}));
+app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
 app.use(compression());
-app.use(bodyParser.json({limit: '50mb'}));
+app.use(bodyParser.json({ limit: '50mb' }));
 
 app.use('/files', router.router);
 
@@ -24,13 +26,13 @@ describe('codim router', () => {
     let listener;
     async function saveLocators(locatorsObject) {
         const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`)
-                  .send(locatorsObject);
-        await Promise.fromCallback((callback) => request.end(callback));
+            .send(locatorsObject);
+        await promiseFromCallback((callback) => request.end(callback));
     }
 
     async function loadLocators() {
         const request = superagent.get(`http://localhost:${listener.address().port}/files/locators`);
-        return await Promise.fromCallback((callback) => request.end(callback)).then(x => x.text).then(JSON.parse);
+        return await promiseFromCallback((callback) => request.end(callback)).then(x => x.text).then(JSON.parse);
     }
 
     let tmpDir;
@@ -46,17 +48,16 @@ describe('codim router', () => {
 
     it('saves locators', async () => {
         await saveLocators({
-            locators: [{ id: 'foo', name: 'foo', body: {internal: 'bar' }}],
-            mergeIntoExisting: false
+            locators: [{ id: 'foo', name: 'foo', body: { internal: 'bar' } }],
+            mergeIntoExisting: false,
         });
         const locators = await loadLocators();
         expect(locators).to.deep.eq({
-            "contents": {},
-            "locators": {
-              "foo": "foo"
+            contents: {},
+            locators: {
+                foo: 'foo',
             },
-            "success": true
+            success: true,
         });
     });
-
 });

package/agent/routers/codim/service.js

@@ -12,7 +12,7 @@ const findTestFolder = _.memoize(async (fromFolder) => {
     const files = await fs.readdirAsync(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.some(x => x === 'tests') && (await fs.statAsync(path.join(fromFolder, 'tests'))).isDirectory();
+    const isInProjectFolder = files.includes('tests') && (await fs.statAsync(path.join(fromFolder, 'tests'))).isDirectory();
     if (isInProjectFolder) {
         return path.join(fromFolder, 'tests');
     }

package/agent/routers/general/index.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const { getPackageVersion } = require('../../../testimNpmDriver');
 const { doLogin } = require('../../../credentialsManager');
@@ -9,11 +9,9 @@ module.exports = (app) => {
      * root endpoint
      */
     app.get('/', (req, res) => {
-
         const isStartMode = getStartedWithStart();
 
-        return res.status(200).json({success: true, isTestimAgent: true, startMode: isStartMode});
-
+        return res.status(200).json({ success: true, isTestimAgent: true, startMode: isStartMode });
     });
 
     /**
@@ -22,19 +20,17 @@ module.exports = (app) => {
     app.get('/version', (req, res) => {
         res.status(200).json({
             node: process.version,
-            app: getPackageVersion()
+            app: getPackageVersion(),
         });
     });
 
     app.get('/loginInfo', (req, res) => {
         try {
             const projects = JSON.parse(Buffer.from(req.query.info, 'base64').toString());
-            doLogin({overwriteExisting: false, projects });
+            doLogin({ overwriteExisting: false, projects });
             res.status(200).end();
         } catch (err) {
             res.status(400).end();
         }
     });
-
-    
 };

package/agent/routers/hybrid/registerRoutes.js

@@ -3,7 +3,7 @@
 const service = require('../../../stepPlayers/hybridStepPlayback');
 const express = require('express');
 const lazyRequire = require('../../../commons/lazyRequire');
-const logger = require('../../../commons/logger').getLogger("hybrid-router");
+const logger = require('../../../commons/logger').getLogger('hybrid-router');
 
 /**
  * @param {{
@@ -16,7 +16,7 @@ module.exports.hybridRoutes = function hybridRoutes(testimStandaloneBrowser) {
     router.post('/run', (req, res) => {
         if (!req.body || !req.body.step) {
             res.status(400).send({
-                error: "Missing step"
+                error: 'Missing step',
             });
             return;
         }
@@ -24,15 +24,15 @@ module.exports.hybridRoutes = function hybridRoutes(testimStandaloneBrowser) {
         const {
             step,
             context,
-            loginData // is this safe to pass here?
+            loginData, // is this safe to pass here?
         } = req.body;
         if (!testimStandaloneBrowser.webdriverApi) {
-            res.status(503).send({success: false, reason: 'Testim Agent was not started with Testim Start.' });
+            res.status(503).send({ success: false, reason: 'Testim Agent was not started with Testim Start.' });
         }
 
         // The step run might take very long time, and it will still be valid
         // so we set here unlimited timeout
-        req.setTimeout(0)
+        req.setTimeout(0);
 
         service.execute(
             step,
@@ -41,18 +41,18 @@ module.exports.hybridRoutes = function hybridRoutes(testimStandaloneBrowser) {
             loginData,
             undefined, // don't pass frameManager,
             'agent'
-            ).then((result) => {
-                res.status(200).send(result);
-            }).catch(e => {
-                logger.error("failed to run hybrid code", { e });
-                res.status(500).send(Object.assign({success: false, error: e }));
-            });
+        ).then((result) => {
+            res.status(200).send(result);
+        }).catch(e => {
+            logger.error('failed to run hybrid code', { e });
+            res.status(500).send(Object.assign({ success: false, error: e }));
+        });
     });
 
     router.post('/abort', (req, res) => {
         if (!req.body || !req.body.stepResultId) {
             res.status(400).send({
-                error: `missing stepResultId`
+                error: 'missing stepResultId',
             });
 
             return;
@@ -62,20 +62,20 @@ module.exports.hybridRoutes = function hybridRoutes(testimStandaloneBrowser) {
             service.abort(req.body.stepResultId);
             res.status(204).end();
         } catch (e) {
-            if (e && e.message === "No such stepResultId") {
+            if (e && e.message === 'No such stepResultId') {
                 res.status(400).send({
-                    error: `No such stepResultId`
+                    error: 'No such stepResultId',
                 });
                 return;
             }
 
-            logger.error("hybrid code abort unexpected error", { e });
+            logger.error('hybrid code abort unexpected error', { e });
             res.status(500).send({
-                error: "unexpected error",
-                info: `${e ? e.message : "N/A"}`
+                error: 'unexpected error',
+                info: `${e ? e.message : 'N/A'}`,
             });
         }
     });
 
     return router;
-}
+};

package/agent/routers/index.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 const compression = require('compression');
 const express = require('express');
@@ -7,14 +7,14 @@ const cors = require('cors');
 const { IS_ON_PREM, DISABLE_AGENT_ORIGIN_CHECK } = require('../../commons/config');
 
 
-module.exports = function(beforeMiddleware, standaloneBrowserInfo) {
+module.exports = function (beforeMiddleware, standaloneBrowserInfo) {
     const app = express();
     beforeMiddleware(app);
 
     // view engine setup
-    app.use(bodyParser.urlencoded({extended: false, limit: '50mb'}));
+    app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
     app.use(compression());
-    app.use(bodyParser.json({limit: '50mb'}));
+    app.use(bodyParser.json({ limit: '50mb' }));
 
     /**
      * set cors options
@@ -27,8 +27,8 @@ module.exports = function(beforeMiddleware, standaloneBrowserInfo) {
         allowedHeaders: ['Content-Type', 'Authorization'],
         credentials: true,
         maxAge: 86400,
-        origin: (IS_ON_PREM || DISABLE_AGENT_ORIGIN_CHECK) ? '*' : whitelist
-    }
+        origin: (IS_ON_PREM || DISABLE_AGENT_ORIGIN_CHECK) ? '*' : whitelist,
+    };
     app.use('*', cors(corsOptions));
 
     // Routes
@@ -42,7 +42,7 @@ module.exports = function(beforeMiddleware, standaloneBrowserInfo) {
     app.use('/cliJs', cliJsCode.router);
 
     app.use('/standalone-browser',
-        require("./standalone-browser/registerRoutes").standaloneBrowserRoutes(standaloneBrowserInfo)
+        require('./standalone-browser/registerRoutes').standaloneBrowserRoutes(standaloneBrowserInfo)
     );
 
     app.use('/hybrid', require('./hybrid/registerRoutes').hybridRoutes(standaloneBrowserInfo));

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;
         }