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

'use strict';

const Promise = require('bluebird');
const moment = require('moment');

const { timeoutMessages, testStatus } = require('../commons/constants');
const logger = require('../commons/logger').getLogger('base-worker');
const testResultService = require('../commons/socket/testResultService');
const remoteStepService = require('../commons/socket/remoteStepService');
const { isNetworkHealthy } = require('../commons/httpRequest');
const testimServicesApi = require('../commons/testimServicesApi');
const gridService = require('../services/gridService');
const reporter = require('../reports/reporter');
const utils = require('../utils');
const { getBrowserWithRetries, isGetBrowserError, releasePlayer } = require('./workerUtils');
const featureFlags = require('../commons/featureFlags');

const { GET_BROWSER_TIMEOUT_MSG, TEST_START_TIMEOUT_MSG, TEST_COMPLETE_TIMEOUT_MSG } = timeoutMessages;

const {
    SeleniumError, StopRunOnError, GridError, GetBrowserError,
} = require('../errors');

const DELAY_BETWEEN_TESTS = 1000;
let ordinal = 1;

function buildFailureResult(testId, testName, resultId, err) {
    return {
        testId,
        reason: err,
        name: testName,
        resultId,
        success: false,
    };
}

class BaseWorker {
    constructor(executionQueue, customExtensionLocalLocation) {
        this.id = BaseWorker.getWorkerId();
        this.executionQueue = executionQueue;
        this.customExtensionLocalLocation = customExtensionLocalLocation;
    }

    static getWorkerId() {
        return ordinal++;
    }

    getBrowserOnce() {
        throw new Error('not implemented');
    }

    initPlayer() {
        throw new Error('not implemented');
    }

    runTestOnce(testRunHandler, player) {
        testRunHandler.setSessionId(player.getSessionId());
        return testRunHandler.clearTestResult();
    }

    getGridSlot(browser, testRunHandler) {
        return gridService.getGridSlot(browser, testRunHandler.getExecutionId(), testRunHandler.getTestResultId(), this.onGridSlot, this.options, this.id);
    }

    start(options, onStart, onResult, executionId, onGridSlot, releaseSlotOnTestFinished) {
        this.isCodeMode = options.files.length > 0;
        this.baseUrl = options.baseUrl;
        this.isRegressionBaselineRun = options.isRegressionBaselineRun;
        this.testRunTimeout = options.timeout;
        this.getBrowserTimeout = options.browserTimeout;
        this.newBrowserWaitTimeout = options.newBrowserWaitTimeout;
        this.onStart = onStart;
        this.onResult = onResult;
        this.onGridSlot = onGridSlot;
        this.releaseSlotOnTestFinished = releaseSlotOnTestFinished;

        this.userData = options.userData;
        this.executionId = executionId;
        this.options = options;
        return this.run();
    }

    runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
        const WAIT_BETWEEN_INTERVALS = 3000;
        const retryCount = this.options.disableTimeoutRetry ? 1 : 3;
        const projectId = this.userData && this.userData.projectId;

