@cinnabun/testing 0.0.1

package/__tests__/mock-providers.test.ts

@@ -0,0 +1,88 @@
+import "reflect-metadata";
+import { describe, it, expect, afterEach } from "bun:test";
+import { Service } from "@cinnabun/core";
+import { mockProviders } from "../src/mock-providers.js";
+import { createTestingModule } from "../src/testing-module.js";
+
+afterEach(() => {});
+
+describe("mockProviders", () => {
+  it("returns ProviderOverride array for each provider", () => {
+    @Service()
+    class UserService {
+      findAll() {
+        return [];
+      }
+    }
+
+    const overrides = mockProviders(UserService);
+    expect(overrides).toHaveLength(1);
+    expect(overrides[0].provide).toBe(UserService);
+    expect(overrides[0].useValue).toBeDefined();
+  });
+
+  it("stubbed methods return undefined by default", async () => {
+    @Service()
+    class UserService {
+      findAll() {
+        return [];
+      }
+
+      findById(_id: string) {
+        return null;
+      }
+    }
+
+    const overrides = mockProviders(UserService);
+    const mock = overrides[0].useValue as Record<string, () => undefined>;
+
+    expect(mock.findAll()).toBeUndefined();
+    expect(mock.findById("1")).toBeUndefined();
+  });
+
+  it("works with createTestingModule overrides", async () => {
+    @Service()
+    class DatabaseService {
+      query() {
+        return ["real"];
+      }
+    }
+
+    @Service()
+    class UserService {
+      constructor(public db: DatabaseService) {}
+
+      findAll() {
+        return this.db.query();
+      }
+    }
+
+    const module = await createTestingModule({
+      providers: [UserService, DatabaseService],
+      overrides: mockProviders(DatabaseService),
+    });
+
+    const userService = module.resolve(UserService);
+    expect(userService.db).toBeDefined();
+    expect(userService.db.query()).toBeUndefined();
+
+    await module.close();
+  });
+
+  it("handles multiple providers", () => {
+    @Service()
+    class ServiceA {
+      a() {}
+    }
+
+    @Service()
+    class ServiceB {
+      b() {}
+    }
+
+    const overrides = mockProviders(ServiceA, ServiceB);
+    expect(overrides).toHaveLength(2);
+    expect(overrides[0].provide).toBe(ServiceA);
+    expect(overrides[1].provide).toBe(ServiceB);
+  });
+});

package/__tests__/test-app.test.ts

@@ -0,0 +1,135 @@
+import "reflect-metadata";
+import { describe, it, expect, afterEach } from "bun:test";
+import {
+  RestController,
+  GetMapping,
+  PostMapping,
+  PutMapping,
+  DeleteMapping,
+  HttpCode,
+} from "@cinnabun/core";
+import { createTestApp } from "../src/test-app.js";
+
+let app: Awaited<ReturnType<typeof createTestApp>> | null = null;
+
+afterEach(async () => {
+  if (app) {
+    await app.close();
+    app = null;
+  }
+});
+
+describe("createTestApp", () => {
+  it("serves HTTP requests", async () => {
+    @RestController("/api/items")
+    class ItemController {
+      @GetMapping("/")
+      findAll() {
+        return [{ id: 1, name: "Widget" }];
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [ItemController],
+    });
+
+    const res = await app.get("/api/items");
+    expect(res.status).toBe(200);
+
+    const body = await res.json();
+    expect(body).toEqual([{ id: 1, name: "Widget" }]);
+  });
+
+  it("get() prepends base URL", async () => {
+    @RestController("/health")
+    class HealthController {
+      @GetMapping("/")
+      check() {
+        return { ok: true };
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [HealthController],
+    });
+
+    const res = await app.get("/health");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true });
+  });
+
+  it("post() sends JSON body", async () => {
+    @RestController("/api/users")
+    class UserController {
+      @PostMapping("/")
+      @HttpCode(201)
+      create(_body: { name: string }) {
+        return { created: true };
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [UserController],
+    });
+
+    const res = await app.post("/api/users", { name: "Bob" });
+    expect(res.status).toBe(201);
+    expect(await res.json()).toEqual({ created: true });
+  });
+
+  it("put() sends JSON body", async () => {
+    @RestController("/api/users")
+    class UserController {
+      @PutMapping("/:id")
+      update(_body: { name: string }) {
+        return { updated: true };
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [UserController],
+    });
+
+    const res = await app.put("/api/users/1", { name: "Alice" });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ updated: true });
+  });
+
+  it("delete() works", async () => {
+    @RestController("/api/users")
+    class UserController {
+      @DeleteMapping("/:id")
+      @HttpCode(204)
+      remove() {
+        return null;
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [UserController],
+    });
+
+    const res = await app.delete("/api/users/1");
+    expect(res.status).toBe(204);
+  });
+
+  it("close() shuts down server without error", async () => {
+    @RestController("/")
+    class RootController {
+      @GetMapping("/")
+      index() {
+        return { ok: true };
+      }
+    }
+
+    app = await createTestApp({
+      controllers: [RootController],
+    });
+
+    const resBefore = await app.get("/");
+    expect(resBefore.status).toBe(200);
+
+    await expect(app.close()).resolves.toBeUndefined();
+    app = null;
+  });
+});

