@dangao/bun-server 1.8.0 → 1.8.2

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

@@ -0,0 +1,147 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import {
+  ServiceRegistry,
+  getServiceRegistryMetadata,
+  type ServiceRegistryMetadata,
+} from '../../src/microservice/service-registry/decorators';
+
+describe('ServiceRegistry Decorator', () => {
+  test('should set metadata with service name only', () => {
+    @ServiceRegistry('my-service')
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata).toBeDefined();
+    expect(metadata?.serviceName).toBe('my-service');
+    expect(metadata?.healthy).toBe(true);
+  });
+
+  test('should set metadata with custom ip and port', () => {
+    @ServiceRegistry('my-service', { ip: '192.168.1.100', port: 8080 })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.ip).toBe('192.168.1.100');
+    expect(metadata?.port).toBe(8080);
+  });
+
+  test('should set metadata with weight', () => {
+    @ServiceRegistry('my-service', { weight: 10 })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.weight).toBe(10);
+  });
+
+  test('should set metadata with enabled flag', () => {
+    @ServiceRegistry('my-service', { enabled: false })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.enabled).toBe(false);
+  });
+
+  test('should set metadata with custom metadata', () => {
+    @ServiceRegistry('my-service', {
+      metadata: { version: '1.0.0', region: 'us-east' },
+    })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.metadata).toEqual({ version: '1.0.0', region: 'us-east' });
+  });
+
+  test('should set metadata with cluster name', () => {
+    @ServiceRegistry('my-service', { clusterName: 'production' })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.clusterName).toBe('production');
+  });
+
+  test('should set metadata with namespace id', () => {
+    @ServiceRegistry('my-service', { namespaceId: 'dev-namespace' })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.namespaceId).toBe('dev-namespace');
+  });
+
+  test('should set metadata with group name', () => {
+    @ServiceRegistry('my-service', { groupName: 'DEFAULT_GROUP' })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.groupName).toBe('DEFAULT_GROUP');
+  });
+
+  test('should set metadata with healthy flag', () => {
+    @ServiceRegistry('my-service', { healthy: false })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.healthy).toBe(false);
+  });
+
+  test('should set all options together', () => {
+    @ServiceRegistry('full-service', {
+      ip: '10.0.0.1',
+      port: 9000,
+      weight: 5,
+      enabled: true,
+      metadata: { env: 'production' },
+      clusterName: 'cluster-a',
+      namespaceId: 'ns-prod',
+      groupName: 'app-group',
+      healthy: true,
+    })
+    class TestController {}
+
+    const metadata = getServiceRegistryMetadata(TestController);
+    expect(metadata?.serviceName).toBe('full-service');
+    expect(metadata?.ip).toBe('10.0.0.1');
+    expect(metadata?.port).toBe(9000);
+    expect(metadata?.weight).toBe(5);
+    expect(metadata?.enabled).toBe(true);
+    expect(metadata?.metadata).toEqual({ env: 'production' });
+    expect(metadata?.clusterName).toBe('cluster-a');
+    expect(metadata?.namespaceId).toBe('ns-prod');
+    expect(metadata?.groupName).toBe('app-group');
+    expect(metadata?.healthy).toBe(true);
+  });
+});
+
+describe('getServiceRegistryMetadata', () => {
+  test('should return undefined for non-decorated class', () => {
+    class PlainClass {}
+
+    const metadata = getServiceRegistryMetadata(PlainClass);
+    expect(metadata).toBeUndefined();
+  });
+
+  test('should return metadata for decorated class', () => {
+    @ServiceRegistry('test-service')
+    class DecoratedClass {}
+
+    const metadata = getServiceRegistryMetadata(DecoratedClass);
+    expect(metadata).toBeDefined();
+    expect(metadata?.serviceName).toBe('test-service');
+  });
+
+  test('should keep separate metadata for different classes', () => {
+    @ServiceRegistry('service-a')
+    class ServiceA {}
+
+    @ServiceRegistry('service-b', { port: 3001 })
+    class ServiceB {}
+
+    const metadataA = getServiceRegistryMetadata(ServiceA);
+    const metadataB = getServiceRegistryMetadata(ServiceB);
+
+    expect(metadataA?.serviceName).toBe('service-a');
+    expect(metadataB?.serviceName).toBe('service-b');
+    expect(metadataB?.port).toBe(3001);
+  });
+});

