@ereo/testing 0.1.23 → 0.1.25

package/dist/index.d.ts

@@ -5,12 +5,12 @@
  * Makes testing loaders, actions, middleware, and components trivial.
  */
 export { createTestContext, createContextFactory, type TestContextOptions, type TestContext, } from './context';
-export { testLoader, createLoaderTester, type LoaderTestOptions, type LoaderTestResult, } from './loader';
-export { testAction, createActionTester, type ActionTestOptions, type ActionTestResult, } from './action';
-export { testMiddleware, createMiddlewareTester, type MiddlewareTestOptions, type MiddlewareTestResult, } from './middleware';
-export { createMockRequest, createFormRequest, createMockFormData, createMockHeaders, parseJsonResponse, parseTextResponse, type MockRequestOptions, } from './request';
-export { renderRoute, createRouteRenderer, type RenderRouteOptions, type RenderResult, } from './render';
-export { assertRedirect, assertJson, assertStatus, assertHeaders, assertCookies, type AssertionOptions, } from './assertions';
-export { createTestServer, type TestServer, type TestServerOptions, } from './server';
-export { snapshotLoader, snapshotAction, type SnapshotOptions, } from './snapshot';
+export { testLoader, createLoaderTester, testLoadersParallel, testLoaderMatrix, testLoaderError, type LoaderTestOptions, type LoaderTestResult, } from './loader';
+export { testAction, createActionTester, testActionMatrix, testActionError, testActionWithFile, type ActionTestOptions, type ActionTestResult, } from './action';
+export { testMiddleware, createMiddlewareTester, testMiddlewareChain, testMiddlewareMatrix, testMiddlewareError, testMiddlewareContext, type MiddlewareTestOptions, type MiddlewareTestResult, } from './middleware';
+export { createMockRequest, createFormRequest, createMockFormData, createMockHeaders, createMockFile, parseJsonResponse, parseTextResponse, extractCookies, type MockRequestOptions, } from './request';
+export { renderRoute, createRouteRenderer, renderComponent, renderRouteMatrix, testRouteRenders, getRouteMeta, type RenderRouteOptions, type RenderResult, } from './render';
+export { assertRedirect, assertJson, assertStatus, assertHeaders, assertCookies, assertThrows, assertSchema, type AssertionOptions, } from './assertions';
+export { createTestServer, createMockServer, type TestServer, type TestServerOptions, } from './server';
+export { snapshotLoader, snapshotAction, createSnapshotMatrix, commonReplacers, applyReplacements, deterministicSnapshot, type SnapshotOptions, } from './snapshot';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,UAAU,EACV,YAAY,EACZ,aAAa,EACb,aAAa,EACb,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,iBAAiB,GACvB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,cAAc,EACd,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,UAAU,EACV,YAAY,EACZ,aAAa,EACb,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,iBAAiB,GACvB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -179,6 +179,22 @@ async function parseJsonResponse(response) {
 async function parseTextResponse(response) {
   return response.text();
 }
+function createMockFile(name, content, type = "application/octet-stream") {
+  const blob = typeof content === "string" ? new Blob([content], { type }) : content;
+  return new File([blob], name, { type });
+}
+function extractCookies(response) {
+  const cookies = {};
+  const setCookieHeaders = response.headers.getSetCookie?.() || [];
+  for (const header of setCookieHeaders) {
+    const [nameValue] = header.split(";");
+    const [name, value] = nameValue.split("=");
+    if (name && value !== undefined) {
+      cookies[name.trim()] = value.trim();
+    }
+  }
+  return cookies;
+}
 
 // src/loader.ts
 async function testLoader(loader, options = {}) {
@@ -211,6 +227,31 @@ function createLoaderTester(loader, baseOptions = {}) {
     });
   };
 }
+async function testLoadersParallel(loaders) {
+  return Promise.all(loaders.map(({ loader, params, request, context }) => testLoader(loader, { params, request, context })));
+}
+async function testLoaderMatrix(loader, options) {
+  return Promise.all(options.params.map((params) => testLoader(loader, {
+    params,
+    request: options.request,
+    context: options.context
+  })));
+}
+async function testLoaderError(loader, options = {}) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  const params = options.params || {};
+  try {
+    await loader({ request, params, context });
+    return { error: null, context, request };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error)),
+      context,
+      request
+    };
+  }
+}
 // src/action.ts
 async function testAction(action, options = {}) {
   const requestOptions = {
@@ -273,6 +314,50 @@ function createActionTester(action, baseOptions = {}) {
     });
   };
 }
+async function testActionMatrix(action, options) {
+  return Promise.all(options.submissions.map((submission) => testAction(action, {
+    params: options.params,
+    context: options.context,
+    formData: submission.formData,
+    body: submission.body
+  })));
+}
+async function testActionError(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 || {};
+  try {
+    await action({ request, params, context });
+    return { error: null, context, request };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error)),
+      context,
+      request
+    };
+  }
+}
+async function testActionWithFile(action, options) {
+  const { file, extraFields = {}, ...rest } = options;
+  const blob = typeof file.content === "string" ? new Blob([file.content], { type: file.type || "application/octet-stream" }) : file.content;
+  const formData = {
+    ...extraFields,
+    [file.field]: new File([blob], file.name, { type: file.type })
+  };
+  return testAction(action, {
+    ...rest,
+    formData
+  });
+}
 // src/middleware.ts
 async function testMiddleware(middleware, options = {}) {
   const request = createMockRequest(options.request);
@@ -316,6 +401,78 @@ function createMiddlewareTester(middleware, baseOptions = {}) {
     });
   };
 }
