@vertz/testing 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { NamedMiddlewareDef, NamedModule, NamedServiceDef } from "@vertz/core";
+type DeepPartial<T> = { [P in keyof T]? : T[P] extends object ? DeepPartial<T[P]> : T[P] };
+interface TestResponse {
+	status: number;
+	body: unknown;
+	headers: Record<string, string>;
+	ok: boolean;
+}
+interface TestRequestBuilder extends PromiseLike<TestResponse> {
+	mock<
+		TDeps,
+		TState,
+		TMethods
+	>(service: NamedServiceDef<TDeps, TState, TMethods>, impl: DeepPartial<TMethods>): TestRequestBuilder;
+	mockMiddleware<
+		TReq extends Record<string, unknown>,
+		TProv extends Record<string, unknown>
+	>(middleware: NamedMiddlewareDef<TReq, TProv>, result: TProv): TestRequestBuilder;
+}
+interface RequestOptions {
+	body?: unknown;
+	headers?: Record<string, string>;
+}
+interface TestApp {
+	register(module: NamedModule, options?: Record<string, unknown>): TestApp;
+	mock<
+		TDeps,
+		TState,
+		TMethods
+	>(service: NamedServiceDef<TDeps, TState, TMethods>, impl: DeepPartial<TMethods>): TestApp;
+	mockMiddleware<
+		TReq extends Record<string, unknown>,
+		TProv extends Record<string, unknown>
+	>(middleware: NamedMiddlewareDef<TReq, TProv>, result: TProv): TestApp;
+	env(vars: Record<string, unknown>): TestApp;
+	get(path: string, options?: RequestOptions): TestRequestBuilder;
+	post(path: string, options?: RequestOptions): TestRequestBuilder;
+	put(path: string, options?: RequestOptions): TestRequestBuilder;
+	patch(path: string, options?: RequestOptions): TestRequestBuilder;
+	delete(path: string, options?: RequestOptions): TestRequestBuilder;
+	head(path: string, options?: RequestOptions): TestRequestBuilder;
+}
+declare function createTestApp(): TestApp;
+import { NamedServiceDef as NamedServiceDef2 } from "@vertz/core";
+interface TestServiceBuilder<TMethods> extends PromiseLike<TMethods> {
+	mock<
+		TDep,
+		TState,
+		TMock
+	>(service: NamedServiceDef2<TDep, TState, TMock>, impl: DeepPartial<TMock>): TestServiceBuilder<TMethods>;
+}
+declare function createTestService<
+	TDeps,
+	TState,
+	TMethods
+>(serviceDef: NamedServiceDef2<TDeps, TState, TMethods>): TestServiceBuilder<TMethods>;
+export { createTestService, createTestApp, TestServiceBuilder, TestResponse, TestRequestBuilder, TestApp, DeepPartial };

package/dist/index.js

