@signaltree/events 7.3.5 → 7.3.6

package/testing.cjs.js

@@ -0,0 +1,755 @@
+'use strict';
+
+var factory = require('./factory.cjs.js');
+
+/**
+ * Mock Event Bus for testing
+ *
+ * @example
+ * ```typescript
+ * const eventBus = createMockEventBus();
+ *
+ * // Subscribe to events
+ * eventBus.subscribe('TradeProposalCreated', (event) => {
+ *   expect(event.data.tradeId).toBe('123');
+ * });
+ *
+ * // Publish an event
+ * await eventBus.publish({
+ *   type: 'TradeProposalCreated',
+ *   data: { tradeId: '123' },
+ * });
+ *
+ * // Assert published events
+ * expect(eventBus.getPublishedEvents()).toHaveLength(1);
+ * expect(eventBus.wasPublished('TradeProposalCreated')).toBe(true);
+ * ```
+ */
+class MockEventBus {
+  options;
+  publishedEvents = [];
+  subscriptions = new Map();
+  allSubscriptions = new Set();
+  constructor(options = {}) {
+    this.options = options;
+    this.options = {
+      simulateAsync: false,
+      asyncDelayMs: 10,
+      autoGenerateIds: true,
+      throwOnError: false,
+      ...options
+    };
+  }
+  /**
+   * Publish an event
+   */
+  async publish(event, options) {
+    // Complete the event
+    const fullEvent = {
+      ...event,
+      id: event.id ?? (this.options.autoGenerateIds ? factory.generateEventId() : 'test-event-id'),
+      timestamp: event.timestamp ?? new Date().toISOString(),
+      correlationId: event.correlationId ?? factory.generateCorrelationId()
+    };
+    const queue = options?.queue ?? this.getQueueForPriority(fullEvent.priority);
+    // Record the published event
+    this.publishedEvents.push({
+      event: fullEvent,
+      queue,
+      publishedAt: new Date(),
+      delay: options?.delay
+    });
+    // Simulate async if configured
+    if (this.options.simulateAsync) {
+      await this.delay(this.options.asyncDelayMs ?? 10);
+    }
+    // Notify subscribers
+    await this.notifySubscribers(fullEvent);
+    return {
+      eventId: fullEvent.id,
+      queue
+    };
+  }
+  /**
+   * Publish multiple events
+   */
+  async publishBatch(events, options) {
+    const correlationId = factory.generateCorrelationId();
+    return Promise.all(events.map(event => this.publish({
+      ...event,
+      correlationId
+    }, {
+      ...options
+    })));
+  }
+  /**
+   * Subscribe to a specific event type
+   */
+  subscribe(eventType, handler) {
+    let handlers = this.subscriptions.get(eventType);
+    if (!handlers) {
+      handlers = new Set();
+      this.subscriptions.set(eventType, handlers);
+    }
+    handlers.add(handler);
+    // Return unsubscribe function
+    // handlers is guaranteed to exist at this point since we just set it above
+    return () => {
+      const h = this.subscriptions.get(eventType);
+      if (h) {
+        h.delete(handler);
+      }
+    };
+  }
+  /**
+   * Subscribe to all events
+   */
+  subscribeAll(handler) {
+    this.allSubscriptions.add(handler);
+    return () => {
+      this.allSubscriptions.delete(handler);
+    };
+  }
+  /**
+   * Get all published events
+   */
+  getPublishedEvents() {
+    return [...this.publishedEvents];
+  }
+  /**
+   * Get published events by type
+   */
+  getPublishedEventsByType(type) {
+    return this.publishedEvents.filter(p => p.event.type === type);
+  }
+  /**
+   * Get the last published event
+   */
+  getLastPublishedEvent() {
+    return this.publishedEvents[this.publishedEvents.length - 1];
+  }
+  /**
+   * Get the last published event of a specific type
+   */
+  getLastPublishedEventByType(type) {
+    const events = this.getPublishedEventsByType(type);
+    return events[events.length - 1];
+  }
+  /**
+   * Check if an event type was published
+   */
+  wasPublished(eventType) {
+    return this.publishedEvents.some(p => p.event.type === eventType);
+  }
+  /**
+   * Check if an event with specific data was published
+   */
+  wasPublishedWith(eventType, predicate) {
+    return this.publishedEvents.some(p => p.event.type === eventType && predicate(p.event));
+  }
+  /**
+   * Get count of published events
+   */
+  getPublishedCount(eventType) {
+    if (eventType) {
+      return this.publishedEvents.filter(p => p.event.type === eventType).length;
+    }
+    return this.publishedEvents.length;
+  }
+  /**
+   * Clear all published events (for test cleanup)
+   */
+  clearHistory() {
+    this.publishedEvents = [];
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clearSubscriptions() {
+    this.subscriptions.clear();
+    this.allSubscriptions.clear();
+  }
+  /**
+   * Reset the mock (clear history and subscriptions)
+   */
+  reset() {
+    this.clearHistory();
+    this.clearSubscriptions();
+  }
+  /**
+   * Simulate an incoming event (as if received from server)
+   */
+  async simulateIncomingEvent(event) {
+    await this.notifySubscribers(event);
+  }
+  // Private methods
+  async notifySubscribers(event) {
+    const errors = [];
+    // Notify type-specific subscribers
+    const handlers = this.subscriptions.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          await handler(event);
+        } catch (error) {
+          errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+    // Notify all-event subscribers
+    for (const handler of this.allSubscriptions) {
+      try {
+        await handler(event);
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    if (errors.length > 0 && this.options.throwOnError) {
+      throw new AggregateError(errors, 'Subscriber errors');
+    }
+  }
+  getQueueForPriority(priority) {
+    switch (priority) {
+      case 'critical':
+        return 'events-critical';
+      case 'high':
+        return 'events-high';
+      case 'low':
+        return 'events-low';
+      case 'bulk':
+        return 'events-bulk';
+      default:
+        return 'events-normal';
+    }
+  }
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+/**
+ * Create a mock event bus for testing
+ */
+function createMockEventBus(options) {
+  return new MockEventBus(options);
+}
+
+/**
+ * Default test actor
+ */
+const DEFAULT_TEST_ACTOR = {
+  id: 'test-user-1',
+  type: 'user',
+  name: 'Test User'
+};
+/**
+ * Default test metadata
+ */
+const DEFAULT_TEST_METADATA = {
+  source: 'test',
+  environment: 'test'
+};
+/**
+ * Create a test event
+ *
+ * @example
+ * ```typescript
+ * const event = createTestEvent('TradeProposalCreated', {
+ *   tradeId: '123',
+ *   initiatorId: 'user-1',
+ *   recipientId: 'user-2',
+ * });
+ * ```
+ */
+function createTestEvent(type, data, options = {}) {
+  return {
+    id: options.id ?? factory.generateEventId(),
+    type,
+    version: options.version ?? factory.DEFAULT_EVENT_VERSION,
+    timestamp: options.timestamp ?? new Date().toISOString(),
+    correlationId: options.correlationId ?? factory.generateCorrelationId(),
+    causationId: options.causationId,
+    actor: {
+      ...DEFAULT_TEST_ACTOR,
+      ...options.actor
+    },
+    metadata: {
+      ...DEFAULT_TEST_METADATA,
+      ...options.metadata
+    },
+    data,
+    priority: options.priority,
+    aggregate: options.aggregate
+  };
+}
+/**
+ * Create a test event factory
+ *
+ * @example
+ * ```typescript
+ * const factory = createTestEventFactory({
+ *   defaultActor: { id: 'test-user', type: 'user' },
+ *   defaultMetadata: { source: 'test-service' },
+ * });
+ *
+ * const event = factory.create('TradeProposalCreated', {
+ *   tradeId: '123',
+ * });
+ * ```
+ */
+function createTestEventFactory(config) {
+  const defaultActor = {
+    ...DEFAULT_TEST_ACTOR,
+    ...config?.defaultActor
+  };
+  const defaultMetadata = {
+    ...DEFAULT_TEST_METADATA,
+    ...config?.defaultMetadata
+  };
+  return {
+    create(type, data, options = {}) {
+      return {
+        id: options.id ?? factory.generateEventId(),
+        type,
+        version: options.version ?? factory.DEFAULT_EVENT_VERSION,
+        timestamp: options.timestamp ?? new Date().toISOString(),
+        correlationId: options.correlationId ?? factory.generateCorrelationId(),
+        causationId: options.causationId,
+        actor: {
+          ...defaultActor,
+          ...options.actor
+        },
+        metadata: {
+          ...defaultMetadata,
+          ...options.metadata
+        },
+        data,
+        priority: options.priority,
+        aggregate: options.aggregate
+      };
+    },
+    createMany(type, dataArray, options = {}) {
+      const correlationId = options.correlationId ?? factory.generateCorrelationId();
+      return dataArray.map((data, index) => this.create(type, data, {
+        ...options,
+        correlationId,
+        causationId: index > 0 ? undefined : options.causationId
+      }));
+    },
+    createRandom(type, overrides = {}, options = {}) {
+      // Get random generator for this type if available
+      const generator = config?.randomGenerators?.[type];
+      const randomData = generator ? generator() : {};
+      const overrideData = overrides ? overrides : {};
+      return this.create(type, {
+        ...randomData,
+        ...overrideData
+      }, options);
+    }
+  };
+}
+
+/**
+ * Event assertions class
+ */
+class EventAssertions {
+  publishedEvents;
+  constructor(events) {
+    this.publishedEvents = events;
+  }
+  /**
+   * Assert that an event was published
+   */
+  toHavePublished(eventType) {
+    const found = this.publishedEvents.some(p => p.event.type === eventType);
+    return {
+      passed: found,
+      message: found ? `Event "${eventType}" was published` : `Expected event "${eventType}" to be published, but it was not`,
+      expected: eventType,
+      actual: this.publishedEvents.map(p => p.event.type)
+    };
+  }
+  /**
+   * Assert that an event was NOT published
+   */
+  toNotHavePublished(eventType) {
+    const found = this.publishedEvents.some(p => p.event.type === eventType);
+    return {
+      passed: !found,
+      message: !found ? `Event "${eventType}" was not published` : `Expected event "${eventType}" to NOT be published, but it was`,
+      expected: `NOT ${eventType}`,
+      actual: this.publishedEvents.map(p => p.event.type)
+    };
+  }
+  /**
+   * Assert the number of published events
+   */
+  toHavePublishedCount(count, eventType) {
+    const events = eventType ? this.publishedEvents.filter(p => p.event.type === eventType) : this.publishedEvents;
+    const actual = events.length;
+    const passed = actual === count;
+    return {
+      passed,
+      message: passed ? `Published ${count} events${eventType ? ` of type "${eventType}"` : ''}` : `Expected ${count} events${eventType ? ` of type "${eventType}"` : ''}, got ${actual}`,
+      expected: count,
+      actual
+    };
+  }
+  /**
+   * Assert event was published with specific data
+   */
+  toHavePublishedWith(eventType, predicate) {
+    const matching = this.publishedEvents.find(p => p.event.type === eventType && predicate(p.event));
+    return {
+      passed: !!matching,
+      message: matching ? `Found event "${eventType}" matching predicate` : `Expected to find event "${eventType}" matching predicate`,
+      expected: eventType,
+      actual: matching?.event
+    };
+  }
+  /**
+   * Assert events were published in order
+   */
+  toHavePublishedInOrder(eventTypes) {
+    const publishedTypes = this.publishedEvents.map(p => p.event.type);
+    let typeIndex = 0;
+    for (const publishedType of publishedTypes) {
+      if (publishedType === eventTypes[typeIndex]) {
+        typeIndex++;
+        if (typeIndex === eventTypes.length) break;
+      }
+    }
+    const passed = typeIndex === eventTypes.length;
+    return {
+      passed,
+      message: passed ? `Events published in expected order` : `Expected events in order: [${eventTypes.join(', ')}], got: [${publishedTypes.join(', ')}]`,
+      expected: eventTypes,
+      actual: publishedTypes
+    };
+  }
+  /**
+   * Assert event has valid structure
+   */
+  toBeValidEvent(event) {
+    const issues = [];
+    if (!event.id) issues.push('Missing id');
+    if (!event.type) issues.push('Missing type');
+    if (!event.timestamp) issues.push('Missing timestamp');
+    if (!event.correlationId) issues.push('Missing correlationId');
+    if (!event.version) issues.push('Missing version');
+    if (!event.actor) issues.push('Missing actor');
+    if (!event.metadata) issues.push('Missing metadata');
+    if (event.actor) {
+      if (!event.actor.id) issues.push('Missing actor.id');
+      if (!event.actor.type) issues.push('Missing actor.type');
+    }
+    if (event.metadata) {
+      if (!event.metadata.source) issues.push('Missing metadata.source');
+    }
+    const passed = issues.length === 0;
+    return {
+      passed,
+      message: passed ? 'Event has valid structure' : `Event has invalid structure: ${issues.join(', ')}`,
+      expected: 'Valid event structure',
+      actual: issues
+    };
+  }
+  /**
+   * Assert all events have same correlation ID
+   */
+  toHaveSameCorrelationId() {
+    if (this.publishedEvents.length === 0) {
+      return {
+        passed: true,
+        message: 'No events to check'
+      };
+    }
+    const correlationId = this.publishedEvents[0].event.correlationId;
+    const allMatch = this.publishedEvents.every(p => p.event.correlationId === correlationId);
+    return {
+      passed: allMatch,
+      message: allMatch ? `All events have correlation ID: ${correlationId}` : 'Events have different correlation IDs',
+      expected: correlationId,
+      actual: this.publishedEvents.map(p => p.event.correlationId)
+    };
+  }
+  /**
+   * Assert event was published to specific queue
+   */
+  toHavePublishedToQueue(eventType, queue) {
+    const matching = this.publishedEvents.find(p => p.event.type === eventType && p.queue === queue);
+    return {
+      passed: !!matching,
+      message: matching ? `Event "${eventType}" was published to queue "${queue}"` : `Expected event "${eventType}" to be published to queue "${queue}"`,
+      expected: {
+        eventType,
+        queue
+      },
+      actual: this.publishedEvents.filter(p => p.event.type === eventType).map(p => ({
+        type: p.event.type,
+        queue: p.queue
+      }))
+    };
+  }
+  /**
+   * Get all assertions as an array
+   */
+  getAllResults() {
+    return [];
+  }
+}
+/**
+ * Create event assertions helper
+ *
+ * @example
+ * ```typescript
+ * const eventBus = createMockEventBus();
+ * // ... publish events ...
+ *
+ * const assertions = createEventAssertions(eventBus.getPublishedEvents());
+ *
+ * expect(assertions.toHavePublished('TradeCreated').passed).toBe(true);
+ * expect(assertions.toHavePublishedCount(3).passed).toBe(true);
+ * expect(assertions.toHavePublishedInOrder(['TradeCreated', 'TradeAccepted']).passed).toBe(true);
+ * ```
+ */
+function createEventAssertions(events) {
+  return new EventAssertions(events);
+}
+
+/**
+ * Test Helpers - Utility functions for testing
+ *
+ * Provides:
+ * - Event waiting utilities
+ * - Mock implementations
+ * - Test fixtures
+ */
+/**
+ * Wait for an event to be published
+ *
+ * @example
+ * ```typescript
+ * const eventPromise = waitForEvent(eventBus, 'TradeCreated');
+ * await performAction();
+ * const event = await eventPromise;
+ * expect(event.data.tradeId).toBe('123');
+ * ```
+ */
+function waitForEvent(eventBus, eventType, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      unsubscribe();
+      reject(new Error(`Timeout waiting for event "${eventType}" after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const unsubscribe = eventBus.subscribe(eventType, event => {
+      clearTimeout(timeout);
+      unsubscribe();
+      resolve(event);
+    });
+  });
+}
+/**
+ * Wait for multiple events to be published
+ *
+ * @example
+ * ```typescript
+ * const eventsPromise = waitForEvents(eventBus, ['TradeCreated', 'NotificationSent']);
+ * await performAction();
+ * const events = await eventsPromise;
+ * ```
+ */
+function waitForEvents(eventBus, eventTypes, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const remaining = new Set(eventTypes);
+    const collected = [];
+    const unsubscribes = [];
+    const timeout = setTimeout(() => {
+      unsubscribes.forEach(unsub => unsub());
+      reject(new Error(`Timeout waiting for events: [${Array.from(remaining).join(', ')}] after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const checkComplete = () => {
+      if (remaining.size === 0) {
+        clearTimeout(timeout);
+        unsubscribes.forEach(unsub => unsub());
+        resolve(collected);
+      }
+    };
+    for (const eventType of eventTypes) {
+      const unsub = eventBus.subscribe(eventType, event => {
+        if (remaining.has(eventType)) {
+          remaining.delete(eventType);
+          collected.push(event);
+          checkComplete();
+        }
+      });
+      unsubscribes.push(unsub);
+    }
+  });
+}
+/**
+ * Collect events during an action
+ *
+ * @example
+ * ```typescript
+ * const events = await collectEvents(eventBus, async () => {
+ *   await createTrade();
+ *   await acceptTrade();
+ * });
+ * expect(events).toHaveLength(2);
+ * ```
+ */
+async function collectEvents(eventBus, action, eventTypes) {
+  const events = [];
+  const unsubscribe = eventBus.subscribeAll(event => {
+    if (!eventTypes || eventTypes.includes(event.type)) {
+      events.push(event);
+    }
+  });
+  try {
+    await action();
+    // Give async handlers time to complete
+    await new Promise(resolve => setTimeout(resolve, 10));
+  } finally {
+    unsubscribe();
+  }
+  return events;
+}
+/**
+ * Create a mock idempotency store
+ *
+ * @example
+ * ```typescript
+ * const store = mockIdempotencyStore({
+ *   duplicateIds: ['event-1', 'event-2'],
+ * });
+ *
+ * const result = await store.check({ id: 'event-1' }, 'consumer');
+ * expect(result.isDuplicate).toBe(true);
+ * ```
+ */
+function mockIdempotencyStore(options) {
+  const duplicateIds = new Set(options?.duplicateIds ?? []);
+  const processedRecords = options?.processedRecords ?? new Map();
+  const processingLocks = new Map();
+  return {
+    async check(event, consumer, checkOptions) {
+      const key = `${consumer}:${event.id}`;
+      if (duplicateIds.has(event.id) || processedRecords.has(key)) {
+        const record = processedRecords.get(key);
+        return {
+          isDuplicate: true,
+          processedAt: record?.completedAt ?? record?.startedAt,
+          result: record?.result
+        };
+      }
+      const shouldAcquire = options?.shouldAcquireLock ?? checkOptions?.acquireLock ?? true;
+      if (shouldAcquire) {
+        processingLocks.set(key, true);
+      }
+      return {
+        isDuplicate: false,
+        lockAcquired: shouldAcquire
+      };
+    },
+    async markProcessing(event, consumer) {
+      const key = `${consumer}:${event.id}`;
+      if (processingLocks.has(key)) {
+        return false;
+      }
+      processingLocks.set(key, true);
+      return true;
+    },
+    async markCompleted(event, consumer, result) {
+      const key = `${consumer}:${event.id}`;
+      processedRecords.set(key, {
+        eventId: event.id,
+        eventType: event.type,
+        startedAt: new Date(),
+        completedAt: new Date(),
+        status: 'completed',
+        result,
+        consumer,
+        attempts: 1
+      });
+      processingLocks.delete(key);
+    },
+    async markFailed(event, consumer, error) {
+      const key = `${consumer}:${event.id}`;
+      processedRecords.set(key, {
+        eventId: event.id,
+        eventType: event.type,
+        startedAt: new Date(),
+        completedAt: new Date(),
+        status: 'failed',
+        error: error instanceof Error ? error.message : String(error),
+        consumer,
+        attempts: 1
+      });
+      processingLocks.delete(key);
+    },
+    async releaseLock(event, consumer) {
+      const key = `${consumer}:${event.id}`;
+      processingLocks.delete(key);
+    },
+    async getRecord(eventId, consumer) {
+      return processedRecords.get(`${consumer}:${eventId}`) ?? null;
+    }
+  };
+}
+/**
+ * Create a mock error classifier
+ *
+ * @example
+ * ```typescript
+ * const classifier = mockErrorClassifier({
+ *   defaultClassification: 'transient',
+ *   customClassifications: {
+ *     'ValidationError': 'permanent',
+ *     'NetworkError': 'transient',
+ *   },
+ * });
+ * ```
+ */
+function mockErrorClassifier(options) {
+  const defaultClassification = options?.defaultClassification ?? 'unknown';
+  const customClassifications = options?.customClassifications ?? {};
+  const defaultRetryConfig = {
+    maxAttempts: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+    jitter: 0.1,
+    ...options?.retryConfig
+  };
+  return {
+    classify(error) {
+      const errorName = error instanceof Error ? error.constructor.name : 'Error';
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      // Check custom classifications
+      const customClass = customClassifications[errorName] ?? customClassifications[errorMessage];
+      const classification = customClass ?? defaultClassification;
+      return {
+        classification,
+        retryConfig: defaultRetryConfig,
+        sendToDlq: classification === 'permanent' || classification === 'poison',
+        reason: `Mock classification: ${classification}`
+      };
+    },
+    isRetryable(error) {
+      const result = this.classify(error);
+      return result.classification === 'transient' || result.classification === 'unknown';
+    }
+  };
+}
+
+exports.EventAssertions = EventAssertions;
+exports.MockEventBus = MockEventBus;
+exports.collectEvents = collectEvents;
+exports.createEventAssertions = createEventAssertions;
+exports.createMockEventBus = createMockEventBus;
+exports.createTestEvent = createTestEvent;
+exports.createTestEventFactory = createTestEventFactory;
+exports.mockErrorClassifier = mockErrorClassifier;
+exports.mockIdempotencyStore = mockIdempotencyStore;
+exports.waitForEvent = waitForEvent;
+exports.waitForEvents = waitForEvents;