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

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.runTests = void 0;
const utils_1 = require("@terascope/utils");
const misc_1 = require("../misc");
const services_1 = require("./services");
const scripts_1 = require("../scripts");
const utils = __importStar(require("./utils"));
const signale_1 = __importDefault(require("../signale"));
const packages_1 = require("../packages");
const utils_2 = require("../publish/utils");
const tracker_1 = require("./tracker");
const logger = utils_1.debugLogger('ts-scripts:cmd:test');
async function runTests(pkgInfos, options) {
    const tracker = new tracker_1.TestTracker(options);
    logger.info('running tests with options', options);
    try {
        await _runTests(pkgInfos, options, tracker);
    }
    catch (err) {
        tracker.addError(err);
    }
    finally {
        tracker.finish();
    }
}
exports.runTests = runTests;
async function _runTests(pkgInfos, options, tracker) {
    var _a;
    if ((_a = options.suite) === null || _a === void 0 ? void 0 : _a.includes('e2e')) {
        await runE2ETest(options, tracker);
        return;
    }
    const filtered = utils.filterBySuite(pkgInfos, options);
    if (!filtered.length) {
        signale_1.default.warn('No tests found.');
        return;
    }
    const availableSuites = misc_1.getAvailableTestSuites();
    const grouped = utils.groupBySuite(filtered, availableSuites, options);
    for (const [suite, pkgs] of Object.entries(grouped)) {
        if (!pkgs.length || suite === 'e2e')
            continue;
        try {
            await runTestSuite(suite, pkgs, options, tracker);
            if (tracker.hasErrors()) {
                if (options.bail || utils_1.isCI) {
                    break;
                }
            }
        }
        catch (err) {
            tracker.addError(err);
            break;
        }
    }
}
async function runTestSuite(suite, pkgInfos, options, tracker) {
    if (suite === 'e2e')
        return;
    // jest or our tests have a memory leak, limiting this seems to help
    const MAX_CHUNK_SIZE = utils_1.isCI ? 7 : 10;
    const CHUNK_SIZE = options.debug ? 1 : MAX_CHUNK_SIZE;
    if (options.watch && pkgInfos.length > MAX_CHUNK_SIZE) {
        throw new Error(`Running more than ${MAX_CHUNK_SIZE} packages will cause memory leaks`);
    }
    tracker.expected += pkgInfos.length;
    const chunked = utils_1.chunk(pkgInfos, CHUNK_SIZE);
    // don't log unless this useful information (more than one package)
    if (chunked.length > 1 && chunked[0].length > 1) {
        misc_1.writeHeader(`Running test suite "${suite}"`, false);
    }
    const cleanupKeys = [`${suite}:services`];
    tracker.addCleanup(`${suite}:services`, await services_1.ensureServices(options.forceSuite || suite, options));
    const timeLabel = `test suite "${suite}"`;
    signale_1.default.time(timeLabel);
    const env = printAndGetEnv(suite, options);
    let chunkIndex = -1;
    for (const pkgs of chunked) {
        chunkIndex++;
        if (!pkgs.length)
            continue;
        if (pkgs.length === 1) {
            misc_1.writePkgHeader('Running test', pkgs, false);
        }
        else {
            misc_1.writeHeader(`Running batch of ${pkgs.length} tests`, false);
        }
        const args = utils.getArgs(options);
        args.projects = pkgs.map((pkgInfo) => pkgInfo.relativeDir);
        tracker.started += pkgs.length;
        try {
            await scripts_1.runJest(misc_1.getRootDir(), args, env, options.jestArgs, options.debug);
            tracker.ended += pkgs.length;
        }
        catch (err) {
            tracker.ended += pkgs.length;
            tracker.addError(err.message);
            const teardownPkgs = pkgs.map((pkg) => ({
                name: pkg.name,
                dir: pkg.dir,
                suite: pkg.terascope.testSuite
            }));
            const cleanupKey = `${suite}:teardown:${pkgs.map((pkg) => pkg.folderName).join(',')}`;
            cleanupKeys.push(cleanupKey);
            tracker.addCleanup(cleanupKey, async () => {
                options.keepOpen = false;
                await utils.globalTeardown(options, teardownPkgs);
            });
            if (options.bail || utils_1.isCI) {
                signale_1.default.error('Bailing out of tests due to error');
                break;
            }
        }
        finally {
            if (options.reportCoverage) {
                await utils.reportCoverage(suite, chunkIndex);
            }
        }
    }
    if (!options.keepOpen) {
        await utils_1.pMap(cleanupKeys, (key) => tracker.runCleanupByKey(key));
    }
    signale_1.default.timeEnd(timeLabel);
}
async function runE2ETest(options, tracker) {
    tracker.expected++;
    const suite = 'e2e';
    let startedTest = false;
    const e2eDir = packages_1.getE2EDir();
    if (!e2eDir) {
        throw new Error('Missing e2e test directory');
    }
    const rootInfo = misc_1.getRootInfo();
    const [registry] = rootInfo.terascope.docker.registries;
    const e2eImage = `${registry}:e2e`;
    if (utils_1.isCI) {
        // pull the services first in CI
        await services_1.pullServices(suite, options);
    }
    try {
        const devImage = await utils_2.buildDevDockerImage();
        await scripts_1.dockerTag(devImage, e2eImage);
    }
    catch (err) {
        tracker.addError(err);
    }
    try {
        tracker.addCleanup('e2e:services', await services_1.ensureServices(suite, options));
    }
    catch (err) {
        tracker.addError(err);
    }
    if (!tracker.hasErrors()) {
        const timeLabel = `test suite "${suite}"`;
        signale_1.default.time(timeLabel);
        startedTest = true;
        const env = printAndGetEnv(suite, options);
        tracker.started++;
        try {
            await scripts_1.runJest(e2eDir, utils.getArgs(options), env, options.jestArgs, options.debug);
            tracker.ended++;
        }
        catch (err) {
            tracker.ended++;
            tracker.addError(err.message);
        }
        signale_1.default.timeEnd(timeLabel);
    }
    if (!startedTest)
        return;
    if (!options.keepOpen) {
        try {
            await utils.logE2E(e2eDir, tracker.hasErrors());
        }
        catch (err) {
            signale_1.default.error(new utils_1.TSError(err, {
                reason: `Writing the "${suite}" logs failed`,
            }));
        }
    }
    if (tracker.hasErrors()) {
        tracker.addCleanup('e2e:teardown', async () => {
            options.keepOpen = false;
            await utils.globalTeardown(options, [{
                    name: suite,
                    dir: e2eDir,
                    suite,
                }]);
        });
    }
}
function printAndGetEnv(suite, options) {
    const env = utils.getEnv(options, suite);
    if (options.debug || options.trace || utils_1.isCI) {
        const envStr = Object
            .entries(env)
            .filter(([_, val]) => val != null && val !== '')
            .map(([key, val]) => `${key}: "${val}"`)
            .join(', ');
        signale_1.default.debug(`Setting ${suite} test suite env to ${envStr}`);
    }
    return env;
}
//# sourceMappingURL=index.js.map