@cratis/chronicle 6.46.0 → 6.48.0

package/testing/ReactorScenario.ts

@@ -13,6 +13,8 @@ import type { AppendedEvent } from '../events/AppendedEvent.js';
 import type { EventContext } from '../events/EventContext.js';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
 import { getFilterTagsFor } from '../events/filterEventsByTagDecorator.js';
+import { getEventSourceTypeFor } from '../events/eventSourceTypeDecorator.js';
+import { getDeclaredEventStreamTypeFor, getEventStreamTypeFor } from '../events/eventStreamTypeDecorator.js';
 import type { IEventLog } from '../eventSequences/IEventLog.js';
 import type { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
 import type { AppendOptions } from '../eventSequences/AppendOptions.js';
@@ -63,6 +65,12 @@ export class ReactorScenario {
         if (getFilterTagsFor(_reactor).length) {
             throw new UnsupportedReactorOperation('reactor.filterEventsByTag', _reactor.name, 'Tag-filtered delivery is not fixture-backed.');
         }
+        if (getEventSourceTypeFor(_reactor) !== '') {
+            throw new UnsupportedReactorOperation('reactor.eventSourceType', _reactor.name, 'Source-type-filtered delivery is not fixture-backed.');
+        }
+        if (getEventStreamTypeFor(_reactor) !== 'All') {
+            throw new UnsupportedReactorOperation('reactor.eventStreamType', _reactor.name, 'Stream-type-filtered delivery is not fixture-backed.');
+        }
         if (_options.commandTypes?.length) {
             throw new UnsupportedReactorOperation('options.commandTypes', _reactor.name, 'Command classification belongs to the explicit-composition increment.');
         }
@@ -97,6 +105,7 @@ export class ReactorScenario {
             'getSnapshotsById', 'dehydrateSession', 'release', 'releaseMany']);
         const readModels = new Proxy({}, { get: (_, key) => {
             if (key === 'watch') return async function* () { unsupported('readModels.watch'); };
+            if (key === 'createWatcher') return () => unsupported('readModels.createWatcher');
             if (key === 'materialized') return unsupported('readModels.materialized');
             if (typeof key !== 'string' || !readModelMethods.has(key)) return undefined;
             return async () => unsupported(`readModels.${key}`);
@@ -282,7 +291,8 @@ export class ReactorScenario {
         if (result == null) return;
         const items = Array.isArray(result) ? result : [result];
         const events = normalizeReactorSideEffects(result, context.eventSourceId,
-            context.eventStreamType ?? 'Default', context.eventStreamId ?? context.eventSourceId);
+            context.eventStreamType ?? 'Default', context.eventStreamId ?? context.eventSourceId,
+            getEventSourceTypeFor(this._reactor), getDeclaredEventStreamTypeFor(this._reactor));
         if (items.length !== events.length || events.some(entry => !this._eventTypes.includes(entry.event.constructor as Constructor))) {
             throw new UnsupportedReactorOperation('handler.return', this._reactor.name,
                 'Only registered events and production EventForEventSourceId wrappers may be recorded; commands and unknown values are unsupported.');

package/testing/ReducerReadModelProcessor.ts

@@ -3,6 +3,10 @@
 
 import type { Constructor } from '@cratis/fundamentals';
 import { ReducerEventDispatcher } from '../reducers/ReducerEventDispatcher.js';
+import { getEventSourceTypeFor } from '../events/eventSourceTypeDecorator.js';
+import { getEventStreamTypeFor } from '../events/eventStreamTypeDecorator.js';
+import { getFilterTagsFor } from '../events/filterEventsByTagDecorator.js';
+import { UnsupportedReducerOperation } from './UnsupportedReducerOperation.js';
 import type { IReadModelProcessor } from './IReadModelProcessor.js';
 import type { ReadModelState } from './ReadModelState.js';
 import type { ScenarioEvent } from './ScenarioEvent.js';
@@ -12,6 +16,15 @@ export class ReducerReadModelProcessor<TReadModel extends object> implements IRe
     private readonly _dispatcher: ReducerEventDispatcher;
 
     constructor(private readonly _readModelType: Constructor<TReadModel>, private readonly _reducerType: Constructor, eventTypes: Constructor[]) {
+        if (getFilterTagsFor(_reducerType).length) {
+            throw new UnsupportedReducerOperation('reducer.filterEventsByTag', _reducerType.name, 'Tag-filtered delivery is not fixture-backed.');
+        }
+        if (getEventSourceTypeFor(_reducerType) !== '') {
+            throw new UnsupportedReducerOperation('reducer.eventSourceType', _reducerType.name, 'Source-type-filtered delivery is not fixture-backed.');
+        }
+        if (getEventStreamTypeFor(_reducerType) !== 'All') {
+            throw new UnsupportedReducerOperation('reducer.eventStreamType', _reducerType.name, 'Stream-type-filtered delivery is not fixture-backed.');
+        }
         this._dispatcher = new ReducerEventDispatcher(_reducerType, eventTypes);
     }
 

package/testing/UnsupportedReducerOperation.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** An operation whose kernel/observer semantics have not been established for this scenario. */
+export class UnsupportedReducerOperation extends Error {
+    constructor(readonly operation: string, readonly artifact: string, reason: string) {
+        super(`Unsupported reducer operation '${operation}' for '${artifact}': ${reason} Use a kernel-backed test.`);
+        this.name = 'UnsupportedReducerOperation';
+    }
+}

package/testing/for_ReactorScenario/when_recording_side_effects/with_declared_stream_type.spec.ts

@@ -0,0 +1,50 @@
+// 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 { beforeEach, chai, describe, it, vi } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { eventStreamType } from '../../../events/eventStreamTypeDecorator.js';
+import type { EventForEventSourceId } from '../../../eventSequences/EventForEventSourceId.js';
+import type { IEventLog } from '../../../eventSequences/IEventLog.js';
+import { reactor } from '../../../reactors/reactor.js';
+import { dispatchReactorSideEffects } from '../../../reactors/ReactorSideEffects.js';
+import { ReactorScenario } from '../../ReactorScenario.js';
+
+chai.should();
+@eventType('scenario-type-side-effect-input')
+class Input { @field(String) name = 'input'; }
+@eventType('scenario-type-side-effect-output')
+class Outbound { @field(String) name = 'output'; }
+const bare = new Outbound();
+const explicit = { eventSourceId: 'other', event: new Outbound(), eventSourceType: 'explicit-source', eventStreamType: 'explicit-stream' };
+const omitted = { eventSourceId: 'omitted', event: new Outbound() };
+
+@reactor('scenario-type-side-effects')
+@eventStreamType('All')
+class AllStreamsReactor { input() { return [bare, explicit, omitted]; } }
+
+// Non-default filters still require kernel-backed delivery. An explicit unrestricted stream
+// decorator exercises declared side-effect metadata without pretending to implement filtering.
+describe('when recording side effects with an explicit unrestricted stream decorator', () => {
+    let scenario: ReactorScenario;
+    let appended: EventForEventSourceId[];
+    beforeEach(async () => {
+        scenario = new ReactorScenario(AllStreamsReactor, { artifacts: { eventTypes: [Input, Outbound] }, constraints: 'disabled' });
+        await scenario.when.forEventSource('trigger').events(new Input());
+        const eventLog = { appendMany: vi.fn(async (events: EventForEventSourceId[]) => {
+            appended = events;
+            return [{ isSuccess: true, errors: [], constraintViolations: [] }];
+        }) } as unknown as IEventLog;
+        await dispatchReactorSideEffects(eventLog, [bare, explicit, omitted], scenario.sideEffects[0].triggeringContext,
+            AllStreamsReactor, 'store', 'namespace');
+    });
+    it('should record the same target metadata as production dispatch', () => {
+        scenario.sideEffects.map(effect => effect.target).should.deep.equal(appended);
+        scenario.sideEffects[0].target.eventStreamType!.should.equal('All');
+    });
+    it('should preserve explicitly targeted events instead of inheriting reactor metadata', () => {
+        scenario.sideEffects[1].target.should.equal(explicit);
+        scenario.sideEffects[2].target.should.equal(omitted);
+    });
+});

package/testing/for_observerScenarios/when_selecting_filters/with_reducer_tag_filters.spec.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { filterEventsByTag, reducer, tag } from '../../../index.js';
+import { ReadModelScenario, UnsupportedReducerOperation } from '../../index.js';
+
+chai.should();
+class State { count = 0; }
+let created = false;
+@reducer('tag-filtered-scenario', undefined, State)
+@filterEventsByTag('vip')
+class TagFiltered {
+    constructor() { created = true; }
+}
+class InheritedTagFiltered extends TagFiltered {}
+@reducer('label-only-scenario', undefined, State)
+@tag('vip')
+class Labeled {}
+@reducer('empty-tag-filter-scenario', undefined, State)
+@filterEventsByTag('')
+class EmptyFilter {}
+
+for (const type of [TagFiltered, InheritedTagFiltered]) {
+    describe(`when creating a reducer scenario for ${type.name}`, () => {
+        it('should reject tag-filtered delivery before activating the reducer', () => {
+            created = false;
+            try {
+                new ReadModelScenario(State, { reducers: [type], eventTypes: [], projections: [] });
+                throw new Error('Expected unsupported reducer operation');
+            } catch (error) {
+                (error instanceof UnsupportedReducerOperation).should.be.true;
+                const unsupported = error as UnsupportedReducerOperation;
+                unsupported.operation.should.equal('reducer.filterEventsByTag');
+                unsupported.artifact.should.equal(type.name);
+                unsupported.message.should.contain('Tag-filtered delivery is not fixture-backed.');
+                unsupported.message.should.contain('Use a kernel-backed test.');
+            }
+            created.should.be.false;
+        });
+    });
+}
+
+for (const type of [Labeled, EmptyFilter]) {
+    describe(`when creating a reducer scenario for ${type.name}`, () => {
+        it('should allow metadata that does not restrict delivery', () => {
+            (() => new ReadModelScenario(State, { reducers: [type], eventTypes: [], projections: [] })).should.not.throw();
+        });
+    });
+}

package/testing/for_observerScenarios/when_selecting_filters/with_source_and_stream_types.spec.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { eventSourceType, eventStreamType, reactor, reducer } from '../../../index.js';
+import { ReactorScenario, ReadModelScenario, UnsupportedReactorOperation, UnsupportedReducerOperation } from '../../index.js';
+
+chai.should();
+function should(value: unknown): ReturnType<typeof chai.expect> {
+    return (value as { should: ReturnType<typeof chai.expect> }).should;
+}
+
+class State { count = 0; }
+@reactor('source-filtered-scenario')
+@reducer('source-filtered-scenario', undefined, State)
+@eventSourceType('Customers')
+class SourceFiltered {}
+@reactor('stream-filtered-scenario')
+@reducer('stream-filtered-scenario', undefined, State)
+@eventStreamType('Orders')
+class StreamFiltered {}
+@reactor('default-filtered-scenario')
+@reducer('default-filtered-scenario', undefined, State)
+@eventSourceType('')
+@eventStreamType('All')
+class DefaultFiltered {}
+class InheritedSourceFiltered extends SourceFiltered {}
+
+for (const type of [SourceFiltered, StreamFiltered, InheritedSourceFiltered]) {
+    describe(`when creating observer scenarios for ${type.name}`, () => {
+        it('should reject unproven reactor filter semantics before delivering events', () => {
+            should(() => new ReactorScenario(type)).throw(UnsupportedReactorOperation, 'Use a kernel-backed test.');
+        });
+        it('should reject unproven reducer filter semantics before folding events', () => {
+            should(() => new ReadModelScenario(State, { reducers: [type], eventTypes: [], projections: [] }))
+                .throw(UnsupportedReducerOperation, 'Use a kernel-backed test.');
+        });
+    });
+}
+
+describe('when creating observer scenarios with explicit default filters', () => {
+    it('should allow the existing unrestricted reactor scenario', () => {
+        should(() => new ReactorScenario(DefaultFiltered, { artifacts: { eventTypes: [] } })).not.throw();
+    });
+    it('should allow the existing unrestricted reducer scenario', () => {
+        should(() => new ReadModelScenario(State, { reducers: [DefaultFiltered], eventTypes: [], projections: [] })).not.throw();
+    });
+});

package/testing/index.ts

@@ -7,6 +7,7 @@ export type { ReactorScenarioOptions } from './ReactorScenarioOptions.js';
 export type { ReactorDeliveryResult } from './ReactorDeliveryResult.js';
 export type { RecordedReactorSideEffect } from './RecordedReactorSideEffect.js';
 export { UnsupportedReactorOperation } from './UnsupportedReactorOperation.js';
+export { UnsupportedReducerOperation } from './UnsupportedReducerOperation.js';
 export type { EventScenarioOptions } from './EventScenarioOptions.js';
 export { EventScenarioGivenBuilder } from './EventScenarioGivenBuilder.js';
 export { EventScenarioGiven } from './EventScenarioGiven.js';