package/tests/microservice/tracer.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+
+import { Tracer } from '../../src/microservice/tracing/tracer';
+import { SpanKind, SpanStatus, type Span, type TraceCollector } from '../../src/microservice/tracing/types';
+
+describe('Tracer', () => {
+  let tracer: Tracer;
+
+  beforeEach(() => {
+    tracer = new Tracer();
+  });
+
+  describe('constructor', () => {
+    test('should create tracer with default options', () => {
+      const t = new Tracer();
+      const span = t.startSpan('test');
+      expect(span).toBeDefined();
+    });
+
+    test('should create tracer with custom options', () => {
+      const t = new Tracer({
+        enabled: true,
+        samplingRate: 0.5,
+      });
+      const span = t.startSpan('test');
+      expect(span).toBeDefined();
+    });
+
+    test('should create empty span when disabled', () => {
+      const t = new Tracer({ enabled: false });
+      const span = t.startSpan('test');
+      expect(span.name).toBe('test');
+      expect(span.context.sampled).toBe(false);
+    });
+  });
+
+  describe('startSpan', () => {
+    test('should start a new span', () => {
+      const span = tracer.startSpan('test-operation');
+      expect(span.name).toBe('test-operation');
+      expect(span.kind).toBe(SpanKind.INTERNAL);
+      expect(span.context.traceId).toBeDefined();
+      expect(span.context.spanId).toBeDefined();
+      expect(span.startTime).toBeDefined();
+      expect(span.status).toBe(SpanStatus.UNSET);
+    });
+
+    test('should start span with custom kind', () => {
+      const span = tracer.startSpan('http-request', SpanKind.CLIENT);
+      expect(span.kind).toBe(SpanKind.CLIENT);
+    });
+
+    test('should start span with parent context', () => {
+      const parentSpan = tracer.startSpan('parent');
+      const childSpan = tracer.startSpan('child', SpanKind.INTERNAL, parentSpan.context);
+
+      expect(childSpan.context.traceId).toBe(parentSpan.context.traceId);
+      expect(childSpan.context.parentSpanId).toBe(parentSpan.context.spanId);
+    });
+
+    test('should use custom trace id generator', () => {
+      const customTracer = new Tracer({
+        traceIdGenerator: () => 'custom-trace-id-12345678901234',
+      });
+      const span = customTracer.startSpan('test');
+      expect(span.context.traceId).toBe('custom-trace-id-12345678901234');
+    });
+
+    test('should use custom span id generator', () => {
+      const customTracer = new Tracer({
+        spanIdGenerator: () => 'custom-span-id',
+      });
+      const span = customTracer.startSpan('test');
+      expect(span.context.spanId).toBe('custom-span-id');
+    });
+  });
+
+  describe('endSpan', () => {
+    test('should end span with OK status', () => {
+      const span = tracer.startSpan('test');
+      tracer.endSpan(span.context.spanId);
+
+      // Span should be ended (removed from active spans)
+      // We can verify by checking span properties were set
+      expect(span.endTime).toBeDefined();
+      expect(span.duration).toBeDefined();
+      expect(span.status).toBe(SpanStatus.OK);
+    });
+
+    test('should end span with error status', () => {
+      const span = tracer.startSpan('test');
+      const error = new Error('Test error');
+      tracer.endSpan(span.context.spanId, SpanStatus.ERROR, error);
+
+      expect(span.status).toBe(SpanStatus.ERROR);
+      expect(span.error).toBe(error);
+    });
+
+    test('should not throw for unknown span id', () => {
+      expect(() => tracer.endSpan('unknown-span-id')).not.toThrow();
+    });
+  });
+
+  describe('addCollector', () => {
+    test('should collect span data', () => {
+      const collectedSpans: Span[] = [];
+      const collector: TraceCollector = {
+        collect: (span: Span) => {
+          collectedSpans.push(span);
+        },
+      };
+
+      tracer.addCollector(collector);
+      const span = tracer.startSpan('test');
+      tracer.endSpan(span.context.spanId);
+
+      // Span should be collected if sampled
+      expect(collectedSpans.length).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should handle collector errors gracefully', () => {
+      const failingCollector: TraceCollector = {
+        collect: () => {
+          throw new Error('Collector failed');
+        },
+      };
+
+      tracer.addCollector(failingCollector);
+      const span = tracer.startSpan('test');
+
+      // Should not throw even if collector fails
+      expect(() => tracer.endSpan(span.context.spanId)).not.toThrow();
+    });
+  });
+
+  describe('setSpanTag', () => {
+    test('should set string tag', () => {
+      const span = tracer.startSpan('test');
+      tracer.setSpanTag(span.context.spanId, 'http.method', 'GET');
+
+      expect(span.tags?.['http.method']).toBe('GET');
+    });
+
+    test('should set number tag', () => {
+      const span = tracer.startSpan('test');
+      tracer.setSpanTag(span.context.spanId, 'http.status_code', 200);
+
+      expect(span.tags?.['http.status_code']).toBe(200);
+    });
+
+    test('should set boolean tag', () => {
+      const span = tracer.startSpan('test');
+      tracer.setSpanTag(span.context.spanId, 'error', true);
+
+      expect(span.tags?.['error']).toBe(true);
+    });
+
+    test('should not throw for unknown span id', () => {
+      expect(() => tracer.setSpanTag('unknown', 'key', 'value')).not.toThrow();
+    });
+  });
+
+  describe('addSpanEvent', () => {
+    test('should not throw when adding event', () => {
+      const span = tracer.startSpan('test');
+      expect(() => tracer.addSpanEvent(span.context.spanId, 'event-name', { key: 'value' })).not.toThrow();
+    });
+
+    test('should not throw when adding multiple events', () => {
+      const span = tracer.startSpan('test');
+      expect(() => tracer.addSpanEvent(span.context.spanId, 'event1')).not.toThrow();
+      expect(() => tracer.addSpanEvent(span.context.spanId, 'event2')).not.toThrow();
+    });
+
+    test('should not throw for unknown span id', () => {
+      expect(() => tracer.addSpanEvent('unknown', 'event')).not.toThrow();
+    });
+  });
+
+  describe('sampling', () => {
+    test('should respect sampling rate', () => {
+      // Create tracer with 0% sampling rate
+      const lowSamplingTracer = new Tracer({ samplingRate: 0 });
+      const span = lowSamplingTracer.startSpan('test');
+      expect(span.context.sampled).toBe(false);
+    });
+
+    test('should sample all with 100% rate', () => {
+      const fullSamplingTracer = new Tracer({ samplingRate: 1.0 });
+      const span = fullSamplingTracer.startSpan('test');
+      // Note: sampled could still be true depending on implementation
+      expect(span.context).toBeDefined();
+    });
+  });
+
+  describe('parent-child relationship', () => {
+    test('should add child to parent span', () => {
+      const parentSpan = tracer.startSpan('parent');
+      tracer.startSpan('child', SpanKind.INTERNAL, parentSpan.context);
+
+      // Parent should have the child in children array
+      expect(parentSpan.children?.length).toBe(1);
+    });
+
+    test('should handle multiple children', () => {
+      const parentSpan = tracer.startSpan('parent');
+      tracer.startSpan('child1', SpanKind.INTERNAL, parentSpan.context);
+      tracer.startSpan('child2', SpanKind.INTERNAL, parentSpan.context);
+
+      expect(parentSpan.children?.length).toBe(2);
+    });
+  });
+});

