@vertz/testing 0.2.1 → 0.2.4

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { NamedMiddlewareDef, NamedModule, NamedServiceDef } from "@vertz/server";
-type DeepPartial<T> = { [P in keyof T]? : T[P] extends object ? DeepPartial<T[P]> : T[P] };
+import { HandlerCtx, NamedMiddlewareDef } from "@vertz/server";
 /**
 * Route map entry shape that each route in AppRouteMap must follow.
 */
@@ -20,11 +19,6 @@ interface TestResponse<TResponse = unknown> {
 	ok: boolean;
 }
 interface TestRequestBuilder<TResponse = unknown> extends PromiseLike<TestResponse<TResponse>> {
-	mock<
-		TDeps,
-		TState,
-		TMethods
-	>(service: NamedServiceDef<TDeps, TState, TMethods>, impl: DeepPartial<TMethods>): TestRequestBuilder<TResponse>;
 	mockMiddleware<
 		TReq extends Record<string, unknown>,
 		TProv extends Record<string, unknown>
@@ -37,16 +31,42 @@ interface RequestOptions<TBody = unknown> {
 	body?: TBody;
 	headers?: Record<string, string>;
 }
+type SchemaLike = {
+	parse(value: unknown): {
+		ok: boolean;
+		data?: unknown;
+		error?: unknown;
+	};
+};
 /**
-* Untyped test app interface for backwards compatibility.
+* Route entry for configuring test app routes.
+*/
+interface TestRouteEntry {
+	method: string;
+	path: string;
+	handler: (ctx: HandlerCtx) => unknown;
+	bodySchema?: SchemaLike;
+	querySchema?: SchemaLike;
+	headersSchema?: SchemaLike;
+	responseSchema?: {
+		safeParse(value: unknown): {
+			ok: boolean;
+			error?: {
+				message: string;
+			};
+		};
+	};
+}
+/**
+* Configuration for creating a test app.
+*/
+interface TestAppConfig {
+	routes?: TestRouteEntry[];
+}
+/**
+* Test app interface.
 */
 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>
@@ -64,12 +84,6 @@ interface TestApp {
 * @template TRouteMap - Route map interface mapping route keys (e.g., 'GET /users') to their types.
 */
 interface TestAppWithRoutes<TRouteMap extends RouteMapEntry> {
-	register(module: NamedModule, options?: Record<string, unknown>): TestAppWithRoutes<TRouteMap>;
-	mock<
-		TDeps,
-		TState,
-		TMethods
-	>(service: NamedServiceDef<TDeps, TState, TMethods>, impl: DeepPartial<TMethods>): TestAppWithRoutes<TRouteMap>;
 	mockMiddleware<
 		TReq extends Record<string, unknown>,
 		TProv extends Record<string, unknown>
@@ -107,38 +121,15 @@ interface TestAppWithRoutes<TRouteMap extends RouteMapEntry> {
 	} ? TResponse : unknown>;
 }
 /**
-* Creates a test app for making HTTP requests against registered modules.
-* Returns an untyped app for backwards compatibility.
-* @returns A test app instance for registering modules and making requests.
+* Creates a test app for making HTTP requests against registered routes.
+* @returns A test app instance for making requests.
 */
-declare function createTestApp(): TestApp;
+declare function createTestApp(config?: TestAppConfig): TestApp;
 /**
 * Creates a typed test app with route map for type-safe requests.
 * @template TRouteMap - Route map interface mapping route keys to their types.
 * @returns A typed test app instance.
 */
-declare function createTestApp<TRouteMap extends RouteMapEntry>(): TestAppWithRoutes<TRouteMap>;
-import { NamedServiceDef as NamedServiceDef2 } from "@vertz/core";
-interface TestServiceBuilder<
-	TDeps,
-	TState,
-	TMethods,
-	TOptions extends Record<string, unknown> = Record<string, unknown>,
-	TEnv extends Record<string, unknown> = Record<string, unknown>
-> extends PromiseLike<TMethods> {
-	mock<
-		TDep,
-		TDepState,
-		TMock
-	>(service: NamedServiceDef2<TDep, TDepState, TMock>, impl: DeepPartial<TMock>): TestServiceBuilder<TDeps, TState, TMethods, TOptions, TEnv>;
-	options(opts: Partial<TOptions>): TestServiceBuilder<TDeps, TState, TMethods, TOptions, TEnv>;
-	env(env: Partial<TEnv>): TestServiceBuilder<TDeps, TState, TMethods, TOptions, TEnv>;
-}
-declare function createTestService<
-	TDeps,
-	TState,
-	TMethods,
-	TOptions extends Record<string, unknown> = Record<string, unknown>,
-	TEnv extends Record<string, unknown> = Record<string, unknown>
->(serviceDef: NamedServiceDef2<TDeps, TState, TMethods, TOptions, TEnv>): TestServiceBuilder<TDeps, TState, TMethods, TOptions, TEnv>;
-export { createTestService, createTestApp, TestServiceBuilder, TestResponse, TestRequestBuilder, TestApp, RouteMapEntry, RequestOptions, DeepPartial };
+declare function createTestApp<TRouteMap extends RouteMapEntry>(config?: TestAppConfig): TestAppWithRoutes<TRouteMap>;
+type DeepPartial<T> = { [P in keyof T]? : T[P] extends object ? DeepPartial<T[P]> : T[P] };
+export { createTestApp, TestRouteEntry, TestResponse, TestRequestBuilder, TestAppConfig, TestApp, RouteMapEntry, RequestOptions, DeepPartial };

package/dist/index.js

@@ -8,9 +8,7 @@ import {
   runMiddlewareChain,
   Trie
 } from "@vertz/core/internals";
-import {
-  BadRequestException
-} from "@vertz/server";
+import { BadRequestException } from "@vertz/server";
 function validateSchema(schema, value, label) {
   const result = schema.parse(value);
   if (!result.ok) {
@@ -20,54 +18,21 @@ function validateSchema(schema, value, label) {
   return result.data;
 }
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"];
-function createTestApp() {
-  const serviceMocks = new Map;
+function createTestApp(config) {
   const middlewareMocks = new Map;
-  const registrations = [];
+  const routes = config?.routes ?? [];
   let envOverrides = {};
   function buildHandler(perRequest) {
     const trie = new Trie;
-    const realServices = new Map;
-    for (const { module, options } of registrations) {
-      for (const service of module.services) {
-        if (!realServices.has(service)) {
-          let parsedOptions = {};
-          if (service.options && options) {
-            const parsed = service.options.safeParse(options);
-            if (parsed.ok) {
-              parsedOptions = parsed.data;
-            } else {
-              throw new Error(`Invalid options for service ${service.moduleName}: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
-            }
-          }
-          const env = {};
-          realServices.set(service, service.methods({}, undefined, parsedOptions, env));
-        }
-      }
-    }
-    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);
-        }
-      }
+    for (const route of routes) {
+      const entry = {
+        handler: route.handler,
+        responseSchema: route.responseSchema,
+        bodySchema: route.bodySchema,
+        querySchema: route.querySchema,
+        headersSchema: route.headersSchema
+      };
+      trie.add(route.method, route.path, entry);
     }
     const effectiveMiddlewareMocks = new Map([...middlewareMocks, ...perRequest.middlewares]);
     return async (request) => {
@@ -112,8 +77,8 @@ function createTestApp() {
           headers: validatedHeaders,
           raw,
           middlewareState,
-          services: entry.services,
-          options: entry.options,
+          services: {},
+          options: {},
           env: envOverrides
         });
         const result = await entry.handler(ctx);
@@ -155,14 +120,9 @@ function createTestApp() {
   }
   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;
@@ -178,14 +138,6 @@ function createTestApp() {
     (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;
@@ -205,63 +157,6 @@ class ResponseValidationError extends Error {
     this.name = "ResponseValidationError";
   }
 }
-// src/test-service.ts
-function createTestService(serviceDef) {
-  const serviceMocks = new Map;
-  let providedOptions = {};
-  let providedEnv = {};
-  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;
-      }
-    }
-    let options = {};
-    if (serviceDef.options) {
-      const parsed = serviceDef.options.safeParse(providedOptions);
-      if (parsed.ok) {
-        options = parsed.data;
-      } else {
-        throw new Error(`Invalid options: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
-      }
-    }
-    let env = {};
-    if (serviceDef.env) {
-      const parsed = serviceDef.env.safeParse(providedEnv);
-      if (parsed.ok) {
-        env = parsed.data;
-      } else {
-        throw new Error(`Invalid env: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
-      }
-    }
-    const state = serviceDef.onInit ? await serviceDef.onInit(deps, options, env) : undefined;
-    return serviceDef.methods(deps, state, options, env);
-  }
-  const builder = {
-    mock(service, impl) {
-      serviceMocks.set(service, impl);
-      return builder;
-    },
-    options(opts) {
-      providedOptions = opts;
-      return builder;
-    },
-    env(envVars) {
-      providedEnv = envVars;
-      return builder;
-    },
-    then(onfulfilled, onrejected) {
-      return resolve().then(onfulfilled, onrejected);
-    }
-  };
-  return builder;
-}
 export {
-  createTestService,
   createTestApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/testing",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "type": "module",
   "license": "MIT",
   "description": "Testing utilities for Vertz applications",
@@ -31,14 +31,14 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@vertz/core": "0.2.1",
-    "@vertz/server": "0.2.1"
+    "@vertz/core": "0.2.2",
+    "@vertz/server": "0.2.2"
   },
   "devDependencies": {
     "@types/node": "^25.3.1",
-    "@vertz/schema": "0.2.1",
+    "@vertz/schema": "0.2.2",
     "@vitest/coverage-v8": "^4.0.18",
-    "bunup": "latest",
+    "bunup": "^0.16.31",
     "typescript": "^5.7.0",
     "vitest": "^4.0.18"
   },