package/__tests__/testing-module.test.ts

@@ -0,0 +1,154 @@
+import "reflect-metadata";
+import { describe, it, expect, afterEach } from "bun:test";
+import { Service, PostConstruct, PreDestroy } from "@cinnabun/core";
+import { createTestingModule } from "../src/testing-module.js";
+
+afterEach(() => {});
+
+describe("createTestingModule", () => {
+  it("resolves providers correctly", async () => {
+    @Service()
+    class UserService {
+      findAll() {
+        return [{ id: 1, name: "Alice" }];
+      }
+    }
+
+    const module = await createTestingModule({
+      providers: [UserService],
+    });
+
+    const userService = module.resolve(UserService);
+    expect(userService).toBeInstanceOf(UserService);
+    expect(userService.findAll()).toHaveLength(1);
+    expect(userService.findAll()[0].name).toBe("Alice");
+
+    await module.close();
+  });
+
+  it("replaces real implementation with useValue override", async () => {
+    @Service()
+    class DatabaseService {
+      query() {
+        return [{ id: 1, name: "real" }];
+      }
+    }
+
+    @Service()
+    class UserService {
+      constructor(public db: DatabaseService) {}
+
+      findAll() {
+        return this.db.query();
+      }
+    }
+
+    const mockDb = {
+      query: () => [{ id: 1, name: "mocked" }],
+    };
+
+    const module = await createTestingModule({
+      providers: [UserService, DatabaseService],
+      overrides: [
+        { provide: DatabaseService, useValue: mockDb },
+      ],
+    });
+
+    const userService = module.resolve(UserService);
+    expect(userService.findAll()).toEqual([{ id: 1, name: "mocked" }]);
+
+    await module.close();
+  });
+
+  it("replaces real implementation with useClass override", async () => {
+    @Service()
+    class DatabaseService {
+      query() {
+        return ["real"];
+      }
+    }
+
+    @Service()
+    class MockDatabaseService {
+      query() {
+        return ["mocked"];
+      }
+    }
+
+    @Service()
+    class UserService {
+      constructor(public db: DatabaseService) {}
+
+      findAll() {
+        return this.db.query();
+      }
+    }
+
+    const module = await createTestingModule({
+      providers: [UserService, DatabaseService],
+      overrides: [
+        { provide: DatabaseService, useClass: MockDatabaseService },
+      ],
+    });
+
+    const userService = module.resolve(UserService);
+    expect(userService.findAll()).toEqual(["mocked"]);
+
+    await module.close();
+  });
+
+  it("replaces real implementation with useFactory override", async () => {
+    @Service()
+    class DatabaseService {
+      query() {
+        return ["real"];
+      }
+    }
+
+    @Service()
+    class UserService {
+      constructor(public db: DatabaseService) {}
+
+      findAll() {
+        return this.db.query();
+      }
+    }
+
+    const module = await createTestingModule({
+      providers: [UserService, DatabaseService],
+      overrides: [
+        {
+          provide: DatabaseService,
+          useFactory: () => ({ query: () => ["factory"] }),
+        },
+      ],
+    });
+
+    const userService = module.resolve(UserService);
+    expect(userService.findAll()).toEqual(["factory"]);
+
+    await module.close();
+  });
+
+  it("close() calls @PreDestroy hooks", async () => {
+    let preDestroyCalled = false;
+
+    @Service()
+    class TestService {
+      @PreDestroy()
+      cleanup() {
+        preDestroyCalled = true;
+      }
+    }
+
+    const module = await createTestingModule({
+      providers: [TestService],
+    });
+
+    module.resolve(TestService);
+    expect(preDestroyCalled).toBe(false);
+
+    await module.close();
+    expect(preDestroyCalled).toBe(true);
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createTestingModule } from "./testing-module.js";
+export { createTestApp } from "./test-app.js";
+export { mockProviders } from "./mock-providers.js";
+export type { TestingModuleOptions, ProviderOverride, } from "./interfaces/testing-options.js";
+export type { TestingModule, TestApp } from "./interfaces/testing-module.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createTestingModule } from "./testing-module.js";
+export { createTestApp } from "./test-app.js";
+export { mockProviders } from "./mock-providers.js";

package/dist/interfaces/testing-module.d.ts

@@ -0,0 +1,13 @@
+import type { Container, Constructor } from "@cinnabun/core";
+export interface TestingModule {
+    container: Container;
+    resolve<T>(target: Constructor<T>): T;
+    close(): Promise<void>;
+}
+export interface TestApp extends TestingModule {
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+    get(path: string, headers?: Record<string, string>): Promise<Response>;
+    post(path: string, body?: unknown, headers?: Record<string, string>): Promise<Response>;
+    put(path: string, body?: unknown, headers?: Record<string, string>): Promise<Response>;
+    delete(path: string, headers?: Record<string, string>): Promise<Response>;
+}

package/dist/interfaces/testing-module.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/testing-options.d.ts

@@ -0,0 +1,13 @@
+import type { Constructor } from "@cinnabun/core";
+export interface ProviderOverride {
+    provide: Constructor;
+    useValue?: unknown;
+    useClass?: Constructor;
+    useFactory?: () => unknown;
+}
+export interface TestingModuleOptions {
+    controllers?: Constructor[];
+    providers?: Constructor[];
+    imports?: Constructor[];
+    overrides?: ProviderOverride[];
+}

package/dist/interfaces/testing-options.js

@@ -0,0 +1 @@
+export {};

package/dist/mock-providers.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from "@cinnabun/core";
+import type { ProviderOverride } from "./interfaces/testing-options.js";
+export declare function mockProviders(...providers: Constructor[]): ProviderOverride[];

package/dist/mock-providers.js

@@ -0,0 +1,13 @@
+function createMock() {
+    return new Proxy({}, {
+        get(_, prop) {
+            return () => undefined;
+        },
+    });
+}
+export function mockProviders(...providers) {
+    return providers.map((provide) => ({
+        provide,
+        useValue: createMock(),
+    }));
+}

package/dist/test-app.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import type { TestApp } from "./interfaces/testing-module.js";
+export declare function createTestApp(options: import("./interfaces/testing-options.js").TestingModuleOptions): Promise<TestApp>;

package/dist/test-app.js

@@ -0,0 +1,83 @@
+import "reflect-metadata";
+import { CinnabunApplication } from "@cinnabun/core";
+function applyOverrides(container, overrides) {
+    for (const override of overrides) {
+        let value;
+        if (override.useValue !== undefined) {
+            value = override.useValue;
+        }
+        else if (override.useClass) {
+            value = container.resolve(override.useClass);
+        }
+        else if (override.useFactory) {
+            value = override.useFactory();
+        }
+        else {
+            throw new Error(`ProviderOverride for ${override.provide.name} must specify useValue, useClass, or useFactory`);
+        }
+        container.registerInstance(override.provide, value);
+    }
+}
+function normalizePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+}
+export async function createTestApp(options) {
+    const controllers = options.controllers ?? [];
+    const providers = options.providers ?? [];
+    const app = await CinnabunApplication.create({
+        controllers,
+        providers,
+        preRegister: (container) => {
+            if (options.overrides?.length) {
+                applyOverrides(container, options.overrides);
+            }
+        },
+    });
+    await app.listen(0);
+    const port = app.getPort();
+    const baseUrl = `http://localhost:${port}`;
+    const testApp = {
+        container: app.getContainer(),
+        resolve: (target) => app.getContainer().resolve(target),
+        async close() {
+            await app.close();
+        },
+        async fetch(path, init) {
+            const url = `${baseUrl}${normalizePath(path)}`;
+            return fetch(url, init);
+        },
+        async get(path, headers) {
+            return testApp.fetch(normalizePath(path), {
+                method: "GET",
+                headers,
+            });
+        },
+        async post(path, body, headers) {
+            return testApp.fetch(normalizePath(path), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...headers,
+                },
+                body: JSON.stringify(body ?? {}),
+            });
+        },
+        async put(path, body, headers) {
+            return testApp.fetch(normalizePath(path), {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...headers,
+                },
+                body: JSON.stringify(body ?? {}),
+            });
+        },
+        async delete(path, headers) {
+            return testApp.fetch(normalizePath(path), {
+                method: "DELETE",
+                headers,
+            });
+        },
+    };
+    return testApp;
+}

