@dunx/testing 2.4.0 → 3.0.0

package/README.md

@@ -1,9 +1,17 @@
 # @dunx/testing
 
-The container an app already has, with named bindings **replaced in place**, plus a
-real `Bun.serve` on port 0. No mocking framework, no fake request object, no
-in-memory transport - Bun binds a socket in about a millisecond, so the thing under
-test is the thing that ships.
+The container an app already has, with named bindings **replaced in place**, plus
+a real `Bun.serve` on port 0. Bun binds a socket in about a millisecond, so the
+thing under test is the thing that ships: there is no mocking framework, no fake
+request object and no in-memory transport.
+
+## Install
+
+```bash
+bun add -d @dunx/testing
+```
+
+## Usage
 
 ```ts
 import { provide } from '@dunx/core';
@@ -27,140 +35,29 @@ const { status, body } = await server.json<User[]>('api/users');
 await server.close();
 ```
 
-## Overrides replace; they never append
-
-This is the whole design, and it follows from how `@dunx/core` applies an override:
-by **substitution into the binding that already exists**, never by appending a
-registration that has to out-rank the real one.
-
-A module is a scope, and `providers` are private to it. So a test override cannot be
-an extra module appended at the end that wins - an appended module's providers are
-invisible to every scope that does not import it, being the scope the
-code under test resolves from.
-
-`createTestApp` therefore builds the same scope graph the app would have and
-substitutes by token inside it. Three consequences worth relying on:
-
-- **An override replaces the binding in every scope that holds it.** A test stubbing
-  `Logger` does not have to know how many modules bind it, and does not have to name
-  a scope. Where two scopes genuinely bind one token differently and only one is
-  meant, resolve through the module you care about instead.
-- **An override naming a token nobody binds is an error** rather than a silent no-op. A
-  typo'd token would otherwise leave the suite asserting against the real provider
-  it thought it had swapped, the failure mode this package exists to
-  prevent.
-- **The discarded provider is never instantiated.** Its `useFactory` never runs and
-  its `onInit` never fires. Overriding the database does not open a connection to
-  the real database - that is the one guarantee here that a hand-rolled fixture
-  usually gets wrong, and `app.test.ts` proves it with a factory that throws if it
-  is ever called.
-
-`Logger` and `RequestContext` are overridable too, even though no module binds
-them: core offers a default for each after every module, and the substitution
-applies there as well.
-
-## API
-
-| Export                      | What it is                                                              |
-| --------------------------- | ----------------------------------------------------------------------- |
-| `createTestApp(options)`    | `Promise<App>` - the core container, overrides applied                  |
-| `createTestServer(options)` | `Promise<TestServer>` - the same, plus `Bun.serve` on port 0 and a client |
-| `testClient(url)`           | `TestClient` - the request helpers against any base URL                 |
-| `testRoot(modules)`         | The synthetic root module, for driving `HttpFactory` yourself           |
-| `RecordingLogger`           | A `Logger` that keeps entries instead of writing them                   |
-
-`modules` takes one module ref or several; several become the `imports` of one
-synthetic root, so no fixture module has to be written by hand. Anything a module
-ref can be works - a class, or a `DynamicModule` from a `forRoot`.
-
-`TestServer` is a `TestClient` plus `app` (the real `HttpApp`, for
-`app.get(...)`) and `close()`.
-
-`createTestServer` passes `HttpOptions` through, with two differences: `port`
-is always 0, and **`requestLogging` defaults to `false`** - it is on by default
-in production for good reasons, none of which apply to a suite that would
-otherwise print one JSON line per assertion. Pass `requestLogging: true` to
-test the logging itself.
-
-Everything else is **absent unless passed**, and `middleware` and `onError`
-decide what the application is: forget them and the fixture has no global
-guards and the default error mapper, and answers 200 where production answers
-401. Export one `httpOptions(config)` and spread it into both `main.ts` and
-every suite.
-
-Omitting `middleware` in a graph that declares a `Middleware` no `@UseGuards`
-attaches warns on `console.warn`; `middleware: []` says the omission is
-deliberate.
-
-### The client
-
-Two methods, because a third would be the start of an assertion DSL:
-
-```ts
-const { status, headers, body } = await server.json<Page>('notes?limit=10');
-await server.json('notes/7', { method: 'PATCH', json: { title: 'edited' } });
-const image = await server.request('avatars/7.png'); // the raw Response
-```
-
-`json` on the init object is serialized and sets `content-type: application/json`
-unless `headers` already carries one - one option for every verb, rather than a
-`post`/`put`/`patch` triple. `json()` reads the body as text before parsing, so a
-route that answered 204, HTML or a plain-text error fails with the status,
-content-type and body rather than with `JSON.parse`'s message.
+## What is here
 
