@dangao/bun-server 1.0.0 → 1.0.3

package/tests/health/health-module.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from 'bun:test';
+import 'reflect-metadata';
+
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import {
+  HealthController,
+  HealthModule,
+  HEALTH_INDICATORS_TOKEN,
+  type HealthIndicator,
+} from '../../src/health';
+
+describe('HealthModule', () => {
+  test('should register controller and providers', () => {
+    const indicators: HealthIndicator[] = [
+      {
+        name: 'test',
+        check() {
+          return { status: 'up' };
+        },
+      },
+    ];
+
+    HealthModule.forRoot({ indicators });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, HealthModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.controllers).toContain(HealthController);
+
+    const indicatorProvider = metadata.providers.find(
+      (provider: any) => provider.provide === HEALTH_INDICATORS_TOKEN,
+    );
+    expect(indicatorProvider).toBeDefined();
+    expect(indicatorProvider.useValue).toBe(indicators);
+  });
+});
+
+describe('HealthController', () => {
+  test('should return up status when all indicators are up', async () => {
+    const indicators: HealthIndicator[] = [
+      {
+        name: 'db',
+        check() {
+          return { status: 'up' };
+        },
+      },
+      {
+        name: 'cache',
+        async check() {
+          return { status: 'up' };
+        },
+      },
+    ];
+
+    const controller = new HealthController(indicators, {});
+    const result = await controller.health();
+
+    expect(result.status).toBe('up');
+    expect(result.details.db.status).toBe('up');
+    expect(result.details.cache.status).toBe('up');
+  });
+
+  test('should return down status when any indicator is down', async () => {
+    const indicators: HealthIndicator[] = [
+      {
+        name: 'db',
+        check() {
+          return { status: 'up' };
+        },
+      },
+      {
+        name: 'cache',
+        check() {
+          return {
+            status: 'down',
+            details: { reason: 'unreachable' },
+          };
+        },
+      },
+    ];
+
+    const controller = new HealthController(indicators, {});
+    const result = await controller.ready();
+
+    expect(result.status).toBe('down');
+    expect(result.details.db.status).toBe('up');
+    expect(result.details.cache.status).toBe('down');
+  });
+
+  test('should mark indicator as down when check throws error', async () => {
+    const indicators: HealthIndicator[] = [
+      {
+        name: 'db',
+        check() {
+          throw new Error('connection failed');
+        },
+      },
+    ];
+
+    const controller = new HealthController(indicators, {});
+    const result = await controller.health();
+
+    expect(result.status).toBe('down');
+    expect(result.details.db.status).toBe('down');
+    expect(result.details.db.details?.error).toBe('connection failed');
+  });
+
+  test('should return up status when no indicators registered', async () => {
+    const controller = new HealthController([], {});
+    const result = await controller.health();
+
+    expect(result.status).toBe('up');
+    expect(Object.keys(result.details).length).toBe(0);
+  });
+});
+
+

package/tests/integration/application-router.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+import { ControllerRegistry } from '../../src/controller/controller';
+import { getTestPort } from '../utils/test-port';
+
+describe('Application with Router', () => {
+  let app: Application;
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should handle registered route', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/users', (ctx: Context) => {
+      return ctx.createResponse({ message: 'Hello' });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users`);
+    expect(response.status).toBe(200);
+    
+    const data = await response.json();
+    // @ts-ignore
+    expect(data.message).toBe('Hello');
+  });
+
+  test('should handle route with path parameter', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/users/:id', (ctx: Context) => {
+      return ctx.createResponse({ id: ctx.getParam('id') });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/123`);
+    expect(response.status).toBe(200);
+    
+    const data = await response.json();
+    // @ts-ignore
+    expect(data.id).toBe('123');
+  });
+
+  test('should return 404 for non-existent route', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/unknown`);
+    expect(response.status).toBe(404);
+    
+    const data = await response.json();
+    // @ts-ignore
+    expect(data.error).toBe('Not Found');
+  });
+
+  test('should handle POST request', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.post('/api/users', (ctx: Context) => {
+      return ctx.createResponse({ message: 'Created' });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users`, {
+      method: 'POST',
+    });
+    expect(response.status).toBe(200);
+    
+    const data = await response.json();
+    // @ts-ignore
+    expect(data.message).toBe('Created');
+  });
+});
+

