@jterrazz/test 3.5.0 → 4.0.1

package/dist/index.d.ts

@@ -110,6 +110,99 @@ declare class Orchestrator {
   getAppUrl(): null | string;
 }
 //#endregion
+//#region src/specification/assertions/base.d.ts
+/**
+ * Base assertion that handles .not negation.
+ * Subclasses call this.assert(condition, message, negatedMessage) for each predicate.
+ */
+declare class BaseAssertion {
+  protected negated: boolean;
+  get not(): this;
+  protected assert(condition: boolean, message: string, negatedMessage: string): void;
+}
+//#endregion
+//#region src/specification/assertions/file.d.ts
+/**
+ * Assertions on a file in the working directory.
+ * Usage: result.file("dist/index.js").toExist()
+ */
+declare class FileAssertion extends BaseAssertion {
+  private filePath;
+  private resolvedPath;
+  constructor(filePath: string, workDir: string);
+  toExist(): void;
+  toContain(expected: string): void;
+  toMatch(pattern: RegExp): void;
+}
+//#endregion
+//#region src/specification/assertions/response.d.ts
+/**
+ * Assertions on an HTTP response body.
+ * Usage: result.response.toMatchFile("expected.json")
+ */
+declare class ResponseAssertion extends BaseAssertion {
+  private body;
+  private testDir;
+  constructor(body: unknown, testDir: string);
+  toMatchFile(file: string): void;
+  toContain(subset: Record<string, unknown>): void;
+}
+//#endregion
+//#region src/specification/assertions/string.d.ts
+/**
+ * Assertions on a string (stdout, stderr, response body).
+ * Usage: result.stdout.toContain("hello")
+ */
+declare class StringAssertion extends BaseAssertion {
+  private actual;
+  private label;
+  private testDir?;
+  constructor(actual: string, label: string, testDir?: string);
+  toContain(expected: string, options?: {
+    near?: string;
+  }): void;
+  toMatch(pattern: RegExp): void;
+  toMatchFile(file: string): void;
+  toBeEmpty(): void;
+  private containsNear;
+  private stripAnsi;
+  private truncate;
+}
+//#endregion
+//#region src/specification/assertions/table.d.ts
+/**
+ * Assertions on a database table.
+ * Usage: await result.table("users").toMatch({ columns: ["name"], rows: [["Alice"]] })
+ */
+declare class TableAssertion extends BaseAssertion {
+  private tableName;
+  private db;
+  constructor(tableName: string, db: DatabasePort);
+  toMatch(expected: {
+    columns: string[];
+    rows: unknown[][];
+  }): Promise<void>;
+  toBeEmpty(): Promise<void>;
+}
+//#endregion
+//#region src/specification/assertions/value.d.ts
+/**
+ * Assertions on a single value (exit code, status code).
+ * Usage: result.exitCode.toBe(0)
+ */
+declare class ValueAssertion extends BaseAssertion {
+  private actual;
+  private label;
+  private context?;
+  constructor(actual: number, label: string, context?: {
+    request?: any;
+    responseBody?: unknown;
+    stdout?: string;
+    stderr?: string;
+  });
+  toBe(expected: number): void;
+}
+//#endregion
 //#region src/specification/ports/command.port.d.ts
 /**
  * Result of executing a CLI command.
@@ -174,7 +267,7 @@ declare class SpecificationResult {
   private commandResult?;
   private config;
   private requestInfo?;
-  private response?;
+  private responseData?;
   private testDir;
   private workDir?;
   constructor(options: {
@@ -185,23 +278,16 @@ declare class SpecificationResult {
     testDir: string;
     workDir?: string;
   });
-  expectStatus(code: number): this;
-  expectResponse(file: string): this;
-  expectExitCode(code: number): this;
-  expectStdout(file: string): this;
-  expectStdoutContains(str: string): this;
-  expectStderr(file: string): this;
-  expectStderrContains(str: string): this;
-  expectTable(table: string, options: {
-    columns: string[];
-    rows: unknown[][];
+  get exitCode(): ValueAssertion;
+  get status(): ValueAssertion;
+  get response(): ResponseAssertion;
+  get stdout(): StringAssertion;
+  get stderr(): StringAssertion;
+  file(path: string): FileAssertion;
+  table(tableName: string, options?: {
     service?: string;
-  }): Promise<this>;
-  expectFile(path: string): this;
-  expectNoFile(path: string): this;
-  expectFileContains(path: string, content: string): this;
+  }): TableAssertion;
   private resolveDatabase;
-  private resolveWorkPath;
 }
 declare class SpecificationBuilder {
   private commandArgs;

package/dist/index.js

@@ -837,92 +837,258 @@ 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 {
+	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`);
+	}
+	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`);
+	}
+};
+//#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;
+	}
+	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`);
+	}
+};
+//#endregion
 //#region src/specification/specification.ts
 var SpecificationResult = class {
 	commandResult;
 	config;
 	requestInfo;
-	response;
+	responseData;
 	testDir;
 	workDir;
 	constructor(options) {
-		this.response = options.response;
+		this.responseData = 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;
+	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
+		});
 	}
-	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;
+	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
+		});
 	}
-	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;
+	get response() {
+		if (!this.responseData) throw new Error(".response requires an HTTP action (.get(), .post(), etc.)");
+		return new ResponseAssertion(this.responseData.body, this.testDir);
 	}
-	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");
-		const actual = await db.query(table, options.columns);
-		if (JSON.stringify(actual) !== JSON.stringify(options.rows)) throw new Error(formatTableDiff(table, options.columns, options.rows, actual));
-		return this;
+	get stdout() {
+		if (!this.commandResult) throw new Error(".stdout requires a CLI action (.exec())");
+		return new StringAssertion(this.commandResult.stdout, "stdout", this.testDir);
 	}
-	expectFile(path) {
-		if (!existsSync(this.resolveWorkPath(path))) throw new Error(formatFileMissing(path));
-		return this;
+	get stderr() {
+		if (!this.commandResult) throw new Error(".stderr requires a CLI action (.exec())");
+		return new StringAssertion(this.commandResult.stderr, "stderr", this.testDir);
 	}
-	expectNoFile(path) {
-		if (existsSync(this.resolveWorkPath(path))) throw new Error(formatFileUnexpected(path));
-		return this;
+	file(path) {
+		return new FileAssertion(path, this.workDir ?? this.testDir);
 	}
-	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;
+	table(tableName, options) {
+		const db = this.resolveDatabase(options?.service);
+		if (!db) throw new Error(options?.service ? `table("${tableName}") requires database "${options.service}" but it was not found` : `table("${tableName}") requires a database adapter`);
+		return new TableAssertion(tableName, db);
 	}
 	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;
@@ -1025,6 +1191,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);