@stratal/testing 0.0.0-canary-ccb3f17 → 0.0.0-canary-e5681b8

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { d as deriveTemplateName, f as ensureWorkerDatabase, i as BINDING_ENV_VAR, l as deriveAdminConnectionString, n as buildTruncateSql, o as buildConnectionString, t as buildTableDiscoverySql, u as deriveFileDbName } from "./database-DeMI4Igi.mjs";
-import { t as FakeStorageService } from "./storage-q8RFahgU.mjs";
-import { t as __decorate } from "./decorate-ZDdbRmsv.mjs";
+import { i as BINDING_ENV_VAR, n as buildTruncateSql, p as leaseWorkerDatabase, t as buildTableDiscoverySql } from "./database-Rojs69r3.mjs";
+import { t as FakeStorageService } from "./storage-BiGamMA8.mjs";
+import { t as __decorate } from "./decorate-RQD1h28J.mjs";
 import { NoopRateLimiterStore } from "./mocks/noop-rate-limiter-store.mjs";
-import { n as TestWorkerExports, r as TestEmailProvider, t as TestWorkersCache } from "./test-workers-cache-eiGMw9Yj.mjs";
-import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "./feature-flags-BMYurC1B.mjs";
+import { n as TestWorkerExports, r as TestEmailProvider, t as TestWorkersCache } from "./test-workers-cache-D02Pt_dE.mjs";
+import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "./feature-flags-CZ1a4M2g.mjs";
 import { Application } from "stratal";
 import { LogLevel } from "stratal/logger";
 import { markGatewayMode } from "stratal/response-cache";
