@testim/testim-cli 3.193.0 → 3.197.0

package/services/gridService.test.js

@@ -175,19 +175,19 @@ describe('gridService', () => {
 
     describe('getGridSlot', () => {
         let getGridByIdStub;
-        let getGridByProjectStub;
+        let getGridByNameStub;
         let onGridSlot;
         let addItemToGridCacheStub;
 
         beforeEach(() => {
             getGridByIdStub = sinon.stub(servicesApi, 'getGridById').resolves({ grid: { gridId: 'gridId', type: 'gridId' }, status: 'success' });
-            getGridByProjectStub = sinon.stub(servicesApi, 'getGridByProject').resolves({ grid: { gridId: 'gridId', type: 'gridName' }, status: 'success' });
+            getGridByNameStub = sinon.stub(servicesApi, 'getGridByName').resolves({ grid: { gridId: 'gridId', type: 'gridName' }, status: 'success' });
             addItemToGridCacheStub = sinon.stub(gridService, 'addItemToGridCache').callThrough();
             onGridSlot = sinon.stub().resolves();
         });
         afterEach(() => {
             getGridByIdStub.restore();
-            getGridByProjectStub.restore();
+            getGridByNameStub.restore();
             addItemToGridCacheStub.restore();
         });
 
@@ -195,7 +195,7 @@ describe('gridService', () => {
             const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useLocalChromeDriver: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByProjectStub);
+            sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
             sinon.assert.calledOnce(onGridSlot);
         });
@@ -204,7 +204,7 @@ describe('gridService', () => {
             const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useChromeLauncher: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByProjectStub);
+            sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
             sinon.assert.calledOnce(onGridSlot);
         });
@@ -213,7 +213,7 @@ describe('gridService', () => {
             const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { host: 'localhost', port: 4444 }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'hostAndPort', host: 'localhost', port: 4444 });
             sinon.assert.notCalled(getGridByIdStub);
-            sinon.assert.notCalled(getGridByProjectStub);
+            sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
             sinon.assert.calledOnce(onGridSlot);
         });
@@ -222,7 +222,7 @@ describe('gridService', () => {
             const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
             sinon.assert.calledOnce(getGridByIdStub);
-            sinon.assert.notCalled(getGridByProjectStub);
+            sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
             sinon.assert.calledOnce(onGridSlot);
         });
