cfg-test
Version:
In-source testing using Node.js Test Runner
229 lines (227 loc) • 7.83 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(
from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(
mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod,
enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }),
mod);
// src/core/api.ts
var api_exports = {};
__export(api_exports, {
register: () => register
});
module.exports = __toCommonJS(api_exports);
var import_node_fs = require("node:fs");
var import_node_module = require("node:module");
var import_node_path = require("node:path");
var import_node_path2 = require("node:path");
var import_node_process = __toESM(require("node:process"));
var import_node_url = require("node:url");
var import_define = require("./define.cjs");
var log = __toESM(require("./log.cjs"));
var ARGV = ["/path/to/node", "/path/to/file"];
var fileIndex = ARGV.indexOf("/path/to/file");
var cwd = import_node_process.default.cwd();
var cwdUrl = (0, import_node_url.pathToFileURL)(
cwd.endsWith(import_node_path2.sep) ? import_node_path2.sep : cwd + import_node_path2.sep
);
var require2 = (0, import_node_module.createRequire)(cwdUrl);
var parentUrl = cwdUrl.toString();
function register(options = {}) {
const argv = options.argv || import_node_process.default.argv;
if (!(fileIndex in argv)) {
return;
}
const file = (0, import_node_path.resolve)(argv[fileIndex]);
const execArgv = options.execArgv || import_node_process.default.execArgv;
const nodeOptions = `,${import_node_process.default.env["NODE_OPTIONS"] ? execArgv.
concat(import_node_process.default.env["NODE_OPTIONS"].split(/\s/g)) : execArgv}\
,`;
const isEsmMode = /,--import,cfg-test[,/]/.test(nodeOptions);
const isWatchMode = /,--watch,/.test(nodeOptions);
const isDTsFile = file.endsWith(".d.ts");
const isTypeScript = /\.[cm]?tsx?$/i.test(file);
log.debug(() => [
`esm mode -> ${isEsmMode}`,
`watch mode -> ${isWatchMode}`,
`typescript file -> ${isTypeScript}`,
`declare file -> ${isDTsFile}`,
`argv -> ${argv.map((a) => JSON.stringify(a)).join(" ")}`,
`execArgv -> ${execArgv.map((a) => JSON.stringify(a)).join(" ")}`,
`cwd -> ${JSON.stringify(cwd)}`,
`parentUrl -> ${JSON.stringify(parentUrl)}`,
`target file -> ${JSON.stringify(file)}`
]);
if (isEsmMode && true) {
log.error(() => ["Cannot import `cfg-test` in CommonJS"]);
import_node_process.default.exit(1);
}
const env = {
...import_define.testEnv,
CFG_TEST_CFG: import_node_process.default.env.CFG_TEST_CFG ?? `${[
".config/cfg-test",
".config/cfg-test/config",
"config/cfg-test",
"config/cfg-test/config",
"cfg-test"
]}`,
CFG_TEST_FILE: file
};
if (isEsmMode) {
Object.assign(env, {
CFG_TEST_URL: (0, import_node_url.pathToFileURL)(file)
});
}
Object.assign(env, {
CFG_TEST_WATCH: `${isWatchMode}`
});
const originalEnv = { ...import_node_process.default.env };
log.debug(
() => Object.entries(env).filter(([k, v]) => [void 0, v].includes(originalEnv[k])).
map(([k, v]) => `Added env.${k}=${JSON.stringify(v)} by cfg-test.`)
);
log.warn(
() => Object.entries(env).filter(([k, v]) => [void 0, v].every((v2) => v2 !==
originalEnv[k])).map(([k, v]) => `Updated env.${k}=${JSON.stringify(v)} by c\
fg-test.`)
);
Object.assign(import_node_process.default.env, env);
const cfgTest = new Proxy(require2("node:test"), {
get(target, p, receiver) {
switch (p) {
case "url":
return import_node_process.default.env.CFG_TEST_URL;
case "file":
return import_node_process.default.env.CFG_TEST_FILE;
case "watch":
return import_node_process.default.env.CFG_TEST_WATCH === "true";
case "assert":
return require2("node:assert/strict");
default:
return Reflect.get(target, p, receiver);
}
}
});
global.cfgTest = cfgTest;
let cfg;
for (const id of import_node_process.default.env.CFG_TEST_CFG.split(",")) {
const cfgPath = id.endsWith(".json") ? id : `${id}.json`;
if ((0, import_node_fs.existsSync)(cfgPath)) {
cfg = JSON.parse((0, import_node_fs.readFileSync)(cfgPath, "utf8"));
break;
}
}
if (cfg && cfg.env) {
for (const [key, value] of Object.entries(cfg.env)) {
if (typeof value !== "string") {
continue;
}
if (import_node_process.default.env[key] === void 0) {
log.debug(() => [`Added env.${key} by config file.`]);
} else {
log.warn(() => [`Updated env.${key} by config file.`]);
}
import_node_process.default.env[key] = value;
}
}
if (cfg && cfg.globals) {
for (const [key, value] of Object.entries(cfg.globals)) {
if (key in global) {
log.warn(() => [`Updated global.${key} by config file.`]);
} else {
log.debug(() => [`Added global.${key} by config file.`]);
global[key] = value;
}
}
}
if (cfg && cfg.import) {
if (!Array.isArray(cfg.import)) {
cfg.import = [cfg.import];
}
for (const id of cfg.import) {
log.debug(() => [`Imported module ${id} by config file.`]);
(0, import_node_module.register)(id, parentUrl);
}
}
if (cfg && cfg.require) {
if (!Array.isArray(cfg.require)) {
cfg.require = [cfg.require];
}
for (const id of cfg.require) {
log.debug(() => [`Required module ${id} by config file.`]);
require2(id);
}
}
const ctx = {
log,
argv,
file,
execArgv,
isEsmMode,
parentUrl,
isWatchMode,
isTypeScript,
import(id) {
try {
log.debug(() => [`Register ESM module ${id}.`]);
(0, import_node_module.register)(id, parentUrl);
log.debug(() => [`Registered ESM module ${id}.`]);
} catch (e) {
log.error(() => [`Cannot register ESM module ${id}.`]);
throw e;
}
},
require(id, onLoad) {
try {
log.debug(() => [`Register CJS module ${id}`]);
const mod = require2(id);
log.debug(() => [`Loaded CJS module ${id}`]);
onLoad(mod);
log.debug(() => [`Registered CJS module ${id}`]);
} catch (e) {
log.error(() => [`Cannot register CJS module ${id}.`]);
throw e;
}
}
};
if (isDTsFile) {
if (ctx.isEsmMode) {
ctx.import("cfg-test/dts-loader");
} else {
require2("node:module")._extensions[".ts"] = () => "";
ctx.log.debug(() => ["Registered CJS module cfg-test/dts-loader."]);
}
return;
}
return ctx;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
register
});
//# sourceMappingURL=api.cjs.map