@iskra-bun/testing-kit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @iskra-bun/testing-kit
+
+## 0.1.0
+
+### Minor Changes
+
+- f9654df: Initial public release. Test utilities for Iskra apps: `createTestApp`, `createMockLogger`, `createMockDriver`, `withTempDir`, and `createTestServer`.
+
+### Patch Changes
+
+- Updated dependencies [f9654df]
+- Updated dependencies
+- Updated dependencies [f9654df]
+    - @iskra-bun/core@0.1.1

package/README.md

@@ -0,0 +1,88 @@
+# @iskra-bun/testing-kit
+
+Utilidades compartidas de testing para paquetes de Iskra — elimina el bootstrapping duplicado de App/Driver/Logger en cada suite de tests.
+
+## Inicio Rapido
+
+```typescript
+import {
+    createTestApp,
+    createMockLogger,
+    createMockDriver,
+    withTempDir,
+    createTestServer,
+} from '@iskra-bun/testing-kit';
+
+// App real con logger silencioso
+const app = createTestApp();
+
+// Driver mock con registro de llamadas
+const driver = createMockDriver();
+app.register(driver);
+await app.start();
+// ['init', 'start']
+console.log(driver.calls);
+
+await app.stop();
+```
+
+## API
+
+### `createTestApp(overrides?)`
+
+Devuelve una instancia real de `App` configurada para tests: logger a nivel `error`, OTel desactivado, nombre `TestApp` por defecto. Se puede iniciar y parar normalmente.
+
+```typescript
+const app = createTestApp({ name: 'MiTest' });
+app.register(myDriver);
+await app.start();
+await app.stop();
+```
+
+### `createMockLogger()`
+
+Devuelve un objeto que implementa la interfaz `Logger` de core y captura todas las llamadas en arrays para aserciones.
+
+```typescript
+const logger = createMockLogger();
+logger.info('mensaje');
+expect(logger.logs.info[0].args[0]).toBe('mensaje');
+logger.reset(); // borra todos los registros
+```
+
+### `createMockDriver(name?, hooks?)`
+
+Devuelve un `Driver` que registra las llamadas al ciclo de vida (`init`, `start`, `stop`) y su orden. Los hooks opcionales permiten inyectar comportamiento o lanzar errores.
+
+```typescript
+const driver = createMockDriver('mi-driver', {
+    stop: async () => { throw new Error('fallo intencional'); },
+});
+// driver.calls => ['init', 'start', 'stop']
+// driver.initialized / driver.started / driver.stopped => boolean
+driver.reset();
+```
+
+### `withTempDir(fn)`
+
+Crea un directorio temporal, ejecuta `fn(dir)` y lo elimina siempre al final, incluso si `fn` lanza.
+
+```typescript
+await withTempDir(async (dir) => {
+    await Bun.write(`${dir}/data.json`, '{}');
+    // dir se limpia al salir
+});
+```
+
+### `createTestServer(handler)`
+
+Envuelve cualquier objeto con `.request()` (compatible con Hono sin importarlo) en un cliente de test con métodos HTTP de conveniencia.
+
+```typescript
+const client = createTestServer(honoApp);
+const res = await client.get('/health');
+expect(res.status).toBe(200);
+
+const created = await client.post('/users', { name: 'Ana' });
+expect(created.status).toBe(201);
+```

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+import { AppConfig, App, Logger, Driver } from '@iskra-bun/core';
+
+/**
+ * Creates a real App instance configured for testing:
+ * - Logger level defaults to 'error' so tests stay silent
+ * - OTel is disabled to avoid side effects
+ * - Config name defaults to 'TestApp'
+ * - Accepts optional overrides merged shallowly over the defaults
+ *
+ * The returned app is a genuine App so start()/stop()/register() all work
+ * exactly as in production.
+ *
+ * Usage:
+ *   const app = createTestApp();
+ *   app.register(myDriver);
+ *   await app.start();
+ *   await app.stop();
+ */
+declare function createTestApp(overrides?: Partial<AppConfig>): App;
+
+interface MockLogEntry {
+    args: unknown[];
+}
+interface MockLoggerLogs {
+    trace: MockLogEntry[];
+    debug: MockLogEntry[];
+    info: MockLogEntry[];
+    warn: MockLogEntry[];
+    error: MockLogEntry[];
+    fatal: MockLogEntry[];
+}
+interface MockLogger extends Logger {
+    logs: MockLoggerLogs;
+    reset(): void;
+}
+/**
+ * Creates a Logger-compatible mock that captures all log calls into arrays
+ * for assertion in tests. No output is written to stdout/stderr.
+ *
+ * Usage:
+ *   const logger = createMockLogger();
+ *   logger.info('hello');
+ *   expect(logger.logs.info).toHaveLength(1);
+ *   logger.reset();
+ */
+declare function createMockLogger(): MockLogger;
+
+type LifecycleCall = 'init' | 'start' | 'stop';
+interface MockDriverHooks {
+    init?: (app: App) => Promise<void> | void;
+    start?: () => Promise<void> | void;
+    stop?: () => Promise<void> | void;
+}
+interface MockDriver extends Driver {
+    /** Ordered record of which lifecycle methods were called */
+    calls: LifecycleCall[];
+    /** Whether init() was called */
+    initialized: boolean;
+    /** Whether start() was called */
+    started: boolean;
+    /** Whether stop() was called */
+    stopped: boolean;
+    /** Reset all recorded state */
+    reset(): void;
+}
+/**
+ * Creates a Driver-compatible mock that records every lifecycle call and its
+ * order. Optional hooks let tests inject arbitrary behavior or throw errors.
+ *
+ * Usage:
+ *   const driver = createMockDriver({ stop: async () => { throw new Error('boom'); } });
+ *   await app.register(driver).start();
+ *   expect(driver.calls).toEqual(['init', 'start']);
+ */
+declare function createMockDriver(name?: string, hooks?: MockDriverHooks): MockDriver;
+
+/**
+ * Creates a temporary directory, invokes `fn` with its path, and always
+ * removes it afterwards — even when `fn` throws.
+ *
+ * Usage:
+ *   await withTempDir(async (dir) => {
+ *       await Bun.write(join(dir, 'file.txt'), 'hello');
+ *       // dir is cleaned up automatically on return or throw
+ *   });
+ */
+declare function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T>;
+
+/**
+ * Minimal structural interface for objects that accept a fetch-style request.
+ * Matches Hono's `app.request()` signature without importing Hono.
+ */
+interface RequestHandler {
+    request(input: string | Request | URL, requestInit?: RequestInit, env?: unknown, executionCtx?: unknown): Response | Promise<Response>;
+}
+interface TestServerClient {
+    get(path: string, init?: RequestInit): Promise<Response>;
+    post(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    put(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    patch(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    delete(path: string, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Wraps any object with a `.request()` method (structurally typed — no Hono
+ * import required) in a small fetch-style client for testing HTTP handlers.
+ *
+ * Usage:
+ *   const client = createTestServer(honoApp);
+ *   const res = await client.get('/health');
+ *   expect(res.status).toBe(200);
+ */
+declare function createTestServer(handler: RequestHandler): TestServerClient;
+
+export { type LifecycleCall, type MockDriver, type MockDriverHooks, type MockLogEntry, type MockLogger, type MockLoggerLogs, type RequestHandler, type TestServerClient, createMockDriver, createMockLogger, createTestApp, createTestServer, withTempDir };

package/dist/index.js

@@ -0,0 +1,169 @@
+// src/test-app.ts
+import { App } from "@iskra-bun/core";
+
+// src/mock-logger.ts
+function makeRecorder(logs) {
+  return (...args) => {
+    logs.push({ args });
+  };
+}
+function createMockLogger() {
+  const logs = {
+    trace: [],
+    debug: [],
+    info: [],
+    warn: [],
+    error: [],
+    fatal: []
+  };
+  const mock = {
+    logs,
+    reset() {
+      logs.trace.length = 0;
+      logs.debug.length = 0;
+      logs.info.length = 0;
+      logs.warn.length = 0;
+      logs.error.length = 0;
+      logs.fatal.length = 0;
+    },
+    trace: makeRecorder(logs.trace),
+    debug: makeRecorder(logs.debug),
+    info: makeRecorder(logs.info),
+    warn: makeRecorder(logs.warn),
+    error: makeRecorder(logs.error),
+    fatal: makeRecorder(logs.fatal),
+    silent: () => {
+    },
+    child(_bindings, _options) {
+      return mock;
+    },
+    // Minimal pino.Logger shape — fields tests never touch
+    level: "error",
+    isLevelEnabled: (_level) => false,
+    setBindings: (_bindings) => {
+    },
+    flush: (_cb) => {
+    },
+    bindings: () => ({})
+  };
+  return mock;
+}
+
+// src/test-app.ts
+function createTestApp(overrides) {
+  const config = {
+    name: "TestApp",
+    logger: { level: "error" },
+    ...overrides
+  };
+  const app = new App(config);
+  app.logger = createMockLogger();
+  return app;
+}
+
+// src/mock-driver.ts
+function createMockDriver(name = "mock-driver", hooks = {}) {
+  const calls = [];
+  const driver = {
+    name,
+    calls,
+    initialized: false,
+    started: false,
+    stopped: false,
+    reset() {
+      calls.length = 0;
+      driver.initialized = false;
+      driver.started = false;
+      driver.stopped = false;
+    },
+    async init(app) {
+      calls.push("init");
+      driver.initialized = true;
+      if (hooks.init) {
+        await hooks.init(app);
+      }
+    },
+    async start() {
+      calls.push("start");
+      driver.started = true;
+      if (hooks.start) {
+        await hooks.start();
+      }
+    },
+    async stop() {
+      calls.push("stop");
+      driver.stopped = true;
+      if (hooks.stop) {
+        await hooks.stop();
+      }
+    }
+  };
+  return driver;
+}
+
+// src/with-temp-dir.ts
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+async function withTempDir(fn) {
+  const dir = await mkdtemp(join(tmpdir(), "iskra-test-"));
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+// src/test-server.ts
+function buildJsonInit(body, base = {}) {
+  return {
+    ...base,
+    headers: {
+      "content-type": "application/json",
+      ...base.headers
+    },
+    body: JSON.stringify(body)
+  };
+}
+function createTestServer(handler) {
+  return {
+    get(path, init) {
+      return Promise.resolve(handler.request(path, { method: "GET", ...init }));
+    },
+    post(path, body, init) {
+      return Promise.resolve(
+        handler.request(
+          path,
+          body !== void 0 ? { method: "POST", ...buildJsonInit(body, init) } : { method: "POST", ...init }
+        )
+      );
+    },
+    put(path, body, init) {
+      return Promise.resolve(
+        handler.request(
+          path,
+          body !== void 0 ? { method: "PUT", ...buildJsonInit(body, init) } : { method: "PUT", ...init }
+        )
+      );
+    },
+    patch(path, body, init) {
+      return Promise.resolve(
+        handler.request(
+          path,
+          body !== void 0 ? { method: "PATCH", ...buildJsonInit(body, init) } : { method: "PATCH", ...init }
+        )
+      );
+    },
+    delete(path, init) {
+      return Promise.resolve(handler.request(path, { method: "DELETE", ...init }));
+    }
+  };
+}
+export {
+  createMockDriver,
+  createMockLogger,
+  createTestApp,
+  createTestServer,
+  withTempDir
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/test-app.ts","../src/mock-logger.ts","../src/mock-driver.ts","../src/with-temp-dir.ts","../src/test-server.ts"],"sourcesContent":["import { App } from '@iskra-bun/core';\nimport type { AppConfig } from '@iskra-bun/core';\nimport type { Logger } from '@iskra-bun/core';\nimport { createMockLogger } from './mock-logger';\n\n/**\n * Creates a real App instance configured for testing:\n * - Logger level defaults to 'error' so tests stay silent\n * - OTel is disabled to avoid side effects\n * - Config name defaults to 'TestApp'\n * - Accepts optional overrides merged shallowly over the defaults\n *\n * The returned app is a genuine App so start()/stop()/register() all work\n * exactly as in production.\n *\n * Usage:\n *   const app = createTestApp();\n *   app.register(myDriver);\n *   await app.start();\n *   await app.stop();\n */\nexport function createTestApp(overrides?: Partial<AppConfig>): App {\n    const config: AppConfig = {\n        name: 'TestApp',\n        logger: { level: 'error' },\n        ...overrides,\n    };\n\n    const app = new App(config);\n\n    // Replace the pino logger with a mock logger so tests produce no output\n    // and can assert on logged messages when needed.\n    app.logger = createMockLogger() as unknown as Logger;\n\n    return app;\n}\n","import type { Logger } from '@iskra-bun/core';\n\nexport interface MockLogEntry {\n    args: unknown[];\n}\n\nexport interface MockLoggerLogs {\n    trace: MockLogEntry[];\n    debug: MockLogEntry[];\n    info: MockLogEntry[];\n    warn: MockLogEntry[];\n    error: MockLogEntry[];\n    fatal: MockLogEntry[];\n}\n\nexport interface MockLogger extends Logger {\n    logs: MockLoggerLogs;\n    reset(): void;\n}\n\nfunction makeRecorder(logs: MockLogEntry[]): (...args: unknown[]) => void {\n    return (...args: unknown[]) => {\n        logs.push({ args });\n    };\n}\n\n/**\n * Creates a Logger-compatible mock that captures all log calls into arrays\n * for assertion in tests. No output is written to stdout/stderr.\n *\n * Usage:\n *   const logger = createMockLogger();\n *   logger.info('hello');\n *   expect(logger.logs.info).toHaveLength(1);\n *   logger.reset();\n */\nexport function createMockLogger(): MockLogger {\n    const logs: MockLoggerLogs = {\n        trace: [],\n        debug: [],\n        info: [],\n        warn: [],\n        error: [],\n        fatal: [],\n    };\n\n    const mock = {\n        logs,\n        reset() {\n            logs.trace.length = 0;\n            logs.debug.length = 0;\n            logs.info.length = 0;\n            logs.warn.length = 0;\n            logs.error.length = 0;\n            logs.fatal.length = 0;\n        },\n        trace: makeRecorder(logs.trace),\n        debug: makeRecorder(logs.debug),\n        info: makeRecorder(logs.info),\n        warn: makeRecorder(logs.warn),\n        error: makeRecorder(logs.error),\n        fatal: makeRecorder(logs.fatal),\n        silent: () => {},\n        child(_bindings: Record<string, unknown>, _options?: unknown) {\n            // Child loggers share parent capture arrays for simplicity\n            return mock as unknown as Logger;\n        },\n        // Minimal pino.Logger shape — fields tests never touch\n        level: 'error' as const,\n        isLevelEnabled: (_level: string) => false,\n        setBindings: (_bindings: Record<string, unknown>) => {},\n        flush: (_cb?: (err?: Error) => void) => {},\n        bindings: () => ({} as Record<string, unknown>),\n    } as unknown as MockLogger;\n\n    return mock;\n}\n","import type { App, Driver } from '@iskra-bun/core';\n\nexport type LifecycleCall = 'init' | 'start' | 'stop';\n\nexport interface MockDriverHooks {\n    init?: (app: App) => Promise<void> | void;\n    start?: () => Promise<void> | void;\n    stop?: () => Promise<void> | void;\n}\n\nexport interface MockDriver extends Driver {\n    /** Ordered record of which lifecycle methods were called */\n    calls: LifecycleCall[];\n    /** Whether init() was called */\n    initialized: boolean;\n    /** Whether start() was called */\n    started: boolean;\n    /** Whether stop() was called */\n    stopped: boolean;\n    /** Reset all recorded state */\n    reset(): void;\n}\n\n/**\n * Creates a Driver-compatible mock that records every lifecycle call and its\n * order. Optional hooks let tests inject arbitrary behavior or throw errors.\n *\n * Usage:\n *   const driver = createMockDriver({ stop: async () => { throw new Error('boom'); } });\n *   await app.register(driver).start();\n *   expect(driver.calls).toEqual(['init', 'start']);\n */\nexport function createMockDriver(\n    name: string = 'mock-driver',\n    hooks: MockDriverHooks = {},\n): MockDriver {\n    const calls: LifecycleCall[] = [];\n\n    const driver: MockDriver = {\n        name,\n        calls,\n        initialized: false,\n        started: false,\n        stopped: false,\n\n        reset() {\n            calls.length = 0;\n            driver.initialized = false;\n            driver.started = false;\n            driver.stopped = false;\n        },\n\n        async init(app: App) {\n            calls.push('init');\n            driver.initialized = true;\n            if (hooks.init) {\n                await hooks.init(app);\n            }\n        },\n\n        async start() {\n            calls.push('start');\n            driver.started = true;\n            if (hooks.start) {\n                await hooks.start();\n            }\n        },\n\n        async stop() {\n            calls.push('stop');\n            driver.stopped = true;\n            if (hooks.stop) {\n                await hooks.stop();\n            }\n        },\n    };\n\n    return driver;\n}\n","import { mkdtemp, rm } from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\n/**\n * Creates a temporary directory, invokes `fn` with its path, and always\n * removes it afterwards — even when `fn` throws.\n *\n * Usage:\n *   await withTempDir(async (dir) => {\n *       await Bun.write(join(dir, 'file.txt'), 'hello');\n *       // dir is cleaned up automatically on return or throw\n *   });\n */\nexport async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {\n    const dir = await mkdtemp(join(tmpdir(), 'iskra-test-'));\n    try {\n        return await fn(dir);\n    } finally {\n        await rm(dir, { recursive: true, force: true });\n    }\n}\n","/**\n * Minimal structural interface for objects that accept a fetch-style request.\n * Matches Hono's `app.request()` signature without importing Hono.\n */\nexport interface RequestHandler {\n    request(\n        input: string | Request | URL,\n        requestInit?: RequestInit,\n        env?: unknown,\n        executionCtx?: unknown,\n    ): Response | Promise<Response>;\n}\n\nexport interface TestServerClient {\n    get(path: string, init?: RequestInit): Promise<Response>;\n    post(path: string, body?: unknown, init?: RequestInit): Promise<Response>;\n    put(path: string, body?: unknown, init?: RequestInit): Promise<Response>;\n    patch(path: string, body?: unknown, init?: RequestInit): Promise<Response>;\n    delete(path: string, init?: RequestInit): Promise<Response>;\n}\n\nfunction buildJsonInit(body: unknown, base: RequestInit = {}): RequestInit {\n    return {\n        ...base,\n        headers: {\n            'content-type': 'application/json',\n            ...base.headers,\n        },\n        body: JSON.stringify(body),\n    };\n}\n\n/**\n * Wraps any object with a `.request()` method (structurally typed — no Hono\n * import required) in a small fetch-style client for testing HTTP handlers.\n *\n * Usage:\n *   const client = createTestServer(honoApp);\n *   const res = await client.get('/health');\n *   expect(res.status).toBe(200);\n */\nexport function createTestServer(handler: RequestHandler): TestServerClient {\n    return {\n        get(path, init) {\n            return Promise.resolve(handler.request(path, { method: 'GET', ...init }));\n        },\n        post(path, body, init) {\n            return Promise.resolve(\n                handler.request(\n                    path,\n                    body !== undefined\n                        ? { method: 'POST', ...buildJsonInit(body, init) }\n                        : { method: 'POST', ...init },\n                ),\n            );\n        },\n        put(path, body, init) {\n            return Promise.resolve(\n                handler.request(\n                    path,\n                    body !== undefined\n                        ? { method: 'PUT', ...buildJsonInit(body, init) }\n                        : { method: 'PUT', ...init },\n                ),\n            );\n        },\n        patch(path, body, init) {\n            return Promise.resolve(\n                handler.request(\n                    path,\n                    body !== undefined\n                        ? { method: 'PATCH', ...buildJsonInit(body, init) }\n                        : { method: 'PATCH', ...init },\n                ),\n            );\n        },\n        delete(path, init) {\n            return Promise.resolve(handler.request(path, { method: 'DELETE', ...init }));\n        },\n    };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@iskra-bun/testing-kit",
+    "version": "0.1.0",
+    "description": "Utilidades compartidas de testing para paquetes de Iskra.",
+    "keywords": [
+        "iskra",
+        "bun",
+        "typescript",
+        "testing",
+        "mocks"
+    ],
+    "author": "Joan Lascano",
+    "license": "AGPL-3.0-or-later",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fearful/iskra.git",
+        "directory": "packages/testing-kit"
+    },
+    "homepage": "https://github.com/fearful/iskra/tree/main/packages/testing-kit#readme",
+    "bugs": "https://github.com/fearful/iskra/issues",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "bun": "./src/index.ts",
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "bun test",
+        "build": "tsup --config ../../tsup.config.ts"
+    },
+    "dependencies": {
+        "@iskra-bun/core": "0.1.1"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.5",
+        "@types/node": "^22.10.2"
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { createTestApp } from './test-app';
+export { createMockLogger } from './mock-logger';
+export type { MockLogger, MockLoggerLogs, MockLogEntry } from './mock-logger';
+export { createMockDriver } from './mock-driver';
+export type { MockDriver, MockDriverHooks, LifecycleCall } from './mock-driver';
+export { withTempDir } from './with-temp-dir';
+export { createTestServer } from './test-server';
+export type { RequestHandler, TestServerClient } from './test-server';

package/src/mock-driver.ts

@@ -0,0 +1,79 @@
+import type { App, Driver } from '@iskra-bun/core';
+
+export type LifecycleCall = 'init' | 'start' | 'stop';
+
+export interface MockDriverHooks {
+    init?: (app: App) => Promise<void> | void;
+    start?: () => Promise<void> | void;
+    stop?: () => Promise<void> | void;
+}
+
+export interface MockDriver extends Driver {
+    /** Ordered record of which lifecycle methods were called */
+    calls: LifecycleCall[];
+    /** Whether init() was called */
+    initialized: boolean;
+    /** Whether start() was called */
+    started: boolean;
+    /** Whether stop() was called */
+    stopped: boolean;
+    /** Reset all recorded state */
+    reset(): void;
+}
+
+/**
+ * Creates a Driver-compatible mock that records every lifecycle call and its
+ * order. Optional hooks let tests inject arbitrary behavior or throw errors.
+ *
+ * Usage:
+ *   const driver = createMockDriver({ stop: async () => { throw new Error('boom'); } });
+ *   await app.register(driver).start();
+ *   expect(driver.calls).toEqual(['init', 'start']);
+ */
+export function createMockDriver(
+    name: string = 'mock-driver',
+    hooks: MockDriverHooks = {},
+): MockDriver {
+    const calls: LifecycleCall[] = [];
+
+    const driver: MockDriver = {
+        name,
+        calls,
+        initialized: false,
+        started: false,
+        stopped: false,
+
+        reset() {
+            calls.length = 0;
+            driver.initialized = false;
+            driver.started = false;
+            driver.stopped = false;
+        },
+
+        async init(app: App) {
+            calls.push('init');
+            driver.initialized = true;
+            if (hooks.init) {
+                await hooks.init(app);
+            }
+        },
+
+        async start() {
+            calls.push('start');
+            driver.started = true;
+            if (hooks.start) {
+                await hooks.start();
+            }
+        },
+
+        async stop() {
+            calls.push('stop');
+            driver.stopped = true;
+            if (hooks.stop) {
+                await hooks.stop();
+            }
+        },
+    };
+
+    return driver;
+}

package/src/mock-logger.ts

@@ -0,0 +1,77 @@
+import type { Logger } from '@iskra-bun/core';
+
+export interface MockLogEntry {
+    args: unknown[];
+}
+
+export interface MockLoggerLogs {
+    trace: MockLogEntry[];
+    debug: MockLogEntry[];
+    info: MockLogEntry[];
+    warn: MockLogEntry[];
+    error: MockLogEntry[];
+    fatal: MockLogEntry[];
+}
+
+export interface MockLogger extends Logger {
+    logs: MockLoggerLogs;
+    reset(): void;
+}
+
+function makeRecorder(logs: MockLogEntry[]): (...args: unknown[]) => void {
+    return (...args: unknown[]) => {
+        logs.push({ args });
+    };
+}
+
+/**
+ * Creates a Logger-compatible mock that captures all log calls into arrays
+ * for assertion in tests. No output is written to stdout/stderr.
+ *
+ * Usage:
+ *   const logger = createMockLogger();
+ *   logger.info('hello');
+ *   expect(logger.logs.info).toHaveLength(1);
+ *   logger.reset();
+ */
+export function createMockLogger(): MockLogger {
+    const logs: MockLoggerLogs = {
+        trace: [],
+        debug: [],
+        info: [],
+        warn: [],
+        error: [],
+        fatal: [],
+    };
+
+    const mock = {
+        logs,
+        reset() {
+            logs.trace.length = 0;
+            logs.debug.length = 0;
+            logs.info.length = 0;
+            logs.warn.length = 0;
+            logs.error.length = 0;
+            logs.fatal.length = 0;
+        },
+        trace: makeRecorder(logs.trace),
+        debug: makeRecorder(logs.debug),
+        info: makeRecorder(logs.info),
+        warn: makeRecorder(logs.warn),
+        error: makeRecorder(logs.error),
+        fatal: makeRecorder(logs.fatal),
+        silent: () => {},
+        child(_bindings: Record<string, unknown>, _options?: unknown) {
+            // Child loggers share parent capture arrays for simplicity
+            return mock as unknown as Logger;
+        },
+        // Minimal pino.Logger shape — fields tests never touch
+        level: 'error' as const,
+        isLevelEnabled: (_level: string) => false,
+        setBindings: (_bindings: Record<string, unknown>) => {},
+        flush: (_cb?: (err?: Error) => void) => {},
+        bindings: () => ({} as Record<string, unknown>),
+    } as unknown as MockLogger;
+
+    return mock;
+}

package/src/test-app.ts

@@ -0,0 +1,36 @@
+import { App } from '@iskra-bun/core';
+import type { AppConfig } from '@iskra-bun/core';
+import type { Logger } from '@iskra-bun/core';
+import { createMockLogger } from './mock-logger';
+
+/**
+ * Creates a real App instance configured for testing:
+ * - Logger level defaults to 'error' so tests stay silent
+ * - OTel is disabled to avoid side effects
+ * - Config name defaults to 'TestApp'
+ * - Accepts optional overrides merged shallowly over the defaults
+ *
+ * The returned app is a genuine App so start()/stop()/register() all work
+ * exactly as in production.
+ *
+ * Usage:
+ *   const app = createTestApp();
+ *   app.register(myDriver);
+ *   await app.start();
+ *   await app.stop();
+ */
+export function createTestApp(overrides?: Partial<AppConfig>): App {
+    const config: AppConfig = {
+        name: 'TestApp',
+        logger: { level: 'error' },
+        ...overrides,
+    };
+
+    const app = new App(config);
+
+    // Replace the pino logger with a mock logger so tests produce no output
+    // and can assert on logged messages when needed.
+    app.logger = createMockLogger() as unknown as Logger;
+
+    return app;
+}

package/src/test-server.ts

@@ -0,0 +1,81 @@
+/**
+ * Minimal structural interface for objects that accept a fetch-style request.
+ * Matches Hono's `app.request()` signature without importing Hono.
+ */
+export interface RequestHandler {
+    request(
+        input: string | Request | URL,
+        requestInit?: RequestInit,
+        env?: unknown,
+        executionCtx?: unknown,
+    ): Response | Promise<Response>;
+}
+
+export interface TestServerClient {
+    get(path: string, init?: RequestInit): Promise<Response>;
+    post(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    put(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    patch(path: string, body?: unknown, init?: RequestInit): Promise<Response>;
+    delete(path: string, init?: RequestInit): Promise<Response>;
+}
+
+function buildJsonInit(body: unknown, base: RequestInit = {}): RequestInit {
+    return {
+        ...base,
+        headers: {
+            'content-type': 'application/json',
+            ...base.headers,
+        },
+        body: JSON.stringify(body),
+    };
+}
+
+/**
+ * Wraps any object with a `.request()` method (structurally typed — no Hono
+ * import required) in a small fetch-style client for testing HTTP handlers.
+ *
+ * Usage:
+ *   const client = createTestServer(honoApp);
+ *   const res = await client.get('/health');
+ *   expect(res.status).toBe(200);
+ */
+export function createTestServer(handler: RequestHandler): TestServerClient {
+    return {
+        get(path, init) {
+            return Promise.resolve(handler.request(path, { method: 'GET', ...init }));
+        },
+        post(path, body, init) {
+            return Promise.resolve(
+                handler.request(
+                    path,
+                    body !== undefined
+                        ? { method: 'POST', ...buildJsonInit(body, init) }
+                        : { method: 'POST', ...init },
+                ),
+            );
+        },
+        put(path, body, init) {
+            return Promise.resolve(
+                handler.request(
+                    path,
+                    body !== undefined
+                        ? { method: 'PUT', ...buildJsonInit(body, init) }
+                        : { method: 'PUT', ...init },
+                ),
+            );
+        },
+        patch(path, body, init) {
+            return Promise.resolve(
+                handler.request(
+                    path,
+                    body !== undefined
+                        ? { method: 'PATCH', ...buildJsonInit(body, init) }
+                        : { method: 'PATCH', ...init },
+                ),
+            );
+        },
+        delete(path, init) {
+            return Promise.resolve(handler.request(path, { method: 'DELETE', ...init }));
+        },
+    };
+}

package/src/with-temp-dir.ts

@@ -0,0 +1,22 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * Creates a temporary directory, invokes `fn` with its path, and always
+ * removes it afterwards — even when `fn` throws.
+ *
+ * Usage:
+ *   await withTempDir(async (dir) => {
+ *       await Bun.write(join(dir, 'file.txt'), 'hello');
+ *       // dir is cleaned up automatically on return or throw
+ *   });
+ */
+export async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
+    const dir = await mkdtemp(join(tmpdir(), 'iskra-test-'));
+    try {
+        return await fn(dir);
+    } finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}