@ereo/testing 0.1.6

package/dist/index.js

@@ -0,0 +1,658 @@
+// @bun
+var __require = import.meta.require;
+
+// src/context.ts
+function createTestContext(options = {}) {
+  const store = new Map(Object.entries(options.store || {}));
+  const env = { ...options.env };
+  const responseHeaders = new Headers(options.responseHeaders);
+  const url = typeof options.url === "string" ? new URL(options.url) : options.url || new URL("http://localhost:3000/");
+  let cacheOptions;
+  const cacheTags = new Set(options.cacheTags || []);
+  const cacheOperations = [];
+  const cache = {
+    set(opts) {
+      cacheOptions = opts;
+      if (opts.tags) {
+        opts.tags.forEach((tag) => cacheTags.add(tag));
+      }
+      cacheOperations.push({
+        type: "set",
+        options: { ...opts },
+        timestamp: Date.now()
+      });
+    },
+    get() {
+      cacheOperations.push({
+        type: "get",
+        timestamp: Date.now()
+      });
+      return cacheOptions;
+    },
+    getTags() {
+      return Array.from(cacheTags);
+    }
+  };
+  const context = {
+    cache,
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+    },
+    responseHeaders,
+    url,
+    env,
+    getStore() {
+      return Object.fromEntries(store);
+    },
+    getCacheOperations() {
+      return [...cacheOperations];
+    },
+    reset() {
+      store.clear();
+      Object.entries(options.store || {}).forEach(([k, v]) => store.set(k, v));
+      cacheOptions = undefined;
+      cacheTags.clear();
+      (options.cacheTags || []).forEach((tag) => cacheTags.add(tag));
+      cacheOperations.length = 0;
+      responseHeaders.forEach((_, key) => responseHeaders.delete(key));
+      Object.entries(options.responseHeaders || {}).forEach(([k, v]) => responseHeaders.set(k, v));
+    }
+  };
+  return context;
+}
+function createContextFactory(baseOptions = {}) {
+  return (overrides = {}) => createTestContext({
+    ...baseOptions,
+    ...overrides,
+    store: { ...baseOptions.store, ...overrides.store },
+    env: { ...baseOptions.env, ...overrides.env },
+    responseHeaders: {
+      ...baseOptions.responseHeaders,
+      ...overrides.responseHeaders
+    },
+    cacheTags: [
+      ...baseOptions.cacheTags || [],
+      ...overrides.cacheTags || []
+    ]
+  });
+}
+// src/request.ts
+function createMockRequest(url, options) {
+  if (typeof url === "string") {
+    options = { ...options, url };
+  } else if (url) {
+    options = url;
+  } else {
+    options = options || {};
+  }
+  return createMockRequestImpl(options);
+}
+function createMockRequestImpl(options = {}) {
+  const {
+    method = "GET",
+    url = "/",
+    headers = {},
+    body,
+    searchParams,
+    formData,
+    cookies
+  } = options;
+  let requestUrl = url.startsWith("http") ? url : `http://localhost:3000${url}`;
+  if (searchParams) {
+    const urlObj = new URL(requestUrl);
+    for (const [key, value] of Object.entries(searchParams)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => urlObj.searchParams.append(key, v));
+      } else {
+        urlObj.searchParams.set(key, value);
+      }
+    }
+    requestUrl = urlObj.toString();
+  }
+  const requestHeaders = new Headers(headers);
+  if (cookies) {
+    const cookieString = Object.entries(cookies).map(([name, value]) => `${name}=${value}`).join("; ");
+    requestHeaders.set("Cookie", cookieString);
+  }
+  let requestBody = null;
+  if (formData) {
+    const fd = new FormData;
+    for (const [key, value] of Object.entries(formData)) {
+      fd.append(key, value);
+    }
+    requestBody = fd;
+  } else if (body) {
+    if (typeof body === "object" && !(body instanceof Blob) && !(body instanceof FormData)) {
+      requestBody = JSON.stringify(body);
+      if (!requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "application/json");
+      }
+    } else {
+      requestBody = body;
+    }
+  }
+  return new Request(requestUrl, {
+    method,
+    headers: requestHeaders,
+    body: requestBody
+  });
+}
+function createFormRequest(url, data) {
+  const formData = new URLSearchParams;
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === "string") {
+      formData.append(key, value);
+    }
+  }
+  return new Request(url.startsWith("http") ? url : `http://localhost:3000${url}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: formData.toString()
+  });
+}
+function createMockFormData(data) {
+  const formData = new FormData;
+  for (const [key, value] of Object.entries(data)) {
+    formData.append(key, value);
+  }
+  return formData;
+}
+function createMockHeaders(data) {
+  return new Headers(data);
+}
+async function parseJsonResponse(response) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Failed to parse JSON response: ${text.slice(0, 100)}`);
+  }
+}
+async function parseTextResponse(response) {
+  return response.text();
+}
+
+// src/loader.ts
+async function testLoader(loader, options = {}) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  const params = options.params || {};
+  const startTime = performance.now();
+  const data = await loader({ request, params, context });
+  const duration = performance.now() - startTime;
+  return {
+    data,
+    context,
+    request,
+    duration
+  };
+}
+function createLoaderTester(loader, baseOptions = {}) {
+  return async (overrides = {}) => {
+    return testLoader(loader, {
+      ...baseOptions,
+      ...overrides,
+      params: { ...baseOptions.params, ...overrides.params },
+      request: { ...baseOptions.request, ...overrides.request },
+      context: {
+        ...baseOptions.context,
+        ...overrides.context,
+        store: { ...baseOptions.context?.store, ...overrides.context?.store },
+        env: { ...baseOptions.context?.env, ...overrides.context?.env }
+      }
+    });
+  };
+}
+// src/action.ts
+async function testAction(action, options = {}) {
+  const requestOptions = {
+    method: "POST",
+    ...options.request
+  };
+  if (options.formData) {
+    requestOptions.formData = options.formData;
+  } else if (options.body) {
+    requestOptions.body = options.body;
+  }
+  const request = createMockRequest(requestOptions);
+  const context = createTestContext(options.context);
+  const params = options.params || {};
+  const startTime = performance.now();
+  const result = await action({ request, params, context });
+  const duration = performance.now() - startTime;
+  let data;
+  let response = null;
+  let isRedirect = false;
+  let redirectTo = null;
+  if (result instanceof Response) {
+    response = result;
+    isRedirect = result.status >= 300 && result.status < 400;
+    redirectTo = result.headers.get("Location");
+    try {
+      const cloned = result.clone();
+      data = await parseJsonResponse(cloned);
+    } catch {
+      data = undefined;
+    }
+  } else {
+    data = result;
+  }
+  return {
+    data,
+    response,
+    context,
+    request,
+    duration,
+    isRedirect,
+    redirectTo
+  };
+}
+function createActionTester(action, baseOptions = {}) {
+  return async (overrides = {}) => {
+    return testAction(action, {
+      ...baseOptions,
+      ...overrides,
+      params: { ...baseOptions.params, ...overrides.params },
+      request: { ...baseOptions.request, ...overrides.request },
+      context: {
+        ...baseOptions.context,
+        ...overrides.context,
+        store: { ...baseOptions.context?.store, ...overrides.context?.store },
+        env: { ...baseOptions.context?.env, ...overrides.context?.env }
+      },
+      formData: overrides.formData || baseOptions.formData,
+      body: overrides.body || baseOptions.body
+    });
+  };
+}
+// src/middleware.ts
+async function testMiddleware(middleware, options = {}) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  let nextCalled = false;
+  let nextCallCount = 0;
+  const next = options.next || (async () => {
+    nextCalled = true;
+    nextCallCount++;
+    return options.nextResponse || new Response("OK", { status: 200 });
+  });
+  const wrappedNext = async () => {
+    nextCalled = true;
+    nextCallCount++;
+    return next();
+  };
+  const startTime = performance.now();
+  const response = await middleware(request, context, wrappedNext);
+  const duration = performance.now() - startTime;
+  return {
+    response,
+    context,
+    request,
+    nextCalled,
+    nextCallCount,
+    duration
+  };
+}
+function createMiddlewareTester(middleware, baseOptions = {}) {
+  return async (overrides = {}) => {
+    return testMiddleware(middleware, {
+      ...baseOptions,
+      ...overrides,
+      request: { ...baseOptions.request, ...overrides.request },
+      context: {
+        ...baseOptions.context,
+        ...overrides.context,
+        store: { ...baseOptions.context?.store, ...overrides.context?.store },
+        env: { ...baseOptions.context?.env, ...overrides.context?.env }
+      }
+    });
+  };
+}
+// src/render.ts
+async function renderRoute(module, options = {}) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  const params = options.params || {};
+  let loaderData;
+  if (options.loaderData !== undefined) {
+    loaderData = options.loaderData;
+  } else if (module.loader) {
+    loaderData = await module.loader({ request, params, context });
+  } else {
+    loaderData = undefined;
+  }
+  const Component = module.default;
+  if (!Component) {
+    throw new Error("Route module has no default export");
+  }
+  const props = {
+    loaderData,
+    params,
+    children: options.children
+  };
+  const element = {
+    type: Component,
+    props,
+    key: null
+  };
+  return {
+    element,
+    loaderData,
+    context,
+    request,
+    props
+  };
+}
+function createRouteRenderer(module, baseOptions = {}) {
+  return async (overrides = {}) => {
+    return renderRoute(module, {
+      ...baseOptions,
+      ...overrides,
+      params: { ...baseOptions.params, ...overrides.params },
+      request: { ...baseOptions.request, ...overrides.request },
+      context: {
+        ...baseOptions.context,
+        ...overrides.context,
+        store: { ...baseOptions.context?.store, ...overrides.context?.store },
+        env: { ...baseOptions.context?.env, ...overrides.context?.env }
+      }
+    });
+  };
+}
+// src/assertions.ts
+function assertRedirect(response, expectedLocation, options = {}) {
+  if (!response) {
+    throw new Error(options.message || "Expected a response but got null");
+  }
+  const status = response.status;
+  const expectedStatus = options.status || 302;
+  if (status < 300 || status >= 400) {
+    throw new Error(options.message || `Expected redirect status (3xx) but got ${status}`);
+  }
+  if (options.status && status !== expectedStatus) {
+    throw new Error(options.message || `Expected redirect status ${expectedStatus} but got ${status}`);
+  }
+  const location = response.headers.get("Location");
+  if (expectedLocation) {
+    if (!location) {
+      throw new Error(options.message || "Expected Location header but it was not set");
+    }
+    if (location !== expectedLocation) {
+      throw new Error(options.message || `Expected redirect to "${expectedLocation}" but got "${location}"`);
+    }
+  }
+}
+async function assertJson(responseOrData, expected, options = {}) {
+  let data;
+  if (responseOrData instanceof Response) {
+    try {
+      data = await responseOrData.clone().json();
+    } catch {
+      throw new Error(options.message || "Failed to parse response body as JSON");
+    }
+  } else {
+    data = responseOrData;
+  }
+  for (const [key, value] of Object.entries(expected)) {
+    const actual = data[key];
+    if (JSON.stringify(actual) !== JSON.stringify(value)) {
+      throw new Error(options.message || `Expected "${key}" to be ${JSON.stringify(value)} but got ${JSON.stringify(actual)}`);
+    }
+  }
+}
+function assertStatus(response, expected, options = {}) {
+  if (!response) {
+    throw new Error(options.message || "Expected a response but got null");
+  }
+  const expectedStatuses = Array.isArray(expected) ? expected : [expected];
+  if (!expectedStatuses.includes(response.status)) {
+    throw new Error(options.message || `Expected status ${expectedStatuses.join(" or ")} but got ${response.status}`);
+  }
+}
+function assertHeaders(response, expected, options = {}) {
+  if (!response) {
+    throw new Error(options.message || "Expected a response but got null");
+  }
+  for (const [name, expectedValue] of Object.entries(expected)) {
+    const actual = response.headers.get(name);
+    if (actual === null) {
+      throw new Error(options.message || `Expected header "${name}" to be set but it was not`);
+    }
+    if (expectedValue instanceof RegExp) {
+      if (!expectedValue.test(actual)) {
+        throw new Error(options.message || `Expected header "${name}" to match ${expectedValue} but got "${actual}"`);
+      }
+    } else {
+      if (actual !== expectedValue) {
+        throw new Error(options.message || `Expected header "${name}" to be "${expectedValue}" but got "${actual}"`);
+      }
+    }
+  }
+}
+function assertCookies(response, expected, options = {}) {
+  if (!response) {
+    throw new Error(options.message || "Expected a response but got null");
+  }
+  const setCookieHeaders = response.headers.getSetCookie?.() || [];
+  const cookies = new Map;
+  for (const header of setCookieHeaders) {
+    const [nameValue] = header.split(";");
+    const eqIndex = nameValue.indexOf("=");
+    if (eqIndex > 0) {
+      const name = nameValue.slice(0, eqIndex).trim();
+      cookies.set(name, header);
+    }
+  }
+  for (const [name, expectations] of Object.entries(expected)) {
+    const cookieHeader = cookies.get(name);
+    if (expectations.exists === false) {
+      if (cookieHeader) {
+        throw new Error(options.message || `Expected cookie "${name}" not to be set but it was`);
+      }
+      continue;
+    }
+    if (expectations.exists !== false && !cookieHeader) {
+      throw new Error(options.message || `Expected cookie "${name}" to be set but it was not`);
+    }
+    if (!cookieHeader)
+      continue;
+    const headerLower = cookieHeader.toLowerCase();
+    if (expectations.value) {
+      const [nameValue] = cookieHeader.split(";");
+      const value = nameValue.split("=").slice(1).join("=");
+      if (expectations.value instanceof RegExp) {
+        if (!expectations.value.test(value)) {
+          throw new Error(options.message || `Expected cookie "${name}" value to match ${expectations.value} but got "${value}"`);
+        }
+      } else {
+        if (value !== expectations.value) {
+          throw new Error(options.message || `Expected cookie "${name}" value to be "${expectations.value}" but got "${value}"`);
+        }
+      }
+    }
+    if (expectations.httpOnly !== undefined) {
+      const hasHttpOnly = headerLower.includes("httponly");
+      if (expectations.httpOnly !== hasHttpOnly) {
+        throw new Error(options.message || `Expected cookie "${name}" HttpOnly to be ${expectations.httpOnly}`);
+      }
+    }
+    if (expectations.secure !== undefined) {
+      const hasSecure = headerLower.includes("secure");
+      if (expectations.secure !== hasSecure) {
+        throw new Error(options.message || `Expected cookie "${name}" Secure to be ${expectations.secure}`);
+      }
+    }
+    if (expectations.sameSite) {
+      const hasSameSite = headerLower.includes(`samesite=${expectations.sameSite.toLowerCase()}`);
+      if (!hasSameSite) {
+        throw new Error(options.message || `Expected cookie "${name}" SameSite to be ${expectations.sameSite}`);
+      }
+    }
+    if (expectations.path) {
+      const hasPath = headerLower.includes(`path=${expectations.path.toLowerCase()}`);
+      if (!hasPath) {
+        throw new Error(options.message || `Expected cookie "${name}" Path to be ${expectations.path}`);
+      }
+    }
+  }
+}
+// src/server.ts
+async function createTestServer(options = {}) {
+  const port = options.port || await getAvailablePort();
+  const url = `http://localhost:${port}`;
+  const { createApp } = await import("@ereo/core");
+  const { initFileRouter } = await import("@ereo/router");
+  const { createServer } = await import("@ereo/server");
+  const app = createApp({
+    config: {
+      ...options.config,
+      server: {
+        port,
+        hostname: "localhost",
+        development: true,
+        ...options.config?.server
+      }
+    }
+  });
+  const router = await initFileRouter({
+    routesDir: options.routesDir || options.config?.routesDir || "app/routes",
+    watch: false
+  });
+  await router.loadAllModules();
+  const server = createServer({
+    port,
+    hostname: "localhost",
+    development: true,
+    logging: false
+  });
+  server.setApp(app);
+  server.setRouter(router);
+  await server.start();
+  const makeFetch = async (path, init) => {
+    const fullUrl = path.startsWith("http") ? path : `${url}${path}`;
+    return fetch(fullUrl, init);
+  };
+  const makeBodyRequest = async (method, path, body, init) => {
+    const headers = new Headers(init?.headers);
+    let requestBody;
+    if (body !== undefined) {
+      if (body instanceof FormData) {
+        requestBody = body;
+      } else {
+        requestBody = JSON.stringify(body);
+        if (!headers.has("Content-Type")) {
+          headers.set("Content-Type", "application/json");
+        }
+      }
+    }
+    return makeFetch(path, {
+      ...init,
+      method,
+      headers,
+      body: requestBody
+    });
+  };
+  const testServer = {
+    url,
+    port,
+    fetch: makeFetch,
+    get: (path, init) => makeFetch(path, { ...init, method: "GET" }),
+    post: (path, body, init) => makeBodyRequest("POST", path, body, init),
+    put: (path, body, init) => makeBodyRequest("PUT", path, body, init),
+    delete: (path, init) => makeFetch(path, { ...init, method: "DELETE" }),
+    patch: (path, body, init) => makeBodyRequest("PATCH", path, body, init),
+    submitForm: async (path, formData, init) => {
+      const fd = new FormData;
+      for (const [key, value] of Object.entries(formData)) {
+        fd.append(key, value);
+      }
+      return makeFetch(path, {
+        ...init,
+        method: "POST",
+        body: fd
+      });
+    },
+    stop: async () => {
+      server.stop();
+    }
+  };
+  return testServer;
+}
+async function getAvailablePort() {
+  const server = Bun.serve({
+    port: 0,
+    fetch() {
+      return new Response("");
+    }
+  });
+  const port = server.port ?? 0;
+  server.stop();
+  return port;
+}
+// src/snapshot.ts
+function prepareForSnapshot(data, options = {}) {
+  if (data === null || data === undefined) {
+    return data;
+  }
+  if (typeof data !== "object") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => prepareForSnapshot(item, options));
+  }
+  const obj = data;
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (options.exclude?.includes(key)) {
+      continue;
+    }
+    if (options.include && !options.include.includes(key)) {
+      continue;
+    }
+    if (options.replacers && key in options.replacers) {
+      result[key] = options.replacers[key];
+      continue;
+    }
+    result[key] = prepareForSnapshot(value, options);
+  }
+  return result;
+}
+async function snapshotLoader(loader, testOptions = {}, snapshotOptions = {}) {
+  const result = await testLoader(loader, testOptions);
+  return prepareForSnapshot(result.data, snapshotOptions);
+}
+async function snapshotAction(action, testOptions = {}, snapshotOptions = {}) {
+  const result = await testAction(action, testOptions);
+  return prepareForSnapshot(result.data, snapshotOptions);
+}
+export {
+  testMiddleware,
+  testLoader,
+  testAction,
+  snapshotLoader,
+  snapshotAction,
+  renderRoute,
+  parseTextResponse,
+  parseJsonResponse,
+  createTestServer,
+  createTestContext,
+  createRouteRenderer,
+  createMockRequest,
+  createMockHeaders,
+  createMockFormData,
+  createMiddlewareTester,
+  createLoaderTester,
+  createFormRequest,
+  createContextFactory,
+  createActionTester,
+  assertStatus,
+  assertRedirect,
+  assertJson,
+  assertHeaders,
+  assertCookies
+};