@dangao/bun-server 1.0.0 → 1.0.3

package/tests/perf/optimization.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, test } from 'bun:test';
+import { Router } from '../../src/router/router';
+import { Context } from '../../src/core/context';
+import { MiddlewarePipeline } from '../../src/middleware/pipeline';
+import { Container } from '../../src/di/container';
+import { Injectable, Inject } from '../../src/di/decorators';
+import { PerformanceHarness } from '../../src/testing/harness';
+import 'reflect-metadata';
+
+/**
+ * 性能优化验证测试
+ * 验证路由匹配缓存、中间件管道优化、DI 容器优化的效果
+ */
+
+describe('Performance Optimization Tests', () => {
+  test('route matching cache should improve performance', async () => {
+    // 创建两个独立的 router 实例，确保测试准确性
+    const createRouter = () => {
+      const r = new Router();
+      // 注册多个路由
+      for (let i = 0; i < 100; i++) {
+        r.get(`/api/users/${i}`, (ctx: Context) => ctx.createResponse({ id: i }));
+      }
+      // 注册动态路由（这个路由会在最后匹配，因为前面有100个静态路由）
+      r.get('/api/users/:id', (ctx: Context) => ctx.createResponse({ id: ctx.getParam('id') }));
+      return r;
+    };
+
+    // 第一次匹配（无缓存）- 每次迭代都创建新的 router，确保没有缓存
+    const result1 = await PerformanceHarness.benchmark(
+      'route match (first, no cache)',
+      10000,
+      async () => {
+        const r = createRouter();
+        return r.findRoute('GET', '/api/users/123');
+      },
+    );
+
+    // 第二次匹配（有缓存）- 使用同一个 router 实例，缓存已建立
+    const router2 = createRouter();
+    // 预热缓存
+    router2.findRoute('GET', '/api/users/123');
+    
+    const result2 = await PerformanceHarness.benchmark(
+      'route match (cached)',
+      10000,
+      async () => {
+        return router2.findRoute('GET', '/api/users/123');
+      },
+    );
+
+    // 缓存后的性能应该更好或至少相当（允许一定的性能波动）
+    // 使用更宽松的断言：缓存版本不应该明显更慢（允许15%的性能波动）
+    // 因为性能测试本身存在波动性，特别是在高频操作时
+    const performanceRatio = result2.durationMs / result1.durationMs;
+    expect(performanceRatio).toBeLessThanOrEqual(1.15); // 缓存版本不应该比无缓存版本慢超过15%
+    
+    // 验证缓存确实被使用：缓存版本的性能应该至少相当
+    expect(result2.opsPerSecond).toBeGreaterThan(result1.opsPerSecond * 0.85);
+  });
+
+  test('middleware pipeline optimization should reduce memory allocation', async () => {
+    const pipeline = new MiddlewarePipeline();
+    
+    // 添加多个中间件
+    for (let i = 0; i < 50; i++) {
+      pipeline.use(async (ctx, next) => {
+        return await next();
+      });
+    }
+
+    const context = new Context(new Request('http://localhost:3000/test'));
+
+    const result = await PerformanceHarness.benchmark(
+      'middleware pipeline',
+      1000,
+      async () => {
+        return await pipeline.run(context, async () => {
+          return new Response('ok');
+        });
+      },
+    );
+
+    // 优化后的中间件管道应该快速执行
+    expect(result.durationMs).toBeLessThan(1000); // 1000次操作应该在1秒内完成
+    expect(result.opsPerSecond).toBeGreaterThan(1000);
+  });
+
+  test('DI container dependency plan cache should improve resolution', async () => {
+    @Injectable()
+    class Level1 {
+      public name = 'level1';
+    }
+
+    @Injectable()
+    class Level2 {
+      public constructor(@Inject(Level1) public level1: Level1) {}
+    }
+
+    @Injectable()
+    class Level3 {
+      public constructor(@Inject(Level2) public level2: Level2) {}
+    }
+
+    const container = new Container();
+    container.register(Level1);
+    container.register(Level2);
+    container.register(Level3);
+
+    // 第一次解析（构建依赖计划）
+    const result1 = await PerformanceHarness.benchmark(
+      'DI resolve (first, build plan)',
+      1000,
+      () => {
+        return container.resolve(Level3);
+      },
+    );
+
+    // 第二次解析（使用缓存的依赖计划）
+    const result2 = await PerformanceHarness.benchmark(
+      'DI resolve (cached plan)',
+      1000,
+      () => {
+        return container.resolve(Level3);
+      },
+    );
+
+    // 使用缓存计划后的性能应该更好（虽然单例也会影响）
+    // 主要验证不会退化
+    expect(result2.durationMs).toBeLessThanOrEqual(result1.durationMs * 1.5);
+    expect(result2.opsPerSecond).toBeGreaterThan(5000);
+  });
+
+  test('router should handle many routes efficiently', async () => {
+    const router = new Router();
+    
+    // 注册大量路由
+    for (let i = 0; i < 1000; i++) {
+      router.get(`/api/items/${i}`, (ctx: Context) => ctx.createResponse({ id: i }));
+    }
+
+    const context = new Context(new Request('http://localhost:3000/api/items/500'));
+
+    const result = await PerformanceHarness.benchmark(
+      'router with many routes',
+      100,
+      async () => {
+        return router.findRoute('GET', '/api/items/500');
+      },
+    );
+
+    // 即使有大量路由，匹配应该快速完成
+    expect(result.durationMs).toBeLessThan(500); // 100次操作应该在500ms内完成
+    expect(result.opsPerSecond).toBeGreaterThan(200);
+  });
+
+  test('middleware pipeline should handle many middlewares efficiently', async () => {
+    const pipeline = new MiddlewarePipeline();
+    
+    // 添加大量中间件
+    for (let i = 0; i < 200; i++) {
+      pipeline.use(async (ctx, next) => {
+        return await next();
+      });
+    }
+
+    const context = new Context(new Request('http://localhost:3000/test'));
+
+    const result = await PerformanceHarness.benchmark(
+      'middleware pipeline (many middlewares)',
+      100,
+      async () => {
+        return await pipeline.run(context, async () => {
+          return new Response('ok');
+        });
+      },
+    );
+
+    // 即使有大量中间件，执行应该快速完成
+    expect(result.durationMs).toBeLessThan(2000); // 100次操作应该在2秒内完成
+    expect(result.opsPerSecond).toBeGreaterThan(50);
+  });
+});

