349 lines
9.8 KiB
JavaScript
349 lines
9.8 KiB
JavaScript
|
/*
|
||
|
|
Copyright 2012-2015, Yahoo Inc.
|
||
|
|
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
|
||
|
|
*/
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
function percent(covered, total) {
|
||
|
|
let tmp;
|
||
|
|
if (total > 0) {
|
||
|
|
tmp = (1000 * 100 * covered) / total + 5;
|
||
|
|
return Math.floor(tmp / 10) / 100;
|
||
|
|
} else {
|
||
|
|
return 100.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function blankSummary() {
|
||
|
|
const empty = function() {
|
||
|
|
return {
|
||
|
|
total: 0,
|
||
|
|
covered: 0,
|
||
|
|
skipped: 0,
|
||
|
|
pct: 'Unknown'
|
||
|
|
};
|
||
|
|
};
|
||
|
|
return {
|
||
|
|
lines: empty(),
|
||
|
|
statements: empty(),
|
||
|
|
functions: empty(),
|
||
|
|
branches: empty()
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// asserts that a data object "looks like" a summary coverage object
|
||
|
|
function assertValidSummary(obj) {
|
||
|
|
const valid =
|
||
|
|
obj && obj.lines && obj.statements && obj.functions && obj.branches;
|
||
|
|
if (!valid) {
|
||
|
|
throw new Error(
|
||
|
|
'Invalid summary coverage object, missing keys, found:' +
|
||
|
|
Object.keys(obj).join(',')
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* CoverageSummary provides a summary of code coverage . It exposes 4 properties,
|
||
|
|
* `lines`, `statements`, `branches`, and `functions`. Each of these properties
|
||
|
|
* is an object that has 4 keys `total`, `covered`, `skipped` and `pct`.
|
||
|
|
* `pct` is a percentage number (0-100).
|
||
|
|
* @param {Object|CoverageSummary} [obj=undefined] an optional data object or
|
||
|
|
* another coverage summary to initialize this object with.
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function CoverageSummary(obj) {
|
||
|
|
if (!obj) {
|
||
|
|
this.data = blankSummary();
|
||
|
|
} else if (obj instanceof CoverageSummary) {
|
||
|
|
this.data = obj.data;
|
||
|
|
} else {
|
||
|
|
this.data = obj;
|
||
|
|
}
|
||
|
|
assertValidSummary(this.data);
|
||
|
|
}
|
||
|
|
|
||
|
|
['lines', 'statements', 'functions', 'branches'].forEach(p => {
|
||
|
|
Object.defineProperty(CoverageSummary.prototype, p, {
|
||
|
|
enumerable: true,
|
||
|
|
get() {
|
||
|
|
return this.data[p];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* merges a second summary coverage object into this one
|
||
|
|
* @param {CoverageSummary} obj - another coverage summary object
|
||
|
|
*/
|
||
|
|
CoverageSummary.prototype.merge = function(obj) {
|
||
|
|
const keys = ['lines', 'statements', 'branches', 'functions'];
|
||
|
|
keys.forEach(key => {
|
||
|
|
this[key].total += obj[key].total;
|
||
|
|
this[key].covered += obj[key].covered;
|
||
|
|
this[key].skipped += obj[key].skipped;
|
||
|
|
this[key].pct = percent(this[key].covered, this[key].total);
|
||
|
|
});
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* returns a POJO that is JSON serializable. May be used to get the raw
|
||
|
|
* summary object.
|
||
|
|
*/
|
||
|
|
CoverageSummary.prototype.toJSON = function() {
|
||
|
|
return this.data;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* return true if summary has no lines of code
|
||
|
|
*/
|
||
|
|
CoverageSummary.prototype.isEmpty = function() {
|
||
|
|
return this.lines.total === 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
// returns a data object that represents empty coverage
|
||
|
|
function emptyCoverage(filePath) {
|
||
|
|
return {
|
||
|
|
path: filePath,
|
||
|
|
statementMap: {},
|
||
|
|
fnMap: {},
|
||
|
|
branchMap: {},
|
||
|
|
s: {},
|
||
|
|
f: {},
|
||
|
|
b: {}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
// asserts that a data object "looks like" a coverage object
|
||
|
|
function assertValidObject(obj) {
|
||
|
|
const valid =
|
||
|
|
obj &&
|
||
|
|
obj.path &&
|
||
|
|
obj.statementMap &&
|
||
|
|
obj.fnMap &&
|
||
|
|
obj.branchMap &&
|
||
|
|
obj.s &&
|
||
|
|
obj.f &&
|
||
|
|
obj.b;
|
||
|
|
if (!valid) {
|
||
|
|
throw new Error(
|
||
|
|
'Invalid file coverage object, missing keys, found:' +
|
||
|
|
Object.keys(obj).join(',')
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* provides a read-only view of coverage for a single file.
|
||
|
|
* The deep structure of this object is documented elsewhere. It has the following
|
||
|
|
* properties:
|
||
|
|
*
|
||
|
|
* * `path` - the file path for which coverage is being tracked
|
||
|
|
* * `statementMap` - map of statement locations keyed by statement index
|
||
|
|
* * `fnMap` - map of function metadata keyed by function index
|
||
|
|
* * `branchMap` - map of branch metadata keyed by branch index
|
||
|
|
* * `s` - hit counts for statements
|
||
|
|
* * `f` - hit count for functions
|
||
|
|
* * `b` - hit count for branches
|
||
|
|
*
|
||
|
|
* @param {Object|FileCoverage|String} pathOrObj is a string that initializes
|
||
|
|
* and empty coverage object with the specified file path or a data object that
|
||
|
|
* has all the required properties for a file coverage object.
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function FileCoverage(pathOrObj) {
|
||
|
|
if (!pathOrObj) {
|
||
|
|
throw new Error(
|
||
|
|
'Coverage must be initialized with a path or an object'
|
||
|
|
);
|
||
|
|
}
|
||
|
|
if (typeof pathOrObj === 'string') {
|
||
|
|
this.data = emptyCoverage(pathOrObj);
|
||
|
|
} else if (pathOrObj instanceof FileCoverage) {
|
||
|
|
this.data = pathOrObj.data;
|
||
|
|
} else if (typeof pathOrObj === 'object') {
|
||
|
|
this.data = pathOrObj;
|
||
|
|
} else {
|
||
|
|
throw new Error('Invalid argument to coverage constructor');
|
||
|
|
}
|
||
|
|
assertValidObject(this.data);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* returns computed line coverage from statement coverage.
|
||
|
|
* This is a map of hits keyed by line number in the source.
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.getLineCoverage = function() {
|
||
|
|
const statementMap = this.data.statementMap;
|
||
|
|
const statements = this.data.s;
|
||
|
|
const lineMap = Object.create(null);
|
||
|
|
|
||
|
|
Object.keys(statements).forEach(st => {
|
||
|
|
if (!statementMap[st]) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const line = statementMap[st].start.line;
|
||
|
|
const count = statements[st];
|
||
|
|
const prevVal = lineMap[line];
|
||
|
|
if (prevVal === undefined || prevVal < count) {
|
||
|
|
lineMap[line] = count;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return lineMap;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* returns an array of uncovered line numbers.
|
||
|
|
* @returns {Array} an array of line numbers for which no hits have been
|
||
|
|
* collected.
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.getUncoveredLines = function() {
|
||
|
|
const lc = this.getLineCoverage();
|
||
|
|
const ret = [];
|
||
|
|
Object.keys(lc).forEach(l => {
|
||
|
|
const hits = lc[l];
|
||
|
|
if (hits === 0) {
|
||
|
|
ret.push(l);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* returns a map of branch coverage by source line number.
|
||
|
|
* @returns {Object} an object keyed by line number. Each object
|
||
|
|
* has a `covered`, `total` and `coverage` (percentage) property.
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.getBranchCoverageByLine = function() {
|
||
|
|
const branchMap = this.branchMap;
|
||
|
|
const branches = this.b;
|
||
|
|
const ret = {};
|
||
|
|
Object.keys(branchMap).forEach(k => {
|
||
|
|
const line = branchMap[k].line || branchMap[k].loc.start.line;
|
||
|
|
const branchData = branches[k];
|
||
|
|
ret[line] = ret[line] || [];
|
||
|
|
ret[line].push(...branchData);
|
||
|
|
});
|
||
|
|
Object.keys(ret).forEach(k => {
|
||
|
|
const dataArray = ret[k];
|
||
|
|
const covered = dataArray.filter(item => item > 0);
|
||
|
|
const coverage = (covered.length / dataArray.length) * 100;
|
||
|
|
ret[k] = {
|
||
|
|
covered: covered.length,
|
||
|
|
total: dataArray.length,
|
||
|
|
coverage
|
||
|
|
};
|
||
|
|
});
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
|
||
|
|
// expose coverage data attributes
|
||
|
|
['path', 'statementMap', 'fnMap', 'branchMap', 's', 'f', 'b'].forEach(p => {
|
||
|
|
Object.defineProperty(FileCoverage.prototype, p, {
|
||
|
|
enumerable: true,
|
||
|
|
get() {
|
||
|
|
return this.data[p];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
/**
|
||
|
|
* return a JSON-serializable POJO for this file coverage object
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.toJSON = function() {
|
||
|
|
return this.data;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* merges a second coverage object into this one, updating hit counts
|
||
|
|
* @param {FileCoverage} other - the coverage object to be merged into this one.
|
||
|
|
* Note that the other object should have the same structure as this one (same file).
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.merge = function(other) {
|
||
|
|
Object.keys(other.s).forEach(k => {
|
||
|
|
this.data.s[k] += other.s[k];
|
||
|
|
});
|
||
|
|
Object.keys(other.f).forEach(k => {
|
||
|
|
this.data.f[k] += other.f[k];
|
||
|
|
});
|
||
|
|
Object.keys(other.b).forEach(k => {
|
||
|
|
let i;
|
||
|
|
const retArray = this.data.b[k];
|
||
|
|
const secondArray = other.b[k];
|
||
|
|
if (!retArray) {
|
||
|
|
this.data.b[k] = secondArray;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (i = 0; i < retArray.length; i += 1) {
|
||
|
|
retArray[i] += secondArray[i];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
FileCoverage.prototype.computeSimpleTotals = function(property) {
|
||
|
|
let stats = this[property];
|
||
|
|
const ret = { total: 0, covered: 0, skipped: 0 };
|
||
|
|
|
||
|
|
if (typeof stats === 'function') {
|
||
|
|
stats = stats.call(this);
|
||
|
|
}
|
||
|
|
Object.keys(stats).forEach(key => {
|
||
|
|
const covered = !!stats[key];
|
||
|
|
ret.total += 1;
|
||
|
|
if (covered) {
|
||
|
|
ret.covered += 1;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
ret.pct = percent(ret.covered, ret.total);
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
|
||
|
|
FileCoverage.prototype.computeBranchTotals = function() {
|
||
|
|
const stats = this.b;
|
||
|
|
const ret = { total: 0, covered: 0, skipped: 0 };
|
||
|
|
|
||
|
|
Object.keys(stats).forEach(key => {
|
||
|
|
const branches = stats[key];
|
||
|
|
let covered;
|
||
|
|
branches.forEach(branchHits => {
|
||
|
|
covered = branchHits > 0;
|
||
|
|
if (covered) {
|
||
|
|
ret.covered += 1;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
ret.total += branches.length;
|
||
|
|
});
|
||
|
|
ret.pct = percent(ret.covered, ret.total);
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* resets hit counts for all statements, functions and branches
|
||
|
|
* in this coverage object resulting in zero coverage.
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.resetHits = function() {
|
||
|
|
const statements = this.s;
|
||
|
|
const functions = this.f;
|
||
|
|
const branches = this.b;
|
||
|
|
Object.keys(statements).forEach(s => {
|
||
|
|
statements[s] = 0;
|
||
|
|
});
|
||
|
|
Object.keys(functions).forEach(f => {
|
||
|
|
functions[f] = 0;
|
||
|
|
});
|
||
|
|
Object.keys(branches).forEach(b => {
|
||
|
|
const hits = branches[b];
|
||
|
|
branches[b] = hits.map(() => 0);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* returns a CoverageSummary for this file coverage object
|
||
|
|
* @returns {CoverageSummary}
|
||
|
|
*/
|
||
|
|
FileCoverage.prototype.toSummary = function() {
|
||
|
|
const ret = {};
|
||
|
|
ret.lines = this.computeSimpleTotals('getLineCoverage');
|
||
|
|
ret.functions = this.computeSimpleTotals('f', 'fnMap');
|
||
|
|
ret.statements = this.computeSimpleTotals('s', 'statementMap');
|
||
|
|
ret.branches = this.computeBranchTotals();
|
||
|
|
return new CoverageSummary(ret);
|
||
|
|
};
|
||
|
|
|
||
|
|
module.exports = {
|
||
|
|
CoverageSummary,
|
||
|
|
FileCoverage
|
||
|
|
};
|