typescript-assistant/dist/testing/nyc.js

Combines and integrates professional Typescript tools into your project

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createNyc = createNyc;
function delay(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}
function createNyc(dependencies) {
    const { taskRunner, logger, bus, git } = dependencies;
    let runningTask;
    let coolingDown;
    function startNyc() {
        return __awaiter(this, arguments, void 0, function* (withCoverage = true, config, testsGlob = "test/**/*-tests.ts*") {
            let hasFailingTest = false;
            let myCoolingDown = delay(100);
            coolingDown = myCoolingDown;
            yield myCoolingDown;
            if (coolingDown !== myCoolingDown) {
                return false;
            }
            if (runningTask) {
                logger.log("nyc", "Aborting previous nyc run");
                runningTask.kill();
                runningTask = undefined;
            }
            else {
                bus.report({ tool: "test", status: "busy" });
                bus.report({ tool: "coverage", status: "busy" });
            }
            let lastLineWasNotOk = false;
            function handleOutput(line) {
                if (task === runningTask) {
                    let notOk = /^not ok \d+ (.*)/.exec(line);
                    let ok = /^ok \d+ (.*)/.exec(line);
                    if (notOk) {
                        lastLineWasNotOk = true;
                        logger.log("nyc", `FAILED: ${notOk[1]}`);
                        hasFailingTest = true;
                    }
                    else if (ok) {
                        lastLineWasNotOk = false;
                    }
                    else if (lastLineWasNotOk) {
                        logger.log("nyc", line);
                    }
                }
                return true;
            }
            function handleError(line) {
                if (task === runningTask && !line.startsWith("ERROR: Coverage for")) {
                    logger.error("nyc", line);
                }
                return true;
            }
            if (withCoverage) {
                runningTask = taskRunner.runTask("./node_modules/.bin/nyc", [
                    config ? `--nycrc-path ${config}` : "",
                    "--check-coverage",
                    "-- mocha --require ts-node/register/transpile-only --exit --reporter tap",
                    `"${testsGlob}"`,
                ]
                    .join(" ")
                    .trim()
                    .split(" "), {
                    name: "nyc",
                    logger,
                    handleOutput,
                    handleError,
                });
            }
            else {
                logger.log("nyc", "running tests without coverage");
                runningTask = taskRunner.runTask("./node_modules/.bin/mocha", [
                    "--require ts-node/register/transpile-only --exit --reporter tap",
                    `"${testsGlob}"`,
                ]
                    .join(" ")
                    .split(" "), {
                    name: "nyc",
                    logger,
                    handleOutput,
                    handleError,
                });
            }
            let task = runningTask;
            return runningTask.result
                .then(() => {
                if (task === runningTask) {
                    runningTask = undefined;
                    logger.log("nyc", withCoverage ? "code coverage OK" : "tests ok");
                    bus.report({ tool: "test", status: "ready", errors: 0 });
                    bus.report({ tool: "coverage", status: "ready", errors: 0 });
                }
                return true;
            })
                .catch(() => __awaiter(this, void 0, void 0, function* () {
                if (task === runningTask) {
                    runningTask = undefined;
                    logger.log("nyc", "code coverage FAILED");
                    bus.report({
                        tool: "test",
                        status: "ready",
                        errors: hasFailingTest ? 1 : 0,
                    });
                    bus.report({ tool: "coverage", status: "ready", errors: 1 });
                }
                let isOnMasterOrRelease = yield git.isOnMasterOrReleaseBranch();
                return !isOnMasterOrRelease && !hasFailingTest;
            }));
        });
    }
    let callback;
    return {
        run(withCoverage, config, testsGlob) {
            return startNyc(withCoverage, config, testsGlob).catch(() => false);
        },
        start(triggers, withCoverage, config, testsGlob) {
            callback = () => startNyc(withCoverage, config, testsGlob);
            bus.registerAll(triggers, callback);
            callback().catch(() => false);
        },
        stop() {
            bus.unregister(callback);
        },
    };
}
//# sourceMappingURL=nyc.js.map