@dangao/bun-server 1.0.0 → 1.0.3

package/tests/middleware/middleware.test.ts

@@ -0,0 +1,120 @@
+import 'reflect-metadata';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET, POST } from '../../src/router/decorators';
+import { UseMiddleware } from '../../src/middleware';
+import type { Middleware } from '../../src/middleware';
+import { RouteRegistry } from '../../src/router/registry';
+import { Body } from '../../src/controller/decorators';
+import { getTestPort } from '../utils/test-port';
+
+describe('Middleware Integration', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+  });
+
+  afterEach(async () => {
+    await app.stop();
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should apply global middleware', async () => {
+    const headerMiddleware: Middleware = async (ctx, next) => {
+      ctx.setHeader('x-global-middleware', 'enabled');
+      return await next();
+    };
+
+    app.use(headerMiddleware);
+
+    @Controller('/api/middleware/global')
+    class GlobalController {
+      @GET('/')
+      public getData() {
+        return { ok: true };
+      }
+    }
+
+    app.registerController(GlobalController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/global`);
+    expect(response.headers.get('x-global-middleware')).toBe('enabled');
+    const data = await response.json();
+    expect(data).toEqual({ ok: true });
+  });
+
+  test('should apply class and method level middleware', async () => {
+    const calls: string[] = [];
+
+    const classMiddleware: Middleware = async (ctx, next) => {
+      calls.push('class');
+      return await next();
+    };
+
+    const methodMiddleware: Middleware = async (ctx, next) => {
+      calls.push('method');
+      return await next();
+    };
+
+    @UseMiddleware(classMiddleware)
+    @Controller('/api/middleware/controller')
+    class ControllerWithMiddleware {
+      @UseMiddleware(methodMiddleware)
+      @GET('/')
+      public getData() {
+        calls.push('handler');
+        return { value: 'ok' };
+      }
+    }
+
+    app.registerController(ControllerWithMiddleware);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/controller`);
+    const data = await response.json();
+
+    expect(data).toEqual({ value: 'ok' });
+    expect(calls).toEqual(['class', 'method', 'handler']);
+  });
+
+  test('should allow middleware to short-circuit request', async () => {
+    const guard: Middleware = async () => {
+      return new Response(JSON.stringify({ blocked: true }), {
+        status: 403,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    };
+
+    app.use(guard);
+
+    @Controller('/api/middleware/blocked')
+    class BlockedController {
+      @POST('/')
+      public createUser(@Body() user: { name: string }) {
+        return { id: '1', ...user };
+      }
+    }
+
+    app.registerController(BlockedController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/blocked`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John' }),
+    });
+
+    expect(response.status).toBe(403);
+    const data = await response.json();
+    expect(data).toEqual({ blocked: true });
+  });
+});
+
+

package/tests/middleware/pipeline.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test';
+
+import { MiddlewarePipeline } from '../../src/middleware/pipeline';
+import type { Middleware } from '../../src/middleware';
+import { Context } from '../../src/core/context';
+
+function createContext(): Context {
+  const request = new Request('http://localhost:3000/api/test');
+  return new Context(request);
+}
+
+describe('MiddlewarePipeline', () => {
+  test('should execute middlewares in order and call final handler', async () => {
+    const pipeline = new MiddlewarePipeline();
+    const calls: string[] = [];
+
+    const first: Middleware = async (ctx, next) => {
+      calls.push('first:before');
+      const response = await next();
+      calls.push('first:after');
+      return response;
+    };
+
+    const second: Middleware = async (ctx, next) => {
+      calls.push('second:before');
+      const response = await next();
+      calls.push('second:after');
+      return response;
+    };
+
+    pipeline.use(first);
+    pipeline.use(second);
+
+    const context = createContext();
+    const response = await pipeline.run(context, async () => {
+      calls.push('handler');
+      return context.createResponse({ ok: true });
+    });
+
+    const data = await response.json();
+    expect(data).toEqual({ ok: true });
+    expect(calls).toEqual([
+      'first:before',
+      'second:before',
+      'handler',
+      'second:after',
+      'first:after',
+    ]);
+  });
+
+  test('should allow middleware to short circuit the pipeline', async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const blocker: Middleware = async (ctx) => {
+      ctx.setStatus(401);
+      return ctx.createResponse({ error: 'Unauthorized' });
+    };
+
+    pipeline.use(blocker);
+
+    const context = createContext();
+    const response = await pipeline.run(context, async () => {
+      return context.createResponse({ ok: true });
+    });
+
+    expect(response.status).toBe(401);
+    const data = await response.json();
+    expect(data).toEqual({ error: 'Unauthorized' });
+  });
+});
+
+

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