@testim/testim-cli 3.253.0 → 3.255.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,62 +1,60 @@
-"use strict";
+'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 superagent = require('superagent');
-const { expect } = require('chai');
+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(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);
 
 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));
+        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 Promise.fromCallback((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 () => {
         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

@@ -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.some(x => x === '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/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));