@testim/testim-cli 3.197.0 → 3.201.0

package/OverrideTestDataBuilder.js

@@ -32,7 +32,7 @@ class OverrideTestDataBuilder {
             }
         }
         if (this.isObjectNotArray(params) && typeof params.overrideAllTestsData !== 'undefined') {
-            if (this.isObjectNotArray(params.overrideAllTestsData) && !_.isEmpty(params.overrideAllTestsData)) {
+            if (_.isObject(params.overrideAllTestsData) && !_.isEmpty(params.overrideAllTestsData)) {
                 const testNames = this.testInfoList.map(test => test.name);
                 testNames.forEach(testName => this.overrideSingeTest(testName, params.overrideAllTestsData));
                 delete params.overrideAllTestsData;

package/commons/featureFlags.js

@@ -37,7 +37,6 @@ class FeatureFlagsService {
             useSafariWebdriverVisibilityChecks: new Rox.Flag(),
             useClickimVisibilityChecks: new Rox.Flag(),
             useIEWebdriverVisibilityChecks: new Rox.Flag(),
-            enableTDKRun: new Rox.Flag(true),
             runGetElementCodeInAut: new Rox.Flag(),
             enableNpmPackageInstallUsingNpmCli: new Rox.Flag(),
             enableFrameSwitchOptimization: new Rox.Flag(),
@@ -47,8 +46,6 @@ class FeatureFlagsService {
             warnOnBadNetwork: new Rox.Flag(false),
             overrideAzureStorageUrl: new Rox.Flag(),
             useJsInputCodeInSafari: new Rox.Flag(),
-            testNameTestDataInJunitReport: new Rox.Flag(),
-            countRetries: new Rox.Flag(),
             autoSaveDownloadFileFireFox: new Rox.Flag(true),
             safariSelectOptionDispatchEventOnSelectElement: new Rox.Flag(true),
             experimentalPreCodeCompilation: new Rox.Flag(false),

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/executionQueue.js

@@ -3,8 +3,8 @@
 const TestRun = require('./testRunHandler.js');
 
 class ExecutionQueue {
-    constructor(executionId, testList, options, branchToUse, testStatus) {
-        this._waitingTests = testList.map(testInfo => new TestRun(executionId, testInfo, options, branchToUse, testStatus));
+    constructor(executionId, executionName, testList, options, branchToUse, testStatus) {
+        this._waitingTests = testList.map(testInfo => new TestRun(executionId, executionName, testInfo, options, branchToUse, testStatus));
     }
 
     getNext() {