baset-cli/dist/TAP.js

CLI for BaseT project.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const baset_core_1 = require("baset-core");
const stream_1 = require("stream");
function serializeError(err) {
    return {
        name: err.name,
        message: err.message,
        at: err.stack
            ? err.stack
                .split('\n')
                .slice(1, 2)
                .map(line => line.replace('at', '').trim())
                .shift()
            : '',
        actual: err.data.actual.split('\n').join('\n       '),
        expected: err.data.expected.split('\n').join('\n       '),
    };
}
function start() {
    return 'TAP version 13\n';
}
function plan(count) {
    return `1..${count}\n`;
}
function test(title, options) {
    let directive = '';
    if (!options.passed && options.todo)
        directive = '# TODO';
    if (options.passed && options.skip)
        directive = '# SKIP';
    const comments = options.comment
        ? typeof options.comment === 'string'
            ? [options.comment]
            : options.comment
        : [];
    const comment = comments
        .map(line => `  * ${line}`)
        .join('\n');
    const output = [
        `# ${title}`,
        `${options.passed ? 'ok' : 'not ok'} ${options.index} - ${title} ${directive}`.trim(),
        options.comment,
    ];
    if (!options.passed && !options.todo) {
        const errors = Array.isArray(options.error)
            ? options.error
            : [options.error];
        errors.forEach(error => {
            const obj = serializeError(error instanceof baset_core_1.TestError
                ? error
                : {
                    name: error.name,
                    message: error.message,
                    stack: error.stack,
                    data: {
                        actual: '',
                        expected: '',
                    },
                });
            !(error instanceof baset_core_1.TestError) && output.push(error.stack);
            output.push([
                '  ---',
                `    name: ${obj.name}`,
                `    message: ${obj.message}`,
                `    at: ${obj.at}`,
                '    actual:',
                '      |',
                `       ${obj.actual}`,
                '    expected:',
                '      |',
                `       ${obj.expected}`,
                '  ...',
            ].join('\n'));
        });
    }
    return output.filter(Boolean).join('\n') + '\n';
}
function end(stats) {
    return [
        // `\n1..${stats.passed + stats.failed + stats.skipped + stats.todo}`,
        `# tests ${stats.passed + stats.failed + stats.skipped}`,
        `# pass ${stats.passed}`,
        stats.skipped && `# skip ${stats.skipped}`,
        `# fail ${stats.failed + stats.crashed + stats.todo}\n`,
    ].filter(Boolean).join('\n');
}
function diagnostic(message) {
    return `# ${message}\n`;
}
function getTapStream(count, outStream) {
    const tapStream = new stream_1.Readable({
        objectMode: true,
        read() { },
    });
    function finish(getResults) {
        return __awaiter(this, void 0, void 0, function* () {
            const stats = {
                crashed: 0,
                failed: 0,
                passed: 0,
                skipped: 0,
                todo: 0,
            };
            outStream.write(start());
            outStream.write(plan(count));
            outStream.write(diagnostic('Preparing test environment...'));
            const results = getResults();
            outStream.write(diagnostic('Test environment is ready'));
            for (const result of results) {
                const { name, options } = yield result;
                if (options.passed) {
                    stats.passed++;
                    if (options.skip)
                        stats.skipped++;
                }
                else {
                    stats.failed++;
                    if (options.todo)
                        stats.todo++;
                }
                tapStream.push(test(name, options));
            }
            tapStream.push(end(stats));
            tapStream.emit('end');
            tapStream.emit('close');
            return stats;
        });
    }
    tapStream.pipe(outStream);
    return { finish };
}
exports.getTapStream = getTapStream;
//# sourceMappingURL=TAP.js.map