package/tests/perf/regression.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+import { PerformanceHarness } from '../../src/testing/harness';
+import { getTestPort } from '../utils/test-port';
+
+/**
+ * 性能回归测试
+ * 确保关键路径的性能不会退化
+ */
+describe('Performance Regression Tests', () => {
+  test('router handle should be fast', async () => {
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/test', (ctx: Context) => {
+      return ctx.createResponse({ message: 'ok' });
+    });
+
+    const router = registry.getRouter();
+    const context = new Context(
+      new Request('http://localhost:3000/api/test'),
+    );
+    context.params = {};
+
+    const result = await PerformanceHarness.benchmark(
+      'router handle',
+      1000,
+      async () => {
+        await router.preHandle(context);
+        return await router.handle(context);
+      },
+    );
+
+    // 路由处理应该快速完成
+    expect(result.durationMs).toBeLessThan(1000); // 1000次操作应该在1秒内完成
+    expect(result.opsPerSecond).toBeGreaterThan(1000);
+  });
+
+  test('application request handling should be fast', async () => {
+    const port = getTestPort();
+    const app = new Application({ port });
+    const registry = RouteRegistry.getInstance();
+    registry.get('/api/ping', (ctx: Context) => {
+      return ctx.createResponse({ status: 'ok' });
+    });
+
+    await app.listen();
+
+    try {
+      const result = await PerformanceHarness.benchmark(
+        'application request',
+        100,
+        async () => {
+          const response = await fetch(`http://localhost:${port}/api/ping`);
+          await response.text();
+          return response;
+        },
+      );
+
+      // HTTP 请求处理应该快速完成（包含网络开销）
+      expect(result.durationMs).toBeLessThan(2000); // 100次请求应该在2秒内完成
+      expect(result.opsPerSecond).toBeGreaterThan(50);
+    } finally {
+      await app.stop();
+    }
+  });
+
+  test('DI container resolve should be fast', async () => {
+    const { Container } = await import('../../src/di/container');
+    const { Injectable } = await import('../../src/di/decorators');
+
+    @Injectable()
+    class TestService {
+      public value = 'test';
+    }
+
+    const container = new Container();
+    container.register(TestService);
+
+    const result = await PerformanceHarness.benchmark(
+      'DI resolve',
+      10000,
+      () => {
+        return container.resolve(TestService);
+      },
+    );
+
+    // DI 解析应该非常快（单例缓存）
+    expect(result.durationMs).toBeLessThan(100); // 10000次解析应该在100ms内完成
+    expect(result.opsPerSecond).toBeGreaterThan(10000);
+  });
+
+  test('middleware pipeline should be fast', async () => {
+    const { MiddlewarePipeline } = await import('../../src/middleware/pipeline');
+    const { Context } = await import('../../src/core/context');
+
+    const pipeline = new MiddlewarePipeline();
+    pipeline.use(async (ctx, next) => {
+      return await next();
+    });
+    pipeline.use(async (ctx, next) => {
+      return await next();
+    });
+
+    const context = new Context(new Request('http://localhost:3000/test'));
+    const result = await PerformanceHarness.benchmark(
+      'middleware pipeline',
+      1000,
+      async () => {
+        return await pipeline.run(context, async () => {
+          return new Response('ok');
+        });
+      },
+    );
+
+    // 中间件管道应该快速完成
+    expect(result.durationMs).toBeLessThan(500); // 1000次操作应该在500ms内完成
+    expect(result.opsPerSecond).toBeGreaterThan(1000);
+  });
+});

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