@@ -230,7 +230,7 @@ describe('gridService', () => {
         it('should get grid from server when passing grid name', async () => {
             const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { grid: 'gridName' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridName', gridId: 'gridId' });
-            sinon.assert.calledOnce(getGridByProjectStub);
+            sinon.assert.calledOnce(getGridByNameStub);
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
             sinon.assert.calledOnce(onGridSlot);
@@ -282,9 +282,9 @@ describe('gridService', () => {
         });
 
         it('should call releaseGridSlot with the correct parameters', async () => {
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
             await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.calledWith(releaseGridSlotStub, 'projectId', 'slotId', 'gridId', 'chrome');
+            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
         });
 
         it('should not call releaseGridSlot if the workerId is not in the cache', async () => {
@@ -293,16 +293,16 @@ describe('gridService', () => {
         });
 
         it('should not call releaseGridSlot if no slotId', async () => {
-            gridService.addItemToGridCache('workerId', 'gridId');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId');
             await gridService.releaseGridSlot('workerId', 'projectId');
             sinon.assert.notCalled(releaseGridSlotStub);
         });
 
         it('should handle releaseGridSlot request error', async () => {
             releaseGridSlotStub.rejects({ });
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
             await gridService.releaseGridSlot('workerId', 'projectId');
-            sinon.assert.calledWith(releaseGridSlotStub, 'projectId', 'slotId', 'gridId', 'chrome');
+            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
         });
     });
 
@@ -322,15 +322,15 @@ describe('gridService', () => {
         });
 
         it('should send keepAlive to server on an interval', async () => {
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
             await gridService.keepAlive.start('projectId');
             clock.tick(10010);
-            sinon.assert.calledOnceWithExactly(keepAliveStub, 'projectId', [{ gridId: 'gridId', slotId: 'slotId', browser: 'chrome' }]);
+            sinon.assert.calledOnceWithExactly(keepAliveStub, 'projectId', [{ gridId: 'gridId', companyId: 'companyId', slotId: 'slotId', browser: 'chrome' }]);
             await gridService.releaseGridSlot('workerId', 'projectId');
         });
 
         it('should send keepAlive to server every 10 seconds', async () => {
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
             await gridService.keepAlive.start('projectId');
             clock.tick(30010);
             sinon.assert.calledThrice(keepAliveStub);
@@ -345,7 +345,7 @@ describe('gridService', () => {
 
         it('should handle keepAlive request error', async () => {
             keepAliveStub.rejects({ });
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
             await gridService.keepAlive.start('projectId');
             clock.tick(10010);
             sinon.assert.calledOnce(keepAliveStub);
@@ -353,13 +353,13 @@ describe('gridService', () => {
         });
 
         it('should release all slots when ending', async () => {
-            gridService.addItemToGridCache('workerId', 'gridId', 'slotId', 'chrome');
-            gridService.addItemToGridCache('workerId1', 'gridId', 'slotId1', 'firefox');
+            gridService.addItemToGridCache('workerId', 'companyId', 'gridId', 'slotId', 'chrome');
+            gridService.addItemToGridCache('workerId1', 'companyId', 'gridId', 'slotId1', 'firefox');
             await gridService.keepAlive.start('projectId');
             await gridService.keepAlive.end('projectId');
             sinon.assert.calledTwice(releaseGridSlotStub);
-            sinon.assert.calledWith(releaseGridSlotStub, 'projectId', 'slotId', 'gridId', 'chrome');
-            sinon.assert.calledWith(releaseGridSlotStub, 'projectId', 'slotId1', 'gridId', 'firefox');
+            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId', 'gridId', 'chrome');
+            sinon.assert.calledWith(releaseGridSlotStub, 'companyId', 'projectId', 'slotId1', 'gridId', 'firefox');
         });
 
         it('should not release slots if there is no slots in use', async () => {

package/services/lambdatestService.js

@@ -16,7 +16,7 @@ const { getExtensionsUrl } = require('../runOptionsUtils');
 
 const logger = require('../commons/logger').getLogger('lambdatestService');
 
-const LT_TUNNEL_BINARY_ORIGIN = 'https://downloads.lambdatest.com/tunnel/alpha';
+const LT_TUNNEL_BINARY_ORIGIN = 'https://downloads.lambdatest.com/tunnel/v3';
 const LT_TUNNEL_BINARY_PATHNAME = {
     win32ia32: 'windows/32bit/LT_Windows.zip',
     win32x64: 'windows/64bit/LT_Windows.zip',

package/testRunHandler.js

@@ -241,7 +241,7 @@ TestRun.prototype.clearTestResult = function () {
             // make sure the execution is created by now
             await this._testRunStatus.waitForExecutionStartedFinished();
             // we probably can save this backend call by initializing the execution
-            return testResultService.clearTestResult(this._options.project, this._testResultId, this._testId, {
+            return testimServicesApi.clearTestResult(this._options.project, this._testResultId, this._testId, {
                 name: this._testName,
                 resultId: this._testResultId,
                 status: 'pending',

package/testRunStatus.js

@@ -47,7 +47,7 @@ const RunStatus = function (testInfoList, options, testPlanId, branchToUse) {
     this.executionStartedPromise = Promise.resolve();
 
     const browserNames = utils.getUniqBrowsers(options, testInfoList);
-    const runnerMode = options.lightweightMode ? options.lightweightMode.type : options.mode; 
+    const runnerMode = options.lightweightMode ? options.lightweightMode.type : options.mode;
     this.execConfig = {
         parallel: TESTIM_CONCURRENT_WORKER_COUNT || options.parallel || 1,
         browser: browserNames,
@@ -167,14 +167,14 @@ RunStatus.prototype.updateTestStatusRunning = function (test, executionId, testR
             delete testConfig.testData;
             testConfig.testDataUrl = testDataUrl;
             await this.executionStartedPromise;
-            return servicesApi.updateTestStatus('RUNNING', executionId, test.testId, test.resultId, test.startTime, null, null, null, testConfig, projectId, remoteRunId, testRetryKey);
+            return servicesApi.updateTestStatus(projectId, executionId, test.testId, test.resultId, 'RUNNING', { startTime: test.startTime, config: testConfig, remoteRunId, testRetryKey });
         });
     if (this.asyncReporting) {
         // silence is golden
     } else {
         return res;
     }
-    return this.executionStartedPromise.then(() => servicesApi.updateTestStatus('RUNNING', executionId, test.testId, test.resultId, test.startTime, null, null, null, test.config, projectId, remoteRunId, testRetryKey));
+    return servicesApi.updateTestStatus(projectId, executionId, test.testId, test.resultId, 'RUNNING', { startTime: test.startTime, config: test.config, remoteRunId, testRetryKey });
 };
 
 RunStatus.prototype.testStartReport = function (test, executionId, testRetryKey) {
@@ -201,9 +201,6 @@ RunStatus.prototype.onGridSlot = function (executionId, resultId, gridInfo) {
     const test = this.getTestResult(resultId);
     test.config.gridInfo = Object.assign({}, gridInfo, { key: undefined, user: undefined });
     logger.info('on get grid info', { gridInfo: test.config.gridInfo });
-    // we don't wait for this call since it's only for analytics/debugging sake.
-    const p = this.updateTestStatusRunning(test, executionId);
-    p.catch(() => {}); // suppress unhandled rejection
 };
 
 RunStatus.prototype.reportTestStatus = function (workerId, result, test, isRerun) {
@@ -277,24 +274,37 @@ RunStatus.prototype.testEnd = function (wid, result, executionId, sessionId, isR
     return test;
 };
 
-RunStatus.prototype.testEndReport = function (test, executionId, result) {
+RunStatus.prototype.testEndReport = async function (test, executionId, result, testResultUpdates) {
     const globalParameters = result.exportsGlobal;
-    return runHook(this.options.afterTest, Object.assign({}, test, { globalParameters }))
-        .then(() => {
-            if (this.options.lightweightMode && this.options.lightweightMode.onlyTestIdsNoSuite) {
-                return undefined;
-            }
-            return servicesApi.updateTestStatus('FINISHED', executionId, test.testId, test.resultId, test.startTime, result.endTime, test.success, test.failureReason, null, this.options.project, this.options.remoteRunId);
-        })
-        .catch(err => {
-            logger.error('Failed to update test finished', { err });
-            throw err;
-        });
+    try {
+        try {
+            await runHook(this.options.afterTest, Object.assign({}, test, { globalParameters }));
+        } catch (err) {
+            logger.error('HOOK threw an error', { test: test.testId, err });
+            // eslint-disable-next-line no-console
+            console.error('HOOK threw an error', err); // show the customer that his hook failed.
+        }
+        if (this.options.lightweightMode && this.options.lightweightMode.onlyTestIdsNoSuite) {
+            return undefined;
+        }
+
+        return await servicesApi.updateTestStatus(this.options.project, executionId, test.testId, test.resultId, 'FINISHED', {
+            startTime: test.startTime,
+            endTime: result.endTime,
+            success: test.success,
+            failureReason: test.failureReason,
+            remoteRunId: this.options.remoteRunId,
+            ...testResultUpdates,
+        }, 5);
+    } catch (err) {
+        logger.error('Failed to update test finished', { err });
+        throw err;
+    }
 };
 
-RunStatus.prototype.testEndAndReport = function (wid, result, executionId, sessionId, isRerun) {
+RunStatus.prototype.testEndAndReport = function (wid, result, executionId, sessionId, isRerun, testResultUpdates) {
     const test = this.testEnd(wid, result, executionId, sessionId, isRerun);
-    return this.testEndReport(test, executionId, result);
+    return this.testEndReport(test, executionId, result, testResultUpdates);
 };
 
 RunStatus.prototype.calcTestRunStatus = function () {

package/utils.js

@@ -19,7 +19,7 @@ const OSS = [
     { osName: 'Windows 7', bs: { os: 'WINDOWS', os_version: '7' }, sl: { platform: 'Windows 7' } },
     { osName: 'Windows XP', bs: { os: 'WINDOWS', os_version: 'XP' }, sl: { platform: 'Windows XP' } },
     { osName: 'macOS Big Sur', bs: { os: 'OS X', os_version: 'Big Sur', safari_version: '14' }, sl: { platform: 'macOS 11', safari_version: '14' } },
-    { osName: 'macOS Catalina',bs: { os: 'OS X', os_version: 'Catalina', safari_version: '13' }, sl: { platform: 'macOS 10.15', safari_version: '13' } },
+    { osName: 'macOS Catalina', bs: { os: 'OS X', os_version: 'Catalina', safari_version: '13' }, sl: { platform: 'macOS 10.15', safari_version: '13' } },
     { osName: 'macOS Mojave', bs: { os: 'OS X', os_version: 'Mojave', safari_version: '12' }, sl: { platform: 'macOS 10.14', safari_version: '12' } },
     { osName: 'macOS High Sierra', bs: { os: 'OS X', os_version: 'High Sierra', safari_version: '11' }, sl: { platform: 'macOS 10.13', safari_version: '11' } },
     { osName: 'macOS Sierra', bs: { os: 'OS X', os_version: 'Sierra', safari_version: '10' }, sl: { platform: 'macOS 10.12', safari_version: '10.0' } },
@@ -35,11 +35,11 @@ const OSS = [
 ];
 
 const BROWSERS = [
-    { browserName: 'Chrome', bs: { browser: 'Chrome', browser_version: '92' }, sl: { browserName: 'chrome', version: '92.0' }, browserValue: 'chrome' },
+    { browserName: 'Chrome', bs: { browser: 'Chrome', browser_version: '94' }, sl: { browserName: 'chrome', version: '94.0' }, browserValue: 'chrome' },
     { browserName: 'Firefox', bs: { browser: 'Firefox', browser_version: '89' }, sl: { browserName: 'firefox', version: '89.0' }, browserValue: 'firefox' },
     { browserName: 'Safari', bs: { browser: 'Safari' }, sl: { browserName: 'safari' }, browserValue: 'safari' },
-    { browserName: 'Edge', bs: { browser: 'Edge', browser_version: '17' }, sl: { browserName: 'MicrosoftEdge', version: '17.17134' }, browserValue: 'edge' },
-    { browserName: 'Edge Chromium', bs: { browser: 'Edge', browser_version: '92' }, sl: { browserName: 'MicrosoftEdge', version: '92' }, synonyms: ['edge-chromium'], browserValue: 'edge-chromium', seleniumName: 'MicrosoftEdge' },
+    { browserName: 'Edge', bs: { browser: 'Edge', browser_version: '18' }, sl: { browserName: 'MicrosoftEdge', version: '18.17763' }, browserValue: 'edge' },
+    { browserName: 'Edge Chromium', bs: { browser: 'Edge', browser_version: '94' }, sl: { browserName: 'MicrosoftEdge', version: '94' }, synonyms: ['edge-chromium'], browserValue: 'edge-chromium', seleniumName: 'MicrosoftEdge' },
     { browserName: 'Internet Explorer 11', bs: { browser: 'IE', browser_version: '11' }, sl: { browserName: 'internet explorer', version: '11.0' }, synonyms: ['ie11'], browserValue: 'ie11' },
     { browserName: 'Browser', bs: {}, sl: { browserName: 'Browser' }, browserValue: 'browser' },
     { browserName: 'Android', bs: { browserName: 'android' }, sl: {}, browserValue: 'android' },
@@ -143,7 +143,7 @@ function getEnvironmentGitBranch() {
 }
 
 function getUniqBrowsers(options, testList) {
-    if ((options.testConfigNames.length || options.testConfigIds.length || options.testPlan.length || options.testPlanIds.length || options.testObject) && !options.browser) {
+    if ((options.testConfigNames.length || options.testConfigIds.length || options.testPlan.length || options.testPlanIds.length) && !options.browser) {
         return _.uniq(testList.map(t => t.runConfig.browserValue));
     }
     return [options.browser.toLowerCase()];

package/workers/BaseWorker.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Promise = require('bluebird');
+const Bluebird = require('bluebird');
 const moment = require('moment');
 const ms = require('ms');
 
@@ -38,12 +38,26 @@ function buildFailureResult(testId, testName, resultId, reason) {
 }
 
 class BaseWorker {
-    constructor(executionQueue, customExtensionLocalLocation) {
+    constructor(executionQueue, options, customExtensionLocalLocation, executionId, onTestStarted, onTestCompleted, onGridSlot, onTestIgnored, releaseSlotOnTestFinished = true) {
         this.lambdatestService = new LambdatestService();
+
         this.id = BaseWorker.getWorkerId();
         this.executionQueue = executionQueue;
         this.customExtensionLocalLocation = customExtensionLocalLocation;
-        this.runTest = Promise.method(this.runTest);
+
+        this.isCodeMode = options.files && options.files.length > 0;
+        this.baseUrl = options.baseUrl;
+        this.isRegressionBaselineRun = options.isRegressionBaselineRun;
+        this.testRunTimeout = options.timeout;
+        this.onTestStarted = onTestStarted;
+        this.onTestCompleted = onTestCompleted;
+        this.onGridSlot = onGridSlot;
+        this.onTestIgnored = onTestIgnored;
+        this.releaseSlotOnTestFinished = releaseSlotOnTestFinished;
+
+        this.userData = options.userData;
+        this.executionId = executionId;
+        this.options = options;
     }
 
     static getWorkerId() {
@@ -69,7 +83,7 @@ class BaseWorker {
         throw new NotImplementedError(true);
     }
 
-    runTestOnce(testRunHandler, player) {
+    async runTestOnce(testRunHandler, player) {
         testRunHandler.setSessionId(player.getSessionId());
         logger.info('Test run started', {
             testId: testRunHandler.getTestId(),
@@ -77,26 +91,9 @@ class BaseWorker {
             seleniumSession: player.getSessionId(),
         });
         if (this.options.lightweightMode && this.options.lightweightMode.disableResults) {
-            return Promise.resolve();
+            return undefined;
         }
-        return testRunHandler.clearTestResult();
-    }
-
-    start(options, onStart, onResult, executionId, onGridSlot, onTestIgnored, releaseSlotOnTestFinished) {
-        this.isCodeMode = options.files.length > 0;
-        this.baseUrl = options.baseUrl;
-        this.isRegressionBaselineRun = options.isRegressionBaselineRun;
-        this.testRunTimeout = options.timeout;
-        this.onStart = onStart;
-        this.onResult = onResult;
-        this.onGridSlot = onGridSlot;
-        this.onTestIgnored = onTestIgnored;
-        this.releaseSlotOnTestFinished = releaseSlotOnTestFinished;
-
-        this.userData = options.userData;
-        this.executionId = executionId;
-        this.options = options;
-        return this.run();
+        return await testRunHandler.clearTestResult();
     }
 
     handleQuarantine(testRunHandler) {
@@ -124,13 +121,12 @@ class BaseWorker {
             let gridInfo = await utils.runWithRetries(async () => {
                 const startTime = Date.now();
                 try {
-                    return await Promise.resolve()
-                        .then(() => this.getSlotOnce(testRunHandler))
+                    return await Bluebird.resolve(this.getSlotOnce(testRunHandler))
                         .timeout(this.options.getBrowserTimeout, timeoutMessages.GET_BROWSER_TIMEOUT_MSG);
                 } catch (error) {
                     logger.error('error getting grid slot', { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId });
                     failedGetSlotAttempts++;
-                    await Promise.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                    await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     throw error;
                 }
             }, this.options.getBrowserRetries);
@@ -154,7 +150,7 @@ class BaseWorker {
                     this.options.gridData.host = gridInfo.host;
                     this.options.gridData.failedGetBrowserAttempts = failedGetBrowserAttempts;
                     const getSessionTimeout = Math.max(this.lambdatestService.getSessionTimeout, this.options.getSessionTimeout);
-                    const getBrowserRes = await Promise.resolve()
+                    const getBrowserRes = await Bluebird.resolve()
                         .log('before getBrowserOnce')
                         .then(() => this.getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo))
                         .log('after getBrowserOnce')
@@ -169,7 +165,7 @@ class BaseWorker {
                     player.onDone();
 
                     if (!(error instanceof PageNotAvailableError)) {
-                        await Promise.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                        await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     }
                     throw error;
                 }
@@ -190,14 +186,15 @@ class BaseWorker {
     }
 
     async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
+        perf.log('inside runTest');
         const projectId = this.userData && this.userData.projectId;
         const quarantineResult = this.handleQuarantine(testRunHandler);
         if (quarantineResult) {
             return quarantineResult;
         }
 
-        perf.log('before runTest onStart');
-        await this.onStart(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
+        perf.log('before runTest onTestStarted');
+        await this.onTestStarted(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
         const testPlayer = await this.getTestPlayer(testRunHandler, customExtensionLocalLocation);
 
         try {
@@ -207,12 +204,12 @@ class BaseWorker {
         }
     }
 
-    runTestCleanup() {
-        return Promise.resolve();
+    async runTestCleanup() {
+        return undefined;
     }
 
     onQueueCompleted() {
-        return Promise.resolve();
+        return undefined;
     }
 
     run() {
@@ -238,9 +235,9 @@ class BaseWorker {
             try {
                 const testRetryKey = testRunHandler.getRetryKey();
                 testResult.testRetryKey = testRetryKey;
-                await this.onResult(this.id, this.testId, testResult, sessionId, shouldRerun);
-                if (!(this.options.lightweightMode && this.options.lightweightMode.general)) {
-                    await Promise.delay(DELAY_BETWEEN_TESTS);
+                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 this.runTestCleanup();
                 if (shouldRerun) {
@@ -340,7 +337,7 @@ class BaseWorker {
 
             const projectId = this.userData && this.userData.projectId;
             const { errorType, reason } = buildError(err);
-            testResultService.updateTestResult(projectId, this.testResultId, this.testId, {
+            testimServicesApi.updateTestResult(projectId, this.testResultId, this.testId, {
                 status: testRunStatus.COMPLETED,
                 success: false,
                 reason,
@@ -390,10 +387,12 @@ class BaseWorker {
             !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),
             !disableResults && testResultService.joinToTestResult(this.testResultId, this.testId),
         ])
-            .log('after join room, before runTest')
             .then(() => this.runTest(testRunHandler, this.customExtensionLocalLocation, shouldRerun))
             .then(testResult => onRunComplete(testResult, testRunHandler))
-            .log('After onRunComplete')
+            .then(result => {
+                perf.log('After onRunComplete');
+                return result;
+            })
             .catch(runError => recoverTestResults(runError, testRunHandler))
             .finally(() => {
                 if (!disableRemoteStep) {

package/workers/BaseWorker.test.js

@@ -15,7 +15,7 @@ describe('BaseWorker', () => {
     let testPlayerMock;
 
     beforeEach(() => {
-        worker = new BaseWorker();
+        worker = new BaseWorker(null, {});
         worker.userData = {};
         worker.options = { gridData: {}, browser: 'chrome', company: { companyId: 'companyId' }, getBrowserTimeout: 1000, getSessionTimeout: 100, getBrowserRetries: 10 };
         worker.testRunConfig = {};

package/workers/WorkerExtensionSingleBrowser.js

@@ -44,9 +44,8 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
             return quarantineResult;
         }
 
-        perf.log('before runTest onStart single browser');
-
-        await this.onStart(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
+        perf.log('before runTest onTestStarted single browser');
+        await this.onTestStarted(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
         const testPlayer = await this.getTestPlayer(testRunHandler, customExtensionLocalLocation);
 
         testRunHandler.markClearBrowser();
@@ -54,6 +53,10 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
     }
 
     async runTestCleanup() {
+        if (!this.executionQueue.hasMoreTests()) {
+            await this.onQueueCompleted();
+            return;
+        }
         if (this.options.lightweightMode && this.options.lightweightMode.general) {
             await Bluebird.delay(DELAY_BETWEEN_TESTS);
         }

package/commons/apkUploader/apkUploader.js

@@ -1,46 +0,0 @@
-const Promise = require('bluebird');
-const utils = require('../../utils');
-const logger = require('../logger').getLogger("apk-uploader");
-const {ArgError} = require('../../errors');
-const reporter = require("../../reports/reporter");
-
-class ApkUploader {
-    constructor() {
-        this._appId = null;
-        this._isInFlightRequest = null;
-    }
-
-    uploadApk(vendorAppId, apkFullPath, apkTimeout, projectId, gridData) {
-        if (this._appId) {
-            return Promise.resolve(this.getAppCaps());
-        }
-        if (this._isInFlightRequest) {
-            return this._isInFlightRequest;
-        }
-
-        this._isInFlightRequest = (vendorAppId
-            ? Promise.resolve(vendorAppId)
-            : utils.runWithRetries(() => this.uploadFile(gridData, apkFullPath, apkTimeout, projectId)))
-            .then(res => {
-                reporter.onUploadApkFinished(res);
-                this._appId = res;
-                return this.getAppCaps();
-            })
-            .catch(err => {
-                logger.error("failed to upload apk", {errStack: err.stack});
-                throw new ArgError(`Failed to upload apk: ${apkFullPath}`);
-            })
-            .finally(() => this._isInFlightRequest = null);
-        return this._isInFlightRequest;
-    }
-
-    uploadFile(key, apkFullPath, apkTimeout) {
-        throw new Error("not implemented");
-    }
-
-    getAppCaps() {
-        throw new Error("not implemented");
-    }
-}
-
-module.exports = ApkUploader;

package/commons/apkUploader/apkUploaderFactory.js

@@ -1,68 +0,0 @@
-const testObjectApkUploader = require('./testObjectApkUploader');
-const saucelabsApkUploader = require('./saucelabsApkUploader');
-const deviceFarmApkUploader = require('./deviceFarmApkUploader');
-
-const reporter = require("../../reports/reporter");
-const path = require('path');
-const Promise = require('bluebird');
-const logger = require('../../commons/logger').getLogger("apk-uploader-factory");
-const { ArgError } = require('../../errors');
-
-function uploadApk(browserOptions) {
-    const { apkLocation, apkTimeout, ipaLocation, ipaTimeout, project, vendorAppId, gridData } = browserOptions;
-
-    if(gridData.type === "hostAndPort") {
-        return Promise.resolve();
-    }
-
-    if(!apkLocation && !ipaLocation && !vendorAppId) {
-        logger.info("App location is not defined");
-        throw new ArgError("No App provided. Please specify the location of the APK/IPA to use in this run using the --apk-location flag or the --ipa-location flag");
-    }
-
-    let appFullPath, appTimeout;
-
-    if(apkLocation) {
-        appFullPath = path.resolve(apkLocation);
-        appTimeout = apkTimeout;
-    } else if(ipaLocation) {
-        appFullPath = path.resolve(ipaLocation);
-        appTimeout = ipaTimeout;
-    }
-    const projectId = project;
-
-    reporter.onUploadApk(appFullPath, vendorAppId);
-
-    if (gridData.type === "testimMobile") {
-        return deviceFarmApkUploader.uploadApk(vendorAppId, appFullPath, appTimeout, projectId, gridData);
-    }
-
-    if (gridData.type === "testobject") {
-        return testObjectApkUploader.uploadApk(vendorAppId, appFullPath, appTimeout, projectId, gridData);
-    }
-
-    if (gridData.type === "saucelabs") {
-        return saucelabsApkUploader.uploadApk(vendorAppId, appFullPath, appTimeout, projectId, gridData);
-    }
-
-    throw new ArgError(`Failed to find matched provider: ${gridData.type}`);
-}
-
-function getAppCaps(gridInfo) {
-    if (gridInfo.type === "testobject") {
-        return testObjectApkUploader.getAppCaps();
-    }
-
-    if (gridInfo.type === "saucelabs") {
-        return saucelabsApkUploader.getAppCaps();
-    }
-
-    if (gridInfo.type === "testimMobile") {
-        return deviceFarmApkUploader.getAppCaps();
-    }
-}
-
-module.exports = {
-    uploadApk,
-    getAppCaps
-};