@testim/testim-cli 3.195.0 → 3.199.0

package/runners/TestPlanRunner.js

@@ -1,24 +1,196 @@
 'use strict';
 
-const Promise = require('bluebird');
+const Bluebird = require('bluebird');
 const _ = require('lodash');
+const constants = require('../commons/constants');
 
+const TESTIM_RUN_STATUS = constants.testRunStatus;
 const reporter = require('../reports/reporter');
-const servicesApi = require('../commons/testimServicesApi');
-const BaseTestPlanRunner = require('./BaseTestPlanRunner');
-const { ArgError } = require('../errors');
+const RealDataService = require('../commons/socket/realDataService');
+const testimServicesApi = require('../commons/testimServicesApi');
+const testimCustomToken = require('../commons/testimCustomToken');
+const TestRunStatus = require('../testRunStatus');
+const analyticsService = require('../services/analyticsService');
+const branchService = require('../services/branchService');
+const config = require('../commons/config');
+const ParallelWorkerManager = require('./ParallelWorkerManager');
+const utils = require('../utils');
+const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtils');
+const { StopRunOnError, ArgError } = require('../errors');
 const Logger = require('../commons/logger');
+const perf = require('../commons/performance-logger');
 
+const guid = utils.guid;
 const logger = Logger.getLogger('test-plan-runner');
+const TDK_CHILD_RESULTS_TIMEOUT = 1000 * 60 * 5;
 
