autotel 4.1.0 → 4.2.1

package/src/messaging-testing.ts

@@ -1,935 +0,0 @@
-/**
- * Testing utilities for messaging instrumentation
- *
- * Provides mock producers, consumers, and assertion helpers
- * for testing event-driven code with Autotel's messaging module.
- *
- * @example Basic test setup
- * ```typescript
- * import { createMessagingTestHarness } from 'autotel/messaging-testing';
- *
- * describe('Order processing', () => {
- *   const harness = createMessagingTestHarness();
- *
- *   beforeEach(() => harness.reset());
- *   afterAll(() => harness.shutdown());
- *
- *   it('should process order and publish event', async () => {
- *     await processOrder({ id: 'order-123' });
- *
- *     harness.assertProducerCalled('orders', {
- *       messageCount: 1,
- *       hasTraceHeaders: true,
- *     });
- *   });
- * });
- * ```
- *
- * @module
- */
-
-import type { Link, SpanContext } from '@opentelemetry/api';
-import type {
-  RebalanceEvent,
-  PartitionAssignment,
-  OutOfOrderInfo,
-} from './messaging';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/**
- * Recorded producer call
- */
-export interface RecordedProducerCall {
-  /** Destination (topic/queue) */
-  destination: string;
-
-  /** System (kafka, sqs, etc.) */
-  system: string;
-
-  /** Message payload */
-  payload: unknown;
-
-  /** Headers injected */
-  headers: Record<string, string>;
-
-  /** Timestamp of call */
-  timestamp: number;
-
-  /** Trace ID from headers */
-  traceId?: string;
-
-  /** Span ID from headers */
-  spanId?: string;
-}
-
-/**
- * Recorded consumer call
- */
-export interface RecordedConsumerCall {
-  /** Destination (topic/queue) */
-  destination: string;
-
-  /** System (kafka, sqs, etc.) */
-  system: string;
-
-  /** Consumer group */
-  consumerGroup?: string;
-
-  /** Message payload */
-  payload: unknown;
-
-  /** Headers extracted */
-  headers?: Record<string, string>;
-
-  /** Timestamp of call */
-  timestamp: number;
-
-  /** Producer links extracted */
-  producerLinks: Link[];
-
-  /** Whether message was duplicate */
-  isDuplicate: boolean;
-
-  /** Out of order info if detected */
-  outOfOrderInfo: OutOfOrderInfo | null;
-
-  /** DLQ reason if routed to DLQ */
-  dlqReason?: string;
-
-  /** Retry attempt number */
-  retryAttempt?: number;
-}
-
-/**
- * Recorded rebalance event
- */
-export interface RecordedRebalanceEvent extends RebalanceEvent {
-  /** Destination (topic) */
-  destination: string;
-
-  /** Consumer group */
-  consumerGroup: string;
-}
-
-/**
- * Mock message for testing
- */
-export interface MockMessage<T = unknown> {
-  /** Message payload */
-  payload: T;
-
-  /** Headers */
-  headers?: Record<string, string>;
-
-  /** Offset/sequence number */
-  offset?: number;
-
-  /** Partition */
-  partition?: number;
-
-  /** Key */
-  key?: string;
-
-  /** Message ID */
-  messageId?: string;
-
-  /** Timestamp */
-  timestamp?: number;
-}
-
-/**
- * Producer assertion options
- */
-export interface ProducerAssertionOptions {
-  /** Expected number of messages */
-  messageCount?: number;
-
-  /** Whether trace headers should be present */
-  hasTraceHeaders?: boolean;
-
-  /** Expected destination */
-  destination?: string;
-
-  /** Custom matcher for payload */
-  payloadMatcher?: (payload: unknown) => boolean;
-
-  /** Expected trace ID */
-  traceId?: string;
-}
-
-/**
- * Consumer assertion options
- */
-export interface ConsumerAssertionOptions {
-  /** Expected number of messages processed */
-  messageCount?: number;
-
-  /** Whether producer links should be present */
-  hasProducerLinks?: boolean;
-
-  /** Expected destination */
-  destination?: string;
-
-  /** Expected consumer group */
-  consumerGroup?: string;
-
-  /** Whether any messages were duplicates */
-  hasDuplicates?: boolean;
-
-  /** Whether any messages were out of order */
-  hasOutOfOrder?: boolean;
-
-  /** Whether any messages went to DLQ */
-  hasDLQ?: boolean;
-}
-
-/**
- * Messaging test harness
- */
-export interface MessagingTestHarness {
-  /** All recorded producer calls */
-  producerCalls: RecordedProducerCall[];
-
-  /** All recorded consumer calls */
-  consumerCalls: RecordedConsumerCall[];
-
-  /** All recorded rebalance events */
-  rebalanceEvents: RecordedRebalanceEvent[];
-
-  /**
-   * Record a producer call
-   */
-  recordProducerCall(call: Omit<RecordedProducerCall, 'timestamp'>): void;
-
-  /**
-   * Record a consumer call
-   */
-  recordConsumerCall(call: Omit<RecordedConsumerCall, 'timestamp'>): void;
-
-  /**
-   * Record a rebalance event
-   */
-  recordRebalanceEvent(event: RecordedRebalanceEvent): void;
-
-  /**
-   * Create a mock message with trace headers
-   */
-  createMockMessage<T>(
-    payload: T,
-    options?: Partial<MockMessage<T>>,
-  ): MockMessage<T>;
-
-  /**
-   * Create mock trace headers
-   */
-  createMockTraceHeaders(
-    traceId?: string,
-    spanId?: string,
-  ): Record<string, string>;
-
-  /**
-   * Assert producer was called with expected options
-   */
-  assertProducerCalled(
-    destination: string,
-    options?: ProducerAssertionOptions,
-  ): void;
-
-  /**
-   * Assert producer was not called
-   */
-  assertProducerNotCalled(destination?: string): void;
-
-  /**
-   * Assert consumer processed messages with expected options
-   */
-  assertConsumerProcessed(
-    destination: string,
-    options?: ConsumerAssertionOptions,
-  ): void;
-
-  /**
-   * Assert consumer was not called
-   */
-  assertConsumerNotCalled(destination?: string): void;
-
-  /**
-   * Assert rebalance occurred
-   */
-  assertRebalanceOccurred(
-    destination: string,
-    type: RebalanceEvent['type'],
-    partitionCount?: number,
-  ): void;
-
-  /**
-   * Get producer calls for destination
-   */
-  getProducerCalls(destination?: string): RecordedProducerCall[];
-
-  /**
-   * Get consumer calls for destination
-   */
-  getConsumerCalls(destination?: string): RecordedConsumerCall[];
-
-  /**
-   * Get the last producer call
-   */
-  getLastProducerCall(destination?: string): RecordedProducerCall | undefined;
-
-  /**
-   * Get the last consumer call
-   */
-  getLastConsumerCall(destination?: string): RecordedConsumerCall | undefined;
-
-  /**
-   * Reset all recorded calls
-   */
-  reset(): void;
-
-  /**
-   * Shutdown the harness
-   */
-  shutdown(): void;
-}
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Generate a random hex string
- */
-function randomHex(length: number): string {
-  let result = '';
-  const chars = '0123456789abcdef';
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-
-/**
- * Create a messaging test harness
- *
- * Provides utilities for recording and asserting on producer/consumer calls
- * during testing.
- *
- * @example
- * ```typescript
- * const harness = createMessagingTestHarness();
- *
- * // In your test setup
- * beforeEach(() => harness.reset());
- *
- * // In your tests
- * it('should publish order event', async () => {
- *   await orderService.createOrder({ id: '123' });
- *
- *   harness.assertProducerCalled('orders', {
- *     messageCount: 1,
- *     hasTraceHeaders: true,
- *   });
- *
- *   const lastCall = harness.getLastProducerCall('orders');
- *   expect(lastCall?.payload).toMatchObject({ orderId: '123' });
- * });
- * ```
- */
-export function createMessagingTestHarness(): MessagingTestHarness {
-  const producerCalls: RecordedProducerCall[] = [];
-  const consumerCalls: RecordedConsumerCall[] = [];
-  const rebalanceEvents: RecordedRebalanceEvent[] = [];
-
-  return {
-    producerCalls,
-    consumerCalls,
-    rebalanceEvents,
-
-    recordProducerCall(call) {
-      producerCalls.push({
-        ...call,
-        timestamp: Date.now(),
-      });
-    },
-
-    recordConsumerCall(call) {
-      consumerCalls.push({
-        ...call,
-        timestamp: Date.now(),
-      });
-    },
-
-    recordRebalanceEvent(event) {
-      rebalanceEvents.push(event);
-    },
-
-    createMockMessage<T>(
-      payload: T,
-      options: Partial<MockMessage<T>> = {},
-    ): MockMessage<T> {
-      return {
-        payload,
-        headers: options.headers ?? this.createMockTraceHeaders(),
-        offset: options.offset ?? Math.floor(Math.random() * 10_000),
-        partition: options.partition ?? 0,
-        key: options.key,
-        messageId: options.messageId ?? `msg-${randomHex(8)}`,
-        timestamp: options.timestamp ?? Date.now(),
-      };
-    },
-
-    createMockTraceHeaders(
-      traceId?: string,
-      spanId?: string,
-    ): Record<string, string> {
-      const tid = traceId ?? randomHex(32);
-      const sid = spanId ?? randomHex(16);
-      return {
-        traceparent: `00-${tid}-${sid}-01`,
-      };
-    },
-
-    assertProducerCalled(
-      destination: string,
-      options: ProducerAssertionOptions = {},
-    ) {
-      const calls = producerCalls.filter((c) => c.destination === destination);
-
-      if (calls.length === 0) {
-        throw new Error(
-          `Expected producer to be called for destination '${destination}', but it was not called`,
-        );
-      }
-
-      if (
-        options.messageCount !== undefined &&
-        calls.length !== options.messageCount
-      ) {
-        throw new Error(
-          `Expected ${options.messageCount} producer calls for '${destination}', got ${calls.length}`,
-        );
-      }
-
-      if (options.hasTraceHeaders) {
-        const withoutHeaders = calls.filter((c) => !c.headers?.traceparent);
-        if (withoutHeaders.length > 0) {
-          throw new Error(
-            `Expected all producer calls for '${destination}' to have trace headers, but ${withoutHeaders.length} did not`,
-          );
-        }
-      }
-
-      if (options.traceId) {
-        const matchingTraceId = calls.filter(
-          (c) => c.traceId === options.traceId,
-        );
-        if (matchingTraceId.length === 0) {
-          throw new Error(
-            `Expected producer call for '${destination}' with traceId '${options.traceId}', but none found`,
-          );
-        }
-      }
-
-      if (options.payloadMatcher) {
-        const matching = calls.filter((c) =>
-          options.payloadMatcher!(c.payload),
-        );
-        if (matching.length === 0) {
-          throw new Error(
-            `Expected producer call for '${destination}' to match payload matcher, but none did`,
-          );
-        }
-      }
-    },
-
-    assertProducerNotCalled(destination?: string) {
-      if (destination) {
-        const calls = producerCalls.filter(
-          (c) => c.destination === destination,
-        );
-        if (calls.length > 0) {
-          throw new Error(
-            `Expected producer not to be called for '${destination}', but it was called ${calls.length} times`,
-          );
-        }
-      } else {
-        if (producerCalls.length > 0) {
-          throw new Error(
-            `Expected no producer calls, but ${producerCalls.length} calls were made`,
-          );
-        }
-      }
-    },
-
-    assertConsumerProcessed(
-      destination: string,
-      options: ConsumerAssertionOptions = {},
-    ) {
-      const calls = consumerCalls.filter((c) => c.destination === destination);
-
-      if (calls.length === 0) {
-        throw new Error(
-          `Expected consumer to process messages for destination '${destination}', but none were processed`,
-        );
-      }
-
-      if (
-        options.messageCount !== undefined &&
-        calls.length !== options.messageCount
-      ) {
-        throw new Error(
-          `Expected ${options.messageCount} consumer calls for '${destination}', got ${calls.length}`,
-        );
-      }
-
-      if (options.consumerGroup) {
-        const wrongGroup = calls.filter(
-          (c) => c.consumerGroup !== options.consumerGroup,
-        );
-        if (wrongGroup.length > 0) {
-          throw new Error(
-            `Expected consumer group '${options.consumerGroup}' for '${destination}', but found different groups`,
-          );
-        }
-      }
-
-      if (options.hasProducerLinks) {
-        const withoutLinks = calls.filter((c) => c.producerLinks.length === 0);
-        if (withoutLinks.length > 0) {
-          throw new Error(
-            `Expected all consumer calls for '${destination}' to have producer links, but ${withoutLinks.length} did not`,
-          );
-        }
-      }
-
-      if (options.hasDuplicates !== undefined) {
-        const duplicates = calls.filter((c) => c.isDuplicate);
-        if (options.hasDuplicates && duplicates.length === 0) {
-          throw new Error(
-            `Expected duplicate messages for '${destination}', but none were detected`,
-          );
-        }
-        if (!options.hasDuplicates && duplicates.length > 0) {
-          throw new Error(
-            `Expected no duplicate messages for '${destination}', but ${duplicates.length} were detected`,
-          );
-        }
-      }
-
-      if (options.hasOutOfOrder !== undefined) {
-        const outOfOrder = calls.filter((c) => c.outOfOrderInfo !== null);
-        if (options.hasOutOfOrder && outOfOrder.length === 0) {
-          throw new Error(
-            `Expected out-of-order messages for '${destination}', but none were detected`,
-          );
-        }
-        if (!options.hasOutOfOrder && outOfOrder.length > 0) {
-          throw new Error(
-            `Expected no out-of-order messages for '${destination}', but ${outOfOrder.length} were detected`,
-          );
-        }
-      }
-
-      if (options.hasDLQ !== undefined) {
-        const dlqCalls = calls.filter((c) => c.dlqReason !== undefined);
-        if (options.hasDLQ && dlqCalls.length === 0) {
-          throw new Error(
-            `Expected DLQ routing for '${destination}', but none occurred`,
-          );
-        }
-        if (!options.hasDLQ && dlqCalls.length > 0) {
-          throw new Error(
-            `Expected no DLQ routing for '${destination}', but ${dlqCalls.length} occurred`,
-          );
-        }
-      }
-    },
-
-    assertConsumerNotCalled(destination?: string) {
-      if (destination) {
-        const calls = consumerCalls.filter(
-          (c) => c.destination === destination,
-        );
-        if (calls.length > 0) {
-          throw new Error(
-            `Expected consumer not to be called for '${destination}', but it processed ${calls.length} messages`,
-          );
-        }
-      } else {
-        if (consumerCalls.length > 0) {
-          throw new Error(
-            `Expected no consumer calls, but ${consumerCalls.length} messages were processed`,
-          );
-        }
-      }
-    },
-
-    assertRebalanceOccurred(
-      destination: string,
-      type: RebalanceEvent['type'],
-      partitionCount?: number,
-    ) {
-      const events = rebalanceEvents.filter(
-        (e) => e.destination === destination && e.type === type,
-      );
-
-      if (events.length === 0) {
-        throw new Error(
-          `Expected rebalance '${type}' for '${destination}', but none occurred`,
-        );
-      }
-
-      if (partitionCount !== undefined) {
-        const matching = events.filter(
-          (e) => e.partitions.length === partitionCount,
-        );
-        if (matching.length === 0) {
-          throw new Error(
-            `Expected rebalance '${type}' for '${destination}' with ${partitionCount} partitions, but none matched`,
-          );
-        }
-      }
-    },
-
-    getProducerCalls(destination?: string) {
-      if (destination) {
-        return producerCalls.filter((c) => c.destination === destination);
-      }
-      return [...producerCalls];
-    },
-
-    getConsumerCalls(destination?: string) {
-      if (destination) {
-        return consumerCalls.filter((c) => c.destination === destination);
-      }
-      return [...consumerCalls];
-    },
-
-    getLastProducerCall(destination?: string) {
-      const calls = this.getProducerCalls(destination);
-      return calls.at(-1);
-    },
-
-    getLastConsumerCall(destination?: string) {
-      const calls = this.getConsumerCalls(destination);
-      return calls.at(-1);
-    },
-
-    reset() {
-      producerCalls.length = 0;
-      consumerCalls.length = 0;
-      rebalanceEvents.length = 0;
-    },
-
-    shutdown() {
-      this.reset();
-    },
-  };
-}
-
-// ============================================================================
-// Mock Broker
-// ============================================================================
-
-/**
- * Mock message broker for testing
- */
-export interface MockMessageBroker {
-  /** Topics/queues in the broker */
-  topics: Map<string, MockMessage[]>;
-
-  /**
-   * Publish a message to a topic
-   */
-  publish(topic: string, message: MockMessage): void;
-
-  /**
-   * Consume messages from a topic
-   */
-  consume(topic: string, count?: number): MockMessage[];
-
-  /**
-   * Peek at messages without consuming
-   */
-  peek(topic: string, count?: number): MockMessage[];
-
-  /**
-   * Get message count for topic
-   */
-  getMessageCount(topic: string): number;
-
-  /**
-   * Clear all messages
-   */
-  clear(topic?: string): void;
-
-  /**
-   * Create a topic
-   */
-  createTopic(topic: string): void;
-
-  /**
-   * Delete a topic
-   */
-  deleteTopic(topic: string): void;
-
-  /**
-   * List all topics
-   */
-  listTopics(): string[];
-}
-
-/**
- * Create a mock message broker for testing
- *
- * Simulates a message broker (Kafka, SQS, RabbitMQ, etc.) for unit testing.
- *
- * @example
- * ```typescript
- * const broker = createMockMessageBroker();
- *
- * // Producer publishes
- * broker.publish('orders', { payload: { orderId: '123' }, headers: {} });
- *
- * // Consumer receives
- * const messages = broker.consume('orders');
- * expect(messages).toHaveLength(1);
- * expect(messages[0].payload).toEqual({ orderId: '123' });
- * ```
- */
-export function createMockMessageBroker(): MockMessageBroker {
-  const topics = new Map<string, MockMessage[]>();
-
-  return {
-    topics,
-
-    publish(topic: string, message: MockMessage) {
-      if (!topics.has(topic)) {
-        topics.set(topic, []);
-      }
-      topics.get(topic)!.push({
-        ...message,
-        timestamp: message.timestamp ?? Date.now(),
-        offset: message.offset ?? topics.get(topic)!.length,
-      });
-    },
-
-    consume(topic: string, count?: number) {
-      const messages = topics.get(topic) ?? [];
-      if (count === undefined) {
-        const all = [...messages];
-        messages.length = 0;
-        return all;
-      }
-      return messages.splice(0, count);
-    },
-
-    peek(topic: string, count?: number) {
-      const messages = topics.get(topic) ?? [];
-      if (count === undefined) {
-        return [...messages];
-      }
-      return messages.slice(0, count);
-    },
-
-    getMessageCount(topic: string) {
-      return topics.get(topic)?.length ?? 0;
-    },
-
-    clear(topic?: string) {
-      if (topic) {
-        topics.set(topic, []);
-      } else {
-        topics.clear();
-      }
-    },
-
-    createTopic(topic: string) {
-      if (!topics.has(topic)) {
-        topics.set(topic, []);
-      }
-    },
-
-    deleteTopic(topic: string) {
-      topics.delete(topic);
-    },
-
-    listTopics() {
-      return [...topics.keys()];
-    },
-  };
-}
-
-// ============================================================================
-// Context Propagation Helpers
-// ============================================================================
-
-/**
- * Extract trace ID from traceparent header
- */
-export function extractTraceIdFromHeader(traceparent: string): string | null {
-  const parts = traceparent.split('-');
-  if (parts.length >= 3 && parts[1] !== undefined) {
-    return parts[1];
-  }
-  return null;
-}
-
-/**
- * Extract span ID from traceparent header
- */
-export function extractSpanIdFromHeader(traceparent: string): string | null {
-  const parts = traceparent.split('-');
-  if (parts.length >= 4 && parts[2] !== undefined) {
-    return parts[2];
-  }
-  return null;
-}
-
-/**
- * Create a mock span context
- */
-export function createMockSpanContext(
-  traceId?: string,
-  spanId?: string,
-): SpanContext {
-  return {
-    traceId: traceId ?? randomHex(32),
-    spanId: spanId ?? randomHex(16),
-    traceFlags: 1,
-    isRemote: true,
-  };
-}
-
-/**
- * Create a mock link to a producer span
- */
-export function createMockProducerLink(
-  traceId?: string,
-  spanId?: string,
-): Link {
-  return {
-    context: createMockSpanContext(traceId, spanId),
-    attributes: {
-      'messaging.link.source': 'producer',
-    },
-  };
-}
-
-// ============================================================================
-// Scenario Builders
-// ============================================================================
-
-/**
- * Create a batch of mock messages
- */
-export function createMockMessageBatch<T>(
-  payloads: T[],
-  options: {
-    startOffset?: number;
-    partition?: number;
-    addTraceHeaders?: boolean;
-    traceId?: string;
-  } = {},
-): MockMessage<T>[] {
-  const startOffset = options.startOffset ?? 0;
-  const addTraceHeaders = options.addTraceHeaders ?? true;
-  const traceId = options.traceId ?? randomHex(32);
-
-  return payloads.map((payload, index) => ({
-    payload,
-    headers: addTraceHeaders
-      ? { traceparent: `00-${traceId}-${randomHex(16)}-01` }
-      : undefined,
-    offset: startOffset + index,
-    partition: options.partition ?? 0,
-    messageId: `msg-${randomHex(8)}`,
-    timestamp: Date.now() + index,
-  }));
-}
-
-/**
- * Create a rebalance scenario
- */
-export function createRebalanceScenario(
-  topic: string,
-  consumerGroup: string,
-  partitions: number[],
-): {
-  assignEvent: RecordedRebalanceEvent;
-  revokeEvent: RecordedRebalanceEvent;
-} {
-  const assignments: PartitionAssignment[] = partitions.map((p) => ({
-    topic,
-    partition: p,
-    offset: 0,
-  }));
-
-  return {
-    assignEvent: {
-      type: 'assigned',
-      partitions: assignments,
-      timestamp: Date.now(),
-      generation: 1,
-      destination: topic,
-      consumerGroup,
-    },
-    revokeEvent: {
-      type: 'revoked',
-      partitions: assignments,
-      timestamp: Date.now() + 1000,
-      generation: 2,
-      destination: topic,
-      consumerGroup,
-    },
-  };
-}
-
-/**
- * Create an out-of-order scenario
- */
-export function createOutOfOrderScenario<T>(
-  payloads: T[],
-  outOfOrderIndices: number[],
-): MockMessage<T>[] {
-  const messages = createMockMessageBatch(payloads, { addTraceHeaders: true });
-
-  // Shuffle specified indices to create out-of-order scenario
-  const shuffled = [...messages];
-  for (const index of outOfOrderIndices) {
-    if (index > 0 && index < shuffled.length) {
-      // Swap with previous to create out-of-order
-      const prev = shuffled[index - 1]!;
-      const curr = shuffled[index]!;
-      shuffled[index - 1] = curr;
-      shuffled[index] = prev;
-    }
-  }
-
-  return shuffled;
-}
-
-/**
- * Create a duplicate message scenario
- */
-export function createDuplicateScenario<T>(
-  payloads: T[],
-  duplicateIndices: number[],
-): MockMessage<T>[] {
-  const messages = createMockMessageBatch(payloads, { addTraceHeaders: true });
-  const result = [...messages];
-
-  for (const index of duplicateIndices) {
-    const originalMessage = messages[index];
-    if (index >= 0 && index < messages.length && originalMessage) {
-      // Insert duplicate after the original
-      result.splice(index + 1, 0, { ...originalMessage });
-    }
-  }
-
-  return result;
-}