vitest-bats 0.0.1

package/runtime.js

@@ -0,0 +1,172 @@
+import { executeBats } from "./bats-executor.js";
+import { generateBatsFile } from "./bats-generator.js";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+
+//#region src/runtime.ts
+/**
+* Symbol brand identifying a BatsResult instance. Used by matchers to
+* detect BatsResult inputs in a way that survives:
+* - Module-graph duplication (per-entry self-contained bundles produced as
+*   the workaround for savvy-web/rslib-builder#158, where each entry has
+*   its own copy of the BatsResult class — `instanceof` would fail).
+* - Property name minification (a `constructor.name === "BatsResult"`
+*   check would break under any minifier that renames classes).
+*
+* Registered with `Symbol.for(...)` so the symbol is shared across module
+* graphs (the global symbol registry is process-wide).
+* @internal
+*/
+const BATS_RESULT_BRAND = Symbol.for("vitest-bats.BatsResult");
+/**
+* The value returned by `ScriptBuilder.run()`/`.exec()`. Wraps the raw exit status,
+* stdout/stderr (whole and split into lines), and recorded mock calls; assert
+* against it with the `expect.extend` matchers from `vitest-bats/setup`.
+* @public
+*/
+var BatsResult = class {
+	/** @internal */
+	[BATS_RESULT_BRAND] = true;
+	status;
+	output;
+	stderr;
+	lines;
+	stderr_lines;
+	calls;
+	_jsonCache = null;
+	constructor(data) {
+		this.status = data.status;
+		this.output = data.output;
+		this.stderr = data.stderr;
+		this.lines = data.output === "" ? [] : data.output.split("\n");
+		this.stderr_lines = data.stderr === "" ? [] : data.stderr.split("\n");
+		this.calls = data.calls;
+	}
+	json() {
+		if (this._jsonCache) return this._jsonCache.value;
+		let parsed;
+		try {
+			parsed = JSON.parse(this.output);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			throw new Error(`vitest-bats: result.output is not valid JSON: ${msg}`);
+		}
+		this._jsonCache = { value: parsed };
+		return parsed;
+	}
+};
+const builders = /* @__PURE__ */ new Set();
+/**
+* Resets every live `ScriptBuilder`'s `env()`/`flags()`/`mock()` configuration.
+* Called automatically between tests by `vitest-bats/setup`'s `beforeEach` hook.
+* @public
+*/
+function resetAllBuilders() {
+	for (const b of builders) b.reset();
+}
+function loadDeps() {
+	return {
+		batsPath: process.env.BATS_PATH ?? "bats",
+		batsSupportPath: process.env.BATS_SUPPORT_PATH ?? ""
+	};
+}
+function loadKcov(scriptPath) {
+	if (process.env.__VITEST_BATS_KCOV__ !== "1") return void 0;
+	const cacheDir = process.env.__VITEST_BATS_CACHE_DIR__;
+	const kcovPath = process.env.KCOV_PATH;
+	if (!cacheDir || !kcovPath) return void 0;
+	const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+	const scriptName = scriptPath.split("/").pop()?.replace(/\.sh$/, "") ?? "script";
+	const outputDir = resolve(cacheDir, "kcov", `${scriptName}-${id}`);
+	mkdirSync(outputDir, { recursive: true });
+	return {
+		kcovPath,
+		outputDir
+	};
+}
+function makeRecorderDir() {
+	const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+	const dir = resolve(tmpdir(), `vitest-bats-${process.pid}`, "recorder", id);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* Test-writing API returned by a `.sh` import. Configure with `env()`/`flags()`/
+* `mock()`, then terminate with `run(...args)` or `exec(shellExpr)` to get a
+* {@link BatsResult}.
+* @public
+*/
+var ScriptBuilder = class {
+	path;
+	name;
+	_env = {};
+	_flags = "";
+	_stubs = [];
+	constructor(path, name) {
+		this.path = path;
+		this.name = name;
+		builders.add(this);
+	}
+	env(vars) {
+		this._env = {
+			...this._env,
+			...vars
+		};
+		return this;
+	}
+	flags(value) {
+		this._flags = value;
+		return this;
+	}
+	mock(cmd, responses = {}) {
+		this._stubs.push({
+			cmd,
+			responses
+		});
+		return this;
+	}
+	run(...args) {
+		return this.execute({ kind: "args" }, args);
+	}
+	exec(shellExpr) {
+		return this.execute({
+			kind: "shell",
+			expression: shellExpr
+		}, []);
+	}
+	reset() {
+		this._env = {};
+		this._flags = "";
+		this._stubs = [];
+	}
+	execute(mode, args) {
+		const recorderDir = makeRecorderDir();
+		const deps = loadDeps();
+		const kcov = loadKcov(this.path);
+		const batsContent = generateBatsFile({
+			scriptPath: this.path,
+			args,
+			env: this._env,
+			flags: this._flags,
+			stubs: this._stubs,
+			recorderDir,
+			deps,
+			mode,
+			...kcov ? { kcov } : {}
+		});
+		try {
+			const data = executeBats({
+				batsPath: deps.batsPath,
+				batsContent,
+				recorderDir
+			});
+			return new BatsResult(data);
+		} finally {
+			this.reset();
+		}
+	}
+};
+
+//#endregion
+export { BATS_RESULT_BRAND, BatsResult, ScriptBuilder, resetAllBuilders };

package/schema.js

@@ -0,0 +1,75 @@
+import { Ajv } from "ajv";
+import addFormatsModule from "ajv-formats";
+
+//#region src/schema.ts
+const addFormats = addFormatsModule.default;
+let ajvSingleton = null;
+function getAjv() {
+	if (!ajvSingleton) {
+		ajvSingleton = new Ajv({
+			strict: false,
+			allErrors: true
+		});
+		addFormats(ajvSingleton);
+	}
+	return ajvSingleton;
+}
+const compiledCache = /* @__PURE__ */ new WeakMap();
+/**
+* Detects whether `schema` implements the Standard Schema (`~standard`) interface,
+* used by the `toMatchSchema` matcher to route to Standard Schema vs. JSON Schema
+* validation.
+* @internal
+*/
+function isStandardSchema(schema) {
+	if (schema === null || typeof schema !== "object") return false;
+	if (!("~standard" in schema)) return false;
+	const std = schema["~standard"];
+	return std !== null && typeof std === "object" && typeof std.validate === "function";
+}
+function pathToString(path) {
+	if (!path || path.length === 0) return "(root)";
+	return path.map((seg) => {
+		const key = typeof seg === "object" && seg !== null && "key" in seg ? seg.key : seg;
+		return typeof key === "number" ? `[${key}]` : String(key);
+	}).reduce((acc, cur) => {
+		if (cur.startsWith("[")) return acc + cur;
+		return acc.length === 0 ? cur : `${acc}.${cur}`;
+	}, "");
+}
+function validateStandard(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) throw new Error("vitest-bats: async Standard Schema validators are not supported. Await result.json() and use a built-in matcher (e.g., await expect(...).resolves.toEqual(...)) instead.");
+	if (!result.issues || result.issues.length === 0) return { ok: true };
+	return {
+		ok: false,
+		issues: result.issues.map((i) => `${pathToString(i.path)}: ${i.message}`)
+	};
+}
+function validateJsonSchema(schema, value) {
+	let compiled = compiledCache.get(schema);
+	if (!compiled) {
+		compiled = getAjv().compile(schema);
+		compiledCache.set(schema, compiled);
+	}
+	if (compiled(value)) return { ok: true };
+	return {
+		ok: false,
+		issues: (compiled.errors ?? []).map((err) => {
+			return `${err.instancePath || "(root)"}: ${err.message ?? "validation failed"}`;
+		})
+	};
+}
+/**
+* Validates `value` against a Standard Schema validator or a raw JSON Schema
+* object, backing the `toMatchSchema`/`toMatchJsonSchema` matchers.
+* @internal
+*/
+function validate(schema, value) {
+	if (isStandardSchema(schema)) return validateStandard(schema, value);
+	if (schema !== null && typeof schema === "object") return validateJsonSchema(schema, value);
+	throw new Error("vitest-bats: schema must be a Standard Schema validator or a JSON Schema object");
+}
+
+//#endregion
+export { isStandardSchema, validate };

package/setup.d.ts

@@ -0,0 +1 @@
+export {}

package/setup.js

@@ -0,0 +1,12 @@
+import { resetAllBuilders } from "./runtime.js";
+import { batsMatchers } from "./matchers.js";
+import { beforeEach, expect } from "vitest";
+
+//#region src/setup.ts
+expect.extend(batsMatchers);
+beforeEach(() => {
+	resetAllBuilders();
+});
+
+//#endregion
+export {  };

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.0"
+    }
+  ]
+}