@dangao/bun-server 1.3.0 → 1.5.0

package/tests/core/graceful-shutdown.test.ts

@@ -0,0 +1,321 @@
+import { describe, expect, test, afterEach, beforeEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { Param } from '../../src/controller/decorators';
+import { getTestPort } from '../utils/test-port';
+import { RouteRegistry } from '../../src/router/registry';
+
+describe('Graceful Shutdown', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach((done) => {
+    port = getTestPort();
+    done();
+  });
+
+  afterEach(async (done) => {
+    if (app) {
+      // 确保清理，使用 stop 而不是 gracefulShutdown 以避免测试间干扰
+      try {
+        const server = app.getServer();
+        if (server?.isRunning()) {
+          await app.stop();
+          // 等待一小段时间确保端口释放
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+      } catch (error) {
+        // 忽略错误，确保清理完成
+      }
+      app = undefined as any;
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    done();
+  });
+
+  test('should reject new requests during shutdown', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/test')
+      public test() {
+        return { message: 'ok' };
+      }
+
+      @GET('/slow')
+      public async slow() {
+        // 模拟慢请求，确保在停机过程中有活跃请求
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        return { message: 'completed' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    const server = app.getServer();
+    expect(server).toBeDefined();
+
+    // 先发送一个慢请求，确保在停机过程中有活跃请求
+    const slowRequestPromise = fetch(`http://localhost:${port}/api/slow`);
+
+    // 等待请求开始处理
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 开始优雅停机（此时有活跃请求，服务器不会立即关闭）
+    const shutdownPromise = app.gracefulShutdown(5000);
+
+    // 等待一小段时间确保 shutdown 状态已设置
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 尝试发送新请求，应该被拒绝
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    expect(response.status).toBe(503);
+    expect(await response.text()).toBe('Server is shutting down');
+
+    // 等待慢请求完成
+    await slowRequestPromise;
+
+    // 等待停机完成
+    await shutdownPromise;
+  });
+
+  test('should wait for active requests to complete', async () => {
+    let requestCompleted = false;
+
+    @Controller('/api')
+    class TestController {
+      @GET('/slow')
+      public async slow() {
+        // 模拟慢请求
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        requestCompleted = true;
+        return { message: 'completed' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    // 发送一个慢请求
+    const requestPromise = fetch(`http://localhost:${port}/api/slow`);
+
+    // 等待请求开始处理
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 开始优雅停机
+    const shutdownPromise = app.gracefulShutdown(5000);
+
+    // 等待请求完成
+    const response = await requestPromise;
+    expect(response.status).toBe(200);
+    const data = (await response.json()) as { message: string };
+    expect(data.message).toBe('completed');
+    expect(requestCompleted).toBe(true);
+
+    // 等待停机完成
+    await shutdownPromise;
+
+    const server = app.getServer();
+    expect(server?.isRunning()).toBe(false);
+  });
+
+  test('should force shutdown after timeout', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/very-slow')
+      public async verySlow() {
+        // 模拟非常慢的请求（超过超时时间）
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        return { message: 'completed' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    // 发送一个非常慢的请求
+    const requestPromise = fetch(`http://localhost:${port}/api/very-slow`);
+
+    // 等待请求开始处理
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 开始优雅停机，设置较短的超时时间
+    const startTime = Date.now();
+    await app.gracefulShutdown(500);
+    const shutdownDuration = Date.now() - startTime;
+
+    // 应该在大约 500ms 后强制关闭（允许一些误差）
+    expect(shutdownDuration).toBeGreaterThanOrEqual(450);
+    expect(shutdownDuration).toBeLessThan(1000);
+
+    const server = app.getServer();
+    expect(server?.isRunning()).toBe(false);
+
+    // 请求可能仍在进行，但不应该影响服务器状态
+    try {
+      await requestPromise;
+    } catch (error) {
+      // 请求可能失败，这是预期的
+    }
+  });
+
+  test('should handle multiple concurrent requests during shutdown', async () => {
+    const completedRequests: number[] = [];
+
+    @Controller('/api')
+    class TestController {
+      @GET('/concurrent/:id')
+      public async concurrent(@Param('id') id: string) {
+        // 模拟异步处理
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        completedRequests.push(Number.parseInt(id));
+        return { id, message: 'completed' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    // 发送多个并发请求
+    const requests = Promise.all([
+      fetch(`http://localhost:${port}/api/concurrent/1`),
+      fetch(`http://localhost:${port}/api/concurrent/2`),
+      fetch(`http://localhost:${port}/api/concurrent/3`),
+    ]);
+
+    // 等待请求开始处理
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 开始优雅停机
+    const shutdownPromise = app.gracefulShutdown(5000);
+
+    // 等待所有请求完成
+    const responses = await requests;
+    expect(responses.length).toBe(3);
+
+    for (const response of responses) {
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as { message: string };
+      expect(data.message).toBe('completed');
+    }
+
+    // 所有请求应该都完成了
+    expect(completedRequests.sort()).toEqual([1, 2, 3]);
+
+    // 等待停机完成
+    await shutdownPromise;
+  });
+
+  test('should handle graceful shutdown with no active requests', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/test')
+      public test() {
+        return { message: 'ok' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    const server = app.getServer();
+    expect(server?.isRunning()).toBe(true);
+
+    // 没有活跃请求时，应该立即关闭
+    const startTime = Date.now();
+    await app.gracefulShutdown(5000);
+    const shutdownDuration = Date.now() - startTime;
+
+    // 应该几乎立即关闭（允许一些处理时间）
+    expect(shutdownDuration).toBeLessThan(100);
+
+    expect(server?.isRunning()).toBe(false);
+  });
+
+  test('should track active requests correctly', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/slow')
+      public async slow() {
+        // 使用慢请求确保在检查时请求仍在处理中
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        return { message: 'ok' };
+      }
+    }
+
+    app = new Application({ port, enableSignalHandlers: false });
+    app.registerController(TestController);
+    await app.listen();
+
+    const server = app.getServer();
+    expect(server).toBeDefined();
+
+    // 发送慢请求
+    const requestPromise = fetch(`http://localhost:${port}/api/slow`);
+
+    // 等待请求开始处理（但不要等到完成）
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // 检查活跃请求数（应该大于 0，因为请求还在处理中）
+    const activeRequests = server?.getActiveRequests() ?? 0;
+    expect(activeRequests).toBeGreaterThan(0);
+
+    // 等待请求完成
+    await requestPromise;
+
+    // 等待一小段时间确保计数更新
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // 活跃请求数应该回到 0
+    const finalActiveRequests = server?.getActiveRequests() ?? 0;
+    expect(finalActiveRequests).toBe(0);
+  });
+
+  test('should use custom graceful shutdown timeout', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/slow')
+      public async slow() {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        return { message: 'completed' };
+      }
+    }
+
+    app = new Application({
+      port,
+      enableSignalHandlers: false,
+      gracefulShutdownTimeout: 2000,
+    });
+    app.registerController(TestController);
+    await app.listen();
+
+    // 发送请求
+    const requestPromise = fetch(`http://localhost:${port}/api/slow`);
+
+    // 等待请求开始处理
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // 使用自定义超时时间（比配置的短）
+    const startTime = Date.now();
+    await app.gracefulShutdown(100);
+    const shutdownDuration = Date.now() - startTime;
+
+    // 应该在大约 100ms 后强制关闭
+    expect(shutdownDuration).toBeGreaterThanOrEqual(80);
+    expect(shutdownDuration).toBeLessThan(200);
+
+    // 等待请求完成（可能失败）
+    try {
+      await requestPromise;
+    } catch (error) {
+      // 请求可能失败，这是预期的
+    }
+  });
+});

package/tests/microservice/config-center.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+import { ConfigCenterModule, CONFIG_CENTER_TOKEN, type ConfigCenter } from '../../src/microservice/config-center';
+import { Container } from '../../src/di/container';
+import { ModuleRegistry } from '../../src/di/module-registry';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { ControllerRegistry } from '../../src/controller/controller';
+
+describe('ConfigCenterModule', () => {
+  beforeEach(() => {
+    // 清除模块元数据
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, ConfigCenterModule);
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should register config center provider', () => {
+    ConfigCenterModule.forRoot({
+      provider: 'nacos',
+      nacos: {
+        client: {
+          serverList: ['http://localhost:8848'],
+          namespaceId: 'public',
+        },
+        watchInterval: 3000,
+      },
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConfigCenterModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const configCenterProvider = metadata.providers.find(
+      (provider: any) => provider.provide === CONFIG_CENTER_TOKEN,
+    );
+    expect(configCenterProvider).toBeDefined();
+  });
+
+  test('should throw error when provider is not supported', () => {
+    expect(() => {
+      ConfigCenterModule.forRoot({
+        provider: 'unsupported' as any,
+      } as any);
+    }).toThrow('Unsupported config center provider');
+  });
+
+  test('should throw error when nacos config is missing', () => {
+    expect(() => {
+      ConfigCenterModule.forRoot({
+        provider: 'nacos',
+      } as any);
+    }).toThrow('Nacos configuration is required');
+  });
+});
+
+describe('ConfigCenter Interface (Mock)', () => {
+  test('should implement ConfigCenter interface', async () => {
+    const mockConfigCenter: ConfigCenter = {
+      async getConfig(dataId: string, groupName: string, namespaceId?: string) {
+        return {
+          content: JSON.stringify({ key: 'value' }),
+          md5: 'abc123',
+          lastModified: Date.now(),
+          contentType: 'application/json',
+        };
+      },
+      watchConfig(dataId: string, groupName: string, listener: any, namespaceId?: string) {
+        return () => {}; // 返回取消监听的函数
+      },
+      async close() {},
+    };
+
+    const result = await mockConfigCenter.getConfig('test-config', 'DEFAULT_GROUP');
+    expect(result.content).toBeDefined();
+    expect(result.md5).toBeDefined();
+  });
+});
+

package/tests/microservice/governance.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { CircuitBreaker, CircuitBreakerState } from '../../src/microservice/governance/circuit-breaker';
+import { RateLimiter } from '../../src/microservice/governance/rate-limiter';
+import { RetryStrategyImpl } from '../../src/microservice/governance';
+
+describe('CircuitBreaker', () => {
+  let circuitBreaker: CircuitBreaker;
+
+  beforeEach(() => {
+    circuitBreaker = new CircuitBreaker({
+      failureThreshold: 0.5,
+      timeWindow: 60000,
+      minimumRequests: 5,
+    });
+  });
+
+  test('should start in CLOSED state', () => {
+    expect(circuitBreaker.getState()).toBe(CircuitBreakerState.CLOSED);
+  });
+
+  test('should execute successful request', async () => {
+    const result = await circuitBreaker.execute(async () => {
+      return { success: true };
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(circuitBreaker.getState()).toBe(CircuitBreakerState.CLOSED);
+  });
+
+  test('should use fallback when circuit is open', async () => {
+    // 模拟多次失败以打开熔断器
+    for (let i = 0; i < 10; i++) {
+      try {
+        await circuitBreaker.execute(async () => {
+          throw new Error('Service error');
+        });
+      } catch {
+        // 忽略错误
+      }
+    }
+
+    // 熔断器应该打开
+    const fallback = async () => ({ fallback: true });
+    const result = await circuitBreaker.execute(async () => {
+      throw new Error('Service error');
+    }, fallback);
+
+    expect(result).toEqual({ fallback: true });
+  });
+});
+
+describe('RateLimiter', () => {
+  let rateLimiter: RateLimiter;
+
+  beforeEach(() => {
+    rateLimiter = new RateLimiter({
+      requestsPerSecond: 10,
+      timeWindow: 1000,
+    });
+  });
+
+  test('should allow requests within limit', async () => {
+    for (let i = 0; i < 10; i++) {
+      const allowed = await rateLimiter.allow('test-key');
+      expect(allowed).toBe(true);
+    }
+  });
+
+  test('should reject requests exceeding limit', async () => {
+    // 先允许 10 个请求
+    for (let i = 0; i < 10; i++) {
+      await rateLimiter.allow('test-key');
+    }
+
+    // 第 11 个请求应该被拒绝
+    const allowed = await rateLimiter.allow('test-key');
+    expect(allowed).toBe(false);
+  });
+
+  test('should get remaining requests', () => {
+    rateLimiter.allow('test-key');
+    const remaining = rateLimiter.getRemaining('test-key');
+    expect(remaining).toBeLessThan(10);
+  });
+
+  test('should reset rate limiter', async () => {
+    // 使用完所有请求
+    for (let i = 0; i < 10; i++) {
+      await rateLimiter.allow('test-key');
+    }
+
+    rateLimiter.reset('test-key');
+    const allowed = await rateLimiter.allow('test-key');
+    expect(allowed).toBe(true);
+  });
+});
+
+describe('RetryStrategy', () => {
+  test('RetryStrategyImpl should retry with fixed delay', async () => {
+    const strategy = new RetryStrategyImpl({
+      maxRetries: 3,
+      retryDelay: 10, // 使用较小的延迟以便测试快速完成
+    });
+
+    let attempts = 0;
+    const result = await strategy.execute(async () => {
+      attempts++;
+      if (attempts < 3) {
+        throw new Error('Retry needed');
+      }
+      return { success: true };
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(attempts).toBe(3);
+  });
+
+  test('RetryStrategyImpl should retry with exponential delay', async () => {
+    const strategy = new RetryStrategyImpl({
+      maxRetries: 3,
+      retryDelay: 10,
+      exponentialBackoff: true,
+      baseDelay: 10,
+      maxDelay: 1000,
+    });
+
+    let attempts = 0;
+    const result = await strategy.execute(async () => {
+      attempts++;
+      if (attempts < 3) {
+        throw new Error('Retry needed');
+      }
+      return { success: true };
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(attempts).toBe(3);
+  });
+
+  test('should respect maxRetries limit', async () => {
+    const strategy = new RetryStrategyImpl({
+      maxRetries: 2,
+      retryDelay: 10,
+    });
+
+    let attempts = 0;
+    await expect(
+      strategy.execute(async () => {
+        attempts++;
+        throw new Error('Always fail');
+      }),
+    ).rejects.toThrow('Always fail');
+
+    expect(attempts).toBe(3); // 1 initial + 2 retries
+  });
+});
+

package/tests/microservice/monitoring.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { ServiceMetricsCollector } from '../../src/microservice/monitoring/metrics-collector';
+
+describe('ServiceMetricsCollector', () => {
+  let collector: ServiceMetricsCollector;
+
+  beforeEach(() => {
+    collector = new ServiceMetricsCollector({
+      enabled: true,
+      autoReportToMetrics: false, // 测试时不自动上报
+    });
+  });
+
+  test('should create metrics collector', () => {
+    expect(collector).toBeDefined();
+  });
+
+  test('should record service call', () => {
+    collector.recordCall('test-service', '127.0.0.1:3000', true, 100);
+
+    const metrics = collector.getMetrics('test-service');
+    expect(metrics.length).toBeGreaterThan(0);
+    expect(metrics[0]?.totalRequests).toBe(1);
+    expect(metrics[0]?.successRequests).toBe(1);
+  });
+
+  test('should calculate error rate', () => {
+    // 记录 10 次调用，5 次成功，5 次失败
+    for (let i = 0; i < 5; i++) {
+      collector.recordCall('test-service', '127.0.0.1:3000', true, 100);
+    }
+    for (let i = 0; i < 5; i++) {
+      collector.recordCall('test-service', '127.0.0.1:3000', false, 200);
+    }
+
+    const metrics = collector.getMetrics('test-service');
+    expect(metrics[0]?.errorRate).toBe(0.5);
+    expect(metrics[0]?.totalRequests).toBe(10);
+    expect(metrics[0]?.successRequests).toBe(5);
+    expect(metrics[0]?.failureRequests).toBe(5);
+  });
+
+  test('should track health status', () => {
+    // 记录多次失败
+    for (let i = 0; i < 3; i++) {
+      collector.recordCall('test-service', '127.0.0.1:3000', false, 500);
+    }
+
+    const healthStatus = collector.getHealthStatus('test-service');
+    expect(healthStatus.length).toBeGreaterThan(0);
+    expect(healthStatus[0]?.healthy).toBe(false);
+    expect(healthStatus[0]?.consecutiveFailures).toBeGreaterThanOrEqual(3);
+  });
+
+  test('should reset metrics', () => {
+    collector.recordCall('test-service', '127.0.0.1:3000', true, 100);
+    collector.reset('test-service', '127.0.0.1:3000');
+
+    const metrics = collector.getMetrics('test-service');
+    expect(metrics.length).toBe(0);
+  });
+
+  test('should calculate latency statistics', () => {
+    const latencies = [50, 100, 150, 200, 250];
+    for (const latency of latencies) {
+      collector.recordCall('test-service', '127.0.0.1:3000', true, latency);
+    }
+
+    const metrics = collector.getMetrics('test-service');
+    expect(metrics[0]?.averageLatency).toBe(150);
+    expect(metrics[0]?.minLatency).toBe(50);
+    expect(metrics[0]?.maxLatency).toBe(250);
+  });
+});
+