autotel-cloudflare 2.1.0

package/src/actors/instrument-actor.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Tests for Actor instrumentation
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { instrumentActor } from './instrument-actor';
+import type { ActorLike } from './types';
+
+// Mock dependencies
+vi.mock('@opentelemetry/api', () => ({
+  trace: {
+    getTracer: () => ({
+      startActiveSpan: vi.fn((name, options, contextOrCallback, maybeCallback) => {
+        const callback = typeof contextOrCallback === 'function' ? contextOrCallback : maybeCallback;
+        const mockSpan = {
+          setAttributes: vi.fn(),
+          setAttribute: vi.fn(),
+          setStatus: vi.fn(),
+          recordException: vi.fn(),
+          end: vi.fn(),
+        };
+        return callback(mockSpan);
+      }),
+    }),
+  },
+  context: {
+    active: () => ({}),
+    with: (_ctx: unknown, fn: () => unknown) => fn(),
+  },
+  propagation: {
+    extract: () => ({}),
+  },
+  SpanStatusCode: {
+    OK: 'OK',
+    ERROR: 'ERROR',
+  },
+  SpanKind: {
+    SERVER: 'SERVER',
+    INTERNAL: 'INTERNAL',
+    CLIENT: 'CLIENT',
+    PRODUCER: 'PRODUCER',
+  },
+}));
+
+vi.mock('autotel-edge', () => ({
+  createInitialiser: () => () => ({}),
+  setConfig: () => ({}),
+  WorkerTracer: class {},
+}));
+
+vi.mock('../bindings/common', () => ({
+  wrap: <T>(target: T, handler: ProxyHandler<T>): T => new Proxy(target, handler) as T,
+}));
+
+// Mock Actor class for testing
+class MockActor implements ActorLike {
+  name = 'test-actor';
+  identifier = 'test-123';
+  storage = {};
+  alarms = {};
+  sockets = {};
+
+  async onInit(): Promise<void> {
+    // Mock initialization
+  }
+
+  async onRequest(request: Request): Promise<Response> {
+    return new Response('OK');
+  }
+
+  async onAlarm(): Promise<void> {
+    // Mock alarm
+  }
+
+  onPersist(key: string, value: unknown): void {
+    // Mock persist
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    return this.onRequest(request);
+  }
+
+  async alarm(): Promise<void> {
+    return this.onAlarm();
+  }
+}
+
+// Mock DurableObjectState
+const mockState = {
+  id: {
+    toString: () => 'do-id-123',
+    name: 'test-do',
+  },
+  storage: {},
+} as unknown as DurableObjectState;
+
+describe('instrumentActor', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return an instrumented class constructor', () => {
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      { service: { name: 'test-service' } },
+    );
+
+    expect(typeof InstrumentedActor).toBe('function');
+  });
+
+  it('should create an instrumented instance', () => {
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      { service: { name: 'test-service' } },
+    );
+
+    const instance = new InstrumentedActor(mockState, {});
+    expect(instance).toBeDefined();
+  });
+
+  it('should support config as a function', () => {
+    const configFn = vi.fn(() => ({ service: { name: 'dynamic-service' } }));
+
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      configFn,
+    );
+
+    new InstrumentedActor(mockState, { API_KEY: 'test' });
+
+    expect(configFn).toHaveBeenCalled();
+  });
+
+  it('should support actors-specific options', () => {
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      {
+        service: { name: 'test-service' },
+        actors: {
+          instrumentStorage: false,
+          capturePersistEvents: true,
+        },
+      },
+    );
+
+    const instance = new InstrumentedActor(mockState, {});
+    expect(instance).toBeDefined();
+  });
+});
+
+describe('ActorInstrumentationOptions', () => {
+  it('should default instrumentStorage to true', () => {
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      { service: { name: 'test' } },
+    );
+
+    const instance = new InstrumentedActor(mockState, {});
+    // Storage should be instrumented by default
+    expect(instance.storage).toBeDefined();
+  });
+
+  it('should respect custom spanNameFormatter', () => {
+    const formatter = vi.fn((actorName: string, lifecycle: string) => `Custom: ${actorName} - ${lifecycle}`);
+
+    const InstrumentedActor = instrumentActor(
+      MockActor as unknown as new (state: DurableObjectState, env: unknown) => ActorLike,
+      {
+        service: { name: 'test' },
+        actors: {
+          spanNameFormatter: formatter,
+        },
+      },
+    );
+
+    const instance = new InstrumentedActor(mockState, {});
+    expect(instance).toBeDefined();
+  });
+});