package/tests/microservice/tracing-collectors.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+
+import {
+  ConsoleTraceCollector,
+  MemoryTraceCollector,
+} from '../../src/microservice/tracing/collectors';
+import { SpanKind, SpanStatus, type Span } from '../../src/microservice/tracing/types';
+
+describe('ConsoleTraceCollector', () => {
+  test('should collect span to console', () => {
+    const collector = new ConsoleTraceCollector();
+    const span: Span = {
+      context: {
+        traceId: 'trace-123',
+        spanId: 'span-456',
+        sampled: true,
+      },
+      name: 'test-span',
+      kind: SpanKind.INTERNAL,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+      duration: 100,
+    };
+
+    // Should not throw
+    expect(() => collector.collect(span)).not.toThrow();
+  });
+
+  test('should handle span with tags', () => {
+    const collector = new ConsoleTraceCollector();
+    const span: Span = {
+      context: {
+        traceId: 'trace-123',
+        spanId: 'span-456',
+        sampled: true,
+      },
+      name: 'tagged-span',
+      kind: SpanKind.CLIENT,
+      startTime: Date.now(),
+      status: SpanStatus.OK,
+      tags: {
+        'http.method': 'GET',
+        'http.url': '/api/test',
+      },
+    };
+
+    expect(() => collector.collect(span)).not.toThrow();
+  });
+});
+
+describe('MemoryTraceCollector', () => {
+  let collector: MemoryTraceCollector;
+
+  beforeEach(() => {
+    collector = new MemoryTraceCollector();
+  });
+
+  describe('collect', () => {
+    test('should store span in memory', () => {
+      const span: Span = {
+        context: {
+          traceId: 'trace-1',
+          spanId: 'span-1',
+          sampled: true,
+        },
+        name: 'test',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      };
+
+      collector.collect(span);
+
+      const spans = collector.getSpans();
+      expect(spans.length).toBe(1);
+      expect(spans[0].name).toBe('test');
+    });
+
+    test('should store multiple spans', () => {
+      for (let i = 0; i < 5; i++) {
+        collector.collect({
+          context: { traceId: `trace-${i}`, spanId: `span-${i}`, sampled: true },
+          name: `span-${i}`,
+          kind: SpanKind.INTERNAL,
+          startTime: Date.now(),
+          status: SpanStatus.OK,
+        });
+      }
+
+      expect(collector.getSpans().length).toBe(5);
+    });
+  });
+
+  describe('getSpans', () => {
+    test('should return copy of spans', () => {
+      const span: Span = {
+        context: { traceId: 't1', spanId: 's1', sampled: true },
+        name: 'test',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      };
+
+      collector.collect(span);
+
+      const spans1 = collector.getSpans();
+      const spans2 = collector.getSpans();
+
+      // Should be different arrays
+      expect(spans1).not.toBe(spans2);
+      expect(spans1).toEqual(spans2);
+    });
+  });
+
+  describe('clear', () => {
+    test('should remove all spans', () => {
+      collector.collect({
+        context: { traceId: 't1', spanId: 's1', sampled: true },
+        name: 'test',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      });
+
+      expect(collector.getSpans().length).toBe(1);
+
+      collector.clear();
+
+      expect(collector.getSpans().length).toBe(0);
+    });
+  });
+
+  describe('getSpansByTraceId', () => {
+    test('should filter spans by trace id', () => {
+      collector.collect({
+        context: { traceId: 'trace-A', spanId: 's1', sampled: true },
+        name: 'span-a1',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      });
+      collector.collect({
+        context: { traceId: 'trace-B', spanId: 's2', sampled: true },
+        name: 'span-b1',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      });
+      collector.collect({
+        context: { traceId: 'trace-A', spanId: 's3', sampled: true },
+        name: 'span-a2',
+        kind: SpanKind.INTERNAL,
+        startTime: Date.now(),
+        status: SpanStatus.OK,
+      });
+
+      const traceASpans = collector.getSpansByTraceId('trace-A');
+
+      expect(traceASpans.length).toBe(2);
+      expect(traceASpans.every((s) => s.context.traceId === 'trace-A')).toBe(true);
+    });
+
+    test('should return empty array for non-existent trace id', () => {
+      const spans = collector.getSpansByTraceId('non-existent');
+      expect(spans).toEqual([]);
+    });
+  });
+});