+async function testMiddlewareChain(middlewares, options = {}) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  const middlewareResults = [];
+  let index = 0;
+  const buildNext = (currentIndex) => {
+    return async () => {
+      middlewareResults[currentIndex].nextCalled = true;
+      if (currentIndex + 1 >= middlewares.length) {
+        return options.nextResponse || new Response("OK", { status: 200 });
+      }
+      const startTime2 = performance.now();
+      middlewareResults.push({
+        index: currentIndex + 1,
+        nextCalled: false,
+        duration: 0
+      });
+      const response2 = await middlewares[currentIndex + 1](request, context, buildNext(currentIndex + 1));
+      middlewareResults[currentIndex + 1].duration = performance.now() - startTime2;
+      return response2;
+    };
+  };
+  middlewareResults.push({ index: 0, nextCalled: false, duration: 0 });
+  const startTime = performance.now();
+  const response = await middlewares[0](request, context, buildNext(0));
+  middlewareResults[0].duration = performance.now() - startTime;
+  return {
+    response,
+    context,
+    request,
+    middlewareResults
+  };
+}
+async function testMiddlewareMatrix(middleware, options) {
+  return Promise.all(options.requests.map((request) => testMiddleware(middleware, {
+    request,
+    context: options.context
+  })));
+}
+async function testMiddlewareError(middleware, options) {
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  try {
+    const response = await middleware(request, context, options.next);
+    return { response, error: null, context };
+  } catch (error) {
+    return {
+      response: null,
+      error: error instanceof Error ? error : new Error(String(error)),
+      context
+    };
+  }
+}
+async function testMiddlewareContext(middleware, options) {
+  const result = await testMiddleware(middleware, options);
+  const contextDiff = {};
+  let contextMatches = true;
+  for (const [key, expected] of Object.entries(options.expectContextValues)) {
+    const actual = result.context.get(key);
+    const matches = JSON.stringify(actual) === JSON.stringify(expected);
+    if (!matches) {
+      contextMatches = false;
+      contextDiff[key] = { expected, actual };
+    }
+  }
+  return {
+    response: result.response,
+    context: result.context,
+    contextMatches,
+    contextDiff
+  };
+}
 // src/render.ts
 async function renderRoute(module, options = {}) {
   const request = createMockRequest(options.request);
@@ -367,6 +524,56 @@ function createRouteRenderer(module, baseOptions = {}) {
     });
   };
 }
+function renderComponent(Component, props) {
+  return {
+    type: Component,
+    props,
+    key: null
+  };
+}
+async function renderRouteMatrix(module, options) {
+  return Promise.all(options.params.map((params) => renderRoute(module, {
+    params,
+    request: options.request,
+    context: options.context
+  })));
+}
+async function testRouteRenders(module, options = {}) {
+  try {
+    const result = await renderRoute(module, options);
+    return { renders: true, error: null, result };
+  } catch (error) {
+    return {
+      renders: false,
+      error: error instanceof Error ? error : new Error(String(error)),
+      result: null
+    };
+  }
+}
+async function getRouteMeta(module, options = {}) {
+  if (!module.meta) {
+    return [];
+  }
+  const request = createMockRequest(options.request);
+  const context = createTestContext(options.context);
+  const params = options.params || {};
+  const url = new URL(request.url);
+  let data;
+  if (options.loaderData !== undefined) {
+    data = options.loaderData;
+  } else if (module.loader) {
+    data = await module.loader({ request, params, context });
+  }
+  return module.meta({
+    data,
+    params,
+    location: {
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash
+    }
+  });
+}
 // src/assertions.ts
 function assertRedirect(response, expectedLocation, options = {}) {
   if (!response) {
@@ -504,6 +711,56 @@ function assertCookies(response, expected, options = {}) {
     }
   }
 }
