@signaltree/events 7.6.0 → 8.0.0

package/dist/testing/mock-event-bus.cjs

@@ -1,301 +0,0 @@
-'use strict';
-
-var factory = require('../core/factory.cjs');
-var types = require('../core/types.cjs');
-
-/**
- * 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,
-      source: 'mock-event-bus',
-      environment: 'test',
-      ...options
-    };
-  }
-  /**
-   * Create an event with defaults (matches EventBusService.createEvent API)
-   *
-   * @example
-   * ```typescript
-   * const event = mockBus.createEvent('TradeAccepted', {
-   *   tradeId: '123',
-   *   acceptedById: 'user-1',
-   * }, {
-   *   actor: { id: 'user-1', type: 'user' },
-   * });
-   * ```
-   */
-  createEvent(type, data, options = {}) {
-    const id = options.id ?? (this.options.autoGenerateIds ? factory.generateEventId() : 'test-event-id');
-    const correlationId = options.correlationId ?? factory.generateCorrelationId();
-    const timestamp = options.timestamp ?? new Date().toISOString();
-    const actor = options.actor ?? {
-      id: 'test-user',
-      type: 'user'
-    };
-    const metadata = {
-      source: this.options.source ?? 'mock-event-bus',
-      environment: this.options.environment ?? 'test',
-      ...options.metadata
-    };
-    return {
-      id,
-      type,
-      version: options.version ?? types.DEFAULT_EVENT_VERSION,
-      timestamp,
-      correlationId,
-      causationId: options.causationId,
-      actor,
-      metadata,
-      data,
-      priority: options.priority,
-      aggregate: options.aggregate
-    };
-  }
-  /**
-   * Convenience method to create and publish an event in one call
-   * (matches EventBusService.publishEvent API)
-   *
-   * @example
-   * ```typescript
-   * await mockBus.publishEvent('TradeAccepted', {
-   *   tradeId: '123',
-   *   acceptedById: 'user-1',
-   * }, {
-   *   actor: { id: 'user-1', type: 'user' },
-   * });
-   * ```
-   */
-  async publishEvent(type, data, options = {}) {
-    const event = this.createEvent(type, data, options);
-    return this.publish(event, {
-      queue: options.queue,
-      delay: options.delay
-    });
-  }
-  /**
-   * 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);
-}
-
-exports.MockEventBus = MockEventBus;
-exports.createMockEventBus = createMockEventBus;