@dangao/bun-server 1.12.1 → 2.0.1

package/tests/interceptor/perf/interceptor-performance.test.ts

@@ -1,340 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { PerformanceHarness } from '../../../src/testing/harness';
-import { InterceptorRegistry } from '../../../src/interceptor/interceptor-registry';
-import { InterceptorChain } from '../../../src/interceptor/interceptor-chain';
-import type { Interceptor } from '../../../src/interceptor/types';
-import type { Container } from '../../../src/di/container';
-import type { Context } from '../../../src/core/context';
-import { Container as DIContainer } from '../../../src/di/container';
-
-/**
- * 简单的无操作拦截器，用于性能测试
- */
-class NoOpInterceptor implements Interceptor {
-  public async execute<T>(
-    target: unknown,
-    propertyKey: string | symbol,
-    originalMethod: (...args: unknown[]) => T | Promise<T>,
-    args: unknown[],
-    container: Container,
-    context?: Context,
-  ): Promise<T> {
-    return await Promise.resolve(originalMethod.apply(target, args));
-  }
-}
-
-/**
- * 简单的同步拦截器，用于性能测试
- */
-class SyncInterceptor implements Interceptor {
-  public async execute<T>(
-    target: unknown,
-    propertyKey: string | symbol,
-    originalMethod: (...args: unknown[]) => T | Promise<T>,
-    args: unknown[],
-    container: Container,
-    context?: Context,
-  ): Promise<T> {
-    // 简单的同步操作
-    const _ = propertyKey.toString();
-    return await Promise.resolve(originalMethod.apply(target, args));
-  }
-}
-
-/**
- * 测试目标类
- */
-class TestTarget {
-  public value = 0;
-
-  public async method(arg: number): Promise<number> {
-    this.value += arg;
-    return this.value;
-  }
-
-  public syncMethod(arg: number): number {
-    this.value += arg;
-    return this.value;
-  }
-}
-
-describe('Interceptor Performance', () => {
-  const container = new DIContainer();
-  const registry = new InterceptorRegistry();
-  const metadataKey = Symbol('test');
-
-  describe('Single Interceptor Performance', () => {
-    test('should benchmark single interceptor execution', async () => {
-      const interceptor = new NoOpInterceptor();
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-
-      const result = await PerformanceHarness.benchmark(
-        'single-interceptor',
-        10000,
-        async () => {
-          await interceptor.execute(
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(1000);
-      expect(result.durationMs).toBeLessThan(10000);
-
-      console.log(`Single Interceptor: ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-
-    test('should benchmark interceptor chain with 1 interceptor', async () => {
-      const interceptor = new NoOpInterceptor();
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-
-      const result = await PerformanceHarness.benchmark(
-        'chain-1-interceptor',
-        10000,
-        async () => {
-          await InterceptorChain.execute(
-            [interceptor],
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(1000);
-      expect(result.durationMs).toBeLessThan(10000);
-
-      console.log(`Chain (1 interceptor): ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-  });
-
-  describe('Interceptor Chain Performance', () => {
-    test('should benchmark interceptor chain with 3 interceptors', async () => {
-      const interceptors = [
-        new NoOpInterceptor(),
-        new NoOpInterceptor(),
-        new NoOpInterceptor(),
-      ];
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-
-      const result = await PerformanceHarness.benchmark(
-        'chain-3-interceptors',
-        10000,
-        async () => {
-          await InterceptorChain.execute(
-            interceptors,
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(500);
-      expect(result.durationMs).toBeLessThan(20000);
-
-      console.log(`Chain (3 interceptors): ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-
-    test('should benchmark interceptor chain with 5 interceptors', async () => {
-      const interceptors = Array.from({ length: 5 }, () => new NoOpInterceptor());
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-
-      const result = await PerformanceHarness.benchmark(
-        'chain-5-interceptors',
-        10000,
-        async () => {
-          await InterceptorChain.execute(
-            interceptors,
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(300);
-      expect(result.durationMs).toBeLessThan(35000);
-
-      console.log(`Chain (5 interceptors): ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-
-    test('should benchmark interceptor chain with 10 interceptors', async () => {
-      const interceptors = Array.from({ length: 10 }, () => new NoOpInterceptor());
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-
-      const result = await PerformanceHarness.benchmark(
-        'chain-10-interceptors',
-        10000,
-        async () => {
-          await InterceptorChain.execute(
-            interceptors,
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(200);
-      expect(result.durationMs).toBeLessThan(50000);
-
-      console.log(`Chain (10 interceptors): ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-  });
-
-  describe('Performance Comparison', () => {
-    test('should compare direct method call vs interceptor chain', async () => {
-      const target = new TestTarget();
-      const originalMethod = target.method.bind(target);
-      const interceptors = [new NoOpInterceptor()];
-
-      // 直接方法调用
-      const directResult = await PerformanceHarness.benchmark(
-        'direct-method-call',
-        10000,
-        async () => {
-          await originalMethod(1);
-        },
-      );
-
-      // 拦截器链调用
-      const interceptorResult = await PerformanceHarness.benchmark(
-        'interceptor-chain',
-        10000,
-        async () => {
-          await InterceptorChain.execute(
-            interceptors,
-            target,
-            'method',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(directResult.iterations).toBe(10000);
-      expect(interceptorResult.iterations).toBe(10000);
-
-      const overhead = (interceptorResult.durationMs / directResult.durationMs - 1) * 100;
-
-      console.log(`Direct call: ${directResult.opsPerSecond.toFixed(2)} ops/sec`);
-      console.log(`Interceptor chain: ${interceptorResult.opsPerSecond.toFixed(2)} ops/sec`);
-      console.log(`Overhead: ${overhead.toFixed(2)}%`);
-
-      // 拦截器开销应该小于 400%（即不超过 5 倍）
-      // 实际测试显示开销约为 275%，这是合理的，因为需要额外的函数调用和参数传递
-      expect(overhead).toBeLessThan(400);
-    });
-
-    test('should compare sync method call vs interceptor chain', async () => {
-      const target = new TestTarget();
-      const originalMethod = target.syncMethod.bind(target);
-      const interceptors = [new SyncInterceptor()];
-
-      // 直接方法调用
-      const directResult = await PerformanceHarness.benchmark(
-        'direct-sync-call',
-        100000,
-        async () => {
-          originalMethod(1);
-        },
-      );
-
-      // 拦截器链调用
-      const interceptorResult = await PerformanceHarness.benchmark(
-        'interceptor-sync-chain',
-        100000,
-        async () => {
-          await InterceptorChain.execute(
-            interceptors,
-            target,
-            'syncMethod',
-            originalMethod,
-            [1],
-            container,
-          );
-        },
-      );
-
-      expect(directResult.iterations).toBe(100000);
-      expect(interceptorResult.iterations).toBe(100000);
-
-      const overhead = (interceptorResult.durationMs / directResult.durationMs - 1) * 100;
-
-      console.log(`Direct sync call: ${directResult.opsPerSecond.toFixed(2)} ops/sec`);
-      console.log(`Interceptor sync chain: ${interceptorResult.opsPerSecond.toFixed(2)} ops/sec`);
-      console.log(`Overhead: ${overhead.toFixed(2)}%`);
-
-      // 拦截器开销应该小于 1000%（即不超过 11 倍）
-      // 同步方法转换为异步会有额外开销，实际测试显示开销约为 656-870%
-      // 性能测试结果可能有波动，使用更宽松的阈值以确保测试稳定性
-      expect(overhead).toBeLessThan(1000);
-    });
-  });
-
-  describe('Registry Performance', () => {
-    test('should benchmark interceptor registry operations', async () => {
-      const result = await PerformanceHarness.benchmark(
-        'registry-register',
-        10000,
-        async (iteration) => {
-          const key = Symbol(`test-${iteration}`);
-          registry.register(key, new NoOpInterceptor(), 100);
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(1000);
-
-      console.log(`Registry register: ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-
-    test('should benchmark interceptor registry lookup', async () => {
-      // 预先注册一些拦截器
-      const keys = Array.from({ length: 100 }, (_, i) => Symbol(`key-${i}`));
-      for (const key of keys) {
-        registry.register(key, new NoOpInterceptor(), 100);
-      }
-
-      const result = await PerformanceHarness.benchmark(
-        'registry-lookup',
-        10000,
-        async (iteration) => {
-          const key = keys[iteration % keys.length];
-          registry.getInterceptors(key);
-        },
-      );
-
-      expect(result.iterations).toBe(10000);
-      expect(result.opsPerSecond).toBeGreaterThan(5000);
-
-      console.log(`Registry lookup: ${result.opsPerSecond.toFixed(2)} ops/sec`);
-    });
-  });
-});
-

package/tests/perf/optimization.test.ts

@@ -1,182 +0,0 @@
-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';
-
-/**
- * 性能优化验证测试
- * 验证路由匹配缓存、中间件管道优化、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

@@ -1,120 +0,0 @@
-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);
-  });
-});