@testim/testim-cli 3.242.0 → 3.245.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.242.0",
+  "version": "3.245.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{
@@ -57,7 +57,6 @@
     "appium-dom-utils": "1.0.6",
     "archiver": "5.3.0",
     "bluebird": "3.7.2",
-    "bluebird-retry": "0.11.0",
     "body-parser": "1.19.1",
     "chalk": "4.1.2",
     "chrome-launcher": "0.15.0",
@@ -87,6 +86,7 @@
     "npm": "8.3.0",
     "object-hash": "3.0.0",
     "ora": "5.4.1",
+    "p-retry": "4.6.2",
     "pako": "1.0.11",
     "portfinder": "1.0.28",
     "promise-queue": "2.2.5",
@@ -116,7 +116,7 @@
     "test": "IS_UNIT_TEST=1 ../../node_modules/mocha/bin/_mocha --timeout 2000  --reporter spec --exit --recursive \"./src/**/*.test.js\" --exclude ./src/codim/template.js/tests/examples/**/*.test.js",
     "test:watch": "IS_UNIT_TEST=1 ../../node_modules/mocha/bin/_mocha --timeout 2000 --exit --recursive \"./src/**/*.test.js\"  --exclude ./src/codim/template.js/tests/examples/**/*.test.js --watch",
     "test:cov": "nyc --reporter=lcov --reporter=text yarn test",
-    "upload-bundle-s3": "scripts/upload.js",
+    "upload-bundle-s3": "ts-node-transpile-only scripts/upload.js",
     "prepare-version": "rm -rf ./deploy && mkdir -p deploy && gulp prepare-version-on-prem",
     "make-onprem-deps": "cp ../../yarn.lock deploy && cd deploy && yarn install --production && bundle-deps",
     "pack-onprem": "yarn prepare-version && yarn make-onprem-deps && cd deploy && npm pack && zip -r testim-cli.zip testim-cli-*.tgz",

package/player/stepActions/RefreshStepAction.js

@@ -6,10 +6,8 @@ require('bluebird');
 class RefreshStepAction extends StepAction {
     execute() {
         return this.driver.reloadTab()
-            .return({ success: true })
-            .catch(error => {
-                return { success: false, reason: error.message };
-            });
+            .then(() => ({ success: true }))
+            .catch(error => ({ success: false, reason: error.message }));
     }
 }
 

package/player/stepActions/evaluateExpressionStepAction.js

@@ -1,14 +1,15 @@
-"use strict";
+'use strict';
+
 const Promise = require('bluebird');
 const sessionPlayer = require('../../commons/getSessionPlayerRequire');
 const StepAction = require('./stepAction');