-### RecordingLogger
+The [Testing guide](../../docs/guide/11-testing.md) is canonical.
 
-The `Logger` contract is seven levels of three overloads each, so every suite that
-wants a quiet app would otherwise hand-write the same thirty lines:
+| Export             | What it does                                                    |
+| ------------------ | ---------------------------------------------------------------- |
+| `createTestApp`    | The container, with overrides applied before anything resolves   |
+| `createTestServer` | The same, behind a real `Bun.serve` on port 0                    |
+| `testClient`       | The fetch-and-parse plumbing against a base url                  |
 
-```ts
-const logger = new RecordingLogger();
-await createTestApp({
-  modules: [PaymentsModule],
-  overrides: [provide(Logger, { useValue: logger })],
-});
-expect(logger.at(LogLevel.ERROR)).toEqual([]);
-```
-
-It records; it does not interpret. No level filtering, no error promotion, no
-merging of extras - those are `@arkv/logger`'s behaviour, and asserting against a
-reimplementation of them would prove nothing.
-
-## Not here
-
-- **A fluent assertion DSL** (`expect(res).toHaveStatus(200)`, supertest-style
-  chaining). `status` and a parsed `body` read fine through `expect` already, and a
-  matcher library would be a second vocabulary to learn for no new capability.
-- **Provider spies / partial mocks.** `provide(Token, { useValue })` with a class
-  the test wrote is smaller than any mocking API, and `bun test` already ships
-  `mock()` and `spyOn()` for a method on an instance the container handed back.
-- **A `providers` key on the options.** `{ modules, overrides }` is the shape, on
-  purpose: a suite tests the modules an app actually ships. A fixture class that
-  needs binding goes in a two-line `@Module`, which is also where it would live if
-  it were real.
-- **A fake HTTP dispatcher.** It could only exercise the parts of the request path
-  dunx wrote, and not the parts Bun owns - route matching, params, method
-  dispatch, upgrades. The real server is cheaper than the lie.
-- **Database fixtures, transactional rollback, seeding.** That is drizzle's
-  surface rather than this package's. `@dunx/infra/db` binds an in-memory `bun:sqlite`
-  with the same driver as production, which is a better fixture than a mock.
-- **A websocket client.** Bun implements `WebSocket` natively, and a gateway test
-  is `new WebSocket(server.url.replace('http', 'ws') + '/chat')`. Wrapping that
-  would add nothing.
+## Notes
 
-## Install it as a devDependency
-
-```bash
-bun add -d @dunx/testing
-```
+- An override replaces the binding in **every scope that holds it**, so a test
+  stubbing `Logger` need not know how many modules bind it. Naming a token
+  nobody binds is an error rather than a silent no-op.
+- The replacement happens before anything resolves, so the discarded provider is
+  never constructed: its `useFactory` never runs and its `onInit` never fires,
+  which makes overriding a database safe.
+- Request logging and boot logging are off unless asked for.
+- An `HttpOptions` field not passed is absent; nothing is inherited from
+  production. `middleware` and `onError` change what the application does, so
+  pass the same object `main.ts` passes.
 
-`@dunx/core` and `@dunx/http` are `dependencies`, at a **caret** range. What matters
-is that your app and this package resolve to **one copy of `@dunx/core`** - two
-copies means two `Logger` classes and two `RequestContext` classes, so tokens that
-match nothing and overrides that silently replace nothing. A caret range hoists to
-the copy your app already has.
+## License
 
-Peers would have expressed that better, and were tried first: `bun run --filter '*'`
-derives its build order from `dependencies` only, so a peer-only manifest cannot be
-built in this monorepo at all. The reasoning and the measurement are in
-[architecture/packaging.md](../../docs/architecture/packaging.md), "Test harness".
+MIT

