46:"/_next/static/chunks/33yus346z0l_n.js" 47:"/_next/static/chunks/1r8ezocsukqp8.js" 48:"/_next/static/chunks/0iv56yrji_20j.js" 49:"/_next/static/chunks/0wa9m1-tphf9u.js" 4a:"/_next/static/chunks/08cuqqn_f60pp.js" 4b:"/_next/static/chunks/3zdsl3f9b0--r.js" 4c:"/_next/static/chunks/2j22cxchii_xx.js" 4d:"/_next/static/chunks/3bgoyiso1rhn7.js" 4e:"/_next/static/chunks/01a-3hvnqu8wl.js" 4f:"/_next/static/chunks/3m1xjj5kw5fie.js" 50:"/_next/static/chunks/0om3fkgfnicab.js" 51:"/_next/static/chunks/0gafyzg9j9yqj.js" 52:"/_next/static/chunks/20w4eaqlekefm.js" 53:"/_next/static/chunks/449--h5z1s6nq.js" 54:"/_next/static/chunks/3k2gyg36fnag_.js" 55:"/_next/static/chunks/18ggtgz2yf759.js" 56:"/_next/static/chunks/0hlb44ca7-4a2.js" 57:"/_next/static/chunks/253gnmj0-cj17.js" 58:"/_next/static/chunks/09nq57stwzkgf.js" 59:"/_next/static/chunks/082jo-0ajazgr.js" 5a:"/_next/static/chunks/2ozcrjb_hh74t.js" 5b:"/_next/static/chunks/05i8en-x14ibi.js" 5c:"/_next/static/chunks/32izpn90gvm22.js" 5d:"/_next/static/chunks/0jbzid2v9xv3h.js" 5e:"/_next/static/chunks/0i3-eynrkvqi7.js" 5f:"/_next/static/chunks/1tn-0fivsxsv1.js" 60:"/_next/static/chunks/34h36hyf_ggow.js" 61:"/_next/static/chunks/20329i6m_04t6.js" 62:"/_next/static/chunks/161uxd62cjny2.js" 63:"/_next/static/chunks/2k8pepwc4pxns.js" 64:I[593304,["$2b","$2c","$2d","$2e","$2f","$30","$46","$47","$48","$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63"],"OwnedHydration"] 65:Ta2f,// Base class for aggregates that produce domain events abstract class AggregateRoot { private readonly _domainEvents: DomainEvent[] = []; public readonly id: TId; protected constructor(id: TId) { this.id = id; } // Subclasses call this to record an event protected addDomainEvent(event: DomainEvent): void { this._domainEvents.push(event); } // Tests and infrastructure can read collected events public getDomainEvents(): readonly DomainEvent[] { return [...this._domainEvents]; } // Called after events are persisted/published public clearDomainEvents(): void { this._domainEvents.length = 0; } } // Concrete aggregate: Order class Order extends AggregateRoot { private _status: OrderStatus; private readonly _items: OrderItem[]; private readonly _customerId: CustomerId; private _totalAmount: Money; private constructor( id: OrderId, customerId: CustomerId, items: OrderItem[], totalAmount: Money ) { super(id); this._status = OrderStatus.Pending; this._customerId = customerId; this._items = items; this._totalAmount = totalAmount; } public static create( customerId: CustomerId, items: OrderItem[] ): Order { const id = OrderId.generate(); const totalAmount = Order.calculateTotal(items); const order = new Order(id, customerId, items, totalAmount); // Raise domain event capturing all relevant data order.addDomainEvent(new OrderPlacedEvent({ orderId: id, customerId: customerId, items: items.map(item => ({ productId: item.productId, quantity: item.quantity, price: item.price, })), totalAmount: totalAmount, occurredAt: new Date(), })); return order; } public confirm(): void { if (this._status !== OrderStatus.Pending) { throw new InvalidOrderStateError( `Cannot confirm order in ${this._status} state` ); } this._status = OrderStatus.Confirmed; this.addDomainEvent(new OrderConfirmedEvent({ orderId: this.id, confirmedAt: new Date(), })); } private static calculateTotal(items: OrderItem[]): Money { return items.reduce( (sum, item) => sum.add(item.price.multiply(item.quantity)), Money.zero() ); } }66:Taef,// Base class for aggregates that produce domain events public abstract class AggregateRoot { private final List domainEvents = new ArrayList<>(); protected final TId id; protected AggregateRoot(TId id) { this.id = id; } // Subclasses call this to record an event protected void addDomainEvent(DomainEvent event) { domainEvents.add(event); } // Tests and infrastructure can read collected events public List getDomainEvents() { return Collections.unmodifiableList(new ArrayList<>(domainEvents)); } // Called after events are persisted/published public void clearDomainEvents() { domainEvents.clear(); } public TId getId() { return id; } } // Concrete aggregate: Order public class Order extends AggregateRoot { private OrderStatus status; private final List items; private final CustomerId customerId; private final Money totalAmount; private Order( OrderId id, CustomerId customerId, List items, Money totalAmount ) { super(id); this.status = OrderStatus.PENDING; this.customerId = customerId; this.items = new ArrayList<>(items); this.totalAmount = totalAmount; } public static Order create(CustomerId customerId, List items) { OrderId id = OrderId.generate(); Money totalAmount = calculateTotal(items); Order order = new Order(id, customerId, items, totalAmount); // Raise domain event capturing all relevant data order.addDomainEvent(OrderPlacedEvent.builder() .orderId(id) .customerId(customerId) .items(items.stream() .map(item -> new OrderItemData( item.getProductId(), item.getQuantity(), item.getPrice() )) .collect(Collectors.toList())) .totalAmount(totalAmount) .occurredAt(Instant.now()) .build()); return order; } public void confirm() { if (status != OrderStatus.PENDING) { throw new InvalidOrderStateException( String.format("Cannot confirm order in %s state", status) ); } status = OrderStatus.CONFIRMED; addDomainEvent(OrderConfirmedEvent.builder() .orderId(id) .confirmedAt(Instant.now()) .build()); } private static Money calculateTotal(List items) { return items.stream() .map(item -> item.getPrice().multiply(item.getQuantity())) .reduce(Money.ZERO, Money::add); } }67:Tfb3,describe('Order Event Raising', () => { describe('Order Creation', () => { it('should raise OrderPlacedEvent when order is created', () => { // Arrange const customerId = CustomerId.from('cust-123'); const items = [ OrderItem.create('prod-1', 2, Money.of(25.00)), OrderItem.create('prod-2', 1, Money.of(50.00)), ]; // Act const order = Order.create(customerId, items); // Assert - Verify event was raised const events = order.getDomainEvents(); expect(events).toHaveLength(1); expect(events[0]).toBeInstanceOf(OrderPlacedEvent); }); it('should include correct customer ID in OrderPlacedEvent', () => { // Arrange const customerId = CustomerId.from('cust-456'); const items = [OrderItem.create('prod-1', 1, Money.of(100.00))]; // Act const order = Order.create(customerId, items); // Assert - Verify event content const event = order.getDomainEvents()[0] as OrderPlacedEvent; expect(event.customerId).toEqual(customerId); }); it('should calculate and include correct total amount', () => { // Arrange const customerId = CustomerId.from('cust-789'); const items = [ OrderItem.create('prod-1', 2, Money.of(25.00)), // 50.00 OrderItem.create('prod-2', 3, Money.of(10.00)), // 30.00 ]; // Act const order = Order.create(customerId, items); // Assert const event = order.getDomainEvents()[0] as OrderPlacedEvent; expect(event.totalAmount.equals(Money.of(80.00))).toBe(true); }); it('should include all order items in event payload', () => { // Arrange const customerId = CustomerId.from('cust-999'); const items = [ OrderItem.create('prod-1', 2, Money.of(25.00)), OrderItem.create('prod-2', 1, Money.of(50.00)), OrderItem.create('prod-3', 5, Money.of(10.00)), ]; // Act const order = Order.create(customerId, items); // Assert const event = order.getDomainEvents()[0] as OrderPlacedEvent; expect(event.items).toHaveLength(3); expect(event.items[0].productId).toBe('prod-1'); expect(event.items[0].quantity).toBe(2); expect(event.items[1].productId).toBe('prod-2'); expect(event.items[2].productId).toBe('prod-3'); }); it('should assign unique order ID to event', () => { // Act - Create two orders const order1 = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))] ); const order2 = Order.create( CustomerId.from('cust-2'), [OrderItem.create('prod-2', 1, Money.of(20.00))] ); // Assert - Verify unique IDs const event1 = order1.getDomainEvents()[0] as OrderPlacedEvent; const event2 = order2.getDomainEvents()[0] as OrderPlacedEvent; expect(event1.orderId).not.toEqual(event2.orderId); }); it('should include timestamp in event', () => { // Arrange const before = new Date(); // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))] ); const after = new Date(); // Assert const event = order.getDomainEvents()[0] as OrderPlacedEvent; expect(event.occurredAt.getTime()).toBeGreaterThanOrEqual(before.getTime()); expect(event.occurredAt.getTime()).toBeLessThanOrEqual(after.getTime()); }); }); });68:Tedb,class OrderEventRaisingTest { @Nested @DisplayName("Order Creation") class OrderCreation { @Test @DisplayName("should raise OrderPlacedEvent when order is created") void shouldRaiseOrderPlacedEventWhenOrderIsCreated() { // Arrange CustomerId customerId = CustomerId.from("cust-123"); List items = List.of( OrderItem.create("prod-1", 2, Money.of(25.00)), OrderItem.create("prod-2", 1, Money.of(50.00)) ); // Act Order order = Order.create(customerId, items); // Assert - Verify event was raised List events = order.getDomainEvents(); assertThat(events).hasSize(1); assertThat(events.get(0)).isInstanceOf(OrderPlacedEvent.class); } @Test @DisplayName("should include correct customer ID in OrderPlacedEvent") void shouldIncludeCorrectCustomerId() { // Arrange CustomerId customerId = CustomerId.from("cust-456"); List items = List.of( OrderItem.create("prod-1", 1, Money.of(100.00)) ); // Act Order order = Order.create(customerId, items); // Assert - Verify event content OrderPlacedEvent event = (OrderPlacedEvent) order.getDomainEvents().get(0); assertThat(event.getCustomerId()).isEqualTo(customerId); } @Test @DisplayName("should calculate and include correct total amount") void shouldCalculateCorrectTotalAmount() { // Arrange CustomerId customerId = CustomerId.from("cust-789"); List items = List.of( OrderItem.create("prod-1", 2, Money.of(25.00)), // 50.00 OrderItem.create("prod-2", 3, Money.of(10.00)) // 30.00 ); // Act Order order = Order.create(customerId, items); // Assert OrderPlacedEvent event = (OrderPlacedEvent) order.getDomainEvents().get(0); assertThat(event.getTotalAmount()).isEqualTo(Money.of(80.00)); } @Test @DisplayName("should include all order items in event payload") void shouldIncludeAllOrderItems() { // Arrange CustomerId customerId = CustomerId.from("cust-999"); List items = List.of( OrderItem.create("prod-1", 2, Money.of(25.00)), OrderItem.create("prod-2", 1, Money.of(50.00)), OrderItem.create("prod-3", 5, Money.of(10.00)) ); // Act Order order = Order.create(customerId, items); // Assert OrderPlacedEvent event = (OrderPlacedEvent) order.getDomainEvents().get(0); assertThat(event.getItems()).hasSize(3); assertThat(event.getItems().get(0).getProductId()).isEqualTo("prod-1"); assertThat(event.getItems().get(0).getQuantity()).isEqualTo(2); } @Test @DisplayName("should include timestamp in event within expected range") void shouldIncludeTimestampInEvent() { // Arrange Instant before = Instant.now(); // Act Order order = Order.create( CustomerId.from("cust-1"), List.of(OrderItem.create("prod-1", 1, Money.of(10.00))) ); Instant after = Instant.now(); // Assert OrderPlacedEvent event = (OrderPlacedEvent) order.getDomainEvents().get(0); assertThat(event.getOccurredAt()) .isAfterOrEqualTo(before) .isBeforeOrEqualTo(after); } } }69:T144b,describe('Order Lifecycle Events', () => { describe('Complete Order Workflow', () => { it('should raise events in correct order through lifecycle', () => { // Arrange const customerId = CustomerId.from('cust-123'); const items = [OrderItem.create('prod-1', 1, Money.of(100.00))]; // Act - Complete workflow const order = Order.create(customerId, items); // Creates OrderPlacedEvent order.confirm(); // Creates OrderConfirmedEvent order.ship(TrackingNumber.from('TRACK123')); // Creates OrderShippedEvent // Assert - Verify events were raised in correct order const events = order.getDomainEvents(); expect(events).toHaveLength(3); // Verify ordering expect(events[0]).toBeInstanceOf(OrderPlacedEvent); expect(events[1]).toBeInstanceOf(OrderConfirmedEvent); expect(events[2]).toBeInstanceOf(OrderShippedEvent); }); it('should maintain event causality through order IDs', () => { // Arrange & Act const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.confirm(); order.ship(TrackingNumber.from('TRACK123')); // Assert - All events reference same order ID const events = order.getDomainEvents(); const orderId = order.id; events.forEach(event => { expect(event.orderId).toEqual(orderId); }); }); it('should include tracking number only in ShippedEvent', () => { // Arrange & Act const trackingNumber = TrackingNumber.from('TRACK456'); const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.confirm(); order.ship(trackingNumber); // Assert const events = order.getDomainEvents(); const placedEvent = events[0] as OrderPlacedEvent; const confirmedEvent = events[1] as OrderConfirmedEvent; const shippedEvent = events[2] as OrderShippedEvent; expect(placedEvent).not.toHaveProperty('trackingNumber'); expect(confirmedEvent).not.toHaveProperty('trackingNumber'); expect(shippedEvent.trackingNumber).toEqual(trackingNumber); }); }); describe('Event Timestamps', () => { it('should have non-decreasing timestamps across events', async () => { // Arrange const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); // Small delay to ensure timestamp difference await sleep(10); order.confirm(); await sleep(10); order.ship(TrackingNumber.from('TRACK123')); // Assert const events = order.getDomainEvents(); for (let i = 1; i < events.length; i++) { const prevEvent = events[i - 1]; const currEvent = events[i]; expect(currEvent.occurredAt.getTime()) .toBeGreaterThanOrEqual(prevEvent.occurredAt.getTime()); } }); }); describe('Conditional Event Raising', () => { it('should raise CancellationEvent only when order is cancellable', () => { // Arrange - Order in pending state const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.clearDomainEvents(); // Clear creation event for clarity // Act order.cancel('Customer changed mind'); // Assert const events = order.getDomainEvents(); expect(events).toHaveLength(1); expect(events[0]).toBeInstanceOf(OrderCancelledEvent); const cancelEvent = events[0] as OrderCancelledEvent; expect(cancelEvent.reason).toBe('Customer changed mind'); }); it('should not raise event when cancellation fails', () => { // Arrange - Order already shipped (not cancellable) const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.confirm(); order.ship(TrackingNumber.from('TRACK123')); order.clearDomainEvents(); // Act & Assert expect(() => order.cancel('Want to cancel')) .toThrow(InvalidOrderStateError); // Verify no event was raised on failure expect(order.getDomainEvents()).toHaveLength(0); }); }); }); // Helper function function sleep(ms: number): Promise { return new Promise(resolve => setTimeout(resolve, ms)); }6a:T1617,/** * Fluent assertion builder for domain events * Provides expressive, chainable assertions for event verification */ export class EventAssertions { constructor( private readonly events: readonly DomainEvent[], private readonly eventType: new (...args: any[]) => TEvent ) {} static forAggregate(aggregate: AggregateRoot): EventAssertionStart { return new EventAssertionStart(aggregate.getDomainEvents()); } static forEvents(events: readonly DomainEvent[]): EventAssertionStart { return new EventAssertionStart(events); } // Verify exactly one event of this type was raised wasSingleRaised(): SingleEventAssertion { const matching = this.events.filter(e => e instanceof this.eventType); if (matching.length === 0) { throw new Error( `Expected ${this.eventType.name} to be raised, but it was not. ` + `Events raised: ${this.describeEvents()}` ); } if (matching.length > 1) { throw new Error( `Expected exactly one ${this.eventType.name}, but ${matching.length} were raised` ); } return new SingleEventAssertion(matching[0] as TEvent); } // Verify at least one event of this type was raised wasRaised(): MultiEventAssertion { const matching = this.events.filter(e => e instanceof this.eventType); if (matching.length === 0) { throw new Error( `Expected ${this.eventType.name} to be raised, but it was not` ); } return new MultiEventAssertion(matching as TEvent[]); } // Verify no events of this type were raised wasNotRaised(): void { const matching = this.events.filter(e => e instanceof this.eventType); if (matching.length > 0) { throw new Error( `Expected ${this.eventType.name} NOT to be raised, but ${matching.length} were` ); } } // Verify event was raised at specific position wasRaisedAtPosition(position: number): SingleEventAssertion { const eventAtPosition = this.events[position]; if (!eventAtPosition) { throw new Error(`No event at position ${position}`); } if (!(eventAtPosition instanceof this.eventType)) { throw new Error( `Expected ${this.eventType.name} at position ${position}, ` + `but found ${eventAtPosition.constructor.name}` ); } return new SingleEventAssertion(eventAtPosition as TEvent); } private describeEvents(): string { if (this.events.length === 0) return 'none'; return this.events.map(e => e.constructor.name).join(', '); } } export class EventAssertionStart { constructor(private readonly events: readonly DomainEvent[]) {} expectEvent( eventType: new (...args: any[]) => TEvent ): EventAssertions { return new EventAssertions(this.events, eventType); } expectNoEvents(): void { if (this.events.length > 0) { throw new Error( `Expected no events, but ${this.events.length} were raised` ); } } expectExactlyNEvents(n: number): void { if (this.events.length !== n) { throw new Error( `Expected exactly ${n} events, but ${this.events.length} were raised` ); } } } export class SingleEventAssertion { constructor(private readonly event: TEvent) {} // Access the event for detailed assertions get(): TEvent { return this.event; } // Verify event properties with predicate satisfies(predicate: (event: TEvent) => boolean, message?: string): this { if (!predicate(this.event)) { throw new Error(message || 'Event did not satisfy predicate'); } return this; } // Verify specific property value hasProperty( key: K, expectedValue: TEvent[K] ): this { const actualValue = this.event[key]; if (!deepEquals(actualValue, expectedValue)) { throw new Error( `Expected ${String(key)} to be ${JSON.stringify(expectedValue)}, ` + `but was ${JSON.stringify(actualValue)}` ); } return this; } } export class MultiEventAssertion { constructor(private readonly events: TEvent[]) {} // Get count of matching events withCount(expectedCount: number): this { if (this.events.length !== expectedCount) { throw new Error( `Expected ${expectedCount} events, but found ${this.events.length}` ); } return this; } // Get all matching events getAll(): TEvent[] { return [...this.events]; } // Get first matching event first(): SingleEventAssertion { return new SingleEventAssertion(this.events[0]); } // Verify all events satisfy predicate allSatisfy(predicate: (event: TEvent) => boolean): this { this.events.forEach((event, index) => { if (!predicate(event)) { throw new Error(`Event at index ${index} did not satisfy predicate`); } }); return this; } }6b:T7bd,describe('Order Events with Custom Assertions', () => { it('should raise OrderPlacedEvent with correct data', () => { // Arrange const customerId = CustomerId.from('cust-123'); const items = [OrderItem.create('prod-1', 2, Money.of(50.00))]; // Act const order = Order.create(customerId, items); // Assert - Clean, expressive assertions EventAssertions.forAggregate(order) .expectEvent(OrderPlacedEvent) .wasSingleRaised() .hasProperty('customerId', customerId) .satisfies( e => e.totalAmount.equals(Money.of(100.00)), 'Total should be calculated correctly' ); }); it('should raise events in correct order', () => { // Arrange & Act const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.confirm(); order.ship(TrackingNumber.from('TRACK123')); // Assert const assertions = EventAssertions.forAggregate(order); assertions.expectEvent(OrderPlacedEvent).wasRaisedAtPosition(0); assertions.expectEvent(OrderConfirmedEvent).wasRaisedAtPosition(1); assertions.expectEvent(OrderShippedEvent).wasRaisedAtPosition(2); assertions.expectExactlyNEvents(3); }); it('should not raise cancellation event for shipped orders', () => { // Arrange const order = Order.create( CustomerId.from('cust-123'), [OrderItem.create('prod-1', 1, Money.of(100.00))] ); order.confirm(); order.ship(TrackingNumber.from('TRACK123')); order.clearDomainEvents(); // Act expect(() => order.cancel('Changed mind')).toThrow(); // Assert EventAssertions.forAggregate(order) .expectEvent(OrderCancelledEvent) .wasNotRaised(); }); });6c:T110a,describe('Event Metadata', () => { describe('Event ID', () => { it('should generate unique event ID for each event', () => { // Generate many events const events: OrderPlacedEvent[] = []; for (let i = 0; i < 100; i++) { const order = Order.create( CustomerId.from(`cust-${i}`), [OrderItem.create('prod-1', 1, Money.of(10.00))] ); events.push(order.getDomainEvents()[0] as OrderPlacedEvent); } // Verify all IDs are unique const eventIds = events.map(e => e.eventId); const uniqueIds = new Set(eventIds); expect(uniqueIds.size).toBe(events.length); }); it('should generate valid UUID format for event ID', () => { // Arrange & Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))] ); const event = order.getDomainEvents()[0]; // Assert const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; expect(event.eventId).toMatch(uuidRegex); }); }); describe('Correlation ID Propagation', () => { it('should propagate correlation ID from command context', () => { // Arrange const correlationId = CorrelationId.from('req-12345'); const context = CommandContext.with({ correlationId }); // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))], context ); // Assert const event = order.getDomainEvents()[0]; expect(event.correlationId).toEqual(correlationId); }); it('should maintain same correlation ID across multiple events', () => { // Arrange const correlationId = CorrelationId.from('req-99999'); const context = CommandContext.with({ correlationId }); // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))], context ); order.confirm(context); // Assert const events = order.getDomainEvents(); events.forEach(event => { expect(event.correlationId).toEqual(correlationId); }); }); }); describe('Causation Tracking', () => { it('should set causation ID to command ID that triggered event', () => { // Arrange const commandId = CommandId.from('cmd-place-order-123'); const context = CommandContext.with({ commandId }); // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))], context ); // Assert const event = order.getDomainEvents()[0]; expect(event.causationId).toEqual(commandId); }); }); describe('Event Versioning', () => { it('should include schema version for OrderPlacedEvent', () => { // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))] ); // Assert const event = order.getDomainEvents()[0] as OrderPlacedEvent; expect(event.version).toBe(1); // Current schema version }); }); describe('User Context', () => { it('should capture authenticated user ID in event', () => { // Arrange const userId = UserId.from('user-admin-42'); const context = CommandContext.with({ userId }); // Act const order = Order.create( CustomerId.from('cust-1'), [OrderItem.create('prod-1', 1, Money.of(10.00))], context ); // Assert const event = order.getDomainEvents()[0]; expect(event.triggeredBy).toEqual(userId); }); }); });45:["$","$L64",null,{"owner":"anonymous","state":{"mutations":[],"queries":[{"dehydratedAt":1792317892347,"state":{"data":{"json":{"id":"seed_d0c0fd22127045c82855a63d5a1f3747","slug":"testing-event-driven-designs","category":"System Design (LLD)","topic":"Testing Event-Driven Designs","title":"Testing Event-Driven Designs","description":"Master the art of testing event-driven systems. Learn comprehensive strategies for verifying event raising, testing event handlers, integration testing with events, and debugging complex event flows. This module equips you with the techniques used by elite engineers to ensure reliability in asynchronous, loosely coupled architectures.","difficulty":"INTERMEDIATE","estimatedMinutes":90,"pages":[{"id":"seed_58d841b8fa62b59fa9a52f5e82d71f04","title":"Testing Event Raising","order":0,"content":[{"id":"opening-hook","title":"The Invisible Verification Challenge","content":[{"data":{"content":"Event-driven systems present a fundamentally different testing challenge than traditional request-response architectures. When a user places an order, how do you verify that the system correctly raised an `OrderPlaced` event? The event disappears into an event bus, potentially triggering dozens of downstream handlers. There's no return value to assert against, no immediate response to validate.\n\n**This invisibility is the core challenge of testing event-driven designs.** Unlike testing a function that returns a value, testing events requires verifying that *something was published*—and that what was published contains exactly the right data, at exactly the right time, under exactly the right conditions."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will master: (1) Why event raising requires specialized testing strategies, (2) How to intercept and verify events without coupling tests to infrastructure, (3) Patterns for asserting event content, timing, and ordering, (4) Anti-patterns that make event testing brittle and unmaintainable, and (5) Real-world techniques used by Principal Engineers at companies like Stripe, Netflix, and Uber.","variant":"info"},"type":"callout"}]},{"id":"why-special-testing","title":"Why Event Raising Needs Special Testing","content":[{"data":{"content":"In synchronous, procedural code, testing is relatively straightforward. You call a function, receive a return value, and assert that the return value matches expectations:\n\n```typescript\nconst result = calculator.add(2, 3);\nexpect(result).toBe(5); // Simple, direct verification\n```\n\nBut event-driven code breaks this mental model. When an aggregate raises an event, that event doesn't \"return\" anything. The aggregate's responsibility ends at *publishing* the event; what happens next is entirely in the hands of other components."},"type":"text"},{"data":{"items":["**No Return Value** — Events are fire-and-forget from the producer's perspective. There's nothing to assert against unless you capture the event.","**Side Effect, Not Function** — Raising an event is a side effect, not a computation. You must verify that the side effect occurred.","**Temporal Coupling** — Events may be raised at specific points in a workflow. Testing timing matters.","**Content Accuracy** — The event payload must contain exactly the right data. Incomplete events cause downstream failures.","**Infrastructure Entanglement** — Events often flow through message brokers, buses, or queues. Tests shouldn't depend on this infrastructure."],"title":{"icon":"AlertCircle","text":"The Unique Challenges of Testing Event Raising","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"content":"**The fundamental insight:**\n\nTesting event raising requires *observability*—the ability to see what events were raised without actually sending them through production infrastructure. This observability must be built into your architecture, not bolted on as an afterthought.\n\nThe techniques we'll explore make event raising verifiable while keeping tests fast, isolated, and deterministic."},"type":"text"},{"data":{"icon":"Lightbulb","title":"A Principal Engineer's Perspective","content":"At Netflix, Uber, and similar scale, untested event raising causes cascading failures. An order event missing a customer ID propagates through fulfillment, notifications, analytics, and billing—each system failing in its own way. We don't test event raising for academic purity; we test it because production failures from incorrect events are extraordinarily expensive to debug.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"event-capturing-pattern","title":"The Event Capturing Pattern","content":[{"data":{"content":"The most powerful technique for testing event raising is **event capturing**—intercepting events before they reach production infrastructure and storing them for assertion. This pattern allows tests to verify:\n\n1. *What* events were raised\n2. *How many* events were raised\n3. *What data* each event contains\n4. *In what order* events occurred\n\nLet's examine multiple implementations of this pattern, from simple to sophisticated."},"type":"text"},{"data":{"content":"### Approach 1: Collecting Domain Events on Aggregates\n\nIn Domain-Driven Design (DDD), aggregates are natural event producers. A common pattern is to have aggregates collect their events internally, allowing tests to inspect them after operations complete."},"type":"text"},{"data":{"fileName":"aggregate-with-events.ts","languages":[{"code":"$65","label":"TypeScript","value":"typescript"},{"code":"$66","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Lightbulb","title":"Why Collect Events on Aggregates?","content":"Collecting events on the aggregate itself (rather than immediately publishing) has multiple benefits: (1) Events can be inspected in tests without mocking, (2) The repository can publish events atomically with persistence, (3) Failed persistence doesn't result in orphaned events, and (4) The aggregate remains a pure domain object with no infrastructure dependencies.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"writing-event-raising-tests","title":"Writing Tests for Event Raising","content":[{"data":{"content":"With the event capturing pattern in place, writing tests becomes straightforward. Let's examine comprehensive test strategies that cover the full spectrum of event verification."},"type":"text"},{"data":{"content":"### Testing That an Event Was Raised\n\nThe most basic assertion: verify that performing an action resulted in the expected event being produced."},"type":"text"},{"data":{"fileName":"order-event-tests.spec.ts","languages":[{"code":"$67","label":"TypeScript","value":"typescript"},{"code":"$68","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Info","title":"Test Granularity Matters","content":"Notice how each test verifies one specific aspect of the event. This granularity is intentional: when a test fails, you immediately know *what* is broken. A single test asserting everything would tell you 'something is wrong' without pinpointing the issue.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"testing-multiple-events","title":"Testing Multiple Events and Ordering","content":[{"data":{"content":"Real-world aggregates often raise multiple events during their lifecycle. A complex operation might produce several events in a specific order. Testing this ordering is critical when downstream handlers depend on processing events sequentially."},"type":"text"},{"data":{"fileName":"multi-event-tests.spec.ts","languages":[{"code":"$69","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"Critical: Events Should Not Be Raised on Failure","content":"When an operation fails (throws an exception or returns an error), no event should be raised. Events represent facts that happened—if the operation didn't complete successfully, there's no fact to record. The test 'should not raise event when cancellation fails' verifies this crucial invariant.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"custom-assertions","title":"Custom Assertions and Test Utilities","content":[{"data":{"content":"As your event testing matures, you'll find yourself writing the same assertion patterns repeatedly. Custom assertions and test utilities dramatically improve test readability and reduce boilerplate."},"type":"text"},{"data":{"fileName":"event-test-utilities.ts","languages":[{"code":"$6a","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"content":"### Using Custom Assertions in Tests\n\nWith these utilities, tests become dramatically more expressive:"},"type":"text"},{"data":{"fileName":"tests-with-utilities.spec.ts","languages":[{"code":"$6b","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"Sparkles","title":"Test Utility Investment","content":"Building custom test utilities like EventAssertions requires upfront investment, but pays dividends across hundreds of tests. The improved readability also serves as documentation—new team members can understand what's being verified without deep domain knowledge.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"testing-event-metadata","title":"Testing Event Metadata","content":[{"data":{"content":"Beyond the primary payload, events carry metadata essential for tracing, auditing, and debugging. This metadata must also be tested to ensure observability in production."},"type":"text"},{"data":{"rows":[["eventId","Unique identifier for deduplication and tracing","Must be globally unique (UUID); verify format"],["occurredAt","When the event happened","Should be close to 'now'; verify not null"],["correlationId","Links related events across systems","Should propagate from incoming request or be generated"],["causationId","ID of command/event that caused this event","Enables event chain reconstruction"],["userId","Who triggered the action","Must match authenticated user"],["version","Schema version for compatibility","Supports event evolution; verify against expected version"]],"caption":"Common Event Metadata Fields","headers":["Field","Purpose","Testing Considerations"]},"type":"table"},{"data":{"fileName":"event-metadata-tests.spec.ts","languages":[{"code":"$6c","label":"TypeScript","value":"typescript"}]},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"anti-patterns","title":"Anti-Patterns to Avoid","content":[{"data":{"content":"Event testing can go wrong in subtle ways. Let's examine common anti-patterns and their consequences."},"type":"text"},{"data":{"left":[{"data":{"items":["Publishing to real message broker in unit tests","Subscribing and waiting for events in assertions","Tests that require running RabbitMQ/Kafka/etc.","Slow, flaky tests due to network dependencies","Tests that pass locally but fail in CI"],"title":{"icon":"XCircle","text":"Anti-Pattern: Testing Infrastructure","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"}],"right":[{"data":{"items":["Collect events on aggregate, assert in-memory","Infrastructure tested separately (integration tests)","Unit tests run in milliseconds without dependencies","Deterministic, never flaky","Same behavior in any environment"],"title":{"icon":"CheckCircle","text":"Pattern: Test Behavior, Not Wiring","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"}]},"type":"two-column"},{"data":{"left":[{"data":{"items":["Only checking that 'an event' was raised","Not verifying event type","Not verifying event payload","Missing edge case coverage","Hollow tests that pass but prove nothing"],"title":{"icon":"XCircle","text":"Anti-Pattern: Incomplete Assertions","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"}],"right":[{"data":{"items":["Assert exact event type","Verify critical payload fields","Test boundary conditions","Test failure scenarios (no event on error)","Tests document expected behavior precisely"],"title":{"icon":"CheckCircle","text":"Pattern: Comprehensive Verification","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"}]},"type":"two-column"},{"data":{"icon":"AlertCircle","title":"The Worst Anti-Pattern: No Tests At All","content":"Surprisingly common, especially with events. 'The event just gets published, what's to test?' But events are contracts with consumers. An untested event is a liability—you'll discover missing fields or wrong data types when production handlers fail.","variant":"error"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: Mastering Event Raising Tests","content":[{"data":{"content":"Testing event raising is foundational to reliable event-driven systems. Let's consolidate the key principles:"},"type":"text"},{"data":{"type":"ordered","items":["**Use the Event Capturing Pattern** — Collect events on aggregates for in-memory assertion without infrastructure dependencies.","**Test One Aspect Per Test** — Granular tests pinpoint failures precisely; verify type, payload, ordering, and metadata separately.","**Build Custom Assertions** — Invest in fluent assertion utilities that improve readability and reduce boilerplate across your test suite.","**Verify Failure Scenarios** — Ensure no events are raised when operations fail; this prevents downstream systems from processing invalid state.","**Test Metadata Rigorously** — Event IDs, timestamps, correlation IDs, and versioning are critical for production observability.","**Avoid Infrastructure Coupling** — Unit tests should never require message brokers; save that for integration tests."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that we've mastered testing event *raising*, the next page explores the other side of the coin: testing event *handling*. We'll examine how to verify that handlers process events correctly, handle errors gracefully, and maintain idempotency under duplicate delivery."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now possess the techniques to verify that your event-driven components raise the right events, with the right data, at the right times. These skills form the bedrock of trustworthy asynchronous systems. Next, we'll tackle the equally important challenge of testing event consumption.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_ba5240417e07b6161d5fc09872ec5132","title":"Testing Event Handling","order":1,"content":null,"isLocked":true},{"id":"seed_a2f6320d44153e92981d12c3a51d61e2","title":"Integration Testing with Events","order":2,"content":null,"isLocked":true},{"id":"seed_88ca68557d79cb60894ca2af259fbcb9","title":"Event Debugging","order":3,"content":null,"isLocked":true}]}},"dataUpdateCount":1,"dataUpdatedAt":1792317892339,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getModule"],{"input":{"slug":"testing-event-driven-designs"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getModule\"],{\"input\":{\"slug\":\"testing-event-driven-designs\"},\"type\":\"query\"}]"},{"dehydratedAt":1792317892348,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792317892345,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getProgress"],{"input":{"moduleId":"seed_d0c0fd22127045c82855a63d5a1f3747"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getProgress\"],{\"input\":{\"moduleId\":\"seed_d0c0fd22127045c82855a63d5a1f3747\"},\"type\":\"query\"}]"},{"dehydratedAt":1792317892348,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792317892347,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","get"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ba5240417e07b6161d5fc09872ec5132"},"type":"query"}],"queryHash":"[[\"feedback\",\"get\"],{\"input\":{\"contentId\":\"seed_ba5240417e07b6161d5fc09872ec5132\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792317892348,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792317892347,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","getUserLike"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ba5240417e07b6161d5fc09872ec5132"},"type":"query"}],"queryHash":"[[\"feedback\",\"getUserLike\"],{\"input\":{\"contentId\":\"seed_ba5240417e07b6161d5fc09872ec5132\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792317892348,"state":{"data":{"json":[]},"dataUpdateCount":1,"dataUpdatedAt":1792317892347,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["highlights","getHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ba5240417e07b6161d5fc09872ec5132"},"type":"query"}],"queryHash":"[[\"highlights\",\"getHighlights\"],{\"input\":{\"contentId\":\"seed_ba5240417e07b6161d5fc09872ec5132\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792317892348,"state":{"data":"$undefined","dataUpdateCount":0,"dataUpdatedAt":0,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"pending","fetchStatus":"fetching"},"queryKey":[["highlights","getPopularHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_ba5240417e07b6161d5fc09872ec5132","minCount":2},"type":"query"}],"queryHash":"[[\"highlights\",\"getPopularHighlights\"],{\"input\":{\"contentId\":\"seed_ba5240417e07b6161d5fc09872ec5132\",\"contentType\":\"LEARNING_PAGE\",\"minCount\":2},\"type\":\"query\"}]","promise":"$@6d"}]},"children":"$L6e"}]