arrange-act-assert/lib/coverage/Coverage.js

The lightweight "Act-Arrange-Assert" oriented testing framework

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Coverage = void 0;
let Inspector = null;
try {
    Inspector = require("inspector");
}
catch (e) {
    console.error(e);
}
class Coverage {
    constructor() {
        this._session = null;
    }
    _enable(session) {
        return new Promise((resolve, reject) => {
            session.post("Profiler.enable", (err) => {
                if (err) {
                    this._disconnect(session);
                    reject(err);
                }
                else {
                    resolve();
                }
            });
        });
    }
    _disable(session) {
        return new Promise(resolve => {
            session.post("Profiler.disable", resolve);
        });
    }
    _disconnect(session) {
        try {
            session.disconnect();
        }
        catch (e) { }
    }
    _startPreciseCoverage(session) {
        return new Promise((resolve, reject) => {
            session.post("Profiler.startPreciseCoverage", {
                callCount: true,
                detailed: true
            }, (err) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve();
                }
            });
        });
    }
    _stopPreciseCoverage(session) {
        return new Promise(resolve => {
            session.post("Profiler.stopPreciseCoverage", resolve);
        });
    }
    _takePreciseCoverage(session) {
        return new Promise((resolve, reject) => {
            session.post("Profiler.takePreciseCoverage", (err, coverage) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(coverage);
                }
            });
        });
    }
    async start() {
        if (this._session || !Inspector) {
            return;
        }
        this._session = new Inspector.Session();
        this._session.connect();
        await this._enable(this._session);
        if (!this._session) {
            return;
        }
        try {
            await this._startPreciseCoverage(this._session);
        }
        catch (e) {
            if (this._session) {
                await this._disable(this._session);
                if (this._session) {
                    this._disconnect(this._session);
                }
            }
            throw e;
        }
    }
    async takeCoverage() {
        if (!this._session) {
            throw new Error("No session enabled");
        }
        const coverage = await this._takePreciseCoverage(this._session);
        return coverage.result.filter(entry => entry.url.startsWith("file:"));
    }
    async stop() {
        if (!this._session) {
            return;
        }
        await this._stopPreciseCoverage(this._session);
        if (!this._session) {
            return;
        }
        await this._disable(this._session);
        if (!this._session) {
            return;
        }
        this._disconnect(this._session);
        this._session = null;
    }
}
exports.Coverage = Coverage;