Class TestHelpers

Test helpers for common testing patterns in Stratix applications.

Provides utilities to simplify test setup, entity creation, and event testing.

Example

describe('ProductService', () => {
  it('should create product and emit event', async () => {
    const { bus, events } = TestHelpers.createEventBusCapture();
    const handler = new CreateProductHandler(mockRepo, bus);
    
    await handler.handle(new CreateProductCommand('Product', 100));
    
    const event = await TestHelpers.waitForEvent(bus, ProductCreatedEvent);
    expect(event).toBeDefined();
  });
});

Constructors

constructor

Methods

createEntity createCommandBus createQueryBus createEventBusCapture waitForEvent createEventBusSpy

Constructors

constructor

Methods

StaticcreateEntity

  • createEntity<TEntity extends Entity<string>, TProps>(
        EntityClass: new (
            id: EntityId<string>,
            props: TProps,
            createdAt: Date,
            updatedAt: Date,
        ) => TEntity,
        id: string | EntityId<string>,
        props: TProps,
        timestamps?: { createdAt?: Date; updatedAt?: Date },
    ): TEntity

    Creates an entity with minimal boilerplate for testing.

    Type Parameters

    • TEntity extends Entity<string>
    • TProps

    Parameters

    • EntityClass: new (
          id: EntityId<string>,
          props: TProps,
          createdAt: Date,
          updatedAt: Date,
      ) => TEntity

      The entity class to instantiate

    • id: string | EntityId<string>

      Entity ID (string or EntityId)

    • props: TProps

      Entity properties

    • Optionaltimestamps: { createdAt?: Date; updatedAt?: Date }

      Optional timestamps (defaults to now)

    Returns TEntity

    The created entity

    Example

    const product = TestHelpers.createEntity(
      Product,
      'product-123',
      { name: 'Test Product', price: 100 }
    );

StaticcreateCommandBus

  • createCommandBus(): CommandBus

    Creates an in-memory command bus for testing.

    Returns CommandBus

    A new InMemoryCommandBus instance

    Example

    const commandBus = TestHelpers.createCommandBus();
    commandBus.register(CreateProductCommand, new CreateProductHandler(repo));
    await commandBus.execute(new CreateProductCommand('Product', 100));

StaticcreateQueryBus

  • createQueryBus(): QueryBus

    Creates an in-memory query bus for testing.

    Returns QueryBus

    A new InMemoryQueryBus instance

    Example

    const queryBus = TestHelpers.createQueryBus();
    queryBus.register(GetProductQuery, new GetProductHandler(repo));
    const product = await queryBus.execute(new GetProductQuery('product-id'));

StaticcreateEventBusCapture

  • createEventBusCapture(): { bus: EventBus; events: Event[] }

    Creates an event bus that captures all published events.

    Useful for asserting that specific events were published during a test.

    Returns { bus: EventBus; events: Event[] }

    Object with the event bus and array of captured events

    Example

    const { bus, events } = TestHelpers.createEventBusCapture();

    await handler.handle(command);

    expect(events).toHaveLength(1);
    expect(events[0]).toBeInstanceOf(ProductCreatedEvent);

StaticwaitForEvent

  • waitForEvent<TEvent extends Event>(
        bus: EventBus,
        EventType: new (...args: any[]) => TEvent,
        timeoutMs?: number,
    ): Promise<null | TEvent>

    Waits for a specific event type to be published on an event bus.

    Useful for async event testing where you need to wait for an event before making assertions.

    Type Parameters

    • TEvent extends Event

    Parameters

    • bus: EventBus

      The event bus to monitor

    • EventType: new (...args: any[]) => TEvent

      The event class to wait for

    • timeoutMs: number = 5000

      Maximum time to wait in milliseconds (default: 5000)

    Returns Promise<null | TEvent>

    Promise that resolves with the event or null if timeout

    Example

    const bus = new InMemoryEventBus();

    // Trigger async operation that will publish event
    handler.handle(command);

    const event = await TestHelpers.waitForEvent(bus, ProductCreatedEvent);
    expect(event.productId).toBe('product-123');

StaticcreateEventBusSpy

  • createEventBusSpy(): { bus: EventBus; events: Event[] }

    Creates a spy/mock event bus that tracks all published events.

    Different from createEventBusCapture in that it doesn't actually publish events to handlers, just captures them for inspection.

    Returns { bus: EventBus; events: Event[] }

    Object with the mock bus and captured events

    Example

    const { bus, events } = TestHelpers.createEventBusSpy();

    await service.createProduct(data); // This publishes events

    expect(events).toContainEqual(expect.objectContaining({
      type: 'ProductCreated'
    }));

Settings

Member Visibility

On This Page

Constructors
Methods