package/dist/testing-module.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import type { TestingModuleOptions } from "./interfaces/testing-options.js";
+import type { TestingModule } from "./interfaces/testing-module.js";
+export declare function createTestingModule(options: TestingModuleOptions): Promise<TestingModule>;

package/dist/testing-module.js

@@ -0,0 +1,50 @@
+import "reflect-metadata";
+import { Container, resolveModuleTree } from "@cinnabun/core";
+function applyOverrides(container, overrides) {
+    for (const override of overrides) {
+        let value;
+        if (override.useValue !== undefined) {
+            value = override.useValue;
+        }
+        else if (override.useClass) {
+            value = container.resolve(override.useClass);
+        }
+        else if (override.useFactory) {
+            value = override.useFactory();
+        }
+        else {
+            throw new Error(`ProviderOverride for ${override.provide.name} must specify useValue, useClass, or useFactory`);
+        }
+        container.registerInstance(override.provide, value);
+    }
+}
+export async function createTestingModule(options) {
+    const container = new Container();
+    let controllers = options.controllers ?? [];
+    let providers = options.providers ?? [];
+    if (options.imports?.length) {
+        for (const mod of options.imports) {
+            const resolved = await resolveModuleTree(mod);
+            controllers = [...controllers, ...resolved.controllers];
+            providers = [...providers, ...resolved.providers];
+        }
+    }
+    if (options.overrides?.length) {
+        applyOverrides(container, options.overrides);
+    }
+    for (const provider of providers) {
+        container.resolve(provider);
+    }
+    for (const controller of controllers) {
+        container.resolve(controller);
+    }
+    return {
+        container,
+        resolve(target) {
+            return container.resolve(target);
+        },
+        async close() {
+            await container.shutdown();
+        },
+    };
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@cinnabun/testing",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "test": "bun test",
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "@cinnabun/core": "^0.0.3"
+  },
+  "devDependencies": {
+    "@cinnabun/core": "workspace:*",
+    "@types/bun": "latest",
+    "reflect-metadata": "^0.2.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { createTestingModule } from "./testing-module.js";
+export { createTestApp } from "./test-app.js";
+export { mockProviders } from "./mock-providers.js";
+export type {
+  TestingModuleOptions,
+  ProviderOverride,
+} from "./interfaces/testing-options.js";
+export type { TestingModule, TestApp } from "./interfaces/testing-module.js";

package/src/interfaces/testing-module.ts

@@ -0,0 +1,23 @@
+import type { Container, Constructor } from "@cinnabun/core";
+
+export interface TestingModule {
+  container: Container;
+  resolve<T>(target: Constructor<T>): T;
+  close(): Promise<void>;
+}
+
+export interface TestApp extends TestingModule {
+  fetch(path: string, init?: RequestInit): Promise<Response>;
+  get(path: string, headers?: Record<string, string>): Promise<Response>;
+  post(
+    path: string,
+    body?: unknown,
+    headers?: Record<string, string>,
+  ): Promise<Response>;
+  put(
+    path: string,
+    body?: unknown,
+    headers?: Record<string, string>,
+  ): Promise<Response>;
+  delete(path: string, headers?: Record<string, string>): Promise<Response>;
+}

package/src/interfaces/testing-options.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@cinnabun/core";
+
+export interface ProviderOverride {
+  provide: Constructor;
+  useValue?: unknown;
+  useClass?: Constructor;
+  useFactory?: () => unknown;
+}
+
+export interface TestingModuleOptions {
+  controllers?: Constructor[];
+  providers?: Constructor[];
+  imports?: Constructor[];
+  overrides?: ProviderOverride[];
+}

package/src/mock-providers.ts

@@ -0,0 +1,19 @@
+import type { Constructor } from "@cinnabun/core";
+import type { ProviderOverride } from "./interfaces/testing-options.js";
+
+function createMock(): Record<string, () => undefined> {
+  return new Proxy({} as Record<string, () => undefined>, {
+    get(_, prop: string) {
+      return () => undefined;
+    },
+  });
+}
+
+export function mockProviders(
+  ...providers: Constructor[]
+): ProviderOverride[] {
+  return providers.map((provide) => ({
+    provide,
+    useValue: createMock(),
+  }));
+}

package/src/test-app.ts

@@ -0,0 +1,108 @@
+import "reflect-metadata";
+import { CinnabunApplication } from "@cinnabun/core";
+import type { Container } from "@cinnabun/core";
+import type { ProviderOverride } from "./interfaces/testing-options.js";
+import type { TestApp } from "./interfaces/testing-module.js";
+
+function applyOverrides(container: Container, overrides: ProviderOverride[]): void {
+  for (const override of overrides) {
+    let value: unknown;
+    if (override.useValue !== undefined) {
+      value = override.useValue;
+    } else if (override.useClass) {
+      value = container.resolve(override.useClass);
+    } else if (override.useFactory) {
+      value = override.useFactory();
+    } else {
+      throw new Error(
+        `ProviderOverride for ${override.provide.name} must specify useValue, useClass, or useFactory`,
+      );
+    }
+    container.registerInstance(override.provide, value);
+  }
+}
+
+function normalizePath(path: string): string {
+  return path.startsWith("/") ? path : `/${path}`;
+}
+
+export async function createTestApp(
+  options: import("./interfaces/testing-options.js").TestingModuleOptions,
+): Promise<TestApp> {
+  const controllers = options.controllers ?? [];
+  const providers = options.providers ?? [];
+
+  const app = await CinnabunApplication.create({
+    controllers,
+    providers,
+    preRegister: (container) => {
+      if (options.overrides?.length) {
+        applyOverrides(container, options.overrides);
+      }
+    },
+  });
+
+  await app.listen(0);
+  const port = app.getPort();
+  const baseUrl = `http://localhost:${port}`;
+
+  const testApp: TestApp = {
+    container: app.getContainer(),
+    resolve: (target) => app.getContainer().resolve(target),
+    async close() {
+      await app.close();
+    },
+    async fetch(path: string, init?: RequestInit): Promise<Response> {
+      const url = `${baseUrl}${normalizePath(path)}`;
+      return fetch(url, init);
+    },
+    async get(
+      path: string,
+      headers?: Record<string, string>,
+    ): Promise<Response> {
+      return testApp.fetch(normalizePath(path), {
+        method: "GET",
+        headers,
+      });
+    },
+    async post(
+      path: string,
+      body?: unknown,
+      headers?: Record<string, string>,
+    ): Promise<Response> {
+      return testApp.fetch(normalizePath(path), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers,
+        },
+        body: JSON.stringify(body ?? {}),
+      });
+    },
+    async put(
+      path: string,
+      body?: unknown,
+      headers?: Record<string, string>,
+    ): Promise<Response> {
+      return testApp.fetch(normalizePath(path), {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers,
+        },
+        body: JSON.stringify(body ?? {}),
+      });
+    },
+    async delete(
+      path: string,
+      headers?: Record<string, string>,
+    ): Promise<Response> {
+      return testApp.fetch(normalizePath(path), {
+        method: "DELETE",
+        headers,
+      });
+    },
+  };
+
+  return testApp;
+}