@@ -0,0 +1,231 @@
+// src/test-app.ts
+import {
+  BadRequestException
+} from "@vertz/core";
+import {
+  buildCtx,
+  createErrorResponse,
+  createJsonResponse,
+  parseBody,
+  parseRequest,
+  runMiddlewareChain,
+  Trie
+} from "@vertz/core/internals";
+
+class ResponseValidationError extends Error {
+  constructor(message) {
+    super(`Response validation failed: ${message}`);
+    this.name = "ResponseValidationError";
+  }
+}
+function validateSchema(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof BadRequestException)
+      throw error;
+    const message = error instanceof Error ? error.message : `Invalid ${label}`;
+    throw new BadRequestException(message);
+  }
+}
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"];
+function createTestApp() {
+  const serviceMocks = new Map;
+  const middlewareMocks = new Map;
+  const registrations = [];
+  let envOverrides = {};
+  function buildHandler(perRequest) {
+    const trie = new Trie;
+    const realServices = new Map;
+    for (const { module } of registrations) {
+      for (const service of module.services) {
+        if (!realServices.has(service)) {
+          realServices.set(service, service.methods({}, undefined));
+        }
+      }
+    }
+    const serviceMap = new Map([...realServices, ...serviceMocks, ...perRequest.services]);
+    for (const { module, options } of registrations) {
+      for (const router of module.routers) {
+        const resolvedServices = {};
+        if (router.inject) {
+          for (const [name, serviceDef] of Object.entries(router.inject)) {
+            resolvedServices[name] = serviceMap.get(serviceDef);
+          }
+        }
+        for (const route of router.routes) {
+          const fullPath = router.prefix + route.path;
+          const entry = {
+            handler: route.config.handler,
+            options: options ?? {},
+            services: resolvedServices,
+            responseSchema: route.config.response,
+            bodySchema: route.config.body,
+            querySchema: route.config.query,
+            headersSchema: route.config.headers
+          };
+          trie.add(route.method, fullPath, entry);
+        }
+      }
+    }
+    const effectiveMiddlewareMocks = new Map([...middlewareMocks, ...perRequest.middlewares]);
+    return async (request) => {
+      try {
+        const parsed = parseRequest(request);
+        const match = trie.match(parsed.method, parsed.path);
+        if (!match) {
+          const allowed = trie.getAllowedMethods(parsed.path);
+          if (allowed.length > 0) {
+            return createJsonResponse({ error: "MethodNotAllowed", message: "Method Not Allowed", statusCode: 405 }, 405, { allow: allowed.join(", ") });
+          }
+          return createJsonResponse({ error: "NotFound", message: "Not Found", statusCode: 404 }, 404);
+        }
+        const body = await parseBody(request);
+        const raw = {
+          request: parsed.raw,
+          method: parsed.method,
+          url: parsed.raw.url,
+          headers: parsed.raw.headers
+        };
+        const shared = {
+          params: match.params,
+          body,
+          query: parsed.query,
+          headers: parsed.headers,
+          raw
+        };
+        const resolvedMiddlewares = [...effectiveMiddlewareMocks].map(([mw, mockResult]) => ({
+          name: mw.name,
+          handler: () => mockResult,
+          resolvedInject: {}
+        }));
+        const middlewareState = await runMiddlewareChain(resolvedMiddlewares, shared);
+        const entry = match.handler;
+        const validatedBody = entry.bodySchema ? validateSchema(entry.bodySchema, body, "body") : body;
+        const validatedQuery = entry.querySchema ? validateSchema(entry.querySchema, parsed.query, "query") : parsed.query;
+        const validatedHeaders = entry.headersSchema ? validateSchema(entry.headersSchema, parsed.headers, "headers") : parsed.headers;
+        const ctx = buildCtx({
+          params: match.params,
+          body: validatedBody,
+          query: validatedQuery,
+          headers: validatedHeaders,
+          raw,
+          middlewareState,
+          services: entry.services,
+          options: entry.options,
+          env: envOverrides
+        });
+        const result = await entry.handler(ctx);
+        if (entry.responseSchema) {
+          const validation = entry.responseSchema.safeParse(result);
+          if (!validation.success) {
+            throw new ResponseValidationError(validation.error?.message ?? "Unknown validation error");
+          }
+        }
+        return result === undefined ? new Response(null, { status: 204 }) : createJsonResponse(result);
+      } catch (error) {
+        if (error instanceof ResponseValidationError)
+          throw error;
+        return createErrorResponse(error);
+      }
+    };
+  }
+  async function executeRequest(method, path, options, perRequest) {
+    const handler = buildHandler(perRequest);
+    const { body, headers: customHeaders } = options ?? {};
+    const headers = { ...customHeaders };
+    if (body !== undefined) {
+      headers["content-type"] = "application/json";
+    }
+    const request = new Request(`http://localhost${path}`, {
+      method,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      headers
+    });
+    const response = await handler(request);
+    const isJson = response.headers.get("content-type")?.includes("application/json");
+    const responseBody = isJson ? await response.json() : null;
+    return {
+      status: response.status,
+      body: responseBody,
+      headers: Object.fromEntries(response.headers),
+      ok: response.ok
+    };
+  }
+  function createRequestBuilder(method, path, options) {
+    const perRequest = {
+      services: new Map,
+      middlewares: new Map
+    };
+    const builder = {
+      mock(service, impl) {
+        perRequest.services.set(service, impl);
+        return builder;
+      },
+      mockMiddleware(middleware, result) {
+        perRequest.middlewares.set(middleware, result);
+        return builder;
+      },
+      then(onfulfilled, onrejected) {
+        return executeRequest(method, path, options, perRequest).then(onfulfilled, onrejected);
+      }
+    };
+    return builder;
+  }
+  const httpMethods = Object.fromEntries(HTTP_METHODS.map((m) => [
+    m.toLowerCase(),
+    (path, options) => createRequestBuilder(m, path, options)
+  ]));
+  const app = {
+    register(module, options) {
+      registrations.push({ module, options });
+      return app;
+    },
+    mock(service, impl) {
+      serviceMocks.set(service, impl);
+      return app;
+    },
+    mockMiddleware(middleware, result) {
+      middlewareMocks.set(middleware, result);
+      return app;
+    },
+    env(vars) {
+      envOverrides = vars;
+      return app;
+    },
+    ...httpMethods
+  };
+  return app;
+}
+// src/test-service.ts
+function createTestService(serviceDef) {
+  const serviceMocks = new Map;
+  async function resolve() {
+    const deps = {};
+    if (serviceDef.inject) {
+      for (const [name, depDef] of Object.entries(serviceDef.inject)) {
+        const mock = serviceMocks.get(depDef);
+        if (mock === undefined) {
+          throw new Error(`Missing mock for injected dependency "${name}". Call .mock(${name}Service, impl) before awaiting.`);
+        }
+        deps[name] = mock;
+      }
+    }
+    const state = serviceDef.onInit ? await serviceDef.onInit(deps) : undefined;
+    return serviceDef.methods(deps, state);
+  }
+  const builder = {
+    mock(service, impl) {
+      serviceMocks.set(service, impl);
+      return builder;
+    },
+    then(onfulfilled, onrejected) {
+      return resolve().then(onfulfilled, onrejected);
+    }
+  };
+  return builder;
+}
+export {
+  createTestService,
+  createTestApp
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@vertz/testing",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bunup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@vertz/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.1",
+    "@vertz/schema": "0.1.0",
+    "bunup": "latest",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}