@dangao/bun-server 1.0.1 → 1.1.2

package/tests/middleware/rate-limit.test.ts

@@ -0,0 +1,314 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Context } from '../../src/core/context';
+import { Controller } from '../../src/controller';
+import { GET } from '../../src/router/decorators';
+import { createRateLimitMiddleware, MemoryRateLimitStore, type RateLimitOptions } from '../../src/middleware/builtin/rate-limit';
+import { RateLimit } from '../../src/middleware/decorators';
+
+describe('Rate Limit Middleware', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    port = 3000 + Math.floor(Math.random() * 10000);
+    app = new Application({ port });
+  });
+
+  test('should allow requests within limit', async () => {
+    const middleware = createRateLimitMiddleware({
+      max: 5,
+      windowMs: 60000,
+    });
+
+    let requestCount = 0;
+    const handler = async (context: Context) => {
+      requestCount++;
+      return context.createResponse({ count: requestCount });
+    };
+
+    const context1 = new Context(new Request('http://localhost:3000/test'));
+    const response1 = await middleware(context1, async () => handler(context1));
+
+    expect(response1.status).toBe(200);
+    expect(response1.headers.get('RateLimit-Limit')).toBe('5');
+    expect(response1.headers.get('RateLimit-Remaining')).toBe('4');
+  });
+
+  test('should block requests exceeding limit', async () => {
+    const store = new MemoryRateLimitStore();
+    const middleware = createRateLimitMiddleware({
+      max: 2,
+      windowMs: 60000,
+      store,
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    const context1 = new Context(new Request('http://localhost:3000/test'));
+    const context2 = new Context(new Request('http://localhost:3000/test'));
+    const context3 = new Context(new Request('http://localhost:3000/test'));
+
+    // 前两次请求应该成功
+    const response1 = await middleware(context1, async () => handler(context1));
+    expect(response1.status).toBe(200);
+
+    const response2 = await middleware(context2, async () => handler(context2));
+    expect(response2.status).toBe(200);
+    expect(response2.headers.get('RateLimit-Remaining')).toBe('0');
+
+    // 第三次请求应该被限制
+    const response3 = await middleware(context3, async () => handler(context3));
+    expect(response3.status).toBe(429);
+    const data3 = await response3.json();
+    expect(data3.error).toBe('Too Many Requests');
+    expect(data3.retryAfter).toBeDefined();
+  });
+
+  test('should use different keys for different IPs', async () => {
+    const store = new MemoryRateLimitStore();
+    const middleware = createRateLimitMiddleware({
+      max: 1,
+      windowMs: 60000,
+      store,
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    // IP 1 的请求
+    const request1 = new Request('http://localhost:3000/test', {
+      headers: { 'X-Forwarded-For': '192.168.1.1' },
+    });
+    const context1 = new Context(request1);
+    const response1 = await middleware(context1, async () => handler(context1));
+    expect(response1.status).toBe(200);
+
+    // IP 2 的请求（应该也成功，因为使用不同的键）
+    const request2 = new Request('http://localhost:3000/test', {
+      headers: { 'X-Forwarded-For': '192.168.1.2' },
+    });
+    const context2 = new Context(request2);
+    const response2 = await middleware(context2, async () => handler(context2));
+    expect(response2.status).toBe(200);
+
+    // IP 1 的第二次请求（应该被限制）
+    const request3 = new Request('http://localhost:3000/test', {
+      headers: { 'X-Forwarded-For': '192.168.1.1' },
+    });
+    const context3 = new Context(request3);
+    const response3 = await middleware(context3, async () => handler(context3));
+    expect(response3.status).toBe(429);
+  });
+
+  test('should reset after window expires', async () => {
+    const store = new MemoryRateLimitStore();
+    const middleware = createRateLimitMiddleware({
+      max: 1,
+      windowMs: 100, // 100ms 窗口
+      store,
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    const context1 = new Context(new Request('http://localhost:3000/test'));
+    const response1 = await middleware(context1, async () => handler(context1));
+    expect(response1.status).toBe(200);
+
+    // 立即再次请求应该被限制
+    const context2 = new Context(new Request('http://localhost:3000/test'));
+    const response2 = await middleware(context2, async () => handler(context2));
+    expect(response2.status).toBe(429);
+
+    // 等待窗口过期
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    // 应该可以再次请求
+    const context3 = new Context(new Request('http://localhost:3000/test'));
+    const response3 = await middleware(context3, async () => handler(context3));
+    expect(response3.status).toBe(200);
+  });
+
+  test('should work with @RateLimit decorator', async () => {
+    @Controller('/api/rate-limit')
+    class RateLimitController {
+      @RateLimit({ max: 2, windowMs: 60000 })
+      @GET('/test')
+      public test() {
+        return { message: 'ok' };
+      }
+    }
+
+    app.registerController(RateLimitController);
+    app.listen();
+
+    // 前两次请求应该成功
+    const response1 = await fetch(`http://localhost:${port}/api/rate-limit/test`);
+    expect(response1.status).toBe(200);
+    expect(response1.headers.get('RateLimit-Limit')).toBe('2');
+
+    const response2 = await fetch(`http://localhost:${port}/api/rate-limit/test`);
+    expect(response2.status).toBe(200);
+
+    // 第三次请求应该被限制
+    const response3 = await fetch(`http://localhost:${port}/api/rate-limit/test`);
+    expect(response3.status).toBe(429);
+  });
+
+  test('should support custom key generator', async () => {
+    const store = new MemoryRateLimitStore();
+    const middleware = createRateLimitMiddleware({
+      max: 1,
+      windowMs: 60000,
+      store,
+      keyGenerator: (context) => {
+        const userId = context.getHeader('X-User-Id');
+        return userId ? `user:${userId}` : `ip:${context.getClientIp()}`;
+      },
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    // User 1 的请求
+    const request1 = new Request('http://localhost:3000/test', {
+      headers: { 'X-User-Id': 'user1' },
+    });
+    const context1 = new Context(request1);
+    const response1 = await middleware(context1, async () => handler(context1));
+    expect(response1.status).toBe(200);
+
+    // User 2 的请求（应该也成功）
+    const request2 = new Request('http://localhost:3000/test', {
+      headers: { 'X-User-Id': 'user2' },
+    });
+    const context2 = new Context(request2);
+    const response2 = await middleware(context2, async () => handler(context2));
+    expect(response2.status).toBe(200);
+
+    // User 1 的第二次请求（应该被限制）
+    const request3 = new Request('http://localhost:3000/test', {
+      headers: { 'X-User-Id': 'user1' },
+    });
+    const context3 = new Context(request3);
+    const response3 = await middleware(context3, async () => handler(context3));
+    expect(response3.status).toBe(429);
+  });
+
+  test('should support custom message and status code', async () => {
+    const middleware = createRateLimitMiddleware({
+      max: 1,
+      windowMs: 60000,
+      message: 'Rate limit exceeded',
+      statusCode: 503,
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    const context1 = new Context(new Request('http://localhost:3000/test'));
+    await middleware(context1, async () => handler(context1));
+
+    const context2 = new Context(new Request('http://localhost:3000/test'));
+    const response2 = await middleware(context2, async () => handler(context2));
+    expect(response2.status).toBe(503);
+    const data = await response2.json();
+    expect(data.error).toBe('Rate limit exceeded');
+  });
+
+  test('should include standard headers', async () => {
+    const middleware = createRateLimitMiddleware({
+      max: 10,
+      windowMs: 60000,
+      standardHeaders: true,
+      legacyHeaders: true,
+    });
+
+    const handler = async (context: Context) => {
+      return context.createResponse({ success: true });
+    };
+
+    const context = new Context(new Request('http://localhost:3000/test'));
+    const response = await middleware(context, async () => handler(context));
+
+    expect(response.headers.get('RateLimit-Limit')).toBe('10');
+    expect(response.headers.get('RateLimit-Remaining')).toBe('9');
+    expect(response.headers.get('RateLimit-Reset')).toBeDefined();
+    expect(response.headers.get('X-RateLimit-Limit')).toBe('10');
+    expect(response.headers.get('X-RateLimit-Remaining')).toBe('9');
+    expect(response.headers.get('X-RateLimit-Reset')).toBeDefined();
+  });
+
+  test('should get client IP from X-Forwarded-For header', () => {
+    const request = new Request('http://localhost:3000/test', {
+      headers: { 'X-Forwarded-For': '192.168.1.100, 10.0.0.1' },
+    });
+    const context = new Context(request);
+    const ip = context.getClientIp();
+    expect(ip).toBe('192.168.1.100');
+  });
+
+  test('should get client IP from X-Real-IP header', () => {
+    const request = new Request('http://localhost:3000/test', {
+      headers: { 'X-Real-IP': '192.168.1.200' },
+    });
+    const context = new Context(request);
+    const ip = context.getClientIp();
+    expect(ip).toBe('192.168.1.200');
+  });
+});
+
+describe('MemoryRateLimitStore', () => {
+  let store: MemoryRateLimitStore;
+
+  beforeEach(() => {
+    store = new MemoryRateLimitStore();
+  });
+
+  test('should increment count', async () => {
+    const count1 = await store.increment('test-key', 1000);
+    expect(count1).toBe(1);
+
+    const count2 = await store.increment('test-key', 1000);
+    expect(count2).toBe(2);
+  });
+
+  test('should reset count after window expires', async () => {
+    await store.increment('test-key', 100);
+    await store.increment('test-key', 100);
+
+    // 等待窗口过期
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    const count = await store.get('test-key');
+    expect(count).toBe(0);
+  });
+
+  test('should reset count manually', async () => {
+    await store.increment('test-key', 1000);
+    await store.reset('test-key');
+
+    const count = await store.get('test-key');
+    expect(count).toBe(0);
+  });
+
+  test('should cleanup expired entries', async () => {
+    await store.increment('key1', 100);
+    await store.increment('key2', 1000);
+
+    // 等待 key1 过期
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    store.cleanup();
+
+    expect(await store.get('key1')).toBe(0);
+    expect(await store.get('key2')).toBeGreaterThan(0);
+  });
+});

package/tests/middleware/static-file.test.ts

@@ -0,0 +1,62 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { mkdir, rm } from 'fs/promises';
+import { join } from 'path';
+
+import { createStaticFileMiddleware } from '../../src/middleware/builtin/static-file';
+import { Context } from '../../src/core/context';
+
+const TMP_DIR = join(process.cwd(), 'tmp-static-test');
+
+async function writeFile(path: string, content: string): Promise<void> {
+  await Bun.write(path, content);
+}
+
+describe('StaticFileMiddleware', () => {
+  beforeAll(async () => {
+    await mkdir(TMP_DIR, { recursive: true });
+    await writeFile(join(TMP_DIR, 'hello.txt'), 'hello world');
+    await mkdir(join(TMP_DIR, 'nested'), { recursive: true });
+    await writeFile(join(TMP_DIR, 'nested', 'index.html'), '<h1>Nested</h1>');
+  });
+
+  afterAll(async () => {
+    await rm(TMP_DIR, { recursive: true, force: true });
+  });
+
+  test('should serve static files under prefix', async () => {
+    const middleware = createStaticFileMiddleware({
+      root: TMP_DIR,
+      prefix: '/static',
+      enableCache: false,
+    });
+    const ctx = new Context(new Request('http://localhost/static/hello.txt'));
+    const response = await middleware(ctx, async () => ctx.createResponse({ ok: false }));
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe('hello world');
+  });
+
+  test('should serve index file for directory', async () => {
+    const middleware = createStaticFileMiddleware({
+      root: TMP_DIR,
+      prefix: '/static',
+      enableCache: false,
+    });
+    const ctx = new Context(new Request('http://localhost/static/nested/'));
+    const response = await middleware(ctx, async () => ctx.createResponse({ ok: false }));
+    expect(response.status).toBe(200);
+    expect(await response.text()).toContain('Nested');
+  });
+
+  test('should block path traversal', async () => {
+    const middleware = createStaticFileMiddleware({
+      root: TMP_DIR,
+      prefix: '/static',
+    });
+    const ctx = new Context(new Request('http://localhost/static/secret.txt'));
+    ctx.path = '/static/../secret.txt';
+    const response = await middleware(ctx, async () => ctx.createResponse({ ok: true }));
+    expect(response.status).toBe(403);
+  });
+});
+
+

package/tests/perf/harness.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test';
+
+import { PerformanceHarness, StressTester } from '../../src/testing/harness';
+import { Router } from '../../src/router/router';
+import { Context } from '../../src/core/context';
+
+describe('PerformanceHarness', () => {
+  test('should produce benchmark metrics', async () => {
+    let total = 0;
+    const result = await PerformanceHarness.benchmark('increment', 50, () => {
+      total += 1;
+    });
+
+    expect(result.name).toBe('increment');
+    expect(result.iterations).toBe(50);
+    expect(result.opsPerSecond).toBeGreaterThan(0);
+    expect(total).toBe(50);
+  });
+
+  test('should benchmark router lookups', async () => {
+    const router = new Router();
+    for (let i = 0; i < 100; i++) {
+      router.get(`/static/${i}`, (ctx: Context) => ctx.createResponse({ i }));
+    }
+
+    const result = await PerformanceHarness.benchmark('router:static', 200, (iteration) => {
+      const index = iteration % 100;
+      const route = router.findRoute('GET', `/static/${index}`);
+      expect(route).toBeDefined();
+    });
+
+    expect(result.opsPerSecond).toBeGreaterThan(0);
+  });
+});
+
+describe('StressTester', () => {
+  test('should execute tasks concurrently', async () => {
+    let executed = 0;
+    const result = await StressTester.run('stress:noop', 40, 5, async () => {
+      executed += 1;
+    });
+
+    expect(result.iterations).toBe(40);
+    expect(result.errors).toBe(0);
+    expect(executed).toBe(40);
+  });
+});
+

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);
+  });
+});