@@ -166,9 +166,7 @@ function applyLocaleToHeaders(headers, locale, strategy) {
 		case "cookie":
 			headers.set("Cookie", `locale=${locale}`);
 			break;
-		case "header":
-			headers.set("Accept-Language", locale);
-			break;
+		case "header": headers.set("Accept-Language", locale);
 	}
 }
 /**
@@ -427,7 +425,8 @@ var TestResponse = class extends Macroable {
 	* @param path - Dot-notation path (e.g., 'data.user.id')
 	*/
 	async assertJsonPathExists(path) {
-		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to exist`).toBe(true);
+		const exists = hasValueAtPath(await this.json(), path);
+		expect(exists, `Expected JSON path "${path}" to exist`).toBe(true);
 		return this;
 	}
 	/**
@@ -436,7 +435,8 @@ var TestResponse = class extends Macroable {
 	* @param path - Dot-notation path (e.g., 'data.user.deletedAt')
 	*/
 	async assertJsonPathMissing(path) {
-		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to not exist`).toBe(false);
+		const exists = hasValueAtPath(await this.json(), path);
+		expect(exists, `Expected JSON path "${path}" to not exist`).toBe(false);
 		return this;
 	}
 	/**
@@ -777,19 +777,23 @@ var TestCommandResult = class {
 		return this;
 	}
 	assertOutputContains(text) {
-		expect(this.result.output.join("\n"), `Expected output to contain "${text}"`).toContain(text);
+		const joined = this.result.output.join("\n");
+		expect(joined, `Expected output to contain "${text}"`).toContain(text);
 		return this;
 	}
 	assertOutputMissing(text) {
-		expect(this.result.output.join("\n"), `Expected output NOT to contain "${text}"`).not.toContain(text);
+		const joined = this.result.output.join("\n");
+		expect(joined, `Expected output NOT to contain "${text}"`).not.toContain(text);
 		return this;
 	}
 	assertErrorContains(text) {
-		expect(this.result.errors.join("\n"), `Expected errors to contain "${text}"`).toContain(text);
+		const joined = this.result.errors.join("\n");
+		expect(joined, `Expected errors to contain "${text}"`).toContain(text);
 		return this;
 	}
 	assertErrorMissing(text) {
-		expect(this.result.errors.join("\n"), `Expected errors NOT to contain "${text}"`).not.toContain(text);
+		const joined = this.result.errors.join("\n");
+		expect(joined, `Expected errors NOT to contain "${text}"`).not.toContain(text);
 		return this;
 	}
 };
@@ -923,7 +927,8 @@ var TestSseConnection = class {
 	* Assert that the next event matches the expected partial shape
 	*/
 	async assertEvent(expected, timeout = 5e3) {
-		expect(await this.waitForEvent(timeout)).toMatchObject(expected);
+		const event = await this.waitForEvent(timeout);
+		expect(event).toMatchObject(expected);
 	}
 	/**
 	* Assert that the next event's data matches the expected string
@@ -937,7 +942,8 @@ var TestSseConnection = class {
 	*/
 	async assertJsonEventData(expected, timeout = 5e3) {
 		const event = await this.waitForEvent(timeout);
-		expect(JSON.parse(event.data)).toEqual(expected);
+		const parsed = JSON.parse(event.data);
+		expect(parsed).toEqual(expected);
 	}
 	/**
 	* Access the raw Response
@@ -1361,12 +1367,18 @@ var TestingModule = class {
 	}
 	/**
 	* Get Inertia test client for making Inertia requests
+	*
+	* Sends no `X-Inertia-Version`. It used to send `'1'`, which meant any app configuring a real
+	* asset version had every request from this client read as a stale client and answered with a
+	* version-mismatch 409 — an entire Inertia suite failing on a value the tests never chose. The
+	* check needs a version from BOTH sides, so omitting it here leaves the app under test in charge
+	* rather than this header.
+	*
+	* A test that wants the mismatch path asks for it:
+	* `module.inertia.withHeaders({ 'X-Inertia-Version': 'stale' })`.
 	*/
 	get inertia() {
-		return this.http.withHeaders({
-			"X-Inertia": "true",
-			"X-Inertia-Version": "1"
-		});
+		return this.http.withHeaders({ "X-Inertia": "true" });
 	}
 	/**
 	* Get fake storage service for assertions
@@ -1477,7 +1489,8 @@ var TestingModule = class {
 	*/
 	async truncateDb(name, opts = {}) {
 		const db = this.getDb(name);
-		const sql = buildTruncateSql((await db.$queryRawUnsafe(buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? []))).map((t) => ({
+		const rows = await db.$queryRawUnsafe(buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? []));
+		const sql = buildTruncateSql(rows.map((t) => ({
 			schema: t.schemaname,
 			table: t.tablename
 		})));
@@ -1497,13 +1510,15 @@ var TestingModule = class {
 	* Assert that a record exists in the database
 	*/
 	async assertDatabaseHas(table, data, name) {
-		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} with ${JSON.stringify(data)}`).not.toBeNull();
+		const result = await this.getDb(name)[table].findFirst({ where: data });
+		expect(result, `Expected ${table} with ${JSON.stringify(data)}`).not.toBeNull();
 	}
 	/**
 	* Assert that a record does not exist in the database
 	*/
 	async assertDatabaseMissing(table, data, name) {
-		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} NOT to have ${JSON.stringify(data)}`).toBeNull();
+		const result = await this.getDb(name)[table].findFirst({ where: data });
+		expect(result, `Expected ${table} NOT to have ${JSON.stringify(data)}`).toBeNull();
 	}
 	/**
 	* Assert the number of records in a table
@@ -1524,20 +1539,12 @@ var TestingModule = class {
 //#endregion
 //#region src/core/testing-module-builder.ts
 /**
-* Per-file guard: the first `compile()` in a file clones its database; later
-* compiles in the same file skip straight to retargeting.
+* This isolate's worker-database lease, per base connection string. The pool
+* runs each test file in its own isolate (`isolate: true`), so the first
+* `compile()` in a file leases and clones a database and later compiles in the
+* same file reuse it. The lease ends when the pool disposes the isolate.
 */
-const ensuredWorkerDbs = /* @__PURE__ */ new Map();
-/**
-* A crypto-random token generated ONCE per test-file isolate. The pool runs one
-* isolate per file (`isolate: true`), so this is stable across a file's compiles
-* and unique across files — giving every file its own database. Lazily created so
-* DB-less test files never touch `crypto`.
-*/
-let fileToken;
-function currentFileToken() {
-	return fileToken ??= crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-}
+const workerDatabases = /* @__PURE__ */ new Map();
 /**
 * Builder for creating test modules with provider overrides
 */
@@ -1606,21 +1613,24 @@ var TestingModuleBuilder = class {
 		let app = null;
 		try {
 			const allImports = [...Test.getBaseModules(), ...this.config.imports ?? []];
+			const rootModule = this.createTestRootModule({
+				imports: allImports,
+				providers: this.config.providers,
+				controllers: this.config.controllers,
+				consumers: this.config.consumers,
+				jobs: this.config.jobs
+			});
 			app = new Application({
-				module: this.createTestRootModule({
-					imports: allImports,
-					providers: this.config.providers,
-					controllers: this.config.controllers,
-					consumers: this.config.consumers,
-					jobs: this.config.jobs
-				}),
+				module: rootModule,
 				logging: {
 					level: this.config.logging?.level ?? LogLevel.ERROR,
 					formatter: this.config.logging?.formatter ?? "pretty"
 				},
 				env,
 				ctx,
-				exceptionHandler: this.config.exceptionHandler
+				exceptionHandler: this.config.exceptionHandler,
+				trailingSlash: this.config.trailingSlash,
+				versioning: this.config.versioning
 			});
 			await app.initialize();
 			app.container.registerSingleton(STORAGE_TOKENS.StorageService, FakeStorageService);
@@ -1638,9 +1648,7 @@ var TestingModuleBuilder = class {
 				case "factory":
 					app.container.registerFactory(override.token, override.implementation);
 					break;
-				case "existing":
-					app.container.registerExisting(override.token, override.implementation);
-					break;
+				case "existing": app.container.registerExisting(override.token, override.implementation);
 			}
 			await app.ensureHono();
 			testWorkerExports?.setHandler(async (request, props) => {
@@ -1660,10 +1668,9 @@ var TestingModuleBuilder = class {
 		}
 	}
 	/**
-	* Point this app's Hyperdrive binding at the current worker's database,
-	* creating that database from the template on the slot's first compile. Returns
-	* nothing to clean up — worker databases live for the whole run and are reset
-	* between tests, not dropped per file. No-op when the consumer didn't opt into
+	* Point this app's Hyperdrive binding at the database this file leased,
+	* leasing it on the file's first compile. Returns nothing to clean up — the
+	* lease ends with the isolate. No-op when the consumer didn't opt into
 	* `stratalTest({ database })`; throws if they did but no connection string is
 	* configured (a misconfiguration that would otherwise silently skip isolation).
 	*/
@@ -1674,20 +1681,18 @@ var TestingModuleBuilder = class {
 		const db = bindings[bindingName];
 		const base = db?.connectionString;
 		if (!base) throw new Error(`[stratal-testing] stratalTest({ database }) is enabled but no \`${bindingName}\` Hyperdrive binding with a connectionString was found. Provide it via miniflare.hyperdrives (e.g. { ${bindingName}: DATABASE_URL }), or drop the \`database\` option.`);
-		const name = deriveFileDbName(base, currentFileToken());
-		const adminConnectionString = deriveAdminConnectionString(base);
-		let ensure = ensuredWorkerDbs.get(name);
-		if (!ensure) {
-			ensure = ensureWorkerDatabase(adminConnectionString, name, deriveTemplateName(base)).catch((error) => {
-				ensuredWorkerDbs.delete(name);
+		let lease = workerDatabases.get(base);
+		if (!lease) {
+			lease = leaseWorkerDatabase(base).catch((error) => {
+				workerDatabases.delete(base);
 				throw error;
 			});
-			ensuredWorkerDbs.set(name, ensure);
+			workerDatabases.set(base, lease);
 		}
-		await ensure;
+		const { connectionString } = await lease;
 		const isolated = Object.create(Object.getPrototypeOf(db), Object.getOwnPropertyDescriptors(db));
 		Object.defineProperty(isolated, "connectionString", {
-			value: buildConnectionString(base, name),
+			value: connectionString,
 			enumerable: true,
 			configurable: true,
 			writable: true
@@ -1819,7 +1824,8 @@ var MockFetch = class {
 	* ```
 	*/
 	mockJsonResponse(url, data, options = {}) {
-		const handler = http$1[(options.method ?? "GET").toLowerCase()](url, () => HttpResponse$1.json(data, {
+		const method = (options.method ?? "GET").toLowerCase();
+		const handler = http$1[method](url, () => HttpResponse$1.json(data, {
 			status: options.status ?? 200,
 			headers: options.headers
 		}));