@dangao/bun-server 1.2.0 → 1.4.0

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

@@ -0,0 +1,80 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+import { ServiceRegistryModule, SERVICE_REGISTRY_TOKEN, type ServiceRegistry } from '../../src/microservice/service-registry';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { ControllerRegistry } from '../../src/controller/controller';
+
+describe('ServiceRegistryModule', () => {
+  beforeEach(() => {
+    // 清除模块元数据
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, ServiceRegistryModule);
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should register service registry provider', () => {
+    ServiceRegistryModule.forRoot({
+      provider: 'nacos',
+      nacos: {
+        client: {
+          serverList: ['http://localhost:8848'],
+          namespaceId: 'public',
+        },
+        heartbeatInterval: 5000,
+      },
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ServiceRegistryModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const serviceRegistryProvider = metadata.providers.find(
+      (provider: any) => provider.provide === SERVICE_REGISTRY_TOKEN,
+    );
+    expect(serviceRegistryProvider).toBeDefined();
+  });
+
+  test('should throw error when provider is not supported', () => {
+    expect(() => {
+      ServiceRegistryModule.forRoot({
+        provider: 'unsupported' as any,
+      } as any);
+    }).toThrow('Unsupported service registry provider');
+  });
+
+  test('should throw error when nacos config is missing', () => {
+    expect(() => {
+      ServiceRegistryModule.forRoot({
+        provider: 'nacos',
+      } as any);
+    }).toThrow('Nacos configuration is required');
+  });
+});
+
+describe('ServiceRegistry Interface (Mock)', () => {
+  test('should implement ServiceRegistry interface', async () => {
+    const mockServiceRegistry: ServiceRegistry = {
+      async register(instance: any) {},
+      async deregister(instance: any) {},
+      async renew(instance: any) {},
+      async getInstances(serviceName: string, options?: any) {
+        return [
+          {
+            serviceName,
+            ip: '127.0.0.1',
+            port: 3000,
+            healthy: true,
+          },
+        ];
+      },
+      watchInstances(serviceName: string, listener: any, options?: any) {
+        return () => {}; // 返回取消监听的函数
+      },
+      async close() {},
+    };
+
+    const instances = await mockServiceRegistry.getInstances('test-service');
+    expect(instances).toBeDefined();
+    expect(instances.length).toBeGreaterThan(0);
+  });
+});
+

package/tests/microservice/tracing.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Tracer, SpanKind, SpanStatus } from '../../src/microservice/tracing';
+import { ConsoleTraceCollector, MemoryTraceCollector } from '../../src/microservice/tracing';
+
+describe('Tracer', () => {
+  let tracer: Tracer;
+
+  beforeEach(() => {
+    tracer = new Tracer({
+      samplingRate: 1.0,
+      enabled: true,
+    });
+  });
+
+  test('should create tracer instance', () => {
+    expect(tracer).toBeDefined();
+  });
+
+  test('should start and end span', () => {
+    const span = tracer.startSpan('test-span', SpanKind.CLIENT);
+    expect(span).toBeDefined();
+    expect(span.context.traceId).toBeDefined();
+    expect(span.context.spanId).toBeDefined();
+
+    tracer.endSpan(span.context.spanId, SpanStatus.OK);
+    // 验证 span 已结束（通过检查收集器）
+  });
+
+  test('should set span tags', () => {
+    const span = tracer.startSpan('test-span', SpanKind.CLIENT);
+    tracer.setSpanTags(span.context.spanId, {
+      'service.name': 'test-service',
+      'http.method': 'GET',
+    });
+
+    const context = tracer.getCurrentSpanContext(span.context.spanId);
+    expect(context).toBeDefined();
+  });
+
+  test('should add span event', () => {
+    const span = tracer.startSpan('test-span', SpanKind.CLIENT);
+    tracer.addSpanEvent(span.context.spanId, {
+      name: 'test-event',
+      attributes: { key: 'value' },
+    });
+
+    // 验证事件已添加
+    expect(span).toBeDefined();
+  });
+
+  test('should extract span context from headers', () => {
+    const headers = {
+      'X-Trace-Id': 'trace123',
+      'X-Span-Id': 'span456',
+      'X-Parent-Span-Id': 'parent789',
+      'X-Sampled': '1',
+    };
+
+    const context = tracer.extractFromHeaders(headers);
+    expect(context).toBeDefined();
+    expect(context?.traceId).toBe('trace123');
+    expect(context?.spanId).toBe('span456');
+  });
+
+  test('should inject span context to headers', () => {
+    const span = tracer.startSpan('test-span', SpanKind.CLIENT);
+    const headers = tracer.injectToHeaders(span.context);
+
+    expect(headers['X-Trace-Id']).toBe(span.context.traceId);
+    expect(headers['X-Span-Id']).toBe(span.context.spanId);
+  });
+
+  test('should add collector', () => {
+    const collector = new ConsoleTraceCollector();
+    tracer.addCollector(collector);
+    // 验证收集器已添加
+    expect(tracer).toBeDefined();
+  });
+});
+
+describe('MemoryTraceCollector', () => {
+  test('should collect spans', () => {
+    const collector = new MemoryTraceCollector();
+    const span = {
+      context: {
+        traceId: 'trace123',
+        spanId: 'span456',
+      },
+      name: 'test-span',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+    };
+
+    collector.collect(span as any);
+    const spans = collector.getSpans();
+    expect(spans.length).toBe(1);
+    expect(spans[0]?.context.traceId).toBe('trace123');
+  });
+
+  test('should get spans by trace id', () => {
+    const collector = new MemoryTraceCollector();
+    collector.collect({
+      context: { traceId: 'trace1', spanId: 'span1' },
+      name: 'span1',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+    } as any);
+    collector.collect({
+      context: { traceId: 'trace1', spanId: 'span2' },
+      name: 'span2',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+    } as any);
+    collector.collect({
+      context: { traceId: 'trace2', spanId: 'span3' },
+      name: 'span3',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+    } as any);
+
+    const trace1Spans = collector.getSpansByTraceId('trace1');
+    expect(trace1Spans.length).toBe(2);
+  });
+
+  test('should clear spans', () => {
+    const collector = new MemoryTraceCollector();
+    collector.collect({
+      context: { traceId: 'trace1', spanId: 'span1' },
+      name: 'span1',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+    } as any);
+
+    collector.clear();
+    expect(collector.getSpans().length).toBe(0);
+  });
+});
+

package/tests/utils/test-port.ts

@@ -4,26 +4,36 @@
  * @returns 不同测试之间不冲突的端口号
  */
 export function getTestPort(): number {
-  // 选择 30000-59999 之间的随机端口，避免常用端口冲突
-  // 并通过 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;
-      // 端口占用，继续尝试
+  // 优先使用 port=0 让系统自动分配可用端口，避免随机端口碰撞导致的 flake
+  // 取到 probe.port 后立刻 stop，返回这个“刚刚可用”的端口供后续测试使用
+  try {
+    const probe = Bun.serve({
+      port: 0,
+      fetch: () => new Response('ok'),
+    });
+    const port = probe.port;
+    probe.stop();
+    return port;
+  } catch (error) {
+    // fallback：极端情况下（或运行环境限制监听端口）才会走到这里
+    let lastError: unknown = error;
+    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 (err) {
+        lastError = err;
+      }
     }
-  }
 
-  throw new Error(
-    `Unable to find an available test port. Last error: ${String(lastError)}`,
-  );
+    throw new Error(
+      `Unable to find an available test port. Last error: ${String(lastError)}`,
+    );
+  }
 }