@@ -0,0 +1,217 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { Container } from '../../src/di/container';
+import { ModuleRegistry } from '../../src/di/module-registry';
+import {
+  QueueModule,
+  QueueService,
+  QUEUE_SERVICE_TOKEN,
+  MemoryQueueStore,
+  type QueueModuleOptions,
+  type Job,
+} from '../../src/queue';
+
+describe('QueueModule', () => {
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, QueueModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  test('should register queue service provider', () => {
+    QueueModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const queueProvider = metadata.providers.find(
+      (provider: any) => provider.provide === QUEUE_SERVICE_TOKEN,
+    );
+    expect(queueProvider).toBeDefined();
+    expect(queueProvider.useValue).toBeInstanceOf(QueueService);
+  });
+
+  test('should use custom store when provided', () => {
+    const customStore = new MemoryQueueStore();
+    QueueModule.forRoot({
+      store: customStore,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    const queueProvider = metadata.providers.find(
+      (provider: any) => provider.provide === QUEUE_SERVICE_TOKEN,
+    );
+    expect(queueProvider).toBeDefined();
+  });
+
+  test('should configure default queue name', () => {
+    QueueModule.forRoot({
+      defaultQueue: 'custom-queue',
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+  });
+
+  test('should configure worker settings', () => {
+    QueueModule.forRoot({
+      enableWorker: false,
+      concurrency: 5,
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule);
+    expect(metadata).toBeDefined();
+  });
+});
+
+describe('QueueService', () => {
+  let service: QueueService;
+  let store: MemoryQueueStore;
+
+  beforeEach(() => {
+    store = new MemoryQueueStore();
+    service = new QueueService({
+      store,
+      defaultQueue: 'default',
+      enableWorker: false, // 禁用工作进程以便测试
+      concurrency: 1,
+    });
+  });
+
+  afterEach(() => {
+    service.destroy();
+  });
+
+  test('should add job to queue', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    expect(jobId).toBeDefined();
+    expect(typeof jobId).toBe('string');
+  });
+
+  test('should get job by id', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    const job = await service.get(jobId);
+    expect(job).toBeDefined();
+    expect(job?.name).toBe('test-job');
+    expect(job?.data).toEqual({ data: 'test' });
+  });
+
+  test('should delete job', async () => {
+    const jobId = await service.add('test-job', { data: 'test' });
+    const deleted = await service.delete(jobId);
+    expect(deleted).toBe(true);
+    const job = await service.get(jobId);
+    expect(job).toBeUndefined();
+  });
+
+  test('should clear queue', async () => {
+    await service.add('test-job', { data: 'test' });
+    await service.add('test-job2', { data: 'test2' });
+    const cleared = await service.clear();
+    expect(cleared).toBe(true);
+    const count = await service.count();
+    expect(count).toBe(0);
+  });
+
+  test('should count jobs in queue', async () => {
+    await service.add('test-job', { data: 'test' });
+    await service.add('test-job2', { data: 'test2' });
+    const count = await service.count();
+    expect(count).toBe(2);
+  });
+
+  test('should register job handler', async () => {
+    let handlerCalled = false;
+    await service.registerHandler('test-job', async (job) => {
+      handlerCalled = true;
+      expect(job.name).toBe('test-job');
+    });
+    expect(handlerCalled).toBe(false); // Handler not called yet
+  });
+
+  test('should add job with options', async () => {
+    const jobId = await service.add(
+      'test-job',
+      { data: 'test' },
+      {
+        delay: 1000,
+        priority: 10,
+        attempts: 3,
+      },
+    );
+    const job = await service.get(jobId);
+    expect(job).toBeDefined();
+    expect(job?.options?.delay).toBe(1000);
+    expect(job?.options?.priority).toBe(10);
+    expect(job?.options?.attempts).toBe(3);
+  });
+});
+
+describe('MemoryQueueStore', () => {
+  let store: MemoryQueueStore;
+
+  beforeEach(() => {
+    store = new MemoryQueueStore();
+  });
+
+  test('should add and get job', async () => {
+    const jobId = await store.add('test-queue', {
+      name: 'test-job',
+      data: { test: 'data' },
+    });
+    expect(jobId).toBeDefined();
+
+    const job = await store.get('test-queue', jobId);
+    expect(job).toBeDefined();
+    expect(job?.name).toBe('test-job');
+    expect(job?.data).toEqual({ test: 'data' });
+  });
+
+  test('should get next job', async () => {
+    await store.add('test-queue', {
+      name: 'job1',
+      data: { id: 1 },
+    });
+    await store.add('test-queue', {
+      name: 'job2',
+      data: { id: 2 },
+    });
+
+    const nextJob = await store.getNext('test-queue');
+    expect(nextJob).toBeDefined();
+    expect(nextJob?.name).toBe('job1');
+  });
+
+  test('should update job status', async () => {
+    const jobId = await store.add('test-queue', {
+      name: 'test-job',
+      data: {},
+    });
+    const updated = await store.updateStatus('test-queue', jobId, 'active');
+    expect(updated).toBe(true);
+
+    const job = await store.get('test-queue', jobId);
+    expect(job?.status).toBe('active');
+  });
+
+  test('should count jobs', async () => {
+    await store.add('test-queue', { name: 'job1', data: {} });
+    await store.add('test-queue', { name: 'job2', data: {} });
+    const count = await store.count('test-queue');
+    expect(count).toBe(2);
+  });
+
+  test('should clear queue', async () => {
+    await store.add('test-queue', { name: 'job1', data: {} });
+    await store.clear('test-queue');
+    const count = await store.count('test-queue');
+    expect(count).toBe(0);
+  });
+});

package/tests/request/body-parser.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from 'bun:test';
+import { BodyParser } from '../../src/request/body-parser';
+
+describe('BodyParser', () => {
+  test('should parse JSON body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John', age: 30 }),
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John', age: 30 });
+  });
+
+  test('should parse URLEncoded body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: 'name=John&age=30',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John', age: '30' });
+  });
+
+  test('should parse text body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: 'Hello World',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('Hello World');
+  });
+
+  test('should return undefined for empty body', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'GET',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should parse JSON as default', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: JSON.stringify({ name: 'John' }),
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toEqual({ name: 'John' });
+  });
+
+  test('should fall back to text when JSON parse fails', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: 'plain-text',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('plain-text');
+  });
+
+  test('should respect explicit zero content-length', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Length': '0' },
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should return undefined for HEAD requests', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'HEAD',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBeUndefined();
+  });
+
+  test('should parse text content when content headers missing but body exists', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      body: 'fallback text',
+    });
+
+    const body = await BodyParser.parse(request);
+    expect(body).toBe('fallback text');
+  });
+});
+