        return this.onStart(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun)
            .then(() => utils.runWithRetries(() => {
                let localPlayer;
                const callbacksForBrowserRetryLogic = {
                    getBrowserOnce: this.getBrowserOnce.bind(this, testRunHandler, customExtensionLocalLocation),
                    testPlayerFactory: this.initPlayer.bind(this, testRunHandler),
                    releaseSlotOnTestFinished: this.releaseSlotOnTestFinished,
                };
                const browserFetchConfig = {
                    totalTimeoutDuration: this.newBrowserWaitTimeout,
                    singleGetBrowserDuration: this.getBrowserTimeout,
                    projectId,
                    workerId: this.id,
                    reporter,
                };
                const logger = require('../commons/performance-logger');
                logger.log('before getBrowserWithRetries');
                return getBrowserWithRetries(callbacksForBrowserRetryLogic, browserFetchConfig).then((player) => {
                    logger.log('after getBrowserWithRetries');
                    localPlayer = player;
                    return this.runTestOnce(testRunHandler, player);
                }).finally(() => releasePlayer(this.id, this.releaseSlotOnTestFinished, projectId, localPlayer));
            }, retryCount, WAIT_BETWEEN_INTERVALS, err => !isGetBrowserError(err)));
    }

    runTestCleanup() {
        return Promise.resolve();
    }

    run() {
        const runNextTest = () => process.nextTick(() => this.run());

        const onRunComplete = (testResult, testRunHandler, err) => {
            const sessionId = testRunHandler.getSessionId();

            const isTimeoutError = (timeoutMsg) => err.message.includes(timeoutMsg);
            const isIgnoreErrors = err && (err instanceof GetBrowserError || isTimeoutError(TEST_START_TIMEOUT_MSG) || isTimeoutError(TEST_COMPLETE_TIMEOUT_MSG));
            const shouldRerun = !testResult.success && testRunHandler.hasMoreRetries() && !isIgnoreErrors;

            return this.onResult(this.id, this.testId, testResult, sessionId, shouldRerun)
                .delay(DELAY_BETWEEN_TESTS)
                .then(() => this.runTestCleanup())
                .then(() => {
                    if (shouldRerun) {
                        testRunHandler.startNewRetry();
                        logger.info(`retry test id: ${this.testId} name: ${this.testName} again`, {
                            testId: this.testId,
                            testName: this.testName,
                        });
                        return runTestAndCalcResult(testRunHandler, shouldRerun);
                    }
                    return runNextTest();
                })
                .catch(err => {
                    if (err instanceof StopRunOnError) {
                        return;
                    }
                    logger.error('failed to process test result', { err });
                    runNextTest();
                });
        };

        const buildErrorMsg = (err) => {
            const isError = err instanceof Error || err instanceof GridError;
            const msg = isError ? err.message : err;
            if (!isNetworkHealthy() && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
                return 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.' +
                       'Please make sure the CLI has stable access to the internet.';
            }
            if (msg.indexOf(GET_BROWSER_TIMEOUT_MSG) > -1) {
                return "Test couldn't get browser";
            } if (msg.indexOf(TEST_START_TIMEOUT_MSG) > -1) {
                return "Test couldn't be started";
            } if (msg.indexOf(TEST_COMPLETE_TIMEOUT_MSG) > -1) {
                if (!this.testRunTimeout) {
                    return 'Test timeout reached: test is too long';
                }

                const duration = moment.duration(this.testRunTimeout, 'milliseconds');
                const minutesCount = Math.floor(duration.asMinutes());
                const secondsCount = duration.seconds();
                const minutesTimeoutStr = minutesCount > 0 ? ` ${minutesCount} min` : '';
                const secondsTimoutStr = secondsCount > 0 ? ` ${secondsCount} sec` : '';

                return `Test timeout reached (timeout:${minutesTimeoutStr}${secondsTimoutStr}): test is too long`;
            } if (err.failure && err.failure instanceof SeleniumError) {
                return `Test couldn't get browser from grid - ${err.failure.message}`;
            } if (/SeleniumError: connect ECONNREFUSED/.test(err.message)) {
                return 'Failed to connect to the grid, please check if the grid is accessible from your network';
            } if (/terminated due to FORWARDING_TO_NODE_FAILED/.test(err.message)) {
                return 'Session terminated, it is likely that the grid is out of memory or not responding, please try to rerun the test';
            } if (/terminated due to PROXY_REREGISTRATION/.test(err.message)) {
                return 'Session terminated, it is likely that the grid is not responding, please try to rerun the test';
            } if (/forwarding the new session cannot find : Capabilities/.test(err.message)) {
                return 'Session could not be created, please check that the browser you requested is supported in your plan';
            }
            return msg;
        };

        const onRunError = (err, testRunHandler) => {
            const failureReason = buildErrorMsg(err);
            if (!isNetworkHealthy() && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
                // intentional, we want to log to stderr:
                // eslint-disable-next-line no-console
                console.warn('Due to network connectivity issues, Testim CLI has been unable to connect to the grid.');
                // eslint-disable-next-line no-console
                console.warn('Please make sure the CLI has stable access to the internet.');
            }
            logger.warn('error on run', { err });
            const projectId = this.userData && this.userData.projectId;
            return testResultService.updateTestResult(projectId, this.testResultId, this.testId, {
                status: testStatus.COMPLETED,
                success: false,
                reason: failureReason,
                setupStepResult: { status: testStatus.COMPLETED, success: false, reason: failureReason },
            }, testRunHandler.getRemoteRunId()).then(() => onRunComplete(buildFailureResult(this.testId, this.testName, this.testResultId, failureReason), testRunHandler, err));
        };

        const recoverTestResults = (runError, testRunHandler) => {
            const testId = this.testId;
            const resultId = this.testResultId;
            const projectId = this.userData && this.userData.projectId;
            const branch = this.branch;
            if (testId && resultId && projectId && branch) {
                return testimServicesApi.getTestResults(testId, resultId, projectId, branch)
                    .then(testResult => {
                        if (testResult && testResult.status === testStatus.COMPLETED) {
                            logger.warn('Test failed. Got results via API', { err: runError });
                            return onRunComplete(testResult, testRunHandler);
                        }
                        return Promise.reject(runError);
                    })
                    .catch(err => {
                        if (err !== runError) {
                            logger.error('Failed to fetch test results from server', {
                                testId,
                                resultId,
                                projectId,
                                branch,
                                err,
                            });
                        }
                        return onRunError(runError, testRunHandler);
                    });
            }

            // Not enough data to call the API
            return onRunError(runError, testRunHandler);
        };

        const runTestAndCalcResult = (testRunHandler, shouldRerun) => Promise.all([
            remoteStepService.joinToRemoteStep(this.testResultId),
            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')
            .catch(runError => recoverTestResults(runError, testRunHandler))
            .finally(() => remoteStepService.unlistenToRemoteStep(this.testResultId));

        const testRunHandler = this.executionQueue.getNext();
        if (!testRunHandler) { // no more tests to run
            return undefined;
        }
        this.testId = testRunHandler.getTestId();
        this.testName = testRunHandler.getTestName();
        this.testResultId = testRunHandler.getTestResultId();
        this.overrideTestConfigId = testRunHandler.getOverrideTestConfigId();
        this.testRunConfig = testRunHandler.getRunConfig();
        this.branch = testRunHandler.getBranch();
        return runTestAndCalcResult(testRunHandler);
    }
}

module.exports = BaseWorker;