@cratis/chronicle 6.28.0 → 6.30.0

package/testing/ReadModelScenario.composition.spec.ts

@@ -0,0 +1,111 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { reactor } from '../reactors/reactor.js';
+import type { ReactorServices } from '../reactors/ReactorServices.js';
+import { reducer } from '../reducers/reducer.js';
+import { EventScenario, ReactorScenario, ReadModelScenario, UnsupportedProjectionOperation } from './index.js';
+
+chai.should();
+
+@eventType('composition-member-joined')
+class MemberJoined {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+@eventType('composition-member-welcomed')
+class MemberWelcomed {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+@fromEvent(MemberJoined)
+class Member {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+class MemberCount { joined = 0; }
+class MemberCountReducer {
+    memberJoined(_event: MemberJoined, current: MemberCount | undefined): MemberCount {
+        return { joined: (current?.joined ?? 0) + 1 };
+    }
+}
+reducer('composition-member-count', undefined, MemberCount)(MemberCountReducer);
+
+@fromEvent(MemberWelcomed)
+class Welcome {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+@reactor('composition-welcomer')
+class Welcomer {
+    async memberJoined(event: MemberJoined, context: { eventSourceId: string }, services: ReactorServices) {
+        await services.eventStore.eventLog.append(context.eventSourceId, new MemberWelcomed(event.name));
+        return new MemberWelcomed(`returned ${event.name}`);
+    }
+}
+
+const eventTypes = [MemberJoined, MemberWelcomed];
+const catalog = { eventTypes, reducers: [MemberCountReducer], projections: [] };
+
+describe('ReadModelScenario observing an EventScenario', () => {
+    it('projects the committed history at the time of each read', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const members = new ReadModelScenario(Member, catalog).observe(events);
+        await events.append('member-1', new MemberJoined('Ada'));
+        (await members.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        await events.appendMany('member-2', [new MemberJoined('Grace')]);
+        (await members.instanceForEventSourceId('member-2'))!.name.should.equal('Grace');
+    });
+
+    it('folds setup and action events through a reducer', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const counts = new ReadModelScenario(MemberCount, catalog).observe(events);
+        await events.given.forEventSource('club').events(new MemberJoined('Ada'));
+        await events.when.forEventSource('club').events(new MemberJoined('Grace'));
+        (await counts.instance)!.joined.should.equal(2);
+    });
+
+    it('rejects an explicitly routed event instead of guessing its projection semantics', async () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const members = new ReadModelScenario(Member, catalog).observe(events);
+        await events.appendMany([{ eventSourceId: 'member-1', event: new MemberJoined('Ada'), eventSourceType: 'Members' }]);
+        const error = await members.instanceForEventSourceId('member-1').then(() => undefined, (reason: unknown) => reason);
+        error.should.be.instanceOf(UnsupportedProjectionOperation);
+        (error as Error).message.should.contain('routed events');
+    });
+
+    it('rejects seeding events into an observing scenario', () => {
+        const members = new ReadModelScenario(Member, catalog).observe(new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' }));
+        (() => members.given.forEventSource('member-1').events(new MemberJoined('Ada'))).should.throw(UnsupportedProjectionOperation, 'not both');
+    });
+
+    it('rejects observing after seeding or observing twice', () => {
+        const events = new EventScenario({ artifacts: { eventTypes }, constraints: 'disabled' });
+        const seeded = new ReadModelScenario(Member, catalog);
+        seeded.given.forEventSource('member-1').events(new MemberJoined('Ada'));
+        (() => seeded.observe(events)).should.throw(UnsupportedProjectionOperation, 'not both');
+        const observing = new ReadModelScenario(Member, catalog).observe(events);
+        (() => observing.observe(events)).should.throw(UnsupportedProjectionOperation, 'not both');
+    });
+});
+
+describe('ReadModelScenario observing a ReactorScenario', () => {
+    it('reads input events and the reactor\'s explicit appends, but not its recorded returned effects', async () => {
+        const reactorScenario = new ReactorScenario(Welcomer, { artifacts: { eventTypes }, constraints: 'disabled' });
+        const welcomes = new ReadModelScenario(Welcome, catalog).observe(reactorScenario);
+        const members = new ReadModelScenario(Member, catalog).observe(reactorScenario);
+        await reactorScenario.when.forEventSource('member-1').events(new MemberJoined('Ada'));
+        (await members.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        (await welcomes.instanceForEventSourceId('member-1'))!.name.should.equal('Ada');
+        reactorScenario.appendedEvents.length.should.equal(2);
+        reactorScenario.shouldHaveProduced(MemberWelcomed, welcome => welcome.name === 'returned Ada');
+    });
+});

package/testing/ReadModelScenario.ts

@@ -23,6 +23,8 @@ import type { IReadModelProcessor } from './IReadModelProcessor.js';
 import type { ReadModelState } from './ReadModelState.js';
 import { ReducerReadModelProcessor } from './ReducerReadModelProcessor.js';
 import type { ScenarioEvent } from './ScenarioEvent.js';
+import type { EventScenario } from './EventScenario.js';
+import type { ReactorScenario } from './ReactorScenario.js';
 import { ProjectionReadModelProcessor } from './projections/ProjectionReadModelProcessor.js';
 import { UnsupportedProjectionOperation } from './projections/UnsupportedProjectionOperation.js';
 
@@ -39,6 +41,7 @@ export class ReadModelScenario<TReadModel extends object> {
     private readonly _modelName: string;
     private readonly _events: ScenarioEvent[] = [];
     private _results: Promise<Map<string, ReadModelState<TReadModel>>> | undefined;
+    private _observed: EventScenario | ReactorScenario | undefined;
 
     /** Selects the reducer (when present) or a single applicable compiled projection. */
     constructor(readModelType: Constructor<TReadModel>, artifacts?: ScenarioArtifacts) {
@@ -109,8 +112,20 @@ export class ReadModelScenario<TReadModel extends object> {
         return (await this.process()).get(id)?.deleted ?? false;
     }
 
+    /**
+     * Reads the committed history of an EventScenario or ReactorScenario instead of seeded events.
+     * Every read replays that shared sequence as it is at the time of the read.
+     */
+    observe(source: EventScenario | ReactorScenario): this {
+        if (this._observed || this._events.length) throw this.mixedHistory();
+        this._observed = source;
+        this._results = undefined;
+        return this;
+    }
+
     /** Collects events for a source; subsequent reads replay the complete seeded history. */
     collectEventsFor(id: string, events: readonly object[]): void {
+        if (this._observed) throw this.mixedHistory();
         for (const event of events) {
             const metadata = getEventTypeMetadata(event.constructor);
             if (!metadata) throw new Error(`Event '${event.constructor.name}' has no @eventType metadata.`);
@@ -139,13 +154,32 @@ export class ReadModelScenario<TReadModel extends object> {
     }
 
     private process(): Promise<Map<string, ReadModelState<TReadModel>>> {
-        if (!this._results) {
-            const events = [...this._events];
-            this._results = this._processor.process(events).catch(error => {
-                if (!(this._processor instanceof ProjectionReadModelProcessor) || error instanceof UnsupportedProjectionOperation) throw error;
-                throw new Error(`Projection replay for read model '${this._modelName}' failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-            });
-        }
+        if (this._observed) return this.replay(this.observedEvents(this._observed));
+        this._results ??= this.replay([...this._events]);
         return this._results;
     }
+
+    private replay(events: ScenarioEvent[]): Promise<Map<string, ReadModelState<TReadModel>>> {
+        return this._processor.process(events).catch(error => {
+            if (!(this._processor instanceof ProjectionReadModelProcessor) || error instanceof UnsupportedProjectionOperation) throw error;
+            throw new Error(`Projection replay for read model '${this._modelName}' failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        });
+    }
+
+    private observedEvents(source: EventScenario | ReactorScenario): ScenarioEvent[] {
+        return source.appendedEvents.map(event => {
+            const { eventSourceType = 'Default', eventStreamType = 'All', eventStreamId = 'Default' } = event.context;
+            // No fixture establishes how the evaluator should treat an explicitly routed event; the kernel decides.
+            if (eventSourceType !== 'Default' || eventStreamType !== 'All' || eventStreamId !== 'Default') {
+                throw new UnsupportedProjectionOperation(this._modelName, 'observe', `${eventSourceType}/${eventStreamType}/${eventStreamId}`,
+                    'observed events must use the default event source type and stream; routed events require a kernel-backed test');
+            }
+            return { sourceId: event.context.eventSourceId, content: event.content, context: event.context };
+        });
+    }
+
+    private mixedHistory(): UnsupportedProjectionOperation {
+        return new UnsupportedProjectionOperation(this._modelName, 'observe', 'given.events',
+            'a scenario replays either its own seeded events or one observed event sequence, not both');
+    }
 }