@testim/testim-cli/workers/WorkerExtension.js

"use strict";

const Promise = require('bluebird');

const {timeoutMessages} = require('../commons/constants');
const BaseWorker = require('./BaseWorker');
const logger = require('../commons/logger').getLogger("worker-ext");
const ExtensionTestPlayer = require('../player/extensionTestPlayer');
const reporter = require("../reports/reporter");

const TEST_START_TIMEOUT = parseInt(process.env.TESTIM_TEST_START_TIMEOUT) || (2 * 60 * 1000);

class WorkerExtension extends BaseWorker {
    initPlayer() {
        return new ExtensionTestPlayer(this.id);
    }

    getBrowserOnce(testRunHandler, customExtensionLocalLocation, player) {
        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
        const {browserValue} = this.testRunConfig;
        const {driver} = player;
        return this.getGridSlot(browserValue, testRunHandler)
            .then(gridInfo => driver.init(this.options, this.testName, this.testRunConfig, gridInfo, customExtensionLocalLocation, this.testResultId))
            .catch(err => {
                logger.error("failed to get browser", {
                    err: err,
                    testId: testRunHandler.getTestId(),
                    resultId: testRunHandler.getTestResultId()
                });
                return Promise.reject(err);
            });
    }

    runTestOnce(testRunHandler, player) {
        const { driver } = player;

        const runExtTest = (testRunHandler) => {
            return new Promise((resolve, reject) => {
                testRunHandler.listenToRemoteStep(driver);

                return testRunHandler.getRunTestUrl()
                    .then(url => {
                        reporter.onWaitToTestStart(this.id);
                        return Promise.all([driver.url(url), testRunHandler.onStarted()])
                            .timeout(TEST_START_TIMEOUT, timeoutMessages.TEST_START_TIMEOUT_MSG)
                            .catch(Promise.TimeoutError, () => testRunHandler.checkViaRestAPIIfTestStarted());
                    })
                    .then(() => {
                        reporter.onWaitToTestComplete(this.id, this.isCodeMode);
                        return testRunHandler.onCompleted().timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
                            .then(testResult => {
                                resolve(testResult);
                            })
                            .catch(err => {
                                logger.warn("timeout wait until test completed", {err: err});
                                // complete time out
                                reject(new Error(err));
                            });
                    })
                    .catch(err => {
                        logger.warn("failed to start url", {err: err});
                        reject(new Error(err));
                    });
            });
        };

        driver.start();

        return super.runTestOnce(testRunHandler, player)
            .then(() => runExtTest(testRunHandler))
            .catch(err => {
                logger.error("failed to run test", {
                    err: err,
                    testId: testRunHandler.getTestId(),
                    resultId: testRunHandler.getTestResultId()
                });
                return Promise.reject(err);
            });
    }
}

module.exports = WorkerExtension;