@jterrazz/test 4.0.0 → 5.0.0

package/dist/index.js

@@ -220,20 +220,6 @@ function formatStartupReport(mode, services, app) {
 	lines.push("");
 	return lines.join("\n");
 }
-function formatStatusError(expectedStatus, receivedStatus, request, responseBody) {
-	const lines = [];
-	lines.push(`Expected status: ${GREEN}${expectedStatus}${RESET}`);
-	lines.push(`Received status: ${RED}${receivedStatus}${RESET}`);
-	lines.push("");
-	lines.push(`${DIM}${request.method} ${request.path}${RESET}`);
-	if (request.body) lines.push(formatJson(request.body, DIM));
-	if (responseBody) {
-		lines.push("");
-		lines.push(`${DIM}Response:${RESET}`);
-		lines.push(formatJson(responseBody, RED));
-	}
-	return lines.join("\n");
-}
 function formatTableDiff(table, columns, expected, actual) {
 	const lines = [];
 	lines.push(`Table "${table}" mismatch`);
@@ -282,66 +268,9 @@ 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`;
 }
-function formatJson(value, color) {
-	return JSON.stringify(value, null, 2).split("\n").map((line) => `${color}${line}${RESET}`).join("\n");
-}
 function formatRow(row) {
 	return row.map((v) => String(v ?? "null")).join("  |  ");
 }
@@ -837,205 +766,35 @@ var HonoAdapter = class {
 	}
 };
 //#endregion
-//#region src/specification/assertions/base.ts
-/**
-* Base assertion that handles .not negation.
-* Subclasses call this.assert(condition, message, negatedMessage) for each predicate.
-*/
-var BaseAssertion = class {
-	negated = false;
-	get not() {
-		const clone = Object.create(Object.getPrototypeOf(this));
-		Object.assign(clone, this);
-		clone.negated = !this.negated;
-		return clone;
-	}
-	assert(condition, message, negatedMessage) {
-		if (this.negated) {
-			if (condition) throw new Error(negatedMessage);
-		} else if (!condition) throw new Error(message);
-	}
-};
-//#endregion
-//#region src/specification/assertions/file.ts
-/**
-* Assertions on a file in the working directory.
-* Usage: result.file("dist/index.js").toExist()
-*/
-var FileAssertion = class extends BaseAssertion {
-	filePath;
-	resolvedPath;
-	constructor(filePath, workDir) {
-		super();
-		this.filePath = filePath;
-		this.resolvedPath = resolve(workDir, filePath);
-	}
-	toExist() {
-		const exists = existsSync(this.resolvedPath);
-		this.assert(exists, formatFileMissing(this.filePath), formatFileUnexpected(this.filePath));
-	}
-	toContain(expected) {
-		if (!existsSync(this.resolvedPath)) {
-			if (this.negated) return;
-			throw new Error(formatFileMissing(this.filePath));
-		}
-		const content = readFileSync(this.resolvedPath, "utf8");
-		const found = content.includes(expected);
-		this.assert(found, formatFileContentMismatch(this.filePath, expected, content), `Expected file "${this.filePath}" NOT to contain "${expected}"`);
-	}
-	toMatch(pattern) {
-		if (!existsSync(this.resolvedPath)) {
-			if (this.negated) return;
-			throw new Error(formatFileMissing(this.filePath));
-		}
-		const content = readFileSync(this.resolvedPath, "utf8");
-		const found = pattern.test(content);
-		this.assert(found, `Expected file "${this.filePath}" to match: ${pattern}\n\nActual content:\n${content.slice(0, 500)}`, `Expected file "${this.filePath}" NOT to match: ${pattern}`);
-	}
-};
-//#endregion
-//#region src/specification/assertions/response.ts
-/**
-* Assertions on an HTTP response body.
-* Usage: result.response.toMatchFile("expected.json")
-*/
-var ResponseAssertion = class extends BaseAssertion {
-	body;
-	testDir;
-	constructor(body, testDir) {
-		super();
-		this.body = body;
-		this.testDir = testDir;
-	}
-	toMatchFile(file) {
-		const expected = JSON.parse(readFileSync(resolve(this.testDir, "responses", file), "utf8"));
-		const match = JSON.stringify(this.body) === JSON.stringify(expected);
-		this.assert(match, formatResponseDiff(file, expected, this.body), `Expected response NOT to match file "${file}", but it did`);
-	}
-	toContain(subset) {
-		const bodyStr = JSON.stringify(this.body);
-		const subsetStr = JSON.stringify(subset);
-		const bodyObj = typeof this.body === "object" && this.body !== null ? this.body : {};
-		const match = Object.entries(subset).every(([key, value]) => JSON.stringify(bodyObj[key]) === JSON.stringify(value));
-		this.assert(match, `Expected response to contain: ${subsetStr}\n\nActual response:\n${bodyStr}`, `Expected response NOT to contain: ${subsetStr}`);
-	}
-};
-//#endregion
-//#region src/specification/assertions/string.ts
-/**
-* Assertions on a string (stdout, stderr, response body).
-* Usage: result.stdout.toContain("hello")
-*/
-var StringAssertion = class extends BaseAssertion {
-	actual;
-	label;
-	testDir;
-	constructor(actual, label, testDir) {
-		super();
-		this.actual = actual;
-		this.label = label;
-		this.testDir = testDir;
-	}
-	toContain(expected, options) {
-		if (options?.near) {
-			const found = this.containsNear(expected, options.near);
-			this.assert(found, `Expected ${this.label} to contain "${expected}" near "${options.near}"\n\n${this.label}:\n${this.truncate(this.actual)}`, `Expected ${this.label} NOT to contain "${expected}" near "${options.near}", but it was found`);
-		} else {
-			const found = this.actual.includes(expected);
-			this.assert(found, `Expected ${this.label} to contain: "${expected}"\n\nActual ${this.label}:\n${this.truncate(this.actual)}`, `Expected ${this.label} NOT to contain: "${expected}"`);
-		}
-	}
-	toMatch(pattern) {
-		const found = pattern.test(this.actual);
-		this.assert(found, `Expected ${this.label} to match: ${pattern}\n\nActual ${this.label}:\n${this.truncate(this.actual)}`, `Expected ${this.label} NOT to match: ${pattern}`);
-	}
-	toMatchFile(file) {
-		if (!this.testDir) throw new Error("toMatchFile requires a test directory context");
-		const expected = readFileSync(resolve(this.testDir, "expected", file), "utf8").trim();
-		const actual = this.actual.trim();
-		const match = actual === expected;
-		this.assert(match, formatStdoutDiff(file, expected, actual), `Expected ${this.label} NOT to match file "${file}", but it did`);
-	}
-	toBeEmpty() {
-		const empty = this.actual.trim() === "";
-		this.assert(empty, `Expected ${this.label} to be empty\n\nActual ${this.label}:\n${this.truncate(this.actual)}`, `Expected ${this.label} NOT to be empty`);
-	}
-	containsNear(target, near, proximity = 500) {
-		const clean = this.stripAnsi(this.actual);
-		const nearLower = near.toLowerCase();
-		const targetLower = target.toLowerCase();
-		let searchFrom = 0;
-		while (true) {
-			const idx = clean.toLowerCase().indexOf(nearLower, searchFrom);
-			if (idx === -1) break;
-			const windowStart = Math.max(0, idx - proximity);
-			const windowEnd = Math.min(clean.length, idx + nearLower.length + proximity);
-			if (clean.substring(windowStart, windowEnd).toLowerCase().includes(targetLower)) return true;
-			searchFrom = idx + 1;
-		}
-		return false;
-	}
-	stripAnsi(str) {
-		return str.replace(/\x1b\[[0-9;]*m/g, "");
-	}
-	truncate(str, maxLines = 20) {
-		const lines = str.split("\n");
-		if (lines.length <= maxLines) return str;
-		return `${lines.slice(0, maxLines).join("\n")}\n... (${lines.length - maxLines} more lines)`;
-	}
-};
-//#endregion
-//#region src/specification/assertions/table.ts
-/**
-* Assertions on a database table.
-* Usage: await result.table("users").toMatch({ columns: ["name"], rows: [["Alice"]] })
-*/
-var TableAssertion = class extends BaseAssertion {
+//#region src/specification/specification.ts
+var TableAssertion = class {
 	tableName;
 	db;
 	constructor(tableName, db) {
-		super();
 		this.tableName = tableName;
 		this.db = db;
 	}
 	async toMatch(expected) {
 		const actual = await this.db.query(this.tableName, expected.columns);
-		const match = JSON.stringify(actual) === JSON.stringify(expected.rows);
-		this.assert(match, formatTableDiff(this.tableName, expected.columns, expected.rows, actual), `Expected table "${this.tableName}" NOT to match, but it did`);
+		if (JSON.stringify(actual) !== JSON.stringify(expected.rows)) throw new Error(formatTableDiff(this.tableName, expected.columns, expected.rows, actual));
 	}
 	async toBeEmpty() {
 		const actual = await this.db.query(this.tableName, ["*"]);
-		const empty = actual.length === 0;
-		this.assert(empty, `Expected table "${this.tableName}" to be empty, but it has ${actual.length} rows`, `Expected table "${this.tableName}" NOT to be empty, but it is`);
+		if (actual.length !== 0) throw new Error(`Expected table "${this.tableName}" to be empty, but it has ${actual.length} rows`);
 	}
 };
-//#endregion
-//#region src/specification/assertions/value.ts
-/**
-* Assertions on a single value (exit code, status code).
-* Usage: result.exitCode.toBe(0)
-*/
-var ValueAssertion = class extends BaseAssertion {
-	actual;
-	label;
-	context;
-	constructor(actual, label, context) {
-		super();
-		this.actual = actual;
-		this.label = label;
-		this.context = context;
+var ResponseAccessor = class {
+	body;
+	testDir;
+	constructor(body, testDir) {
+		this.body = body;
+		this.testDir = testDir;
 	}
-	toBe(expected) {
-		const match = this.actual === expected;
-		let message;
-		if (this.label === "exit code" && this.context?.stdout !== void 0) message = formatExitCodeError(expected, this.actual, this.context.stdout ?? "", this.context.stderr ?? "");
-		else if (this.label === "status" && this.context?.request) message = formatStatusError(expected, this.actual, this.context.request, this.context.responseBody);
-		else message = `Expected ${this.label}: ${expected}\nReceived ${this.label}: ${this.actual}`;
-		this.assert(match, message, `Expected ${this.label} NOT to be ${expected}, but it was`);
+	toMatchFile(file) {
+		const expected = JSON.parse(readFileSync(resolve(this.testDir, "responses", file), "utf8"));
+		if (JSON.stringify(this.body) !== JSON.stringify(expected)) throw new Error(formatResponseDiff(file, expected, this.body));
 	}
 };
-//#endregion
-//#region src/specification/specification.ts
 var SpecificationResult = class {
 	commandResult;
 	config;
@@ -1053,32 +812,34 @@ var SpecificationResult = class {
 	}
 	get exitCode() {
 		if (!this.commandResult) throw new Error(".exitCode requires a CLI action (.exec())");
-		return new ValueAssertion(this.commandResult.exitCode, "exit code", {
-			stderr: this.commandResult.stderr,
-			stdout: this.commandResult.stdout
-		});
+		return this.commandResult.exitCode;
 	}
 	get status() {
-		if (!this.responseData || !this.requestInfo) throw new Error(".status requires an HTTP action (.get(), .post(), etc.)");
-		return new ValueAssertion(this.responseData.status, "status", {
-			request: this.requestInfo,
-			responseBody: this.responseData.body
-		});
-	}
-	get response() {
-		if (!this.responseData) throw new Error(".response requires an HTTP action (.get(), .post(), etc.)");
-		return new ResponseAssertion(this.responseData.body, this.testDir);
+		if (!this.responseData) throw new Error(".status requires an HTTP action (.get(), .post(), etc.)");
+		return this.responseData.status;
 	}
 	get stdout() {
 		if (!this.commandResult) throw new Error(".stdout requires a CLI action (.exec())");
-		return new StringAssertion(this.commandResult.stdout, "stdout", this.testDir);
+		return this.commandResult.stdout;
 	}
 	get stderr() {
 		if (!this.commandResult) throw new Error(".stderr requires a CLI action (.exec())");
-		return new StringAssertion(this.commandResult.stderr, "stderr", this.testDir);
+		return this.commandResult.stderr;
+	}
+	get response() {
+		if (!this.responseData) throw new Error(".response requires an HTTP action (.get(), .post(), etc.)");
+		return new ResponseAccessor(this.responseData.body, this.testDir);
 	}
 	file(path) {
-		return new FileAssertion(path, this.workDir ?? this.testDir);
+		const resolvedPath = resolve(this.workDir ?? this.testDir, path);
+		const exists = existsSync(resolvedPath);
+		return {
+			get content() {
+				if (!exists) throw new Error(`File not found: ${path}`);
+				return readFileSync(resolvedPath, "utf8");
+			},
+			exists
+		};
 	}
 	table(tableName, options) {
 		const db = this.resolveDatabase(options?.service);
@@ -1191,6 +952,7 @@ var SpecificationBuilder = class {
 		return this.runCliAction(workDir);
 	}
 	prepareWorkDir() {
+		if (!this.projectName && this.fixtures.length === 0) return this.config.fixturesRoot ?? process.cwd();
 		const tempDir = mkdtempSync(resolve(tmpdir(), "spec-cli-"));
 		if (this.projectName && this.config.fixturesRoot) {
 			const projectDir = resolve(this.config.fixturesRoot, this.projectName);
@@ -1222,8 +984,8 @@ var SpecificationBuilder = class {
 		else if (Array.isArray(this.commandArgs)) {
 			commandResult = {
 				exitCode: 0,
-				stdout: "",
-				stderr: ""
+				stderr: "",
+				stdout: ""
 			};
 			for (const args of this.commandArgs) {
 				commandResult = await this.config.command.exec(args, workDir);
@@ -1252,16 +1014,26 @@ function getCallerDir() {
 	}
 	throw new Error("Cannot detect caller directory from stack trace");
 }
-/**
-* Create a specification runner.
-* Automatically detects the test directory from the call site.
-*/
 function createSpecificationRunner(config) {
 	return (label) => {
 		return new SpecificationBuilder(config, getCallerDir(), label);
 	};
 }
 //#endregion
+//#region src/specification/grep.ts
+/**
+* Extract text blocks from output that contain a pattern.
+* Splits by blank lines (how linter/compiler output is structured),
+* returns only blocks matching the pattern.
+*
+* @example
+* expect(grep(result.stdout, "unused-var.ts")).toContain("no-unused-vars")
+* expect(grep(result.stdout, "valid/sorted.ts")).not.toContain("sort-imports")
+*/
+function grep(output, pattern) {
+	return output.replace(/\x1b\[[0-9;]*m/g, "").split(/\n\s*\n/).filter((block) => block.includes(pattern)).join("\n\n");
+}
+//#endregion
 //#region src/specification/index.ts
 /**
 * Resolve root — if relative, resolves from the caller's directory.
@@ -1380,6 +1152,6 @@ async function cli(options) {
 	return runner;
 }
 //#endregion
-export { ExecAdapter, FetchAdapter, HonoAdapter, Orchestrator, cli, e2e, integration, mockOf, mockOfDate, normalizeOutput, postgres, redis, stripAnsi };
+export { ExecAdapter, FetchAdapter, HonoAdapter, Orchestrator, cli, e2e, grep, integration, mockOf, mockOfDate, normalizeOutput, postgres, redis, stripAnsi };
 
 //# sourceMappingURL=index.js.map