package/tests/integration/body-parsing.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { RouteRegistry } from '../../src/router/registry';
+import type { Context } from '../../src/core/context';
+import { ControllerRegistry } from '../../src/controller/controller';
+import { getTestPort } from '../utils/test-port';
+
+describe('Application Body Parsing Integration', () => {
+  let app: Application;
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should parse JSON body in POST request', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.post('/api/users-json', async (ctx: Context) => {
+      const body = await ctx.getBody();
+      return ctx.createResponse({ received: body });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users-json`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John', age: 30 }),
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.received).toEqual({ name: 'John', age: 30 });
+  });
+
+  test('should parse URLEncoded body', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.post('/api/users-urlencoded', async (ctx: Context) => {
+      const body = await ctx.getBody();
+      return ctx.createResponse({ received: body });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users-urlencoded`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: 'name=John&age=30',
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.received).toEqual({ name: 'John', age: '30' });
+  });
+
+  test('should handle empty body', async () => {
+    const port = getTestPort();
+    app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.post('/api/users-empty', async (ctx: Context) => {
+      const body = await ctx.getBody();
+      // 空 body 时，body 应该是 undefined
+      // 返回一个简单的响应，验证 body 确实是 undefined
+      return ctx.createResponse({ 
+        message: 'Empty body handled',
+        bodyExists: body !== undefined,
+      });
+    });
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users-empty`, {
+      method: 'POST',
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    // 验证响应包含消息
+    expect(data.message).toBe('Empty body handled');
+    // 空 body 时，bodyExists 应该是 false
+    expect(data.bodyExists).toBe(false);
+  });
+});
+

package/tests/integration/cache-e2e.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import {
+  Application,
+  CacheModule,
+  CacheService,
+  CACHE_SERVICE_TOKEN,
+  ConfigModule,
+  Controller,
+  GET,
+  Inject,
+  Injectable,
+  Module,
+  Param,
+} from '../../src';
+import { getTestPort } from '../utils/test-port';
+
+@Injectable()
+class ProductService {
+  public constructor(
+    @Inject(CACHE_SERVICE_TOKEN) private readonly cache: CacheService,
+  ) {}
+
+  public async getProduct(id: string): Promise<{ id: string; name: string }> {
+    return await this.cache.getOrSet(
+      `product:${id}`,
+      async () => {
+        // 模拟数据库查询
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        return { id, name: `Product ${id}` };
+      },
+      60000,
+    );
+  }
+}
+
+@Controller('/api/products')
+class ProductController {
+  public constructor(
+    @Inject(ProductService) private readonly productService: ProductService,
+  ) {}
+
+  @GET('/:id')
+  public async getProduct(@Param('id') id: string) {
+    return await this.productService.getProduct(id);
+  }
+}
+
+@Module({
+  controllers: [ProductController],
+  providers: [ProductService],
+})
+class AppModule {}
+
+describe('Cache E2E', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(async () => {
+    port = getTestPort();
+    ConfigModule.forRoot({
+      defaultConfig: { app: { name: 'Cache E2E Test', port } },
+    });
+    CacheModule.forRoot({
+      defaultTtl: 60000,
+    });
+    app = new Application({ port });
+    app.registerModule(CacheModule);
+    app.registerModule(AppModule);
+    await app.listen();
+  });
+
+  afterEach(async () => {
+    await app.stop();
+  });
+
+  test('should cache product data', async () => {
+    const start1 = Date.now();
+    const response1 = await fetch(`http://localhost:${port}/api/products/1`);
+    const time1 = Date.now() - start1;
+    if (response1.status !== 200) {
+      const errorText = await response1.text();
+      console.error('Error response:', errorText);
+    }
+    expect(response1.status).toBe(200);
+    const data1 = await response1.json();
+    expect(data1.id).toBe('1');
+    expect(data1.name).toBe('Product 1');
+    expect(time1).toBeGreaterThan(40); // 第一次查询需要时间
+
+    const start2 = Date.now();
+    const response2 = await fetch(`http://localhost:${port}/api/products/1`);
+    const time2 = Date.now() - start2;
+    expect(response2.status).toBe(200);
+    const data2 = await response2.json();
+    expect(data2).toEqual(data1);
+    expect(time2).toBeLessThan(10); // 第二次查询应该很快（从缓存）
+  });
+
+  test('should cache different products separately', async () => {
+    const response1 = await fetch(`http://localhost:${port}/api/products/1`);
+    const response2 = await fetch(`http://localhost:${port}/api/products/2`);
+
+    expect(response1.status).toBe(200);
+    expect(response2.status).toBe(200);
+
+    const data1 = await response1.json();
+    const data2 = await response2.json();
+
+    expect(data1.id).toBe('1');
+    expect(data2.id).toBe('2');
+    expect(data1.name).toBe('Product 1');
+    expect(data2.name).toBe('Product 2');
+  });
+});