@buenojs/bueno 0.8.3 → 0.8.5

package/dist/testing/index.js

@@ -0,0 +1,1111 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/context/index.ts
+var exports_context = {};
+__export(exports_context, {
+  createContext: () => createContext,
+  Context: () => Context
+});
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  for (const part of cookieHeader.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed) {
+      const [name, ...rest] = trimmed.split("=");
+      if (name && rest.length > 0) {
+        cookies[name.trim()] = rest.join("=").trim();
+      }
+    }
+  }
+  return cookies;
+}
+
+class Context {
+  req;
+  params;
+  query;
+  _cookies;
+  _bodyCache;
+  _response;
+  _variables = {};
+  constructor(request, params = {}) {
+    this.req = request;
+    this.params = params;
+    this.query = this.parseQuery(request.url);
+    this._response = {
+      status: 200,
+      headers: new Headers
+    };
+  }
+  get method() {
+    return this.req.method;
+  }
+  get url() {
+    return new URL(this.req.url);
+  }
+  get path() {
+    return this.url.pathname;
+  }
+  getHeader(name) {
+    return this.req.headers.get(name) ?? undefined;
+  }
+  getCookie(name) {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies[name];
+  }
+  get cookies() {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies;
+  }
+  async body() {
+    if (this._bodyCache !== undefined) {
+      return this._bodyCache;
+    }
+    const text = await this.req.text();
+    this._bodyCache = text ? JSON.parse(text) : null;
+    return this._bodyCache;
+  }
+  async parseBody() {
+    return this.body();
+  }
+  async bodyText() {
+    return this.req.text();
+  }
+  async bodyFormData() {
+    return this.req.formData();
+  }
+  async bodyArrayBuffer() {
+    return this.req.arrayBuffer();
+  }
+  async bodyBlob() {
+    return this.req.blob();
+  }
+  set(key, value) {
+    this._variables[key] = value;
+    return this;
+  }
+  get(key) {
+    return this._variables[key];
+  }
+  has(key) {
+    return key in this._variables;
+  }
+  status(code) {
+    this._response.status = code;
+    return this;
+  }
+  setHeader(name, value) {
+    this._response.headers.set(name, value);
+    return this;
+  }
+  appendHeader(name, value) {
+    this._response.headers.append(name, value);
+    return this;
+  }
+  json(data) {
+    this._response.headers.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  text(data) {
+    if (!this._response.headers.has("Content-Type")) {
+      this._response.headers.set("Content-Type", "text/plain");
+    }
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  html(data) {
+    this._response.headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url
+      }
+    });
+  }
+  notFound(message = "Not Found") {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  error(message, status = 500) {
+    return new Response(JSON.stringify({ error: message }), {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  newResponse(body, options) {
+    return new Response(body, {
+      status: this._response.status,
+      headers: this._response.headers,
+      ...options
+    });
+  }
+  parseQuery(url) {
+    const query = {};
+    const searchParams = new URL(url).searchParams;
+    for (const [key, value] of searchParams.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  accepts(...types) {
+    const acceptHeader = this.req.headers.get("Accept");
+    if (!acceptHeader)
+      return types[0];
+    for (const type of types) {
+      if (acceptHeader.includes(type) || acceptHeader.includes("*/*")) {
+        return type;
+      }
+    }
+    return;
+  }
+  get isXHR() {
+    return this.req.headers.get("X-Requested-With") === "XMLHttpRequest";
+  }
+  get ip() {
+    return this.req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? this.req.headers.get("x-real-ip") ?? undefined;
+  }
+}
+function createContext(request, params = {}) {
+  return new Context(request, params);
+}
+
+// src/middleware/index.ts
+var exports_middleware = {};
+__export(exports_middleware, {
+  createPipeline: () => createPipeline,
+  compose: () => compose,
+  Pipeline: () => Pipeline
+});
+function compose(middleware) {
+  return async (context, handler) => {
+    let index = -1;
+    const dispatch = async (i) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      if (i >= middleware.length) {
+        return handler(context);
+      }
+      const fn = middleware[i];
+      return fn(context, async () => {
+        return dispatch(i + 1);
+      });
+    };
+    return dispatch(0);
+  };
+}
+
+class Pipeline {
+  middleware = [];
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+  async execute(context, handler) {
+    const fn = compose(this.middleware);
+    return fn(context, handler);
+  }
+  get length() {
+    return this.middleware.length;
+  }
+}
+function createPipeline() {
+  return new Pipeline;
+}
+
+// src/testing/index.ts
+import {
+  copyFile,
+  stat as fsStat,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  unlink
+} from "fs/promises";
+import { join, relative, resolve } from "path";
+function createTestRequest(path, options = {}) {
+  const {
+    method = "GET",
+    headers = {},
+    query = {},
+    body,
+    cookies = {}
+  } = options;
+  const url = new URL(`http://localhost${path}`);
+  for (const [key, value] of Object.entries(query)) {
+    url.searchParams.set(key, value);
+  }
+  const requestHeaders = new Headers(headers);
+  if (Object.keys(cookies).length > 0) {
+    const cookieString = Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ");
+    requestHeaders.set("Cookie", cookieString);
+  }
+  let requestBody;
+  if (body !== undefined) {
+    if (typeof body === "string") {
+      requestBody = body;
+      if (!requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "text/plain");
+      }
+    } else if (body instanceof FormData) {
+      requestBody = body;
+    } else if (body instanceof URLSearchParams) {
+      requestBody = body;
+      if (!requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "application/x-www-form-urlencoded");
+      }
+    } else {
+      requestBody = JSON.stringify(body);
+      if (!requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "application/json");
+      }
+    }
+  }
+  return new Request(url.toString(), {
+    method,
+    headers: requestHeaders,
+    body: requestBody
+  });
+}
+async function createTestResponse(response) {
+  const clone = response.clone();
+  let body = null;
+  try {
+    const contentType = response.headers.get("Content-Type") || "";
+    if (contentType.includes("application/json")) {
+      body = await response.json();
+    } else {
+      body = await response.text();
+    }
+  } catch {
+    body = null;
+  }
+  return {
+    status: response.status,
+    headers: response.headers,
+    body,
+    text: await clone.text(),
+    json: async () => response.json()
+  };
+}
+
+class AppTester {
+  router;
+  constructor(router) {
+    this.router = router;
+  }
+  async request(path, options) {
+    const request = createTestRequest(path, options);
+    const url = new URL(request.url);
+    const match = this.router.match(request.method, url.pathname);
+    if (!match) {
+      return createTestResponse(new Response("Not Found", { status: 404 }));
+    }
+    const context = new Context(request, match.params);
+    if (match.middleware && match.middleware.length > 0) {
+      const { compose: compose2 } = await Promise.resolve().then(() => exports_middleware);
+      const pipeline = compose2(match.middleware);
+      const response2 = await pipeline(context, async () => match.handler(context));
+      return createTestResponse(response2);
+    }
+    const response = await match.handler(context);
+    return createTestResponse(response);
+  }
+  async get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  async post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  async put(path, body, options) {
+    return this.request(path, { ...options, method: "PUT", body });
+  }
+  async patch(path, body, options) {
+    return this.request(path, { ...options, method: "PATCH", body });
+  }
+  async delete(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+}
+function createTester(router) {
+  return new AppTester(router);
+}
+function createMockContext(path, options = {}) {
+  const request = createTestRequest(path, options);
+  return new Context(request, {});
+}
+function createMockContextWithParams(path, params, options = {}) {
+  const request = createTestRequest(path, options);
+  return new Context(request, params);
+}
+function assertStatus(response, expected) {
+  if (response.status !== expected) {
+    throw new Error(`Expected status ${expected}, got ${response.status}`);
+  }
+}
+function assertOK(response) {
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(`Expected OK status, got ${response.status}`);
+  }
+}
+function assertJSON(response) {
+  const contentType = response.headers.get("Content-Type");
+  if (!contentType?.includes("application/json")) {
+    throw new Error(`Expected JSON response, got ${contentType}`);
+  }
+}
+function assertBody(response, expected) {
+  if (JSON.stringify(response.body) !== JSON.stringify(expected)) {
+    throw new Error(`Expected body ${JSON.stringify(expected)}, got ${JSON.stringify(response.body)}`);
+  }
+}
+function assertHeader(response, name, value) {
+  const headerValue = response.headers.get(name);
+  if (!headerValue) {
+    throw new Error(`Expected header ${name} to be present`);
+  }
+  if (value && headerValue !== value) {
+    throw new Error(`Expected header ${name} to be ${value}, got ${headerValue}`);
+  }
+}
+function assertRedirect(response, location) {
+  if (response.status < 300 || response.status >= 400) {
+    throw new Error(`Expected redirect status, got ${response.status}`);
+  }
+  if (location) {
+    assertHeader(response, "Location", location);
+  }
+}
+function snapshotResponse(response) {
+  return {
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: response.body
+  };
+}
+
+class FixtureFactory {
+  sequences = new Map;
+  id(prefix = "test") {
+    const seq = (this.sequences.get(prefix) ?? 0) + 1;
+    this.sequences.set(prefix, seq);
+    return `${prefix}_${seq}`;
+  }
+  email(domain = "test.com") {
+    return `${this.id("email")}@${domain}`;
+  }
+  uuid() {
+    return crypto.randomUUID();
+  }
+  reset() {
+    this.sequences.clear();
+  }
+}
+function createFixtureFactory() {
+  return new FixtureFactory;
+}
+async function waitFor(condition, timeout = 5000, interval = 50) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await condition()) {
+      return;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
+  }
+  throw new Error("Timeout waiting for condition");
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+class TestCache {
+  store = new Map;
+  _operations = [];
+  _stats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+    deletes: 0
+  };
+  get operations() {
+    return this._operations;
+  }
+  async get(key) {
+    const value = this.store.get(key);
+    this._operations.push({
+      type: "get",
+      key,
+      value: value ?? null,
+      timestamp: Date.now()
+    });
+    if (value !== undefined) {
+      this._stats.hits++;
+      return value;
+    }
+    this._stats.misses++;
+    return null;
+  }
+  async set(key, value) {
+    this.store.set(key, value);
+    this._stats.sets++;
+    this._operations.push({
+      type: "set",
+      key,
+      value,
+      timestamp: Date.now()
+    });
+  }
+  async delete(key) {
+    const existed = this.store.delete(key);
+    this._stats.deletes++;
+    this._operations.push({
+      type: "delete",
+      key,
+      timestamp: Date.now()
+    });
+    return existed;
+  }
+  async has(key) {
+    const exists = this.store.has(key);
+    this._operations.push({
+      type: "has",
+      key,
+      value: exists,
+      timestamp: Date.now()
+    });
+    return exists;
+  }
+  async clearAll() {
+    this.store.clear();
+    this._operations.push({
+      type: "clear",
+      timestamp: Date.now()
+    });
+  }
+  getStats() {
+    return {
+      ...this._stats,
+      keyCount: this.store.size
+    };
+  }
+  getKeys() {
+    return Array.from(this.store.keys());
+  }
+  getEntries() {
+    return Array.from(this.store.entries());
+  }
+  async setMany(entries) {
+    for (const [key, value] of Object.entries(entries)) {
+      await this.set(key, value);
+    }
+  }
+  peek(key) {
+    const value = this.store.get(key);
+    return value !== undefined ? value : null;
+  }
+  reset() {
+    this.store.clear();
+    this._operations = [];
+    this._stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0
+    };
+  }
+}
+async function createTestCache(initialData) {
+  const cache = new TestCache;
+  if (initialData) {
+    await cache.setMany(initialData);
+  }
+  return cache;
+}
+function assertCacheHas(cache, key) {
+  const keys = cache.getKeys();
+  if (!keys.includes(key)) {
+    throw new Error(`Expected cache to have key "${key}". Available keys: [${keys.join(", ")}]`);
+  }
+}
+function assertCacheNotHas(cache, key) {
+  const keys = cache.getKeys();
+  if (keys.includes(key)) {
+    throw new Error(`Expected cache to NOT have key "${key}"`);
+  }
+}
+function assertCacheValue(cache, key, expected) {
+  const value = cache.peek(key);
+  if (value === null) {
+    throw new Error(`Expected cache to have key "${key}"`);
+  }
+  if (JSON.stringify(value) !== JSON.stringify(expected)) {
+    throw new Error(`Expected cache value for "${key}" to be ${JSON.stringify(expected)}, got ${JSON.stringify(value)}`);
+  }
+}
+function assertCacheStats(cache, expected) {
+  const stats = cache.getStats();
+  for (const [key, value] of Object.entries(expected)) {
+    const actualValue = stats[key];
+    if (actualValue !== value) {
+      throw new Error(`Expected cache stat "${key}" to be ${value}, got ${actualValue}`);
+    }
+  }
+}
+
+class TestDatabase {
+  sql = null;
+  _operations = [];
+  _isConnected = false;
+  _schema = {};
+  get operations() {
+    return this._operations;
+  }
+  async connect() {
+    if (this._isConnected)
+      return;
+    try {
+      const { SQL } = await Promise.resolve(globalThis.Bun);
+      this.sql = new SQL(":memory:", { adapter: "sqlite" });
+      this._isConnected = true;
+    } catch (error) {
+      throw new Error(`Failed to connect to test database: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  async query(sqlString, params = []) {
+    this.ensureConnection();
+    this._operations.push({
+      type: "query",
+      sql: sqlString,
+      params,
+      timestamp: Date.now()
+    });
+    const sql = this.sql;
+    return sql.unsafe(sqlString, params);
+  }
+  async queryOne(sqlString, params = []) {
+    const results = await this.query(sqlString, params);
+    return results.length > 0 ? results[0] : null;
+  }
+  async execute(sqlString, params = []) {
+    this.ensureConnection();
+    this._operations.push({
+      type: "execute",
+      sql: sqlString,
+      params,
+      timestamp: Date.now()
+    });
+    const sql = this.sql;
+    const results = await sql.unsafe(sqlString, params);
+    const lastIdResult = await sql.unsafe("SELECT last_insert_rowid() as id");
+    const insertId = lastIdResult[0];
+    return {
+      rows: results,
+      rowCount: results.length,
+      insertId: insertId?.id
+    };
+  }
+  async transaction(callback) {
+    this.ensureConnection();
+    this._operations.push({
+      type: "transaction",
+      sql: "BEGIN TRANSACTION",
+      timestamp: Date.now()
+    });
+    const sql = this.sql;
+    try {
+      await sql.unsafe("BEGIN TRANSACTION");
+      const result = await callback(this);
+      await sql.unsafe("COMMIT");
+      return result;
+    } catch (error) {
+      await sql.unsafe("ROLLBACK");
+      throw error;
+    }
+  }
+  async rollback() {
+    this.ensureConnection();
+    const sql = this.sql;
+    await sql.unsafe("ROLLBACK");
+  }
+  async close() {
+    if (!this._isConnected)
+      return;
+    const sql = this.sql;
+    if (sql.close) {
+      await sql.close();
+    }
+    this.sql = null;
+    this._isConnected = false;
+  }
+  async getTables() {
+    const result = await this.query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+    return result.map((row) => row.name);
+  }
+  async seed(tables) {
+    for (const [table, rows] of Object.entries(tables)) {
+      for (const row of rows) {
+        const keys = Object.keys(row);
+        const values = Object.values(row);
+        const placeholders = values.map(() => "?").join(", ");
+        const columns = keys.join(", ");
+        await this.execute(`INSERT INTO ${table} (${columns}) VALUES (${placeholders})`, values);
+      }
+    }
+  }
+  async reset() {
+    const tables = await this.getTables();
+    for (const table of tables) {
+      await this.execute(`DROP TABLE IF EXISTS ${table}`);
+    }
+    this._operations = [];
+    this._schema = {};
+  }
+  async createTable(name, columns) {
+    const columnDefs = Object.entries(columns).map(([colName, def]) => `${colName} ${def}`).join(", ");
+    await this.execute(`CREATE TABLE ${name} (${columnDefs})`);
+    this._schema[name] = columns;
+  }
+  async dropTable(name) {
+    await this.execute(`DROP TABLE IF EXISTS ${name}`);
+    delete this._schema[name];
+  }
+  async truncate(name) {
+    await this.execute(`DELETE FROM ${name}`);
+  }
+  getSchema() {
+    return { ...this._schema };
+  }
+  async getTableInfo(table) {
+    return this.query(`PRAGMA table_info(${table})`);
+  }
+  async count(table, where, params = []) {
+    const sql = where ? `SELECT COUNT(*) as count FROM ${table} WHERE ${where}` : `SELECT COUNT(*) as count FROM ${table}`;
+    const result = await this.queryOne(sql, params);
+    return Number(result?.count ?? 0);
+  }
+  async exists(table, where, params = []) {
+    const count = await this.count(table, where, params);
+    return count > 0;
+  }
+  clearOperations() {
+    this._operations = [];
+  }
+  ensureConnection() {
+    if (!this._isConnected || !this.sql) {
+      throw new Error("TestDatabase not connected. Call connect() first.");
+    }
+  }
+}
+async function createTestDatabase(options = {}) {
+  const db = new TestDatabase;
+  await db.connect();
+  if (options.schema) {
+    for (const [table, columns] of Object.entries(options.schema)) {
+      await db.createTable(table, columns);
+    }
+  }
+  if (options.seed) {
+    await db.seed(options.seed);
+  }
+  return db;
+}
+async function assertTableRowCount(db, table, expected) {
+  const count = await db.count(table);
+  if (count !== expected) {
+    throw new Error(`Expected table "${table}" to have ${expected} rows, but found ${count}`);
+  }
+}
+async function assertTableHasRow(db, table, condition, params = []) {
+  const exists = await db.exists(table, condition, params);
+  if (!exists) {
+    throw new Error(`Expected table "${table}" to have a row matching: ${condition}`);
+  }
+}
+async function assertTableNotHasRow(db, table, condition, params = []) {
+  const exists = await db.exists(table, condition, params);
+  if (exists) {
+    throw new Error(`Expected table "${table}" to NOT have a row matching: ${condition}`);
+  }
+}
+async function assertTableExists(db, table) {
+  const tables = await db.getTables();
+  if (!tables.includes(table)) {
+    throw new Error(`Expected table "${table}" to exist. Available tables: [${tables.join(", ")}]`);
+  }
+}
+async function assertTableNotExists(db, table) {
+  const tables = await db.getTables();
+  if (tables.includes(table)) {
+    throw new Error(`Expected table "${table}" to NOT exist`);
+  }
+}
+async function assertTableValue(db, table, column, condition, expected, params = []) {
+  const sql = `SELECT ${column} as value FROM ${table} WHERE ${condition} LIMIT 1`;
+  const result = await db.queryOne(sql, params);
+  if (!result) {
+    throw new Error(`Expected to find a row in "${table}" matching: ${condition}`);
+  }
+  if (JSON.stringify(result.value) !== JSON.stringify(expected)) {
+    throw new Error(`Expected ${column} to be ${JSON.stringify(expected)}, got ${JSON.stringify(result.value)}`);
+  }
+}
+
+class TestStorage {
+  _basePath;
+  _operations = [];
+  _initialized = false;
+  get basePath() {
+    return this._basePath;
+  }
+  get operations() {
+    return this._operations;
+  }
+  constructor(basePath) {
+    this._basePath = basePath;
+  }
+  async init() {
+    if (this._initialized)
+      return;
+    await mkdir(this._basePath, { recursive: true });
+    this._initialized = true;
+  }
+  async write(path, content) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    if (parentDir) {
+      await mkdir(parentDir, { recursive: true });
+    }
+    const file = Bun.file(fullPath);
+    const writer = file.writer();
+    if (typeof content === "string") {
+      writer.write(content);
+    } else if (content instanceof Uint8Array) {
+      writer.write(content);
+    } else if (content instanceof ArrayBuffer) {
+      writer.write(new Uint8Array(content));
+    }
+    await writer.end();
+    const size = typeof content === "string" ? new TextEncoder().encode(content).length : content.byteLength;
+    this._operations.push({
+      type: "write",
+      path,
+      size,
+      timestamp: Date.now()
+    });
+  }
+  async read(path) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const file = Bun.file(fullPath);
+    this._operations.push({
+      type: "read",
+      path,
+      timestamp: Date.now()
+    });
+    if (!await file.exists()) {
+      return null;
+    }
+    return file.text();
+  }
+  async readBytes(path) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const file = Bun.file(fullPath);
+    this._operations.push({
+      type: "read",
+      path,
+      timestamp: Date.now()
+    });
+    if (!await file.exists()) {
+      return null;
+    }
+    return file.arrayBuffer();
+  }
+  async delete(path) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const file = Bun.file(fullPath);
+    const exists = await file.exists();
+    if (exists) {
+      await unlink(fullPath);
+    }
+    this._operations.push({
+      type: "delete",
+      path,
+      timestamp: Date.now()
+    });
+    return exists;
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const file = Bun.file(fullPath);
+    const exists = await file.exists();
+    this._operations.push({
+      type: "exists",
+      path,
+      timestamp: Date.now()
+    });
+    return exists;
+  }
+  async list(prefix) {
+    await this.ensureInitialized();
+    const files = [];
+    const scanDir = async (dir) => {
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name);
+          if (entry.isDirectory()) {
+            await scanDir(fullPath);
+          } else if (entry.isFile()) {
+            const relativePath = relative(this._basePath, fullPath);
+            if (!prefix || relativePath.startsWith(prefix)) {
+              files.push(relativePath);
+            }
+          }
+        }
+      } catch {}
+    };
+    await scanDir(this._basePath);
+    this._operations.push({
+      type: "list",
+      path: prefix,
+      timestamp: Date.now()
+    });
+    return files.sort();
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const fullPath = this.resolvePath(path);
+    const file = Bun.file(fullPath);
+    if (!await file.exists()) {
+      this._operations.push({
+        type: "stat",
+        path,
+        timestamp: Date.now()
+      });
+      return null;
+    }
+    const stats = await fsStat(fullPath);
+    this._operations.push({
+      type: "stat",
+      path,
+      size: stats.size,
+      timestamp: Date.now()
+    });
+    return {
+      size: stats.size,
+      created: stats.birthtimeMs,
+      modified: stats.mtimeMs
+    };
+  }
+  async copy(src, dest) {
+    await this.ensureInitialized();
+    const srcPath = this.resolvePath(src);
+    const destPath = this.resolvePath(dest);
+    const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+    if (parentDir) {
+      await mkdir(parentDir, { recursive: true });
+    }
+    await copyFile(srcPath, destPath);
+    const stats = await fsStat(destPath);
+    this._operations.push({
+      type: "copy",
+      src,
+      dest,
+      size: stats.size,
+      timestamp: Date.now()
+    });
+  }
+  async move(src, dest) {
+    await this.ensureInitialized();
+    const srcPath = this.resolvePath(src);
+    const destPath = this.resolvePath(dest);
+    const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+    if (parentDir) {
+      await mkdir(parentDir, { recursive: true });
+    }
+    await rename(srcPath, destPath);
+    this._operations.push({
+      type: "move",
+      src,
+      dest,
+      timestamp: Date.now()
+    });
+  }
+  async clear() {
+    await this.ensureInitialized();
+    try {
+      const files = await this.list();
+      for (const file of files) {
+        const fullPath = this.resolvePath(file);
+        await unlink(fullPath);
+      }
+    } catch {}
+    this._operations.push({
+      type: "clear",
+      timestamp: Date.now()
+    });
+  }
+  getBasePath() {
+    return this._basePath;
+  }
+  async reset() {
+    await this.clear();
+    this._operations = [];
+  }
+  async cleanup() {
+    try {
+      await rm(this._basePath, { recursive: true, force: true });
+    } catch {}
+    this._operations = [];
+    this._initialized = false;
+  }
+  resolvePath(path) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    return resolve(this._basePath, normalizedPath);
+  }
+  async ensureInitialized() {
+    if (!this._initialized) {
+      await this.init();
+    }
+  }
+}
+async function createTestStorage(options = {}) {
+  const basePath = options.basePath ?? await createTempDir("bueno-test-storage-");
+  const storage = new TestStorage(basePath);
+  await storage.init();
+  return storage;
+}
+async function createTempDir(prefix) {
+  const { mkdtemp } = await import("fs/promises");
+  const { tmpdir } = await import("os");
+  const { join: join2 } = await import("path");
+  return mkdtemp(join2(tmpdir(), prefix));
+}
+async function assertFileExists(storage, path) {
+  const exists = await storage.exists(path);
+  if (!exists) {
+    const files = await storage.list();
+    throw new Error(`Expected file "${path}" to exist. Available files: [${files.join(", ")}]`);
+  }
+}
+async function assertFileNotExists(storage, path) {
+  const exists = await storage.exists(path);
+  if (exists) {
+    throw new Error(`Expected file "${path}" to NOT exist`);
+  }
+}
+async function assertFileContent(storage, path, expected) {
+  const content = await storage.read(path);
+  if (content === null) {
+    throw new Error(`Expected file "${path}" to exist`);
+  }
+  if (content !== expected) {
+    throw new Error(`Expected file content for "${path}" to be:
+${expected}
+
+Got:
+${content}`);
+  }
+}
+async function assertFileSize(storage, path, expectedSize) {
+  const stats = await storage.stat(path);
+  if (stats === null) {
+    throw new Error(`Expected file "${path}" to exist`);
+  }
+  if (stats.size !== expectedSize) {
+    throw new Error(`Expected file "${path}" to have size ${expectedSize}, got ${stats.size}`);
+  }
+}
+export {
+  waitFor,
+  snapshotResponse,
+  sleep,
+  createTester,
+  createTestStorage,
+  createTestResponse,
+  createTestRequest,
+  createTestDatabase,
+  createTestCache,
+  createMockContextWithParams,
+  createMockContext,
+  createFixtureFactory,
+  assertTableValue,
+  assertTableRowCount,
+  assertTableNotHasRow,
+  assertTableNotExists,
+  assertTableHasRow,
+  assertTableExists,
+  assertStatus,
+  assertRedirect,
+  assertOK,
+  assertJSON,
+  assertHeader,
+  assertFileSize,
+  assertFileNotExists,
+  assertFileExists,
+  assertFileContent,
+  assertCacheValue,
+  assertCacheStats,
+  assertCacheNotHas,
+  assertCacheHas,
+  assertBody,
+  TestStorage,
+  TestDatabase,
+  TestCache,
+  FixtureFactory,
+  AppTester
+};