@terascope/scripts/dist/src/helpers/test-runner/tracker.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TestTracker = void 0;
const ms_1 = __importDefault(require("ms"));
const utils_1 = require("@terascope/utils");
const signale_1 = __importDefault(require("../signale"));
const misc_1 = require("../misc");
class TestTracker {
    constructor(options) {
        this.options = options;
        this.started = 0;
        this.ended = 0;
        this.expected = 0;
        this.cleanups = new Map();
        this.errors = new Set();
        this.shuttingDown = false;
        this.onSIGTERM = () => {
            process.stderr.write('\n');
            signale_1.default.info('received SIGTERM');
            this.finish();
        };
        this.onSIGINT = () => {
            process.stderr.write('\n');
            signale_1.default.info('received SIGINT');
            this.finish();
        };
        process.on('SIGINT', this.onSIGINT);
        process.on('SIGTERM', this.onSIGTERM);
    }
    hasErrors() {
        return this.errors.size > 0;
    }
    addError(error) {
        this.errors.add(utils_1.isString(error) ? error : utils_1.getFullErrorStack(error));
    }
    addCleanup(key, fn, ...args) {
        this.cleanups.set(key, () => fn(...args));
    }
    async runCleanupByKey(key) {
        if (!this.cleanups.has(key))
            return;
        const fn = this.cleanups.get(key);
        if (!utils_1.isFunction(fn)) {
            signale_1.default.warn(new Error(`Expected cleanup function for key ${key} got nothing`));
            this.cleanups.delete(key);
            return;
        }
        try {
            await fn();
            this.cleanups.delete(key);
        }
        catch (err) {
            signale_1.default.warn(err, `cleanup ${key} error`);
        }
    }
    async finish() {
        if (this.shuttingDown) {
            await this.end(true);
            process.removeListener('SIGINT', this.onSIGINT);
            process.removeListener('SIGTERM', this.onSIGTERM);
            return;
        }
        this.shuttingDown = true;
        if (this.options.keepOpen) {
            signale_1.default.info('keeping the tests open so the services don\'t shutdown, use ctrl-c to exit.');
            const id = setTimeout(() => {
                this.end();
            }, ms_1.default('1 hour'));
            this.addCleanup('keepOpen', (timeoutId) => clearTimeout(timeoutId), id);
            return;
        }
        await this.end();
    }
    async end(force = false) {
        if (!force) {
            const keys = [...this.cleanups.keys()];
            if (keys.length && this.options.debug) {
                signale_1.default.info('Cleaning up after tests tests');
            }
            for (const key of keys) {
                await this.runCleanupByKey(key);
            }
        }
        else {
            signale_1.default.warn('Skipping cleanup because the SIGTERM and SIGINT was called more than once');
        }
        let errorMsg = '';
        const errors = [...this.errors];
        if (errors.length > 1) {
            errorMsg = `Multiple Test Failures:${misc_1.formatList(errors)}`;
        }
        else if (errors.length === 1) {
            ([errorMsg] = errors);
        }
        if (errors.length) {
            process.stderr.write('\n');
            signale_1.default.fatal(`${errorMsg}`);
            process.stderr.write('\n');
            const exitCode = (process.exitCode || 0) > 0 ? process.exitCode : 1;
            process.exit(exitCode);
        }
        if (this.started === 0 || this.expected === 0) {
            signale_1.default.warn('No tests ran');
            // if not tests are expected to run, it is safe to exit
            process.exit(this.expected === 0 ? 0 : 1);
        }
        if (this.ended !== this.expected) {
            const msg = `started: ${this.started}, completed: ${this.ended}, total: ${this.expected}`;
            signale_1.default.error(`Incomplete tests - ${msg}`);
            process.exit(1);
        }
        signale_1.default.success('All tests completed');
        process.exit(0);
    }
}
exports.TestTracker = TestTracker;
//# sourceMappingURL=tracker.js.map