@signaltree/events 7.3.6 → 7.4.1

package/dist/testing/assertions.cjs

@@ -0,0 +1,172 @@
+'use strict';
+
+/**
+ * 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);
+}
+
+exports.EventAssertions = EventAssertions;
+exports.createEventAssertions = createEventAssertions;

package/dist/testing/assertions.js

@@ -0,0 +1,169 @@
+/**
+ * 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);
+}
+
+export { EventAssertions, createEventAssertions };

package/dist/testing/factories.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+var factory = require('../core/factory.cjs');
+var types = require('../core/types.cjs');
+
+/**
+ * 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 ?? types.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 ?? types.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);
+    }
+  };
+}
+
+exports.createTestEvent = createTestEvent;
+exports.createTestEventFactory = createTestEventFactory;

package/dist/testing/factories.js

@@ -0,0 +1,119 @@
+import { generateCorrelationId, generateEventId } from '../core/factory.js';
+import { DEFAULT_EVENT_VERSION } from '../core/types.js';
+
+/**
+ * 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 ?? generateEventId(),
+    type,
+    version: options.version ?? DEFAULT_EVENT_VERSION,
+    timestamp: options.timestamp ?? new Date().toISOString(),
+    correlationId: options.correlationId ?? 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 ?? generateEventId(),
+        type,
+        version: options.version ?? DEFAULT_EVENT_VERSION,
+        timestamp: options.timestamp ?? new Date().toISOString(),
+        correlationId: options.correlationId ?? 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 ?? 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);
+    }
+  };
+}
+
+export { createTestEvent, createTestEventFactory };