package/dist/index.js

@@ -154,6 +154,3 @@ export {
   testClient,
   testRoot
 };
-
-//# debugId=542D5DFC23443AC664756E2164756E21
-//# sourceMappingURL=index.js.map

package/dist/server.d.ts

@@ -18,11 +18,10 @@ export interface TestServer extends TestClient {
     close(): Promise<void>;
 }
 /**
- * A **real** `Bun.serve` on port 0, with the same override semantics as
- * {@link createTestApp}. Nothing is faked: `Bun.serve` binds in about a
- * millisecond, and a fake would only be able to prove the parts of the request
- * path dunx wrote rather than the parts Bun owns - routing, params, method
- * dispatch, upgrades.
+ * A real `Bun.serve` on port 0, with the same override semantics as
+ * {@link createTestApp}. `Bun.serve` binds in about a millisecond, and a fake
+ * could only prove the parts of the request path dunx wrote rather than the parts
+ * Bun owns - routing, params, method dispatch, upgrades.
  *
  * ```ts
  * const server = await createTestServer({ modules: [ApiModule], prefix: 'api' });
@@ -30,15 +29,11 @@ export interface TestServer extends TestClient {
  * await server.close();
  * ```
  *
- * Request logging and boot logging are both **off** unless asked for: they are on by
- * default in production for good reasons, none of which apply to a suite that would
- * print one JSON line per assertion and one route table per file.
+ * Request logging and boot logging are off unless asked for, since a suite would
+ * otherwise print one JSON line per assertion and one route table per file.
  *
- * **An `HttpOptions` field not passed is absent, not inherited from production.**
- * `middleware` (where global guards live) and `onError` are the two that change
- * what the application does, so pass the same object `main.ts` passes - one
- * exported `httpOptions(config)` spread into both. Omitting `middleware` in a graph
- * that declares a `Middleware` no `@UseGuards` attaches writes one line to
- * `console.warn`; `middleware: []` says the omission is deliberate.
+ * An `HttpOptions` field not passed is absent, not inherited from production.
+ * `middleware` and `onError` change what the application does, so pass the same
+ * object `main.ts` passes. `middleware: []` says the omission is deliberate.
  */
 export declare const createTestServer: (options: TestServerOptions) => Promise<TestServer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/testing",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "Test harness for dunx apps: a container with providers replaced in place, and a real Bun.serve on port 0",
   "keywords": [
     "bun",
@@ -51,8 +51,8 @@
     "@dunx/http": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "^2.4.0",
-    "@dunx/http": "^2.4.0",
+    "@dunx/core": "^3.0.0",
+    "@dunx/http": "^3.0.0",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {
@@ -61,6 +61,6 @@
     }
   },
   "engines": {
-    "bun": ">=1.3.0"
+    "bun": ">=1.4.0"
   }
 }

package/dist/index.js.map

