@dangao/bun-server 1.1.4 → 1.2.0

package/tests/di/scoped-lifecycle.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Container } from '../../src/di/container';
+import { Injectable } from '../../src/di/decorators';
+import { Lifecycle } from '../../src/di/types';
+import { contextStore } from '../../src/core/context-service';
+import { Context } from '../../src/core/context';
+
+describe('Lifecycle.Scoped', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+  });
+
+  test('should create new instance for each request', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly id: string;
+
+      public constructor() {
+        this.id = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    let instance1: ScopedService;
+    let instance2: ScopedService;
+
+    await contextStore.run(context1, async () => {
+      instance1 = container.resolve(ScopedService);
+    });
+
+    await contextStore.run(context2, async () => {
+      instance2 = container.resolve(ScopedService);
+    });
+
+    // 每个请求应该有独立的实例
+    expect(instance1!.id).not.toBe(instance2!.id);
+  });
+
+  test('should reuse instance within same request', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly id: string;
+
+      public constructor() {
+        this.id = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let instance1: ScopedService;
+    let instance2: ScopedService;
+
+    await contextStore.run(context, async () => {
+      instance1 = container.resolve(ScopedService);
+      instance2 = container.resolve(ScopedService);
+    });
+
+    // 同一请求内应该复用同一个实例
+    expect(instance1!.id).toBe(instance2!.id);
+  });
+
+  test('should handle scoped service with dependencies', async () => {
+    @Injectable({ lifecycle: Lifecycle.Singleton })
+    class SingletonService {
+      public readonly id = 'singleton';
+    }
+
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public constructor(public readonly singleton: SingletonService) {}
+    }
+
+    container.register(SingletonService);
+    container.register(ScopedService);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let scopedInstance: ScopedService;
+
+    await contextStore.run(context, async () => {
+      scopedInstance = container.resolve(ScopedService);
+    });
+
+    expect(scopedInstance!.singleton).toBeDefined();
+    expect(scopedInstance!.singleton.id).toBe('singleton');
+  });
+
+  test('should handle scoped service depending on another scoped service', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedServiceA {
+      public readonly id = 'A';
+    }
+
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedServiceB {
+      public constructor(public readonly serviceA: ScopedServiceA) {}
+    }
+
+    container.register(ScopedServiceA);
+    container.register(ScopedServiceB);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let serviceB: ScopedServiceB;
+    let serviceA: ScopedServiceA;
+
+    await contextStore.run(context, async () => {
+      serviceB = container.resolve(ScopedServiceB);
+      serviceA = container.resolve(ScopedServiceA);
+    });
+
+    // 同一请求内，ScopedServiceB 应该注入同一个 ScopedServiceA 实例
+    expect(serviceB!.serviceA).toBe(serviceA!);
+  });
+
+  test('should return undefined when resolving scoped service outside request context', () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {}
+
+    container.register(ScopedService);
+
+    // 不在请求上下文中，应该能够解析（但实例不会被缓存）
+    const instance = container.resolve(ScopedService);
+    expect(instance).toBeDefined();
+    expect(instance).toBeInstanceOf(ScopedService);
+  });
+
+  test('should handle concurrent requests with scoped services', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly requestId: string;
+
+      public constructor() {
+        this.requestId = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    const promises = [
+      contextStore.run(context1, async () => {
+        const instance1 = container.resolve(ScopedService);
+        await new Promise(resolve => setTimeout(resolve, 10));
+        const instance2 = container.resolve(ScopedService);
+        return { instance1: instance1.requestId, instance2: instance2.requestId };
+      }),
+      contextStore.run(context2, async () => {
+        const instance1 = container.resolve(ScopedService);
+        await new Promise(resolve => setTimeout(resolve, 10));
+        const instance2 = container.resolve(ScopedService);
+        return { instance1: instance1.requestId, instance2: instance2.requestId };
+      }),
+    ];
+
+    const results = await Promise.all(promises);
+
+    // 每个请求内的实例应该相同
+    expect(results[0].instance1).toBe(results[0].instance2);
+    expect(results[1].instance1).toBe(results[1].instance2);
+
+    // 不同请求的实例应该不同
+    expect(results[0].instance1).not.toBe(results[1].instance1);
+  });
+
+  test('should handle scoped service with factory', async () => {
+    let factoryCallCount = 0;
+
+    container.register('ScopedService', {
+      lifecycle: Lifecycle.Scoped,
+      factory: () => {
+        factoryCallCount++;
+        return { id: factoryCallCount };
+      },
+    });
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    let instance1: { id: number };
+    let instance2: { id: number };
+    let instance1Again: { id: number };
+
+    await contextStore.run(context1, async () => {
+      instance1 = container.resolve<{ id: number }>('ScopedService');
+      instance1Again = container.resolve<{ id: number }>('ScopedService');
+    });
+
+    await contextStore.run(context2, async () => {
+      instance2 = container.resolve<{ id: number }>('ScopedService');
+    });
+
+    // 同一请求内应该复用实例
+    expect(instance1!.id).toBe(instance1Again!.id);
+
+    // 不同请求应该创建新实例
+    expect(instance1!.id).not.toBe(instance2!.id);
+
+    // 工厂函数应该被调用 2 次（每个请求一次）
+    expect(factoryCallCount).toBe(2);
+  });
+});
+

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

@@ -1,20 +1,25 @@
-import { describe, expect, test, beforeEach } from 'bun:test';
+import { describe, expect, test, beforeEach, afterEach } 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';
+import { getTestPort } from '../utils/test-port';
 
 describe('Rate Limit Middleware', () => {
   let app: Application;
   let port: number;
 
   beforeEach(() => {
-    port = 3000 + Math.floor(Math.random() * 10000);
+    port = getTestPort();
     app = new Application({ port });
   });
 
+  afterEach(async () => {
+    await app.stop();
+  });
+
   test('should allow requests within limit', async () => {
     const middleware = createRateLimitMiddleware({
       max: 5,

package/tests/utils/test-port.ts

@@ -1,10 +1,29 @@
 /**
  * 获取测试专用端口
- * 使用随机高位端口，降低并行测试的端口冲突概率
+ * 使用随机高位端口，并主动探测端口可用性，降低并行测试/系统占用导致的端口冲突概率
  * @returns 不同测试之间不冲突的端口号
  */
 export function getTestPort(): number {
   // 选择 30000-59999 之间的随机端口，避免常用端口冲突
-  return 30000 + Math.floor(Math.random() * 30000);
+  // 并通过 Bun.serve 探测端口是否可用（可用则立刻 stop），避免 EADDRINUSE 造成测试雪崩失败
+  let lastError: unknown;
+  for (let i = 0; i < 50; i++) {
+    const port = 30000 + Math.floor(Math.random() * 30000);
+    try {
+      const probe = Bun.serve({
+        port,
+        fetch: () => new Response('ok'),
+      });
+      probe.stop();
+      return port;
+    } catch (error) {
+      lastError = error;
+      // 端口占用，继续尝试
+    }
+  }
+
+  throw new Error(
+    `Unable to find an available test port. Last error: ${String(lastError)}`,
+  );
 }