@dangao/bun-server 1.2.0 → 1.4.0

package/tests/controller/param-map.test.ts

@@ -0,0 +1,237 @@
+import { describe, expect, test } from 'bun:test';
+
+import { ParamBinder } from '../../src/controller/param-binder';
+import {
+  QueryMap,
+  HeaderMap,
+  type QueryMapOptions,
+  type HeaderMapOptions,
+} from '../../src/controller/decorators';
+import { Context } from '../../src/core/context';
+
+class QueryMapController {
+  public constructor(public readonly store: unknown[] = []) {}
+
+  public async handle(@QueryMap() query: Record<string, string | string[]>) {
+    this.store.push(query);
+    return query;
+  }
+
+  public async handleTransformed(
+    @QueryMap<{ name: string; age: number }>((input) => ({
+      name: (input.name as string) ?? '',
+      age: Number((input.age as string) ?? '0'),
+    }))
+    query: { name: string; age: number },
+  ) {
+    this.store.push(query);
+    return query;
+  }
+
+  public async handleValidated(
+    @QueryMap<{ foo: string }>(
+      ((input) => ({ foo: input.foo as string })) as QueryMapOptions<{ foo: string }>['transform'],
+    )
+    query: { foo: string },
+  ) {
+    if (!query.foo) {
+      throw new Error('validation failed');
+    }
+    this.store.push(query);
+    return query;
+  }
+}
+
+class HeaderMapController {
+  public constructor(public readonly store: unknown[] = []) {}
+
+  public async handle(
+    @HeaderMap() headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handlePicked(
+    @HeaderMap({
+      normalize: true,
+      pick: ['x-custom', 'x-list'],
+    })
+    headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handlePickedWithNormalizeFalse(
+    @HeaderMap({
+      normalize: false,
+      pick: ['X-Custom', 'X-List'], // 混合大小写
+    })
+    headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handleTransformed(
+    @HeaderMap<{ token: string }>((input) => ({
+      token: (input.authorization as string) ?? '',
+    }))
+    headers: { token: string },
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+}
+
+function createContext(url: string, init?: RequestInit) {
+  return new Context(new Request(url, init));
+}
+
+describe('ParamBinder QueryMap', () => {
+  test('should aggregate query params into map with arrays', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?q=1&q=2&name=alice');
+    const params = await ParamBinder.bind(
+      controller,
+      'handle',
+      ctx,
+    );
+    expect(params[0]).toEqual({ q: ['1', '2'], name: 'alice' });
+  });
+
+  test('should transform query map', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?name=alice&age=20');
+    const params = await ParamBinder.bind(
+      controller,
+      'handleTransformed',
+      ctx,
+    );
+    expect(params[0]).toEqual({ name: 'alice', age: 20 });
+  });
+
+  test('should validate query map via user code', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?foo=bar');
+    const params = await ParamBinder.bind(
+      controller,
+      'handleValidated',
+      ctx,
+    );
+    expect(params[0]).toEqual({ foo: 'bar' });
+  });
+});
+
+describe('ParamBinder HeaderMap', () => {
+  test('should aggregate headers into map with optional array', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Token': 'abc',
+        'X-List': 'a, b',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handle',
+      ctx,
+    );
+    expect(params[0]).toMatchObject({
+      'x-token': 'abc',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should pick and normalize headers', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Custom': 'val',
+        'X-List': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePicked',
+      ctx,
+    );
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should pick headers with case-insensitive pick when normalize=true (default)', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-CUSTOM': 'val',
+        'X-LIST': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePicked',
+      ctx,
+    );
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should transform headers', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        Authorization: '  Bearer token123  ',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handleTransformed',
+      ctx,
+    );
+    expect(params[0]).toEqual({ token: 'Bearer token123' });
+  });
+
+  test('should trim single header value when no comma', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Single': '  abc  ',
+      },
+    });
+    const params = await ParamBinder.bind(controller, 'handle', ctx);
+    expect(params[0]).toMatchObject({
+      'x-single': 'abc',
+    });
+  });
+
+  test('should pick headers with mixed-case pick keys when normalize=false', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Custom': 'val',
+        'X-List': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePickedWithNormalizeFalse',
+      ctx,
+    );
+    // Headers API 总是返回小写的 key，所以即使 normalize=false，结果中的 key 也是小写
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+});
+
+

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