+async function assertThrows(fn, expected = {}, options = {}) {
+  let error = null;
+  try {
+    await fn();
+  } catch (e) {
+    error = e instanceof Error ? e : new Error(String(e));
+  }
+  if (!error) {
+    throw new Error(options.message || "Expected function to throw but it did not");
+  }
+  if (expected.message) {
+    if (expected.message instanceof RegExp) {
+      if (!expected.message.test(error.message)) {
+        throw new Error(options.message || `Expected error message to match ${expected.message} but got "${error.message}"`);
+      }
+    } else {
+      if (error.message !== expected.message) {
+        throw new Error(options.message || `Expected error message to be "${expected.message}" but got "${error.message}"`);
+      }
+    }
+  }
+  if (expected.name && error.name !== expected.name) {
+    throw new Error(options.message || `Expected error name to be "${expected.name}" but got "${error.name}"`);
+  }
+  if (expected.status && "status" in error && error.status !== expected.status) {
+    throw new Error(options.message || `Expected error status to be ${expected.status} but got ${error.status}`);
+  }
+}
+function assertSchema(data, schema, options = {}) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error(options.message || "Expected data to be an object");
+  }
+  const obj = data;
+  for (const [key, expectedType] of Object.entries(schema)) {
+    const value = obj[key];
+    let actualType;
+    if (value === null) {
+      actualType = "null";
+    } else if (value === undefined) {
+      actualType = "undefined";
+    } else if (Array.isArray(value)) {
+      actualType = "array";
+    } else {
+      actualType = typeof value;
+    }
+    if (actualType !== expectedType) {
+      throw new Error(options.message || `Expected "${key}" to be ${expectedType} but got ${actualType}`);
+    }
+  }
+}
 // src/server.ts
 async function createTestServer(options = {}) {
   const port = options.port || await getAvailablePort();
@@ -597,6 +854,45 @@ async function getAvailablePort() {
   server.stop();
   return port;
 }
+async function createMockServer(options) {
+  const port = options.port || await getAvailablePort();
+  const server = Bun.serve({
+    port,
+    async fetch(request) {
+      const url = new URL(request.url);
+      const method = request.method;
+      const path = url.pathname;
+      const routeKey = `${method} ${path}`;
+      const handler = options.routes[routeKey];
+      if (!handler) {
+        return new Response("Not Found", { status: 404 });
+      }
+      let responseData;
+      if (typeof handler === "function") {
+        let body;
+        try {
+          body = await request.json();
+        } catch {
+          body = undefined;
+        }
+        responseData = handler({ body, params: {} });
+      } else {
+        responseData = handler;
+      }
+      return new Response(JSON.stringify(responseData), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  });
+  return {
+    url: `http://localhost:${port}`,
+    port,
+    stop: async () => {
+      server.stop();
+    }
+  };
+}
 // src/snapshot.ts
 function prepareForSnapshot(data, options = {}) {
   if (data === null || data === undefined) {
@@ -633,29 +929,83 @@ async function snapshotAction(action, testOptions = {}, snapshotOptions = {}) {
   const result = await testAction(action, testOptions);
   return prepareForSnapshot(result.data, snapshotOptions);
 }
+async function createSnapshotMatrix(loader, options) {
+  const snapshots = {};
+  for (const [name, testOptions] of Object.entries(options.scenarios)) {
+    snapshots[name] = await snapshotLoader(loader, testOptions, options.snapshotOptions);
+  }
+  return snapshots;
+}
+var commonReplacers = {
+  date: /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/g,
+  uuid: /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+  numericId: /\d+/g
+};
+function applyReplacements(data, replacements) {
+  const json = JSON.stringify(data);
+  let result = json;
+  for (const [pattern, replacement] of Object.entries(replacements)) {
+    result = result.split(pattern).join(replacement);
+  }
+  return JSON.parse(result);
+}
+function deterministicSnapshot(data) {
+  return JSON.stringify(data, (_, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((sorted, key) => {
+        sorted[key] = value[key];
+        return sorted;
+      }, {});
+    }
+    return value;
+  }, 2);
+}
 export {
+  testRouteRenders,
+  testMiddlewareMatrix,
+  testMiddlewareError,
+  testMiddlewareContext,
+  testMiddlewareChain,
   testMiddleware,
+  testLoadersParallel,
+  testLoaderMatrix,
+  testLoaderError,
   testLoader,
+  testActionWithFile,
+  testActionMatrix,
+  testActionError,
   testAction,
   snapshotLoader,
   snapshotAction,
+  renderRouteMatrix,
   renderRoute,
+  renderComponent,
   parseTextResponse,
   parseJsonResponse,
+  getRouteMeta,
+  extractCookies,
+  deterministicSnapshot,
   createTestServer,
   createTestContext,
+  createSnapshotMatrix,
   createRouteRenderer,
+  createMockServer,
   createMockRequest,
   createMockHeaders,
   createMockFormData,
+  createMockFile,
   createMiddlewareTester,
   createLoaderTester,
   createFormRequest,
   createContextFactory,
   createActionTester,
+  commonReplacers,
+  assertThrows,
   assertStatus,
+  assertSchema,
   assertRedirect,
   assertJson,
   assertHeaders,
-  assertCookies
+  assertCookies,
+  applyReplacements
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ereo/testing",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "license": "MIT",
   "author": "Ereo Team",
   "homepage": "https://ereo.dev",
@@ -32,9 +32,9 @@
     "typecheck": "tsc --noEmit --skipLibCheck"
   },
   "dependencies": {
-    "@ereo/core": "^0.1.23",
-    "@ereo/router": "^0.1.23",
-    "@ereo/data": "^0.1.23"
+    "@ereo/core": "^0.1.25",
+    "@ereo/router": "^0.1.25",
+    "@ereo/data": "^0.1.25"
   },
   "devDependencies": {
     "@types/bun": "^1.1.0",