@@ -1,13 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/app.ts", "../src/client.ts", "../src/logger.ts", "../src/server.ts"],
-  "sourcesContent": [
-    "import {\n  AppFactory,\n  type App,\n  type AppOptions,\n  type DynamicModule,\n  type ModuleRef,\n  type Registration,\n} from '@dunx/core';\n\n/**\n * The synthetic root. A named class rather than an object literal for the same\n * reason `@dunx/http`'s `HttpModule` is one: it is what a duplicate-binding error\n * would name if the harness itself ever bound anything.\n */\nclass TestModule {}\n\nexport interface TestAppOptions extends AppOptions {\n  /**\n   * The graph under test. A single module, or several - they become the `imports`\n   * of one synthetic root, so no fixture module has to be written by hand.\n   */\n  readonly modules: ModuleRef | readonly ModuleRef[];\n}\n\nconst isList = (\n  modules: ModuleRef | readonly ModuleRef[],\n): modules is readonly ModuleRef[] => Array.isArray(modules);\n\n/**\n * The root `createTestApp` boots. Exported for the case the harness deliberately\n * does not cover: configuring an `HttpApp` before `listen()` (`enableCors`, `use`,\n * `set`), which means calling `HttpFactory.create(testRoot(modules), …)` directly.\n */\nexport const testRoot = (\n  modules: ModuleRef | readonly ModuleRef[],\n): DynamicModule => ({\n  module: TestModule,\n  imports: isList(modules) ? modules : [modules],\n});\n\n/** `exactOptionalPropertyTypes` separates an absent key from an undefined one. */\nexport const appOptions = (\n  overrides: readonly Registration[] | undefined,\n): AppOptions => (overrides ? { overrides } : {});\n\n/**\n * The container the app under test would have, with the bindings named in\n * `overrides` **replaced in place**.\n *\n * ```ts\n * const app = await createTestApp({\n *   modules: [UsersModule],\n *   overrides: [provide(Clock, { useValue: new FixedClock('2026-01-01') })],\n * });\n * ```\n *\n * Replacement, not addition: the discarded provider is never instantiated, so an\n * async `useFactory` that would open the real database never runs. An override\n * naming a token nobody binds throws instead of passing silently.\n */\nexport const createTestApp = (options: TestAppOptions): Promise<App> =>\n  AppFactory.create(testRoot(options.modules), appOptions(options.overrides));\n",
-    "export interface JsonInit extends RequestInit {\n  /**\n   * Serialized as the request body, with `content-type: application/json` set\n   * unless `headers` already carries one. Covers every verb, so there is no\n   * `post()`/`put()`/`patch()` triple here. Takes precedence over `body`.\n   */\n  readonly json?: unknown;\n}\n\nexport interface JsonResponse<T> {\n  readonly status: number;\n  readonly headers: Headers;\n  readonly body: T;\n}\n\nexport interface TestClient {\n  /** The server's base URL, as `listen()` returned it. */\n  readonly url: string;\n  /** The raw `Response` - for bytes, HTML, or asserting on a header. */\n  request(path?: string, init?: JsonInit): Promise<Response>;\n  /** Status, headers and parsed body in one await, which is the common assertion. */\n  json<T = unknown>(path?: string, init?: JsonInit): Promise<JsonResponse<T>>;\n}\n\nconst target = (base: string, path: string): URL => new URL(path, base);\n\nconst withJson = (init: JsonInit): RequestInit => {\n  const { json, ...rest } = init;\n  if (json === undefined) return rest;\n\n  const headers = new Headers(init.headers);\n  if (!headers.has('content-type')) {\n    headers.set('content-type', 'application/json');\n  }\n  return { ...rest, headers, body: JSON.stringify(json) };\n};\n\n/**\n * `fetch` against one base URL, plus the JSON round-trip every suite otherwise\n * rewrites. Deliberately not an assertion DSL: it returns values that `expect`\n * already reads well, so failures point at the assertion rather than at a matcher\n * this package would have to define.\n *\n * `createTestServer` returns one of these already bound to the server it started;\n * this is here for an app booted some other way.\n */\nexport const testClient = (url: string): TestClient => ({\n  url,\n  request: (path = '', init: JsonInit = {}) =>\n    fetch(target(url, path), withJson(init)),\n  json: async <T>(path = '', init: JsonInit = {}): Promise<JsonResponse<T>> => {\n    const response = await fetch(target(url, path), withJson(init));\n    // Read as text first: a route that answered 204, HTML or a plain-text error\n    // would otherwise fail with `JSON.parse`'s message and none of the context\n    // needed to see why.\n    const text = await response.text();\n    try {\n      return {\n        status: response.status,\n        headers: response.headers,\n        body: JSON.parse(text) as T,\n      };\n    } catch {\n      const body =\n        text === ''\n          ? 'an empty body'\n          : `a ${response.headers.get('content-type') ?? 'typeless'} body:\\n\\n` +\n            text.slice(0, 300);\n      throw new Error(\n        `${init.method ?? 'GET'} ${target(url, path).pathname} answered ` +\n          `${response.status} with ${body}\\n\\nThat is not JSON - use request() ` +\n          'for a response that is not.',\n      );\n    }\n  },\n});\n",
-    "import { Logger, LogLevel, type LogMessage } from '@dunx/core';\n\nexport interface RecordedLog {\n  readonly level: LogLevel;\n  readonly message: LogMessage;\n  readonly params: readonly unknown[];\n}\n\n/**\n * A {@link Logger} that keeps entries instead of writing them, so a suite can\n * assert on what was logged and stays quiet when it does not care.\n *\n * It is here because the contract is seven levels of three overloads each: every\n * suite that wants a silent logger would otherwise hand-write the same thirty\n * lines. Nothing is interpreted - no level filtering, no error promotion, no\n * merging of extras - because those are the backing logger's behaviour and\n * asserting against a reimplementation of them would prove nothing.\n *\n * ```ts\n * const logger = new RecordingLogger();\n * await createTestApp({\n *   modules: [UsersModule],\n *   overrides: [provide(Logger, { useValue: logger })],\n * });\n * expect(logger.at(LogLevel.WARN)).toHaveLength(0);\n * ```\n */\nexport class RecordingLogger extends Logger {\n  /** Everything is recorded, so a suite can assert on a `verbose` call too. */\n  readonly logLevel: LogLevel = LogLevel.VERBOSE;\n  readonly entries: RecordedLog[] = [];\n\n  verbose(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.VERBOSE, message, params);\n  }\n\n  debug(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.DEBUG, message, params);\n  }\n\n  info(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.INFO, message, params);\n  }\n\n  /** @deprecated Use {@link RecordingLogger.info}. Recorded as `info` either way. */\n  log(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.INFO, message, params);\n  }\n\n  warn(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.WARN, message, params);\n  }\n\n  error(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.ERROR, message, params);\n  }\n\n  fatal(message: LogMessage, ...params: unknown[]): void {\n    this.#record(LogLevel.FATAL, message, params);\n  }\n\n  at(level: LogLevel): readonly RecordedLog[] {\n    return this.entries.filter((entry) => entry.level === level);\n  }\n\n  clear(): void {\n    this.entries.length = 0;\n  }\n\n  #record(\n    level: LogLevel,\n    message: LogMessage,\n    params: readonly unknown[],\n  ): void {\n    this.entries.push({ level, message, params });\n  }\n}\n",
-    "import {\n  collectModules,\n  readControllers,\n  type Ctor,\n  type ResolvedModule,\n} from '@dunx/core';\nimport {\n  discoverRoutes,\n  HttpFactory,\n  type HttpApp,\n  type HttpOptions,\n  type Middleware,\n} from '@dunx/http';\nimport { appOptions, testRoot, type TestAppOptions } from './app.js';\nimport { testClient, type TestClient } from './client.js';\n\nexport interface TestServerOptions\n  extends TestAppOptions, Omit<HttpOptions, 'port' | 'overrides'> {\n  /**\n   * `setGlobalPrefix`, applied before `listen()` so the client's URLs carry it.\n   *\n   * Explicitly `| undefined`, unlike the rest of the options: a suite that runs\n   * the same fixture prefixed and unprefixed passes a variable here, and under\n   * `exactOptionalPropertyTypes` that is otherwise a conditional spread. \"No\n   * prefix\" and \"absent\" mean the same thing, so nothing is lost by allowing it.\n   */\n  readonly prefix?: string | undefined;\n}\n\nexport interface TestServer extends TestClient {\n  readonly app: HttpApp;\n  /** `app.shutdown()` - stops the server, then tears the container down. */\n  close(): Promise<void>;\n}\n\nconst middlewareShaped = (ctor: Ctor<unknown>): boolean =>\n  typeof (ctor.prototype as { handle?: unknown } | undefined)?.handle ===\n  'function';\n\n/** Every class provider in the graph that implements `Middleware`. */\nconst declaredMiddleware = (\n  modules: readonly ResolvedModule[],\n): readonly Ctor<unknown>[] => {\n  const found: Ctor<unknown>[] = [];\n  for (const module of modules) {\n    for (const entry of module.options.providers ?? []) {\n      const ctor =\n        typeof entry === 'function'\n          ? entry\n          : entry.provider.kind === 'class'\n            ? entry.provider.ctor\n            : undefined;\n      if (ctor !== undefined && middlewareShaped(ctor)) found.push(ctor);\n    }\n  }\n  return found;\n};\n\n/**\n * The guards `@UseGuards` already puts in the route table. They are not global, so\n * omitting `middleware` costs them nothing and warning about them would be noise.\n */\nconst scopedGuards = (\n  app: HttpApp,\n  modules: readonly ResolvedModule[],\n): ReadonlySet<Ctor<Middleware>> => {\n  const applied = new Set<Ctor<Middleware>>();\n  for (const module of modules) {\n    for (const controller of readControllers(module)) {\n      for (const route of discoverRoutes(app.get(controller) as object)) {\n        for (const guard of route.guards ?? []) applied.add(guard);\n      }\n    }\n  }\n  return applied;\n};\n\n/**\n * The one silent way this harness can lie: `middleware` and `onError` default\n * away, so a suite that forgets them boots a server with no global guards and the\n * default error mapper, which still answers 200 where the application answers 401.\n * A first integration run of 12 pass / 10 fail is the reported cost of finding\n * that out by hand.\n *\n * So a `Middleware` implementation that is in the graph, is not attached by\n * `@UseGuards`, and was not passed here is worth one line on `console.warn` -\n * `console`, not the bound `Logger`, because a suite asserting on a\n * `RecordingLogger` should not see an entry the application never wrote.\n */\nconst warnAboutGlobals = (\n  app: HttpApp,\n  modules: readonly ResolvedModule[],\n): void => {\n  const declared = declaredMiddleware(modules);\n  if (declared.length === 0) return;\n  const scoped = scopedGuards(app, modules);\n  const orphaned = declared.filter(\n    (ctor) => !scoped.has(ctor as Ctor<Middleware>),\n  );\n  if (orphaned.length === 0) return;\n\n  console.warn(\n    `createTestServer: ${orphaned.map((ctor) => ctor.name).join(', ')} ` +\n      'implement Middleware and are in the graph under test, but no `middleware` ' +\n      'was supplied. If they are global in main.ts then this fixture is not the ' +\n      'application: no global guard runs and `onError` is the default mapper. ' +\n      'Export one httpOptions(config) and give it to both, or pass ' +\n      '`middleware: []` to say the omission is deliberate.',\n  );\n};\n\n/**\n * A **real** `Bun.serve` on port 0, with the same override semantics as\n * {@link createTestApp}. Nothing is faked: `Bun.serve` binds in about a\n * millisecond, and a fake would only be able to prove the parts of the request\n * path dunx wrote rather than the parts Bun owns - routing, params, method\n * dispatch, upgrades.\n *\n * ```ts\n * const server = await createTestServer({ modules: [ApiModule], prefix: 'api' });\n * const { status, body } = await server.json('api/users');\n * await server.close();\n * ```\n *\n * Request logging and boot logging are both **off** unless asked for: they are on by\n * default in production for good reasons, none of which apply to a suite that would\n * print one JSON line per assertion and one route table per file.\n *\n * **An `HttpOptions` field not passed is absent, not inherited from production.**\n * `middleware` (where global guards live) and `onError` are the two that change\n * what the application does, so pass the same object `main.ts` passes - one\n * exported `httpOptions(config)` spread into both. Omitting `middleware` in a graph\n * that declares a `Middleware` no `@UseGuards` attaches writes one line to\n * `console.warn`; `middleware: []` says the omission is deliberate.\n */\nexport const createTestServer = async (\n  options: TestServerOptions,\n): Promise<TestServer> => {\n  const { modules, overrides, prefix, requestLogging, bootLogging, ...http } =\n    options;\n\n  const root = testRoot(modules);\n  const app = await HttpFactory.create(root, {\n    ...http,\n    ...appOptions(overrides),\n    requestLogging: requestLogging ?? false,\n    // Off for the same reason: a suite that boots a server per file does not want a\n    // route table per file. A suite asserting on the table asks for it.\n    bootLogging: bootLogging ?? false,\n    port: 0,\n  });\n  if (http.middleware === undefined)\n    warnAboutGlobals(app, collectModules(root));\n  if (prefix !== undefined) app.setGlobalPrefix(prefix);\n\n  return {\n    ...testClient(await app.listen()),\n    app,\n    close: () => app.shutdown(),\n  };\n};\n"
-  ],
-  "mappings": "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",
-  "debugId": "542D5DFC23443AC664756E2164756E21",
-  "names": []
-}