@testim/testim-cli 3.197.0 → 3.198.0

package/commons/npmWrapper.js

@@ -9,7 +9,7 @@ const Promise = require('bluebird');
 const fse = require('fs-extra');
 const logger = require('./logger').getLogger('cli-service');
 const { requireWithFallback } = require('./requireWithFallback');
-const os = require('os');
+const fs = require('fs');
 
 async function getLatestPackageVersion(packageName) {
     const result = await exec(`npm view ${packageName} version`);
@@ -40,6 +40,16 @@ function getLocallyInstalledPackageVersion(rootPath, packageName) {
     return require(path.join(rootPath, `./node_modules/${packageName}/package.json`)).version;
 }
 
+// this is not exactly correct, but it's good enough.
+async function fileExists(path) {
+    try {
+        await fs.promises.access(path);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
 async function installPackageLocally(rootPath, packageName, execOptions) {
     function getPathWithMissingPermissions(error) {
         const pathRegex = /EACCES[^']+'(.+)'/;
@@ -50,26 +60,48 @@ async function installPackageLocally(rootPath, packageName, execOptions) {
         return regexResult[1];
     }
 
-    return exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
-        const pathWithMissingPermissions = getPathWithMissingPermissions(err);
-        if (pathWithMissingPermissions) {
-            logger.info('Failed to install package due to insufficient write access', {
-                ...additionalLogDetails(),
-                package: packageName,
-                path: pathWithMissingPermissions,
-            });
-            // eslint-disable-next-line no-console
-            console.error(`
+    // this is here because our shrinkwrap blocks our lazy deps for some reason
+    const oldShrinkwrap = path.join(rootPath, 'npm-shrinkwrap.json');
+    const newShrinkwrap = path.join(rootPath, 'npm-shrinkwrap-dummy.json');
+    let renamed = false;
+    try {
+        try {
+            if (await fileExists(oldShrinkwrap)) {
+                await fs.promises.rename(oldShrinkwrap, newShrinkwrap);
+                renamed = true;
+            }
+        } catch (err) {
+            // ignore error
+        }
+        return await exec(`npm i ${packageName} --no-save --no-package-lock --no-prune --prefer-offline --no-audit --progress=false`, { ...execOptions, cwd: rootPath }).catch(err => {
+            const pathWithMissingPermissions = getPathWithMissingPermissions(err);
+            if (pathWithMissingPermissions) {
+                logger.info('Failed to install package due to insufficient write access', {
+                    ...additionalLogDetails(),
+                    package: packageName,
+                    path: pathWithMissingPermissions,
+                });
+                // eslint-disable-next-line no-console
+                console.error(`
 
 Testim failed installing the package ${packageName} due to insufficient permissions.
 This is probably due to an installation of @testim/testim-cli with sudo, and running it without sudo.
 Testim had missing write access to ${pathWithMissingPermissions}
 
 `);
-            throw new NpmPermissionsError(pathWithMissingPermissions);
+                throw new NpmPermissionsError(pathWithMissingPermissions);
+            }
+            throw err;
+        });
+    } finally {
+        if (renamed) {
+            try {
+                await fs.promises.rename(newShrinkwrap, oldShrinkwrap);
+            } catch (err) {
+                // ignore error
+            }
         }
-        throw err;
-    });
+    }
 }
 
 const localNpmLocation = path.resolve(require.resolve('npm'), '../../bin/npm-cli.js');

package/commons/npmWrapper.test.js

@@ -5,8 +5,8 @@ const { sinon, expect } = require('../../test/utils/testUtils');
 const os = require('os');
 const { NpmPermissionsError } = require('../errors');
 const path = require('path');
+
 const fs = require('fs');
-const { getCliLocation } = require('../utils');
 
 describe('npmWrapper', () => {
     describe('installPackageLocally', () => {
@@ -22,17 +22,22 @@ describe('npmWrapper', () => {
 
             let fakeChildProcess;
             let fakeLogger;
-
+            let fakeFS;
             let originalConsole;
             beforeEach(() => {
                 fakeChildProcess = { exec: sinon.stub() };
                 fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
-
+                fakeFS = {
+                    promises: {
+                        access: sinon.stub().rejects(new Error()),
+                    },
+                };
                 originalConsole = global.console;
                 global.console = { log: sinon.stub(), error: sinon.stub() };
 
                 npmWrapper = proxyquire('./npmWrapper', {
                     child_process: fakeChildProcess,
+                    fs: fakeFS,
                     './logger': { getLogger: () => fakeLogger },
                 });
             });
@@ -65,7 +70,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             it('should throw an error if an error which isnt related to permissions occurred', async () => {
@@ -73,7 +78,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             it('should throw an error if stderr includes "EACCES", but the path was not specified', async () => {
@@ -81,7 +86,7 @@ describe('npmWrapper', () => {
 
                 stubExecRejection(execErr);
 
-                expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
+                await expect(npmWrapper.installPackageLocally('/some/dir', 'some-package')).to.be.rejectedWith(execErr);
             });
 
             [
@@ -194,5 +199,176 @@ Testim had missing write access to ${expectedPath}
                 expect(fs.existsSync(unexpectedDir), 'expected the package not to be installed - this could be a problem with the test itself, and not the tested class').to.be.false;
             }).timeout(20000);
         });
+
+        describe('shirnkwrap handling', () => {
+            let fakeChildProcess;
+            let fakeLogger;
+            let originalConsole;
+            const shrinkwrapPath = '/some/dir/npm-shrinkwrap.json';
+            const shrinkwrapDummyPath = '/some/dir/npm-shrinkwrap-dummy.json';
+            beforeEach(() => {
+                fakeChildProcess = { exec: sinon.stub() };
+                fakeLogger = { warn: sinon.stub(), info: sinon.stub() };
+                originalConsole = global.console;
+                global.console = { log: sinon.stub(), error: sinon.stub() };
+            });
+
+            afterEach(() => {
+                global.console = originalConsole;
+            });
+
+            it('does not call rename if access fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub(),
+                        rename: sinon.stub(),
+                    },
+                };
+                fakeFS.promises.access.rejects();
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.notCalled(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('calls rename once if rename fails on the first time', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().rejects(),
+                    },
+                };
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledOnce(fakeFS.promises.rename);
+            });
+
+            it('calls rename twice if first is success', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().resolves(),
+                    },
+                };
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('doesn\'t throw if first rename fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(true),
+                        rename: sinon.stub().rejects(),
+                    },
+                };
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledOnce(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+            });
+
+            it('doesn\'t throw is second rename fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
+                            .rejects(),
+                    },
+                };
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                fakeChildProcess.exec.yields(undefined, []); //resolve without errors
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await npmWrapper.installPackageLocally(cwd, pkg);
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+
+            it('calls rename even if exec fails', async () => {
+                const fakeFS = {
+                    promises: {
+                        access: sinon.stub().resolves(),
+                        rename: sinon.stub().onFirstCall().resolves().onSecondCall()
+                            .rejects(),
+                    },
+                };
+
+                fakeChildProcess.exec.throws();
+
+                const npmWrapper = proxyquire('./npmWrapper', {
+                    child_process: fakeChildProcess,
+                    fs: fakeFS,
+                    './logger': { getLogger: () => fakeLogger },
+                });
+
+                const cwd = '/some/dir';
+                const pkg = 'some-package';
+                await expect(npmWrapper.installPackageLocally(cwd, pkg)).to.be.rejected;
+                sinon.assert.calledOnce(fakeFS.promises.access);
+                sinon.assert.calledTwice(fakeFS.promises.rename);
+                expect(fakeFS.promises.access.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[0]).to.be.equal(shrinkwrapPath);
+                expect(fakeFS.promises.rename.getCall(0).args[1]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[0]).to.be.equal(shrinkwrapDummyPath);
+                expect(fakeFS.promises.rename.getCall(1).args[1]).to.be.equal(shrinkwrapPath);
+            });
+        });
     });
 });

package/npm-shrinkwrap.json

@@ -1514,9 +1514,9 @@
       "integrity": "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug=="
     },
     "asn1": {
-      "version": "0.2.4",
-      "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz",
-      "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==",
+      "version": "0.2.6",
+      "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz",
+      "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==",
       "requires": {
         "safer-buffer": "~2.1.0"
       }
@@ -1873,13 +1873,13 @@
       "dev": true
     },
     "browserslist": {
-      "version": "4.17.5",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.17.5.tgz",
-      "integrity": "sha512-I3ekeB92mmpctWBoLXe0d5wPS2cBuRvvW0JyyJHMrk9/HmP2ZjrTboNAZ8iuGqaEIlKguljbQY32OkOJIRrgoA==",
+      "version": "4.17.6",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.17.6.tgz",
+      "integrity": "sha512-uPgz3vyRTlEiCv4ee9KlsKgo2V6qPk7Jsn0KAn2OBqbqKo3iNcPEC1Ti6J4dwnz+aIRfEEEuOzC9IBk8tXUomw==",
       "dev": true,
       "requires": {
-        "caniuse-lite": "^1.0.30001271",
-        "electron-to-chromium": "^1.3.878",
+        "caniuse-lite": "^1.0.30001274",
+        "electron-to-chromium": "^1.3.886",
         "escalade": "^3.1.1",
         "node-releases": "^2.0.1",
         "picocolors": "^1.0.0"
@@ -2033,9 +2033,9 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001274",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001274.tgz",
-      "integrity": "sha512-+Nkvv0fHyhISkiMIjnyjmf5YJcQ1IQHZN6U9TLUMroWR38FNwpsC51Gb68yueafX1V6ifOisInSgP9WJFS13ew==",
+      "version": "1.0.30001278",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001278.tgz",
+      "integrity": "sha512-mpF9KeH8u5cMoEmIic/cr7PNS+F5LWBk0t2ekGT60lFf0Wq+n9LspAj0g3P+o7DQhD3sUdlMln4YFAWhFYn9jg==",
       "dev": true
     },
     "caseless": {
@@ -3172,9 +3172,9 @@
       "integrity": "sha512-GJCAeDBKfREgkBtgrYSf9hQy9kTb3helv0zGdzqhM7iAkW8FA/ZF97VQDbwFiwIT8MQLLOe5VlPZOEvZAqtUAQ=="
     },
     "electron-to-chromium": {
-      "version": "1.3.886",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.886.tgz",
-      "integrity": "sha512-+vYdeBosI63VkCtNWnEVFjgNd/IZwvnsWkKyPtWAvrhA+XfByKoBJcbsMgudVU/bUcGAF9Xp3aXn96voWlc3oQ==",
+      "version": "1.3.890",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.890.tgz",
+      "integrity": "sha512-VWlVXSkv0cA/OOehrEyqjUTHwV8YXCPTfPvbtoeU2aHR21vI4Ejh5aC4AxUwOmbLbBgb6Gd3URZahoCxtBqCYQ==",
       "dev": true
     },
     "emoji-regex": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.197.0",
+  "version": "3.198.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

package/player/stepActions/salesforceApexActionStepAction.js

@@ -0,0 +1,9 @@
+const CliJsStepAction = require('./cliJsStepAction');
+
+class SalesforceApexActionStepAction extends CliJsStepAction {
+    getSkipStatus() {
+        return false;
+    }
+}
+
+module.exports = SalesforceApexActionStepAction;

package/player/stepActions/salesforceAutoLoginStepAction.js

@@ -19,7 +19,7 @@ class SalesforceAutoLoginStepAction extends NavigationStepAction {
                     var done = arguments[1];
                     done();
                 `, timeout);
-                await Promise.delay(1500);
+                await Promise.delay(5000);
                 newUrl = await this.driver.getUrl(); // If we managed to continue correctly we want to get the new redirected url
             }
             await Promise.delay(700);

package/player/stepActions/stepActionRegistrar.js

@@ -21,9 +21,11 @@ const RefreshStepAction = require('./RefreshStepAction');
 const ApiStepAction = require('./apiStepAction');
 const ExtractTextStepAction = require('./extractTextStepAction');
 const TdkHybridStepAction = require('./tdkHybridStepAction');
-const SalesforceAutoLoginStepAction = require('./salesforceAutoLoginStepAction');
 const PixelValidationStepAction = require('./pixelValidationStepAction');
 
+const SalesforceAutoLoginStepAction = require('./salesforceAutoLoginStepAction');
+const SalesforceApexActionStepAction = require('./salesforceApexActionStepAction');
+
 const CliJsStepAction = require('./cliJsStepAction');
 const CliConditionStepAction = require('./cliConditionStepAction');
 const NodePackageStepAction = require('./nodePackageStepAction');
@@ -85,6 +87,7 @@ module.exports = function (driver, stepActionFactory, runMode) {
         'tdk-hybrid': TdkHybridStepAction,
 
         'salesforce-autologin': SalesforceAutoLoginStepAction,
+        'salesforce-apex-action': SalesforceApexActionStepAction,
     };
 
     register(STEP_ACTION_MAPPING, stepActionFactory);

package/testRunHandler.js

@@ -7,6 +7,7 @@ const testimServicesApi = require('./commons/testimServicesApi');
 const { timeoutMessages, CLI_MODE } = require('./commons/constants');
 const logger = require('./commons/logger').getLogger('test-run-handler');
 const perf = require('./commons/performance-logger');
+const { URL } = require('url');
 const Promise = require('bluebird');
 const _ = require('lodash');
 const remoteStepPlayback = require('./stepPlayers/remoteStepPlayback');
@@ -316,6 +317,19 @@ TestRun.prototype.isRetryKeyMismatch = function (testResult) {
     return testResult.testRetryKey && (testResult.testRetryKey !== this.getRetryKey());
 };
 
+TestRun.prototype.validateRunConfig = function () {
+    const baseUrl = this.getBaseUrl();
+    const { browserValue } = this.getRunConfig();
+
+    if (baseUrl) {
+        const { username, password } = new URL(baseUrl);
+
+        if (browserValue === 'safari' && (username || password)) {
+            throw new Error('Basic authentication in URL is not supported in Safari');
+        }
+    }
+};
+
 TestRun.prototype.onStarted = function (startTimeout) {
     return new Promise(resolve => {
         // We can't leave the test result as it may remove other listeners as well
@@ -467,7 +481,7 @@ TestRun.prototype.onCompleted = function () {
                             waitForTestEnd();
                         }
                     } catch (err) {
-                        logger.error('failed to check is complete', {err});
+                        logger.error('failed to check is complete', { err });
                         waitForTestEnd();
                     }
                 }, 3000);

package/testRunStatus.js

@@ -23,11 +23,11 @@ const gitRepoUrl = process.env.GIT_URL || process.env.CIRCLE_REPOSITORY_URL;
 const runnerVersion = utils.getRunnerVersion();
 
 
-function runHook(fn, object) {
+function runHook(fn, ...args) {
     if (!fn || typeof fn !== 'function') {
         return Promise.resolve();
     }
-    return Promise.try(() => fn(object) || {}).catch(err => {
+    return Promise.try(() => fn(...args) || {}).catch(err => {
         logger.warn('failed to run hook', { err });
         throw new ArgError(`failed to run hook promise ${err.message}`);
     });
@@ -181,7 +181,7 @@ RunStatus.prototype.testStartReport = function (test, executionId, testRetryKey)
     if (utils.isQuarantineAndNotRemoteRun(test, this.options)) {
         return Promise.resolve();
     }
-    return runHook(this.options.beforeTest, Object.assign({}, test, { exportsGlobal: this.exportsGlobal }))
+    return runHook(this.options.beforeTest, Object.assign({}, test, { exportsGlobal: this.exportsGlobal }), this.options.userData.loginData.token)
         .then(params => {
             this.options.runParams[test.resultId] = test.config.testData = Object.assign({}, test.config.testData, this.exportsGlobal, this.fileUserParamsData, this.beforeSuiteParams, params);
             test.startTime = Date.now();
@@ -278,7 +278,7 @@ RunStatus.prototype.testEndReport = async function (test, executionId, result, t
     const globalParameters = result.exportsGlobal;
     try {
         try {
-            await runHook(this.options.afterTest, Object.assign({}, test, { globalParameters }));
+            await runHook(this.options.afterTest, Object.assign({}, test, { globalParameters }), this.options.userData.loginData.token);
         } catch (err) {
             logger.error('HOOK threw an error', { test: test.testId, err });
             // eslint-disable-next-line no-console

package/workers/BaseWorker.js

@@ -387,6 +387,7 @@ class BaseWorker {
             !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),
             !disableResults && testResultService.joinToTestResult(this.testResultId, this.testId),
         ])
+            .then(() => testRunHandler.validateRunConfig())
             .then(() => this.runTest(testRunHandler, this.customExtensionLocalLocation, shouldRerun))
             .then(testResult => onRunComplete(testResult, testRunHandler))
             .then(result => {