arrange-act-assert
Version:
The lightweight "Act-Arrange-Assert" oriented testing framework
278 lines (277 loc) • 9.18 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolvablePromise = resolvablePromise;
exports.clearModuleCache = clearModuleCache;
exports.getTestSuiteOptions = getTestSuiteOptions;
exports.getTestOptions = getTestOptions;
exports.getCallSites = getCallSites;
exports.testRegex = testRegex;
exports.getCommonBasePath = getCommonBasePath;
const Util = __importStar(require("util"));
const Path = __importStar(require("path"));
function resolvablePromise() {
let rejected = false;
let resolved = false;
let resolve;
let reject;
const instance = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
instance.resolve = () => {
if (resolved || rejected) {
return;
}
resolved = true;
resolve();
};
instance.reject = (e) => {
if (resolved) {
throw new Error("Already resolved");
}
if (rejected) {
return;
}
rejected = true;
reject(e);
};
return instance;
}
function clearModuleCache(file, _root = Path.dirname(file) + Path.sep) {
const id = require.resolve(file);
if (Object.hasOwnProperty.call(require.cache, id)) {
const mod = require.cache[id];
if (mod && mod.id.startsWith(_root)) {
delete require.cache[id];
for (const child of mod.children) {
clearModuleCache(child.id, _root);
}
}
}
}
function processArgs(args) {
let nextKey = "";
const res = new Map();
for (const arg of args) {
if (arg.startsWith("--")) {
if (nextKey && !res.has(nextKey)) {
res.set(nextKey, []);
}
nextKey = arg.slice(2);
const equalIndex = nextKey.indexOf("=");
if (equalIndex > -1) {
const value = nextKey.substring(equalIndex + 1);
nextKey = nextKey.substring(0, equalIndex);
const values = res.get(nextKey);
if (values) {
values.push(value);
}
else {
res.set(nextKey, [value]);
}
nextKey = "";
}
}
else if (nextKey) {
const values = res.get(nextKey);
if (values) {
values.push(arg);
}
else {
res.set(nextKey, [arg]);
}
}
}
if (nextKey && !res.has(nextKey)) {
res.set(nextKey, []);
}
return res;
}
function getTestSuiteOptions(argv = process.argv) {
const args = processArgs(argv);
const options = {};
const folder = args.get("folder");
if (folder) {
if (folder.length === 0) {
throw new Error(`--folder needs a value`);
}
else if (folder.length > 1 || !folder[0]) {
throw new Error(`Only one --folder argument is allowed`);
}
options.folder = folder[0];
}
const parallel = args.get("parallel");
if (parallel != null) {
if (parallel.length === 0) {
throw new Error(`--parallel needs a value`);
}
else if (parallel.length > 1 || !parallel[0]) {
throw new Error(`Only one --parallel argument is allowed`);
}
const parallelNumber = Number(parallel[0]);
if (!Number.isFinite(parallelNumber)) {
throw new Error(`--parallel must be a number: ${parallel[0]}`);
}
options.parallel = parallelNumber;
}
const includeFiles = args.get("include-files");
if (includeFiles != null) {
options.include = includeFiles.map(filter => new RegExp(filter));
}
const excludeFiles = args.get("exclude-files");
if (excludeFiles != null) {
options.exclude = excludeFiles.map(filter => new RegExp(filter));
}
const prefix = args.get("spawn-args-prefix");
if (prefix != null) {
options.prefix = prefix;
}
const clearModuleCache = args.get("clear-module-cache");
if (clearModuleCache) {
options.clearModuleCache = true;
}
return {
...options,
...getTestOptions(argv)
};
}
function getTestOptions(argv = process.argv) {
const args = processArgs(argv);
const options = {};
const coverageExclude = args.get("coverage-exclude");
if (coverageExclude != null) {
options.coverageExclude = coverageExclude.map(filter => new RegExp(filter));
}
const coverageNoBranches = args.get("coverage-no-branches");
if (coverageNoBranches != null) {
options.coverageNoBranches = true;
}
const snapshotsFolder = args.get("snapshots-folder") || args.get("folder-snapshots");
if (snapshotsFolder) {
if (snapshotsFolder.length === 0) {
throw new Error(`--snapshots-folder needs a value`);
}
else if (snapshotsFolder.length > 1 || !snapshotsFolder[0]) {
throw new Error(`Only one --snapshots-folder argument is allowed`);
}
options.snapshotsFolder = snapshotsFolder[0];
}
const confirmSnapshots = args.get("snapshots-confirm") || args.get("confirm-snapshots");
if (confirmSnapshots) {
options.confirmSnapshots = true;
}
const reviewSnapshots = args.get("snapshots-review") || args.get("review-snapshots");
if (reviewSnapshots) {
options.reviewSnapshots = true;
}
const regenerateSnapshots = args.get("snapshots-regenerate") || args.get("regenerate-snapshots");
if (regenerateSnapshots) {
options.regenerateSnapshots = true;
}
const coverage = args.get("coverage");
if (coverage) {
options.coverage = true;
}
const coverageNoSourceMaps = args.get("coverage-no-source-maps");
if (coverageNoSourceMaps) {
options.coverageNoSourceMaps = true;
}
return options;
}
function getCallSites() {
let callsite = [];
try {
callsite = Util.getCallSites().map(callSite => callSite.scriptName);
}
catch (e) {
try {
callsite = Util.getCallSite().map((callSite) => callSite.scriptName);
}
catch (e) {
const prepareStackTrace = Error.prepareStackTrace;
try {
Error.prepareStackTrace = (_, callSites) => callSites.map(callSite => callSite.getFileName());
callsite = new Error().stack;
}
finally {
Error.prepareStackTrace = prepareStackTrace;
}
}
}
return callsite;
}
function testRegex(path, regex) {
const fullPathForward = path.replace(/\\/g, "/");
const fullPathBackward = path.replace(/\//g, "\\");
for (const r of regex) {
if (r.test(fullPathForward) || r.test(fullPathBackward)) {
return true;
}
}
return false;
}
function getCommonBasePath(files) {
let maxI = Infinity;
const splitFiles = files.map(file => {
const paths = file.split(Path.sep);
if (paths.length - 1 < maxI) {
maxI = paths.length - 1;
}
return paths;
});
if (splitFiles.length > 0) {
const commonBase = [];
loop: for (let i = 0; i < maxI; i++) {
let base = null;
for (const file of splitFiles) {
if (base == null) {
base = file[i];
}
else if (file[i] !== base) {
break loop;
}
}
commonBase.push(base);
}
if (commonBase.length > 0) {
if (commonBase[commonBase.length - 1] !== "") {
commonBase.push("");
}
return commonBase.join(Path.sep);
}
}
return "";
}