@jterrazz/test 3.2.0 → 3.3.1

package/dist/index.js

@@ -2,9 +2,10 @@ import { i as __require, o as __toESM, t as __commonJSMin } from "./chunk.js";
 import { t as require_dist$1 } from "./dist.js";
 import MockDatePackage from "mockdate";
 import { mockDeep } from "vitest-mock-extended";
+import { cpSync, existsSync, mkdtempSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 //#region src/mocking/mock-of-date.ts
 const mockOfDate = MockDatePackage;
 //#endregion
@@ -279,6 +280,60 @@ function formatResponseDiff(file, expected, actual) {
 	}
 	return lines.join("\n");
 }
+function formatExitCodeError(expected, received, stdout, stderr) {
+	const lines = [];
+	lines.push(`Expected exit code: ${GREEN}${expected}${RESET}`);
+	lines.push(`Received exit code: ${RED}${received}${RESET}`);
+	if (stdout.trim()) {
+		lines.push("");
+		lines.push(`${DIM}stdout:${RESET}`);
+		for (const line of stdout.trim().split("\n").slice(-15)) lines.push(`  ${DIM}${line}${RESET}`);
+	}
+	if (stderr.trim()) {
+		lines.push("");
+		lines.push(`${DIM}stderr:${RESET}`);
+		for (const line of stderr.trim().split("\n").slice(-15)) lines.push(`  ${RED}${line}${RESET}`);
+	}
+	return lines.join("\n");
+}
+function formatStdoutDiff(file, expected, actual) {
+	const lines = [];
+	lines.push(`Output mismatch (${file})`);
+	lines.push("");
+	lines.push(`${GREEN}- Expected${RESET}`);
+	lines.push(`${RED}+ Received${RESET}`);
+	lines.push("");
+	const expectedLines = expected.split("\n");
+	const actualLines = actual.split("\n");
+	const maxLines = Math.max(expectedLines.length, actualLines.length);
+	for (let i = 0; i < maxLines; i++) {
+		const exp = expectedLines[i];
+		const act = actualLines[i];
+		if (exp === act) lines.push(`  ${exp}`);
+		else {
+			if (exp !== void 0) lines.push(`${GREEN}- ${exp}${RESET}`);
+			if (act !== void 0) lines.push(`${RED}+ ${act}${RESET}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatFileMissing(path) {
+	return `Expected file to exist: ${RED}${path}${RESET}`;
+}
+function formatFileUnexpected(path) {
+	return `Expected file NOT to exist: ${RED}${path}${RESET}`;
+}
+function formatFileContentMismatch(path, expected, actual) {
+	const lines = [];
+	lines.push(`File "${path}" does not contain expected content`);
+	lines.push("");
+	lines.push(`${GREEN}Expected to contain:${RESET}`);
+	lines.push(`  ${GREEN}${expected}${RESET}`);
+	lines.push("");
+	lines.push(`${RED}Actual content (first 20 lines):${RESET}`);
+	for (const line of actual.split("\n").slice(0, 20)) lines.push(`  ${DIM}${line}${RESET}`);
+	return lines.join("\n");
+}
 function rowLabel(n) {
 	return n === 1 ? "1 row" : `${n} rows`;
 }
@@ -4842,6 +4897,46 @@ var Orchestrator = class {
 	}
 };
 //#endregion
+//#region src/specification/adapters/exec.adapter.ts
+/**
+* Executes CLI commands via execSync.
+* Used by cli() for local command execution.
+*/
+var ExecAdapter = class {
+	command;
+	constructor(command) {
+		this.command = command;
+	}
+	async exec(args, cwd) {
+		const env = {
+			...process.env,
+			INIT_CWD: void 0
+		};
+		try {
+			return {
+				exitCode: 0,
+				stdout: execSync(`${this.command} ${args}`, {
+					cwd,
+					encoding: "utf8",
+					env,
+					stdio: [
+						"pipe",
+						"pipe",
+						"pipe"
+					]
+				}),
+				stderr: ""
+			};
+		} catch (error) {
+			return {
+				exitCode: error.status ?? 1,
+				stdout: error.stdout?.toString() ?? "",
+				stderr: error.stderr?.toString() ?? ""
+			};
+		}
+	}
+};
+//#endregion
 //#region src/specification/adapters/fetch.adapter.ts
 /**
 * Server adapter for real HTTP — sends actual fetch requests.
@@ -4904,25 +4999,60 @@ var HonoAdapter = class {
 //#endregion
 //#region src/specification/specification.ts
 var SpecificationResult = class {
-	response;
+	commandResult;
 	config;
-	testDir;
 	requestInfo;
-	constructor(response, config, testDir, requestInfo) {
-		this.response = response;
-		this.config = config;
-		this.testDir = testDir;
-		this.requestInfo = requestInfo;
+	response;
+	testDir;
+	workDir;
+	constructor(options) {
+		this.response = options.response;
+		this.commandResult = options.commandResult;
+		this.config = options.config;
+		this.testDir = options.testDir;
+		this.requestInfo = options.requestInfo;
+		this.workDir = options.workDir;
 	}
 	expectStatus(code) {
+		if (!this.response || !this.requestInfo) throw new Error("expectStatus requires an HTTP action (.get(), .post(), etc.)");
 		if (this.response.status !== code) throw new Error(formatStatusError(code, this.response.status, this.requestInfo, this.response.body));
 		return this;
 	}
 	expectResponse(file) {
+		if (!this.response) throw new Error("expectResponse requires an HTTP action (.get(), .post(), etc.)");
 		const expected = JSON.parse(readFileSync(resolve(this.testDir, "responses", file), "utf8"));
 		if (JSON.stringify(this.response.body) !== JSON.stringify(expected)) throw new Error(formatResponseDiff(file, expected, this.response.body));
 		return this;
 	}
+	expectExitCode(code) {
+		if (!this.commandResult) throw new Error("expectExitCode requires a CLI action (.exec())");
+		if (this.commandResult.exitCode !== code) throw new Error(formatExitCodeError(code, this.commandResult.exitCode, this.commandResult.stdout, this.commandResult.stderr));
+		return this;
+	}
+	expectStdout(file) {
+		if (!this.commandResult) throw new Error("expectStdout requires a CLI action (.exec())");
+		const expected = readFileSync(resolve(this.testDir, "expected", file), "utf8").trim();
+		const actual = this.commandResult.stdout.trim();
+		if (actual !== expected) throw new Error(formatStdoutDiff(file, expected, actual));
+		return this;
+	}
+	expectStdoutContains(str) {
+		if (!this.commandResult) throw new Error("expectStdoutContains requires a CLI action (.exec())");
+		if (!this.commandResult.stdout.includes(str)) throw new Error(`Expected stdout to contain: "${str}"\n\nActual stdout:\n${this.commandResult.stdout}`);
+		return this;
+	}
+	expectStderr(file) {
+		if (!this.commandResult) throw new Error("expectStderr requires a CLI action (.exec())");
+		const expected = readFileSync(resolve(this.testDir, "expected", file), "utf8").trim();
+		const actual = this.commandResult.stderr.trim();
+		if (actual !== expected) throw new Error(formatStdoutDiff(file, expected, actual));
+		return this;
+	}
+	expectStderrContains(str) {
+		if (!this.commandResult) throw new Error("expectStderrContains requires a CLI action (.exec())");
+		if (!this.commandResult.stderr.includes(str)) throw new Error(`Expected stderr to contain: "${str}"\n\nActual stderr:\n${this.commandResult.stderr}`);
+		return this;
+	}
 	async expectTable(table, options) {
 		const db = this.resolveDatabase(options.service);
 		if (!db) throw new Error(options.service ? `expectTable requires database "${options.service}" but it was not found` : "expectTable requires a database adapter");
@@ -4930,18 +5060,40 @@ var SpecificationResult = class {
 		if (JSON.stringify(actual) !== JSON.stringify(options.rows)) throw new Error(formatTableDiff(table, options.columns, options.rows, actual));
 		return this;
 	}
+	expectFile(path) {
+		if (!existsSync(this.resolveWorkPath(path))) throw new Error(formatFileMissing(path));
+		return this;
+	}
+	expectNoFile(path) {
+		if (existsSync(this.resolveWorkPath(path))) throw new Error(formatFileUnexpected(path));
+		return this;
+	}
+	expectFileContains(path, content) {
+		const resolved = this.resolveWorkPath(path);
+		if (!existsSync(resolved)) throw new Error(formatFileMissing(path));
+		const actual = readFileSync(resolved, "utf8");
+		if (!actual.includes(content)) throw new Error(formatFileContentMismatch(path, content, actual));
+		return this;
+	}
 	resolveDatabase(serviceName) {
 		if (serviceName && this.config.databases) return this.config.databases.get(serviceName);
 		return this.config.database;
 	}
+	resolveWorkPath(path) {
+		if (this.workDir) return resolve(this.workDir, path);
+		return resolve(this.testDir, path);
+	}
 };
 var SpecificationBuilder = class {
+	commandArgs = null;
 	config;
-	testDir;
+	fixtures = [];
 	label;
-	seeds = [];
 	mocks = [];
+	projectName = null;
 	request = null;
+	seeds = [];
+	testDir;
 	constructor(config, testDir, label) {
 		this.config = config;
 		this.testDir = testDir;
@@ -4954,6 +5106,14 @@ var SpecificationBuilder = class {
 		});
 		return this;
 	}
+	fixture(file) {
+		this.fixtures.push({ file });
+		return this;
+	}
+	project(name) {
+		this.projectName = name;
+		return this;
+	}
 	mock(file) {
 		this.mocks.push({ file });
 		return this;
@@ -4967,17 +5127,17 @@ var SpecificationBuilder = class {
 	}
 	post(path, bodyFile) {
 		this.request = {
+			bodyFile,
 			method: "POST",
-			path,
-			bodyFile
+			path
 		};
 		return this;
 	}
 	put(path, bodyFile) {
 		this.request = {
+			bodyFile,
 			method: "PUT",
-			path,
-			bodyFile
+			path
 		};
 		return this;
 	}
@@ -4988,8 +5148,17 @@ var SpecificationBuilder = class {
 		};
 		return this;
 	}
+	exec(args) {
+		this.commandArgs = args;
+		return this;
+	}
 	async run() {
-		if (!this.request) throw new Error(`Specification "${this.label}": no request defined. Call .get(), .post(), etc. before .run()`);
+		const hasHttpAction = this.request !== null;
+		const hasCliAction = this.commandArgs !== null;
+		if (!hasHttpAction && !hasCliAction) throw new Error(`Specification "${this.label}": no action defined. Call .get(), .post(), .exec(), etc. before .run()`);
+		if (hasHttpAction && hasCliAction) throw new Error(`Specification "${this.label}": cannot mix HTTP (.get/.post) and CLI (.exec) actions`);
+		let workDir = null;
+		if (hasCliAction) workDir = this.prepareWorkDir();
 		if (this.config.databases) for (const db of this.config.databases.values()) await db.reset();
 		else if (this.config.database) await this.config.database.reset();
 		for (const entry of this.seeds) {
@@ -5002,13 +5171,43 @@ var SpecificationBuilder = class {
 			const sql = readFileSync(resolve(this.testDir, "seeds", entry.file), "utf8");
 			await db.seed(sql);
 		}
+		if (this.fixtures.length > 0 && workDir) for (const entry of this.fixtures) cpSync(resolve(this.testDir, "fixtures", entry.file), resolve(workDir, entry.file), { recursive: true });
 		for (const entry of this.mocks) JSON.parse(readFileSync(resolve(this.testDir, "mock", entry.file), "utf8"));
+		if (hasHttpAction) return this.runHttpAction();
+		return this.runCliAction(workDir);
+	}
+	prepareWorkDir() {
+		const tempDir = mkdtempSync(resolve(tmpdir(), "spec-cli-"));
+		if (this.projectName && this.config.fixturesRoot) {
+			const projectDir = resolve(this.config.fixturesRoot, this.projectName);
+			if (!existsSync(projectDir)) throw new Error(`project("${this.projectName}"): fixture project not found at ${projectDir}`);
+			cpSync(projectDir, tempDir, { recursive: true });
+		}
+		return tempDir;
+	}
+	async runHttpAction() {
+		if (!this.config.server) throw new Error("HTTP actions require a server adapter (use integration() or e2e())");
 		let body;
 		if (this.request.bodyFile) body = JSON.parse(readFileSync(resolve(this.testDir, "requests", this.request.bodyFile), "utf8"));
-		return new SpecificationResult(await this.config.server.request(this.request.method, this.request.path, body), this.config, this.testDir, {
-			method: this.request.method,
-			path: this.request.path,
-			body
+		const response = await this.config.server.request(this.request.method, this.request.path, body);
+		return new SpecificationResult({
+			config: this.config,
+			requestInfo: {
+				body,
+				method: this.request.method,
+				path: this.request.path
+			},
+			response,
+			testDir: this.testDir
+		});
+	}
+	async runCliAction(workDir) {
+		if (!this.config.command) throw new Error("CLI actions require a command adapter (use cli())");
+		return new SpecificationResult({
+			commandResult: await this.config.command.exec(this.commandArgs, workDir),
+			config: this.config,
+			testDir: this.testDir,
+			workDir
 		});
 	}
 };
@@ -5057,21 +5256,25 @@ function resolveProjectRoot(root) {
 	return resolve(process.cwd(), root);
 }
 /**
+* Resolve a CLI command — checks node_modules/.bin, then treats as absolute/PATH.
+*/
+function resolveCommand(command, root) {
+	if (isAbsolute(command)) return command;
+	const binPath = resolve(root, "node_modules/.bin", command);
+	if (existsSync(binPath)) return binPath;
+	const cwdBinPath = resolve(process.cwd(), "node_modules/.bin", command);
+	if (existsSync(cwdBinPath)) return cwdBinPath;
+	return command;
+}
+/**
 * Create an integration specification runner.
 * Starts infra containers via testcontainers, app runs in-process.
-*
-* @example
-* const db = postgres({ compose: "db" });
-* export const spec = await integration({
-*     services: [db],
-*     app: () => createApp({ databaseUrl: db.connectionString }),
-* });
 */
 async function integration(options) {
 	const orchestrator = new Orchestrator({
-		services: options.services,
 		mode: "integration",
-		root: resolveProjectRoot(options.root)
+		root: resolveProjectRoot(options.root),
+		services: options.services
 	});
 	await orchestrator.start();
 	const app = options.app();
@@ -5089,17 +5292,12 @@ async function integration(options) {
 /**
 * Create an E2E specification runner.
 * Starts full docker compose stack. App URL and database auto-detected.
-*
-* @example
-* export const spec = await e2e({
-*     root: "../fixtures/app",
-* });
 */
 async function e2e(options = {}) {
 	const orchestrator = new Orchestrator({
-		services: [],
 		mode: "e2e",
-		root: resolveProjectRoot(options.root)
+		root: resolveProjectRoot(options.root),
+		services: []
 	});
 	await orchestrator.startCompose();
 	const appUrl = orchestrator.getAppUrl();
@@ -5115,7 +5313,46 @@ async function e2e(options = {}) {
 	runner.orchestrator = orchestrator;
 	return runner;
 }
+/**
+* Create a CLI specification runner.
+* Runs CLI commands against fixture projects. Optionally starts infrastructure.
+*
+* @example
+* export const spec = await cli({
+*     command: resolve(import.meta.dirname, "../../bin/my-cli.sh"),
+*     root: "../fixtures",
+* });
+*/
+async function cli(options) {
+	const root = resolveProjectRoot(options.root);
+	const command = resolveCommand(options.command, root);
+	let orchestrator = null;
+	let database;
+	let databases;
+	if (options.services?.length) {
+		orchestrator = new Orchestrator({
+			mode: "integration",
+			root,
+			services: options.services
+		});
+		await orchestrator.start();
+		database = orchestrator.getDatabase() ?? void 0;
+		const dbMap = orchestrator.getDatabases();
+		databases = dbMap.size > 0 ? dbMap : void 0;
+	}
+	const runner = createSpecificationRunner({
+		command: new ExecAdapter(command),
+		database,
+		databases,
+		fixturesRoot: root
+	});
+	runner.cleanup = async () => {
+		if (orchestrator) await orchestrator.stop();
+	};
+	runner.orchestrator = orchestrator;
+	return runner;
+}
 //#endregion
-export { FetchAdapter, HonoAdapter, Orchestrator, e2e, integration, mockOf, mockOfDate, normalizeOutput, postgres, redis, stripAnsi };
+export { ExecAdapter, FetchAdapter, HonoAdapter, Orchestrator, cli, e2e, integration, mockOf, mockOfDate, normalizeOutput, postgres, redis, stripAnsi };
 
 //# sourceMappingURL=index.js.map