-class TestPlanRunner extends BaseTestPlanRunner {
-    calcTestResultStatus(tests) {
-        const total = Object.keys(tests).length;
-        const passed = Object.keys(tests).reduce((count, resultId) => count + (tests[resultId].success === true ? 1 : 0), 0);
-        return total === passed;
+class TestPlanRunner {
+    constructor(customExtensionLocalLocation) {
+        this.workerManager = new ParallelWorkerManager(customExtensionLocalLocation);
+        this.startTime = Date.now();
     }
+    runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, testStatus) {
+        const executionResults = {};
+        const authData = testimCustomToken.getTokenV3UserData();
 
-    runTestPlans(options, branchToUse) {
+        const runBeforeTests = (beforeTests, testStatus, executionId, tpOptions, branchToUse, authData) => {
+            const workerCount = 1;
+            const stopOnError = true;
+            return this.workerManager.runTests(beforeTests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
+                .then(beforeTestsResults => Object.assign(executionResults, beforeTestsResults));
+        };
+
+        const runTestPlanTests = (tests, testStatus, executionId, tpOptions, branchToUse, authData) => {
+            const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
+            const stopOnError = false;
+            perf.log('right before this.workerManager.runTests');
+            return this.workerManager.runTests(tests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
+                .log('right after this.workerManager.runTests')
+                .then(testsResults => Object.assign(executionResults, testsResults));
+        };
+
+        const runAfterTests = (afterTests, testStatus, executionId, tpOptions, branchToUse, authData) => {
+            const workerCount = 1;
+            const stopOnError = false;
+            return this.workerManager.runTests(afterTests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
+                .then(afterTestsResults => Object.assign(executionResults, afterTestsResults));
+        };
+
+        function catchBeforeTestsFailed(executionId) {
+            return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
+        }
+
+        const sessionType = utils.getSessionType(tpOptions);
+        analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
+        perf.log('right before runBeforeTests');
+        return runBeforeTests(beforeTests, testStatus, executionId, tpOptions, branchToUse, authData)
+            .log('right before runTestPlanTests')
+            .then(() => runTestPlanTests(tests, testStatus, executionId, tpOptions, branchToUse, authData))
+            .log('right after runTestPlanTests')
+            .then(() => runAfterTests(afterTests, testStatus, executionId, tpOptions, branchToUse, authData))
+            .then(() => executionResults)
+            .catch(err => {
+                logger.error('error running test plan', { err });
+                if (err instanceof StopRunOnError) {
+                    return catchBeforeTestsFailed(executionId);
+                }
+                throw err;
+            });
+    }
+
+    async initRealDataService(projectId) {
+        const realDataService = new RealDataService();
+        await realDataService.init(projectId);
+        return realDataService;
+    }
+
+    async listenToTestCreatedInFile(realDataService, projectId, runId, testStatus) {
+        const childTestResults = {};
+        realDataService.joinToTestResultsByRunId(runId, projectId);
+        const promise = new Promise(resolve => {
+            realDataService.listenToTestResultsByRunId(runId, testResult => {
+                const resultId = testResult.id;
+                if (!testStatus.getTestResult(resultId)) {
+                    const prevTestResult = childTestResults[resultId];
+                    const mergedTestResult = _.merge({}, prevTestResult, testResult, { resultId });
+                    childTestResults[resultId] = mergedTestResult;
+                    if (!prevTestResult || prevTestResult.status !== testResult.status) {
+                        const parentTestResult = testStatus.getTestResult(mergedTestResult.parentResultId) || { workerId: 1 };
+                        const workerId = parentTestResult.workerId;
+                        if ([TESTIM_RUN_STATUS.RUNNING].includes(testResult.status)) {
+                            reporter.onTestStarted(mergedTestResult, workerId);
+                        }
+                        if ([TESTIM_RUN_STATUS.COMPLETED].includes(testResult.status)) {
+                            mergedTestResult.duration = (mergedTestResult.endTime - mergedTestResult.startTime) || 0;
+                            reporter.onTestFinished(mergedTestResult, workerId);
+                        }
+                    }
+                }
+
+                const allChildTestResultCompleted = !(Object.values(childTestResults)
+                    .some(result => ['QUEUED', 'RUNNING'].includes(result.runnerStatus)));
+
+                const allParentTestResultCompleted = !(Object.values(testStatus.getAllTestResults())
+                    .some(result => ['QUEUED', 'RUNNING'].includes(result.status)));
+
+                if (allChildTestResultCompleted && allParentTestResultCompleted) {
+                    return resolve(Object.values(childTestResults));
+                }
+
+                if (allParentTestResultCompleted && !allChildTestResultCompleted) {
+                    // wait 10 sec to handle race condition when parent test result (file) finished before child test result
+                    return Bluebird.delay(10000)
+                        .then(() => {
+                            if (promise.isPending()) {
+                                // TODO(Benji) we are missing the child test results here.
+                                // we are resolving here with partial data - we should consider fetching it
+                                // from the server
+                                resolve(childTestResults);
+                            }
+                        });
+                }
+                return undefined;
+            });
+        });
+
+        return await promise;
+    }
+
+    async runTestPlan(beforeTests, tests, afterTests, tpOptions, testPlanName, testPlanId, branch, isAnonymous) {
+        const executionId = guid();
+        const projectId = tpOptions.project;
+        Logger.setExecutionId(executionId);
+        beforeTests.forEach(test => { test.isBeforeTestPlan = true; });
+        afterTests.forEach(test => { test.isAfterTestPlan = true; });
+        const testStatus = new TestRunStatus(_.concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
+
+        const configs = _(_.concat(beforeTests, tests, afterTests)).map(test => (test.overrideTestConfig && test.overrideTestConfig.name) || '').uniq().filter(Boolean)
+            .value();
+        const configName = configs && configs.length === 1 ? configs[0] : null;
+
+        const isCodeMode = tpOptions.files.length > 0;
+
+        if (isCodeMode && tpOptions.mode === constants.CLI_MODE.SELENIUM) {
+            // in selenium mode we don't need to wait for the runner and clickim to sync, so we don't need to wait for reports.
+            testStatus.setAsyncReporting(true);
+        }
+        const testListInfoPromise = tpOptions.lightweightMode && tpOptions.lightweightMode.onlyTestIdsNoSuite ?
+            { beforeTests, tests, afterTests } :
+            testStatus.executionStart(executionId, projectId, this.startTime, testPlanName);
+        let childTestResults;
+        if (isCodeMode) {
+            childTestResults = Bluebird.try(async () => {
+                const realDataService = await this.initRealDataService(projectId);
+                return this.listenToTestCreatedInFile(realDataService, projectId, executionId, testStatus);
+            });
+        }
+        perf.log('before testListInfoPromise');
+        const testListInfo = await testListInfoPromise;
+        if (!(tpOptions.lightweightMode && tpOptions.lightweightMode.onlyTestIdsNoSuite)) {
+            reporter.onTestPlanStarted(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
+        }
+
+        perf.log('before runTestAllPhases');
+        const results = await this.runTestAllPhases(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, branch, tpOptions, executionId, testStatus);
+        const childResults = await Bluebird.resolve(childTestResults)
+            .timeout(TDK_CHILD_RESULTS_TIMEOUT)
+            .catch(async () => {
+                logger.warn('timed out waiting for child resutls on websocket. using REST fallback', { projectId, executionId });
+                const testResults = await testimServicesApi.getRealData(projectId, 'testResult', `runId=${executionId}&sort=runOrder`);
+                return _.chain((testResults && testResults.data && testResults.data.docs) || [])
+                    .groupBy('parentResultId')
+                    .omit('undefined')
+                    .values()
+                    .flatten()
+                    .value();
+            });
+        perf.log('before executionEnd');
+        await testStatus.executionEnd(executionId);
+        perf.log('after executionEnd');
+        return { results, executionId, testPlanName, configName, childTestResults: childResults };
+    }
+
+    async runTestPlans(options, branchToUse) {
         logger.info('start to run test plan', {
             options: Object.assign({}, options, { token: undefined, userParamsData: undefined }),
             branchToUse,
@@ -32,64 +204,117 @@ class TestPlanRunner extends BaseTestPlanRunner {
         const testPlansTests = {};
         const projectId = options.project;
 
-        return this.prepareForTestResources(options)
-            .then(() => servicesApi.getTestPlanTestList(projectId, options.testPlan, options.testPlanIds, branchToUse))
-            .then(data => {
-                const testPlans = data.testPlans;
-                const testPlansData = data.testPlansData;
-                if (!testPlans || testPlans.length === 0) {
-                    return Promise.reject(new ArgError(`no test plan to run ${options.testPlan}`));
-                }
-                if (!testPlansData || Object.keys(testPlansData).length === 0) {
-                    if (options.passZeroTests) {
-                        return [];
-                    }
-                    return Promise.reject(new ArgError(`no test to run in test plan ${options.testPlan}`));
-                }
-                return this.validateConfig(options, flattenTestListData(testPlansData))
-                    .then(() => Promise.map(testPlans, testPlan => {
-                        const id = testPlan.testPlanId;
-                        testPlansResults[id] = {};
-
-                        const tpOptions = Object.assign({}, options);
-                        tpOptions.baseUrl = options.baseUrl || testPlan.startUrl;
-                        tpOptions.host = options.host;
-                        tpOptions.port = options.port;
-                        tpOptions.gridId = options.gridId || testPlan.gridId;
-
-                        //if user pass --grid with test plan we want to use grid option instead of host and port
-                        if (options.grid) {
-                            delete tpOptions.gridId;
-                        }
+        const data = await testimServicesApi.getTestPlanTestList(projectId, options.testPlan, options.testPlanIds, branchToUse);
+        const testPlans = data.testPlans;
+        const testPlansData = data.testPlansData;
+        if (!testPlans || testPlans.length === 0) {
+            throw new ArgError(`no test plan to run ${options.testPlan}`);
+        }
+        if (!testPlansData || Object.keys(testPlansData).length === 0) {
+            if (options.passZeroTests) {
+                return [];
+            }
+            throw new ArgError(`no test to run in test plan ${options.testPlan}`);
+        }
+        await validateConfig(options, flattenTestListData(testPlansData));
+        return await Promise.all(testPlans.map(async testPlan => {
+            const id = testPlan.testPlanId;
+            testPlansResults[id] = {};
 
-                        const testPlanName = tpOptions.overrideExecutionName || testPlan.name;
-
-                        return Promise.map(testPlansData[id], testPlanTests => this.runTestPlan(testPlanTests.beforeTests, testPlanTests.tests, testPlanTests.afterTests, tpOptions, testPlanName, id, branchToUse)
-                            .tap(res => {
-                                const isCodeMode = options.files.length > 0;
-                                reporter.onTestPlanFinished(res.results, testPlan.name, this.startTime, res.executionId, false, isCodeMode, res.childTestResults);
-                                testPlansResults[id][res.executionId] = res.results;
-                            })).tap(() => {
-                            const executions = Object.keys(testPlansResults[id]).map(exeId => ({
-                                executionId: exeId,
-                                status: this.calcTestResultStatus(testPlansResults[id][exeId]),
-                            }));
-                            const tests = Object.keys(testPlansResults[id]).map(exeId => testPlansResults[id][exeId]).reduce((testResult, test) => Object.assign(testResult, test), {});
-                            const success = this.calcTestResultStatus(tests);
-                            Object.assign(testPlansTests, tests);
-                            const executionId = success ? executions[0].executionId : executions.find(exec => !exec.success).executionId;
-                            return servicesApi.saveTestPlanResult(projectId, id, {
-                                success,
-                                executions,
-                                executionId,
-                            });
-                        });
-                    }));
-            }).then(async results => {
-                const flattenResults = _(results).flattenDeep().value();
-                await reporter.onAllTestPlansFinished(flattenResults);
-                return flattenResults.map(res => res.results).reduce((total, cur) => Object.assign(total, cur), {});
-            });
+            const tpOptions = Object.assign({}, options);
+            tpOptions.baseUrl = options.baseUrl || testPlan.startUrl;
+            tpOptions.host = options.host;
+            tpOptions.port = options.port;
+            tpOptions.gridId = options.gridId || testPlan.gridId;
+
+            //if user pass --grid with test plan we want to use grid option instead of host and port
+            if (options.grid) {
+                delete tpOptions.gridId;
+            }
+
+            const testPlanName = tpOptions.overrideExecutionName || testPlan.name;
+            return await Promise.all(testPlansData[id].map(async testPlanTests => {
+                const res = await this.runTestPlan(testPlanTests.beforeTests, testPlanTests.tests, testPlanTests.afterTests, tpOptions, testPlanName, id, branchToUse);
+                const isCodeMode = options.files.length > 0;
+                reporter.onTestPlanFinished(res.results, testPlan.name, this.startTime, res.executionId, false, isCodeMode, res.childTestResults);
+                testPlansResults[id][res.executionId] = res.results;
+
+                const executions = Object.keys(testPlansResults[id]).map(exeId => ({
+                    executionId: exeId,
+                    status: calcTestResultStatus(testPlansResults[id][exeId]),
+                }));
+                const tests = Object.keys(testPlansResults[id]).map(exeId => testPlansResults[id][exeId]).reduce((testResult, test) => Object.assign(testResult, test), {});
+                const success = calcTestResultStatus(tests);
+                Object.assign(testPlansTests, tests);
+                const executionId = success ? executions[0].executionId : executions.find(exec => !exec.success).executionId;
+                await testimServicesApi.saveTestPlanResult(projectId, id, { success, executions, executionId });
+                return res;
+            }));
+        }));
+    }
+
+    async runAnonymousTestPlan(options, branchToUse) {
+        logger.info('start to run anonymous', {
+            options: Object.assign({}, options, { token: undefined }),
+            branchToUse,
+        });
+
+        perf.log('before getSuite');
+        const suiteResult = await getSuite(options, branchToUse);
+        perf.log('after getSuite');
+
+        if (!suiteResult.tests[0] || suiteResult.tests[0].length === 0) {
+            if (options.rerunFailedByRunId) {
+                throw new ArgError('No failed tests found in the provided run');
+            }
+            if (options.passZeroTests) {
+                return [];
+            }
+            throw new ArgError('No tests to run');
+        }
+        branchToUse = suiteResult.branch || branchToUse;
+        if (options.rerunFailedByRunId && !suiteResult.runName) {
+            if (!suiteResult.runExists) {
+                throw new ArgError('Invalid run ID - no such run.');
+            }
+            const isAnonymouslyNamedRun = suiteResult.runName === '';
+            if (isAnonymouslyNamedRun) {
+                suiteResult.runName = `rerun-${options.rerunFailedByRunId}`;
+            }
+        }
+        const testPlanName = options.overrideExecutionName || suiteResult.runName || _.concat(options.label, options.name, options.suites).join(' ');
+        const isAnonymous = true;
+        perf.log('Right before validateConfig + runAnonymousTestPlan tests map');
+        return await Promise.all(suiteResult.tests.map(async suiteTests => { // array of results per execution
+            //override result id for remote run mode and run only the first test data
+            if (options.resultId) {
+                const firstTest = _.first(suiteTests);
+                firstTest.resultId = options.resultId;
+                suiteTests = [firstTest];
+            }
+            await validateConfig(options, suiteTests);
+            perf.log('right before runTestPlan');
+            const res = await this.runTestPlan([], suiteTests, [], options, testPlanName, null, branchToUse, isAnonymous);
+            perf.log('right after runTestPlan');
+            const isCodeMode = options.files.length > 0;
+            await reporter.onTestPlanFinished(res.results, testPlanName, this.startTime, res.executionId, isAnonymous, isCodeMode, res.childTestResults);
+            return res;
+        }));
+    }
+
+    async run(options) {
+        const branchToUse = branchService.getCurrentBranch();
+        let results = [];
+        if (utils.hasTestPlanFlag(options)) {
+            results = await this.runTestPlans(options, branchToUse);
+        } else {
+            results = await this.runAnonymousTestPlan(options, branchToUse);
+        }
+        const flattenResults = _.flattenDeep(results);
+        perf.log('right before onAllTestPlansFinished');
+        await reporter.onAllTestPlansFinished(flattenResults);
+        perf.log('right after onAllTestPlansFinished');
+        return flattenResults.map(res => res.results).reduce((total, cur) => Object.assign(total, cur), {});
     }
 }
 

package/runners/runnerUtils.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const _ = require('lodash');
+const path = require('path');
+const utils = require('../utils.js');
+const analytics = require('../commons/testimAnalytics');
+const { ArgError } = require('../errors');
+
+
+async function getSuite(options, branchToUse) {
+    if (options.lightweightMode && options.lightweightMode.onlyTestIdsNoSuite && options.testId) {
+        return { tests: [options.testId.map(testId => ({ testId, testConfig: { }, resultId: utils.guid() }))] };
+    }
+    // local code test
+    if (options.files.length > 0) {
+        const { buildCodeTests } = require('./buildCodeTests');
+        let webpackConfig = {};
+        if (options.webpackConfig) {
+            const webpackConfigPath = path.join(process.cwd(), options.webpackConfig);
+            webpackConfig = require(webpackConfigPath);
+        }
+
+        return buildCodeTests(options.files, webpackConfig, { baseUrl: options.baseUrl });
+    }
+    // regular test
+    const servicesApi = require('../commons/testimServicesApi');
+    return await servicesApi.getSuiteTestList({
+        projectId: options.project,
+        labels: options.label,
+        testIds: options.testId,
+        testNames: options.name,
+        testConfigNames: options.testConfigNames,
+        suiteNames: options.suites,
+        suiteIds: options.suiteIds,
+        branch: branchToUse,
+        rerunFailedByRunId: options.rerunFailedByRunId,
+        testConfigIds: options.testConfigIds,
+    });
+}
+
+
+function calcTestResultStatus(tests) {
+    const total = Object.keys(tests).length;
+    const passed = Object.keys(tests).reduce((count, resultId) => count + (tests[resultId].success === true ? 1 : 0), 0);
+    return total === passed;
+}
+
+
+
+async function validateConfig(options, testList) {
+    const supportedBrowsers = options.mode === 'extension' ? [
+        'edge-chromium', 'chrome',
+    ] : [
+        'ie11', 'firefox', 'chrome', 'edge', 'edge-chromium', 'safari', 'safari technology preview', 'browser', 'android', 'ios', 'iphone', 'ipad',
+    ];
+    const diff = _.difference(utils.getUniqBrowsers(options, testList), supportedBrowsers);
+
+    if (diff.length > 0) {
+        analytics.trackWithCIUser('invalid-config-run', {
+            browser: diff.join(', '),
+            mode: 'runner',
+        });
+        throw new ArgError(`browser type <${diff}> is not supported in ${options.mode} mode.`);
+    }
+
+    return testList;
+}
+
+module.exports = {
+    getSuite,
+    calcTestResultStatus,
+    validateConfig,
+};

package/services/analyticsService.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const analytics = require('../commons/testimAnalytics');
+const { isCi } = require('../cli/isCiRun');
+
+const calcSource = (source, user) => {
+    if (source !== 'cli' && source !== 'cli-local') {
+        return source;
+    }
+
+    if (isCi && user) {
+        return 'ci-with-user';
+    }
+
+    if (isCi) {
+        return 'ci';
+    }
+
+    if (user) {
+        return 'cli-with-user';
+    }
+
+    return source;
+};
+
+function setLightweightAnalytics(properties, lightweightMode) {
+    if (lightweightMode && lightweightMode.type) {
+        properties[`${lightweightMode.type}Mode`] = true;
+    }
+    return properties;
+}
+
+function analyticsTestStart({
+    executionId, projectId, testId, resultId, companyId, companyName, projectName, companyPlan, sessionType, source, user, lightweightMode,
+}) {
+    const properties = setLightweightAnalytics({
+        executionId,
+        projectId,
+        testId,
+        resultId,
+        companyId,
+        companyName,
+        projectName,
+        companyPlan,
+        sessionType,
+        source: calcSource(source, user),
+    }, lightweightMode);
+    analytics.trackWithCIUser('test-run-ci', properties);
+}
+
+function analyticsTestEnd({
+    executionId, projectId, testId, resultId, result, companyId, companyName, projectName, companyPlan, sessionType, source, user, lightweightMode,
+    logger,
+}) {
+    try {
+        const properties = setLightweightAnalytics({
+            executionId,
+            projectId,
+            testId,
+            resultId,
+            companyId,
+            companyName,
+            projectName,
+            companyPlan,
+            sessionType,
+            mockNetworkEnabled: result.wasMockNetworkActivated,
+            source: calcSource(source, user),
+        }, lightweightMode);
+
+        if (result.success) {
+            analytics.trackWithCIUser('test-run-ci-success', properties);
+            return;
+        }
+        analytics.trackWithCIUser('test-run-ci-fail', Object.assign({}, properties, { failureReason: result.failureReason }));
+    } catch (err) {
+        logger.error('failed to update test end analytics', { err });
+    }
+}
+
+
+
+function analyticsExecsStart({ executionId, projectId, sessionType }) {
+    analytics.trackWithCIUser('batch-run-ci', {
+        executionId,
+        projectId,
+        sessionType,
+    });
+}
+
+module.exports = {
+    analyticsTestStart,
+    analyticsTestEnd,
+    analyticsExecsStart,
+};

package/services/gridService.js

@@ -60,14 +60,14 @@ function getSerializableObject(grid) {
     };
 }
 
-function handleGetGridResponse(projectId, workerId, browser, options, getFun) {
+function handleGetGridResponse(projectId, companyId, workerId, browser, getFun) {
     return getFun()
         .catch(err => {
-            logger.error('failed to get grid', { projectId, err });
+            logger.error('failed to get grid', { projectId, companyId, err });
             throw new Error(gridMessages.UNKNOWN);
         })
         .then(async (res) => {
-            logger.info('get grid info', Object.assign({}, res, { projectId }));
+            logger.info('get grid info', Object.assign({}, res, { projectId, companyId }));
             const isSuccess = () => res.status === 'success';
             const isError = () => res.status === 'error' && res.code;
             if (!res || (!isError() && !isSuccess())) {
@@ -77,7 +77,7 @@ function handleGetGridResponse(projectId, workerId, browser, options, getFun) {
 
             if (isSuccess()) {
                 const serGrid = getSerializableObject(res.grid);
-                module.exports.addItemToGridCache(workerId, serGrid.gridId, serGrid.slotId, browser);
+                module.exports.addItemToGridCache(workerId, companyId, serGrid.gridId, serGrid.slotId, browser);
                 return serGrid;
             }
 
@@ -94,16 +94,23 @@ function handleGetGridResponse(projectId, workerId, browser, options, getFun) {
         });
 }
 
-function addItemToGridCache(workerId, gridId, slotId, browser) {
-    gridCache[workerId] = { gridId, slotId, browser };
+function addItemToGridCache(workerId, companyId, gridId, slotId, browser) {
+    gridCache[workerId] = { gridId, companyId, slotId, browser };
 }
 
-function getHostAndPortById(workerId, projectId, gridId, browser, executionId, options) {
-    return handleGetGridResponse(projectId, workerId, browser, options, () => servicesApi.getGridById(projectId, gridId, browser, executionId));
+function getHostAndPortById(workerId, companyId, projectId, gridId, browser, executionId, options) {
+    return handleGetGridResponse(projectId, companyId, workerId, browser, () => servicesApi.getGridById(companyId, projectId, gridId, browser, executionId));
 }
 
-function getHostAndPortByName(workerId, projectId, gridName, browser, executionId, options) {
-    return handleGetGridResponse(projectId, workerId, browser, options, () => servicesApi.getGridByProject(projectId, gridName, browser, executionId));
+function getHostAndPortByName(workerId, companyId, projectId, gridName, browser, executionId, options) {
+    const get = () => {
+        const grid = options.allGrids && options.allGrids.find(grid => (grid.name || '').toLowerCase() === gridName.toLowerCase());
+        if (grid && grid._id) {
+            return servicesApi.getGridById(companyId, projectId, grid._id, browser, executionId);
+        }
+        return servicesApi.getGridByName(companyId, projectId, gridName, browser, executionId);
+    };
+    return handleGetGridResponse(projectId, companyId, workerId, browser, get);
 }
 
 function getAllGrids(companyId) {
@@ -138,15 +145,15 @@ function releaseGridSlot(workerId, projectId) {
         return Promise.resolve();
     }
 
-    const { slotId, gridId, browser } = gridData;
+    const { slotId, gridId, browser, companyId } = gridData;
     delete gridCache[workerId];
     if (!slotId) {
         logger.warn('failed to find grid slot id', { projectId });
         return Promise.resolve();
     }
 
-    logger.info('release slot id', { projectId, slotId, gridId, browser });
-    return servicesApi.releaseGridSlot(projectId, slotId, gridId, browser)
+    logger.info('release slot id', { projectId, companyId, slotId, gridId, browser });
+    return servicesApi.releaseGridSlot(companyId, projectId, slotId, gridId, browser)
         .catch(err => logger.error('failed to release slot', { projectId, err }));
 }
 
@@ -274,7 +281,8 @@ const getGridSlot = Promise.method(_getGridSlot);
 
 async function _getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
     const getGridDataFromServer = () => {
-        const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher } = options;
+        const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
+        const companyId = company.companyId;
         if (useLocalChromeDriver || useChromeLauncher) {
             return { mode: 'local' };
         }
@@ -282,10 +290,10 @@ async function _getGridSlot(browser, executionId, testResultId, onGridSlot, opti
             return Promise.resolve(getOptionGrid(options));
         }
         if (gridId) {
-            return getHostAndPortById(workerId, project, gridId, browser, executionId, options);
+            return getHostAndPortById(workerId, companyId, project, gridId, browser, executionId, options);
         }
         if (grid) {
-            return getHostAndPortByName(workerId, project, grid, browser, executionId, options);
+            return getHostAndPortByName(workerId, companyId, project, grid, browser, executionId, options);
         }
         throw new GridError('Missing host or grid configuration');
     };