package/tests/microservice/service-client.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { ServiceClient } from '../../src/microservice/service-client/service-client';
+import { LoadBalancerFactory } from '../../src/microservice/service-client/load-balancer';
+import type { ServiceRegistry, ServiceInstance } from '../../src/microservice/service-registry/types';
+
+describe('ServiceClient', () => {
+  let mockServiceRegistry: ServiceRegistry;
+  let serviceClient: ServiceClient;
+
+  beforeEach(() => {
+    // 创建 Mock ServiceRegistry
+    mockServiceRegistry = {
+      async register(instance: ServiceInstance) {},
+      async deregister(instance: ServiceInstance) {},
+      async renew(instance: ServiceInstance) {},
+      async getInstances(serviceName: string) {
+        return [
+          {
+            serviceName,
+            ip: '127.0.0.1',
+            port: 3000,
+            healthy: true,
+            weight: 100,
+          },
+          {
+            serviceName,
+            ip: '127.0.0.1',
+            port: 3001,
+            healthy: true,
+            weight: 200,
+          },
+        ];
+      },
+      watchInstances() {
+        return () => {};
+      },
+      async close() {},
+    };
+
+    serviceClient = new ServiceClient(mockServiceRegistry);
+  });
+
+  test('should create ServiceClient instance', () => {
+    expect(serviceClient).toBeInstanceOf(ServiceClient);
+  });
+
+  test('should throw error when no instances found', async () => {
+    const emptyRegistry: ServiceRegistry = {
+      ...mockServiceRegistry,
+      async getInstances() {
+        return [];
+      },
+    };
+
+    const client = new ServiceClient(emptyRegistry);
+
+    await expect(
+      client.call({
+        serviceName: 'test-service',
+        method: 'GET',
+        path: '/api/test',
+      }),
+    ).rejects.toThrow('No instances found');
+  });
+
+  test('should add request interceptor', () => {
+    const interceptor = {
+      intercept: async (options: any) => {
+        options.headers = { ...options.headers, 'X-Custom': 'value' };
+        return options;
+      },
+    };
+
+    serviceClient.addRequestInterceptor(interceptor);
+    // 验证拦截器已添加（通过调用时验证）
+    expect(serviceClient).toBeDefined();
+  });
+
+  test('should add response interceptor', () => {
+    const interceptor = {
+      intercept: async (response: any) => {
+        return response;
+      },
+    };
+
+    serviceClient.addResponseInterceptor(interceptor);
+    // 验证拦截器已添加
+    expect(serviceClient).toBeDefined();
+  });
+});
+
+describe('LoadBalancerFactory', () => {
+  const instances: ServiceInstance[] = [
+    { serviceName: 'test', ip: '127.0.0.1', port: 3000, weight: 100 },
+    { serviceName: 'test', ip: '127.0.0.1', port: 3001, weight: 200 },
+  ];
+
+  test('should create RandomLoadBalancer', () => {
+    const balancer = LoadBalancerFactory.create('random');
+    expect(balancer).toBeDefined();
+    const instance = balancer.select(instances);
+    expect(instance).toBeDefined();
+    expect(instances).toContain(instance);
+  });
+
+  test('should create RoundRobinLoadBalancer', () => {
+    const balancer = LoadBalancerFactory.create('roundRobin');
+    expect(balancer).toBeDefined();
+    const instance1 = balancer.select(instances);
+    const instance2 = balancer.select(instances);
+    expect(instance1).toBeDefined();
+    expect(instance2).toBeDefined();
+  });
+
+  test('should create WeightedRoundRobinLoadBalancer', () => {
+    const balancer = LoadBalancerFactory.create('weightedRoundRobin');
+    expect(balancer).toBeDefined();
+    const instance = balancer.select(instances);
+    expect(instance).toBeDefined();
+  });
+
+  test('should create ConsistentHashLoadBalancer', () => {
+    const balancer = LoadBalancerFactory.create('consistentHash');
+    expect(balancer).toBeDefined();
+    const instance = balancer.select(instances, 'test-key');
+    expect(instance).toBeDefined();
+  });
+
+  test('should create LeastActiveLoadBalancer', () => {
+    const balancer = LoadBalancerFactory.create('leastActive');
+    expect(balancer).toBeDefined();
+    const instance = balancer.select(instances);
+    expect(instance).toBeDefined();
+  });
+});
+