package/src/testing-module.ts

@@ -0,0 +1,65 @@
+import "reflect-metadata";
+import { Container, resolveModuleTree } from "@cinnabun/core";
+import type { Constructor } from "@cinnabun/core";
+import type { TestingModuleOptions, ProviderOverride } from "./interfaces/testing-options.js";
+import type { TestingModule } from "./interfaces/testing-module.js";
+
+function applyOverrides(
+  container: Container,
+  overrides: ProviderOverride[],
+): void {
+  for (const override of overrides) {
+    let value: unknown;
+    if (override.useValue !== undefined) {
+      value = override.useValue;
+    } else if (override.useClass) {
+      value = container.resolve(override.useClass);
+    } else if (override.useFactory) {
+      value = override.useFactory();
+    } else {
+      throw new Error(
+        `ProviderOverride for ${override.provide.name} must specify useValue, useClass, or useFactory`,
+      );
+    }
+    container.registerInstance(override.provide, value);
+  }
+}
+
+export async function createTestingModule(
+  options: TestingModuleOptions,
+): Promise<TestingModule> {
+  const container = new Container();
+
+  let controllers = options.controllers ?? [];
+  let providers = options.providers ?? [];
+
+  if (options.imports?.length) {
+    for (const mod of options.imports) {
+      const resolved = await resolveModuleTree(mod);
+      controllers = [...controllers, ...resolved.controllers];
+      providers = [...providers, ...resolved.providers];
+    }
+  }
+
+  if (options.overrides?.length) {
+    applyOverrides(container, options.overrides);
+  }
+
+  for (const provider of providers) {
+    container.resolve(provider);
+  }
+
+  for (const controller of controllers) {
+    container.resolve(controller);
+  }
+
+  return {
+    container,
+    resolve<T>(target: Constructor<T>): T {
+      return container.resolve(target);
+    },
+    async close(): Promise<void> {
+      await container.shutdown();
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "types": ["bun"]
+  },
+  "include": ["src"],
+  "exclude": ["src/__tests__"]
+}