+
 const constants = sessionPlayer.commonConstants.stepResult;
 const { stepParamBuilder } = sessionPlayer;
 const logger = require('../../commons/logger').getLogger('evaluate-expression-step-action');
 const _ = require('lodash');
 
 class EvaluateExpressionStepAction extends StepAction {
-
     execute() {
         const step = this.step;
         const context = this.context;
@@ -25,8 +26,8 @@ class EvaluateExpressionStepAction extends StepAction {
 
                 const params = ['context', ...incomingParams.as.functionParameters];
                 const args = [context, ...incomingParams.as.functionArguments];
-                const expressionToEvaluate = step.subType === "text" ? "'" + step.expression.replace(/'/g, "\\\'") + "'" : step.expression;
-                const code = ("return " + expressionToEvaluate).replace(/\n/g, "\\n");
+                const expressionToEvaluate = step.subType === 'text' ? `'${step.expression.replace(/'/g, "\\\'")}'` : step.expression;
+                const code = (`return ${expressionToEvaluate}`).replace(/\n/g, '\\n');
                 const textEvaluateFunction = Function.apply(Function, params.concat([code]));
                 const evaluatedText = textEvaluateFunction.apply(null, args);
 
@@ -38,8 +39,8 @@ class EvaluateExpressionStepAction extends StepAction {
 
                 const result = {
                     success: true,
-                    evaluatedText: evaluatedText,
-                    data: context.data
+                    evaluatedText,
+                    data: context.data,
                 };
 
                 resolve(result);
@@ -48,7 +49,6 @@ class EvaluateExpressionStepAction extends StepAction {
             }
         });
     }
-
 }
 
 module.exports = EvaluateExpressionStepAction;

package/player/stepActions/inputFileStepAction.js

@@ -86,18 +86,22 @@ class InputFileStepAction extends StepAction {
         const target = this.context.data[this.step.targetId || 'targetId'];
         const overrideAzureStorageUrl = featureFlagService.flags.overrideAzureStorageUrl.isEnabled();
         const useJsInputCodeInSafari = featureFlagService.flags.useJsInputCodeInSafari.isEnabled();
+        const useJsInputCodeInFirefox = featureFlagService.flags.useJsInputCodeInFirefox.isEnabled();
         const downloadToBase64 = featureFlagService.flags.downloadToBase64.isEnabled();
 
         let fileUrls = await utils.addTokenToFileUrl(this.context.project.id, this.step.fileUrls, this.stepActionUtils.testimServicesApi, overrideAzureStorageUrl, logger);
 
+
+        const isSafariJsInputCode = this.driver.isSafari() && (useJsInputCodeInSafari || fileUrls.length > 1);
+        const isFirefoxJsInputCode = this.driver.isFirefox() && (useJsInputCodeInFirefox || fileUrls.length > 1);
+
         if (downloadToBase64) {
             fileUrls = await Promise.all(fileUrls.map(async ({ name, url }) => {
                 const res = await download(url);
                 return { name, url: `data:${res.type};base64,${Buffer.from(res.body).toString('base64')}` };
             }));
         }
-
-        if (this.driver.isSafari() && (useJsInputCodeInSafari || fileUrls.length > 1)) {
+        if (isSafariJsInputCode || isFirefoxJsInputCode) {
             await this.driver.executeJSWithArray(`
                 const getLocatedElement = ${codeSnippets.getLocatedElementCode};
                 const downloadAndUploadFile = ${downloadAndUpload()};

package/player/stepActions/scripts/doClick.js

@@ -1,4 +1,6 @@
-"use strict";
+/* globals getLocatedElement, dispatchFocus */
+
+'use strict';
 
 var doClick = function (eventData, done) {
     var eventConstructorSupported = typeof Event === 'function';

package/player/stepActions/scripts/html5dragAction.js

@@ -1,4 +1,6 @@
-"use strict";
+/* global getLocatedElement */
+
+'use strict';
 
 var html5dndAction = function(eventData) {
     var data = {};

package/player/stepActions/scripts/html5dragActionV2.js

@@ -1,4 +1,6 @@
-"use strict";
+/* global getLocatedElement */
+
+'use strict';
 
 var html5dndAction = function (eventData, done) {
     var mouseEventConstructorSupported = typeof MouseEvent === 'function';

package/player/stepActions/scripts/runCode.js

@@ -3,23 +3,40 @@
 'use strict';
 
 const runCode = function (eventData, preCompiledCode) {
+    typeof Object.tstassign !== 'function' && (Object.tstassign = function (n, t) {
+        'use strict';
 
-    "function"!=typeof Object.tstassign&&(Object.tstassign=function(n,t){"use strict";if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var r=Object(n),e=1;e<arguments.length;e++){var o=arguments[e];if(null!=o)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(r[a]=o[a])}return r});
-    Object.assign = typeof Object.assign !== "function" ? Object.tstassign : Object.assign;
+        if (n == null) throw new TypeError('Cannot convert undefined or null to object'); for (var r = Object(n), e = 1; e < arguments.length; e++) { var o = arguments[e]; if (o != null) for (var a in o)Object.prototype.hasOwnProperty.call(o, a) && (r[a] = o[a]); } return r;
+    });
+    Object.assign = typeof Object.assign !== 'function' ? Object.tstassign : Object.assign;
 
     function appendToStorage(name, data) {
         const sessionItem = 'data-testim-' + name;
+
+        const nativeFuncErrMsg = 'Native sessionStorage is not available';
+        function isNativeFunction(fn) {
+            if (!fn || !fn.toString) {
+                return false;
+            }
+            return fn.toString().indexOf('[native code]') > -1;
+        }
         try {
+            if (![window.sessionStorage.setItem, window.sessionStorage.getItem].every(isNativeFunction)) {
+                throw new Error(nativeFuncErrMsg);
+            }
             const oldData = JSON.parse(window.sessionStorage.getItem(sessionItem) || '{}');
             const newData = Object.tstassign({}, oldData, data);
             window.sessionStorage.setItem(sessionItem, JSON.stringify(newData));
         } catch (err) {
-            // any vernation QuotaExceededError from browsers
+            // any variation QuotaExceededError from browsers
             const isQuotaExceededError = err.message.toLowerCase().indexOf('quota') > -1;
+            const isNativeFunctionError = err.message === nativeFuncErrMsg;
+
             if (err.message.indexOf('sessionStorage') > -1 || // Chrome + Firefox
                 err.message.indexOf('The operation is insecure') > -1 || // Safari
                 err.message.indexOf('SecurityError') > -1 || // Edge
-                isQuotaExceededError
+                isQuotaExceededError ||
+                isNativeFunctionError
             ) {
                 var storage = document.head.querySelector('#testim-storage-backup');
                 if (!storage) {
@@ -30,13 +47,13 @@ const runCode = function (eventData, preCompiledCode) {
                 const oldData = JSON.parse(storage.getAttribute(sessionItem) || '{}');
                 const newData = Object.tstassign({}, oldData, data);
                 storage.setAttribute(sessionItem, JSON.stringify(newData));
-                if (isQuotaExceededError) {
+                if (isQuotaExceededError || isNativeFunctionError) {
                     try {
                         window.sessionStorage.removeItem(sessionItem);
                     } catch (e) {
                         // Prevents future retries from looking in sessionStorage with old data
                     }
-                    window.TSTA.useFallbackStorage = true;
+                    (window.TSTA = window.TSTA || {}).useFallbackStorage = true;
                 }
                 return;
             }

package/player/stepActions/scripts/scroll.js

@@ -1,9 +1,4 @@
-// Disabling the eslint to keep this in a format which works on IE 11.
-/* eslint-disable no-var */
-/* eslint-disable no-redeclare */
-/* eslint-disable object-shorthand */
-/* eslint-disable one-var */
-/* eslint-disable operator-linebreak */
+/* globals getLocatedElement, elementScrollTo */
 
 'use strict';
 

package/player/stepActions/scripts/setText.js

@@ -1,4 +1,7 @@
-"use strict";
+/* globals getLocatedElement, dispatchFocus */
+
+'use strict';
+
 /*global KeyboardEvent */
 var setText = function (eventData, done) {
     var eventConstructorSupported = typeof Event === 'function';

package/player/utils/screenshotUtils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const Promise = require('bluebird');
-const utils = require('../../utils');
+const pRetry = require('p-retry');
 
 class ScreenshotUtils {
     constructor(tabId, driver, options = { takeScreenshots: true }) {
@@ -29,7 +29,7 @@ class ScreenshotUtils {
         const SCREENSHOT_RETRY_DELAY = 2000;
         const devicePixelRatioPromise = this.currentDevicePixelRatio ? Promise.resolve(this.currentDevicePixelRatio) : this.getDevicePixelRatio();
         const getScreenshot = () => Promise.all([devicePixelRatioPromise, this.driver.takeScreenshot()]);
-        return utils.runWithRetries(getScreenshot, MAX_RETRY_COUNT, SCREENSHOT_RETRY_DELAY)
+        return pRetry(getScreenshot, { retries: MAX_RETRY_COUNT, minTimeout: SCREENSHOT_RETRY_DELAY })
             .then(([devicePixelRatio, image]) => {
                 const base64 = image ? image.value : '';
                 const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;

package/player/utils/windowUtils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const Promise = require('bluebird');
-const utils = require('../../utils');
+const pRetry = require('p-retry');
 const { PageNotAvailableError } = require('../../errors');
 const logger = require('../../commons/logger').getLogger('window-utils');
 
@@ -152,12 +152,12 @@ WindowUtils.prototype.quit = function () {
 };
 
 WindowUtils.prototype.getOsAndBrowser = function () {
-    return utils.runWithRetries(() => this.driver.getBrowserAndOS())
+    return pRetry(() => this.driver.getBrowserAndOS(), { retries: 3 })
         .then(osAndBrowser => ({ uaBrowserName: osAndBrowser.browser, uaOs: osAndBrowser.os, userAgent: osAndBrowser.userAgent, browserVersion: osAndBrowser.browserVersion }));
 };
 
 WindowUtils.prototype.getUserAgentInfo = function () {
-    return utils.runWithRetries(() => this.driver.getUserAgentInfo());
+    return pRetry(() => this.driver.getUserAgentInfo(), { retries: 3 });
 };
 
 module.exports = WindowUtils;

package/services/lambdatestService.js

@@ -1,6 +1,6 @@
 const os = require('os');
 const childProcess = require('child_process');
-const Promise = require('bluebird');
+const pRetry = require('p-retry');
 const fse = require('fs-extra');
 const portfinder = require('portfinder');
 const ms = require('ms');
@@ -154,7 +154,7 @@ class LambdatestService {
 
         // verify that LT tunnel strated successfully
         try {
-            const ltInfo = await utils.runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
+            const ltInfo = await pRetry(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), { retries: 30, minTimeout: 2000 });
             logger.info('LT tunnel info', ltInfo);
         } catch (err) {
             logger.error('Failed to start LT tunnel', { err, stdoutResult, stderrResult });

package/services/lambdatestService.test.js

@@ -4,6 +4,7 @@ const httpRequest = require('../commons/httpRequest');
 const LambdatestService = require('./lambdatestService');
 const utils = require('../utils');
 const fse = require('fs-extra');
+const { AbortError } = require('p-retry');
 const os = require('os');
 const childProcess = require('child_process');
 const EventEmitter = require('events');
@@ -312,7 +313,7 @@ describe('LambdatestService', () => {
             sinon.assert.calledOnce(httpGetStub);
         });
         it('should throw when tunnel did not start', async () => {
-            sandbox.stub(utils, 'runWithRetries').rejects(new Error('tunnel did not start'));
+            httpGetStub.rejects(new AbortError('tunnel did not start'));
             await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'tunnel did not start');
             processMock.stdout.emit('data', '');
             processMock.stderr.emit('data', '');

package/testRunHandler.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const pRetry = require('p-retry');
 const _ = require('lodash');
 const testimCustomToken = require('./commons/testimCustomToken');
 const remoteStepService = require('./commons/socket/remoteStepService');
@@ -312,12 +313,12 @@ class TestRun {
             const { sessionId: extensionSessionId } = extensionSession || {};
             perf.log('before Runtime.evaluate');
 
-            await utils.runWithRetries(async () => {
+            await pRetry(async () => {
                 const { result } = await cdpTestRunner.cdpCommand('Runtime.evaluate', { expression: 'typeof runTestimTest !== \'undefined\'', returnByValue: true }, extensionSessionId);
                 if (!result.value) {
                     throw new Error('runTestimTest not available on global scope');
                 }
-            }, 100, 30);
+            }, { retries: 100, minTimeout: 30 });
 
             perf.log('after wait for runTestimTest function');
             const { result } = await cdpTestRunner.cdpCommand(

package/testRunStatus.js

@@ -17,7 +17,6 @@ const { calculateCoverage } = require('./coverage/jsCoverage');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
 const featureFlags = require('./commons/featureFlags');
 const { mapFilesToLocalDrive } = require('./services/localRCASaver');
-const { removeHiddenParamsInTestData } = require('./commons/testimServicesApi');
 
 const gitBranch = utils.getEnvironmentGitBranch();
 const gitCommit = process.env.GIT_COMMIT || process.env.CIRCLE_SHA1 || process.env.TRAVIS_COMMIT;
@@ -125,13 +124,6 @@ RunStatus.prototype.addRetryTestResult = async function ({
 
     this.testRunStatus[newResultId] = newTestResult;
 
-    const { projectData } = this.options;
-
-
-    if (newTestResult.config.testData) {
-        newTestResult.config.testData = removeHiddenParamsInTestData(newTestResult.config.testData, projectData.defaults);
-    }
-
     return servicesApi.addTestRetry({
         projectId,
         runId: executionId,
@@ -450,7 +442,8 @@ RunStatus.prototype.executionStart = function (executionId, projectId, startTime
                     logger.error('Failed to start suite', { err });
                     // eslint-disable-next-line no-console
                     console.error('Failed to start test run. Please contact support@testim.io');
-                }).return({ beforeTests, tests, afterTests });
+                })
+                .then(() => ({ beforeTests, tests, afterTests }));
         });
 };
 

package/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const moment = require('moment');
-const retry = require('bluebird-retry');
+const pRetry = require('p-retry');
 const _ = require('lodash');
 const Promise = require('bluebird');
 const fs = Promise.promisifyAll(require('fs'));
@@ -71,20 +71,16 @@ function getRunConfigByBrowserName(browser, saucelabs, browserstack) {
     return _.merge(selectedBrowser, selectedOS);
 }
 
-function handleAngularURIComponent(part) {
-    return part.replace(/(~|\/)/g, m => ({ '~': '~~', '/': '~2F' }[m]));
-}
-
 function getTestUrl(editorUrl, projectId, testId, resultId, branch) {
     let testUrl = '';
-    branch = branch ? handleAngularURIComponent(branch) : 'master';
+    branch = branch ? encodeURIComponent(branch) : 'master';
     if (projectId && testId) {
         testUrl = `${editorUrl}/#/project/${projectId}/branch/${branch}/test/${testId}`;
         if (resultId) {
             testUrl += `?result-id=${resultId}`;
         }
     }
-    return encodeURI(testUrl);
+    return testUrl;
 }
 
 function isPromise(obj) {
@@ -100,17 +96,6 @@ function getDurationSec(ms) {
     return moment.duration(ms).asSeconds();
 }
 
-function runWithRetries(task, times, interval, predicate) {
-    times = times || 3;
-    interval = interval || 3000;
-
-    const opt = { max_tries: times, interval, throw_original: true };
-    if (predicate) {
-        opt.predicate = predicate;
-    }
-    return retry(task, opt);
-}
-
 function getRunnerVersion() {
     try {
         const pack = require(`${__dirname}/package.json`);
@@ -247,7 +232,7 @@ function isURL(path) {
 }
 
 const DOWNLOAD_RETRY = 3;
-const download = async (url) => runWithRetries(() => httpRequest.download(url), DOWNLOAD_RETRY);
+const download = async (url) => pRetry(() => httpRequest.download(url), { retries: DOWNLOAD_RETRY });
 
 const downloadAndSave = async (url, saveToLocation) => {
     const res = await download(url);
@@ -315,6 +300,16 @@ function getPlanType(plan) {
     return 'free';
 }
 
+/**
+ * @param time {number} in ms
+ * @returns {Promise}
+ */
+ function delay(time) {
+    return new Promise(((resolve) => {
+        setTimeout(resolve, time);
+    }));
+}
+
 const calcPercentile = (arr, percentile) => {
     if (arr.length === 0) return 0;
     if (typeof percentile !== 'number') throw new TypeError('p must be a number');
@@ -366,7 +361,6 @@ module.exports = {
     getTestUrl,
     getDuration,
     getDurationSec,
-    runWithRetries,
     getRunnerVersion,
     getEnginesVersion,
     getEnginesVersionAsync,
@@ -395,4 +389,5 @@ module.exports = {
     isQuarantineAndNotRemoteRun,
     groupTestsByRetries,
     getPlanType,
+    delay,
 };

package/utils.test.js

@@ -32,7 +32,7 @@ describe('utils', () => {
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'normal-branch-name'))
                 .to.equal('http://localhost:8080/#/project/project/branch/normal-branch-name/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch/with/slashes'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch~2Fwith~2Fslashes/test/test?result-id=result');
+                .to.equal('http://localhost:8080/#/project/project/branch/branch%2Fwith%2Fslashes/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch with spaces'))
                 .to.equal('http://localhost:8080/#/project/project/branch/branch%20with%20spaces/test/test?result-id=result');
             expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'encoded%20branch'))

package/workers/BaseWorker.js

@@ -2,6 +2,7 @@
 
 const Bluebird = require('bluebird');
 const moment = require('moment');
+const pRetry = require('p-retry');
 const ms = require('ms');
 
 const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus } = require('../commons/constants');
@@ -116,7 +117,8 @@ class BaseWorker {
         try {
             perf.log('before getSlotOnce retries');
             let failedGetSlotAttempts = 0;
-            let gridInfo = await utils.runWithRetries(async () => {
+
+            let gridInfo = await pRetry(async () => {
                 const startTime = Date.now();
                 try {
                     return await Bluebird.resolve(this.getSlotOnce(testRunHandler))
@@ -124,10 +126,10 @@ class BaseWorker {
                 } catch (error) {
                     logger.error('error getting grid slot', { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId });
                     failedGetSlotAttempts++;
-                    await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                    await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     throw error;
                 }
-            }, this.options.getBrowserRetries);
+            }, { retries: this.options.getBrowserRetries - 1, minTimeout: 0 });
             perf.log('after getSlotOnce retries');
 
             perf.log('before getBrowserOnce retries');
@@ -136,7 +138,7 @@ class BaseWorker {
                 throw new Error('No free browser slots in desired grid');
             }
             let failedGetBrowserAttempts = 0;
-            testPlayer = await utils.runWithRetries(async () => {
+            testPlayer = await pRetry(async () => {
                 const startTime = Date.now();
                 const player = this.initPlayer(testRunHandler);
                 try {
@@ -162,11 +164,11 @@ class BaseWorker {
                     player.onDone();
 
                     if (!(error instanceof PageNotAvailableError)) {
-                        await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                        await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     }
                     throw error;
                 }
-            }, getBrowserRetriesNumber, undefined, (err) => !(err instanceof PageNotAvailableError));
+            }, { retries: getBrowserRetriesNumber - 1, minTimeout: 0 });
             perf.log('after getBrowserOnce retries');
         } catch (err) {
             await releasePlayer(this.id, this.releaseSlotOnTestFinished, projectId, testPlayer);
@@ -235,7 +237,7 @@ class BaseWorker {
                 testResult.testRetryKey = testRetryKey;
                 await this.onTestCompleted(this.id, this.testId, testResult, sessionId, shouldRerun);
                 if (this.executionQueue.hasMoreTests() && !(this.options.lightweightMode && this.options.lightweightMode.general)) {
-                    await Bluebird.delay(DELAY_BETWEEN_TESTS);
+                    await utils.delay(DELAY_BETWEEN_TESTS);
                 }
                 await this.runTestCleanup();
                 if (shouldRerun) {

package/workers/BaseWorker.test.js

@@ -3,10 +3,9 @@ const proxyquire = require('proxyquire');
 const { expect, sinon } = require('../../test/utils/testUtils');
 const gridService = require('../services/gridService');
 const reporter = require('../reports/reporter');
-const Bluebird = require('bluebird');
 const { PageNotAvailableError, GridError, GetBrowserError } = require('../errors');
 const servicesApi = require('../commons/testimServicesApi');
-const { releasePlayer } = require('./workerUtils');
+const utils = require('../utils');
 
 
 describe('BaseWorker', () => {
@@ -41,7 +40,7 @@ describe('BaseWorker', () => {
         getGridSlotStub = sinon.stub(gridService, 'getGridSlot').resolves({});
 
 
-        sandbox.stub(Bluebird, 'delay').returns(Promise.resolve());
+        sandbox.stub(utils, 'delay').returns(Promise.resolve());
         sandbox.stub(reporter);
     });
 
@@ -57,7 +56,7 @@ describe('BaseWorker', () => {
             it('should get grid slot from server', async () => {
                 await worker.getTestPlayer(testRunHandlerMock);
                 sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should retry getting slot until it succeeds', async () => {
                 getGridSlotStub.onFirstCall().rejects();
@@ -65,7 +64,7 @@ describe('BaseWorker', () => {
 
                 await worker.getTestPlayer(testRunHandlerMock);
                 sinon.assert.calledTwice(getGridSlotStub);
-                sinon.assert.calledTwice(Bluebird.delay);
+                sinon.assert.calledOnce(utils.delay);
             });
             it('should not proceed to getting browser if all retries used for getting a slot', async () => {
                 getGridSlotStub.resolves({});
@@ -74,7 +73,7 @@ describe('BaseWorker', () => {
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.notCalled(worker.getBrowserOnce);
                 sinon.assert.notCalled(worker.initPlayer);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
         });
 
@@ -84,7 +83,7 @@ describe('BaseWorker', () => {
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.calledOnce(worker.getBrowserOnce);
                 sinon.assert.calledOnce(worker.initPlayer);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should retry getting browser until it succeeds', async () => {
                 worker.getBrowserOnce.onFirstCall().rejects();
@@ -95,16 +94,16 @@ describe('BaseWorker', () => {
                 sinon.assert.calledTwice(worker.getBrowserOnce);
                 sinon.assert.calledTwice(worker.initPlayer);
                 sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.calledTwice(Bluebird.delay);
+                sinon.assert.calledOnce(utils.delay);
             });
             it('should not retry if page is not available', async () => {
                 worker.getBrowserOnce.throws(() => new PageNotAvailableError());
 
-                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(PageNotAvailableError);
+                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(Error);
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.calledOnce(worker.getBrowserOnce);
                 sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should handle get grid error', async () => {
                 worker.getBrowserOnce.throws(() => new GridError());
@@ -153,8 +152,8 @@ describe('BaseWorker', () => {
                 getHybridGridProviderStub.onFirstCall().resolves({ provider: 'loacker', connectionDetails: { host: 'localhost', external: { user: 'user', key: 'password' } } });
                 getHybridGridProviderStub.onSecondCall().resolves({ provider: 'nitzan', connectionDetails: { host: 'google.com', port: 443 } });
                 getHybridGridProviderStub.onThirdCall().resolves({ provider: 'a', connectionDetails: { host: 'google.com', port: 4444 } });
-                worker.getBrowserOnce.onFirstCall().rejects();
-                worker.getBrowserOnce.onSecondCall().rejects();
+                worker.getBrowserOnce.onFirstCall().rejects(new Error());
+                worker.getBrowserOnce.onSecondCall().rejects(new Error());
                 worker.getBrowserOnce.onThirdCall().resolves({});
 
                 await worker.getTestPlayer(testRunHandlerMock);