@cratis/chronicle 6.31.3 → 6.32.0

package/testing/for_EventScenario/when_appending_scoped_constraints/with_unproven_operations.spec.ts

@@ -0,0 +1,119 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import { unique } from '../../../events/constraints/unique.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import type { AppendOptions } from '../../../eventSequences/AppendOptions.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from '../../index.js';
+
+chai.should();
+@eventType('ScopedGuardClaim')
+class Claim { @field(String) key: string; @field(String) other = 'Other'; constructor(key: string) { this.key = key; } }
+@eventType('ScopedGuardFlag')
+class Flag { @field(Boolean) key = true; }
+@eventType('ScopedGuardRemoval')
+class Removed { @field(String) label = 'release'; }
+@eventType('ScopedGuardFieldless')
+class Fieldless {}
+
+function definition(configure: (builder: IConstraintBuilder) => void, name = 'ScopedGuard'): Function {
+    @constraint(name)
+    class Definition { define(builder: IConstraintBuilder) { configure(builder); } }
+    return Definition;
+}
+const scopedConstraint = definition(builder => builder.perEventStreamId().unique(value => value.on(Claim, event => event.key).removedWith(Removed)));
+const create = () => new EventScenario({ artifacts: { eventTypes: [Claim, Removed], constraints: [scopedConstraint] } });
+async function unsupported(action: () => unknown, reason: string): Promise<void> {
+    await Promise.resolve().then(action).then(() => { throw new Error('Unsupported operation succeeded'); }, error => {
+        (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+        (error as Error).message.should.include(reason);
+        (error as Error).message.should.include('Use a kernel-backed test.');
+    });
+}
+
+describe('when configuring unproven scoped property shapes', () => {
+    for (const [name, configure, reason] of [
+        ['composite', (builder: IConstraintBuilder) => builder.unique(value => value.on(Claim, event => event.key, event => event.other)), 'Scoped composite or case-insensitive property keys'],
+        ['casing', (builder: IConstraintBuilder) => builder.unique(value => value.on(Claim, event => event.key).ignoreCasing()), 'Scoped composite or case-insensitive property keys'],
+        ['boolean', (builder: IConstraintBuilder) => builder.unique(value => value.on(Flag, event => event.key)), 'Scoped property keys must be schema-backed strings'],
+        ['covered removal', (builder: IConstraintBuilder) => builder.unique(value => value.on(Claim, event => event.key).removedWith(Claim)), 'Scoped covered-and-removal property events'],
+        ['fieldless removal', (builder: IConstraintBuilder) => builder.unique(value => value.on(Claim, event => event.key).removedWith(Fieldless)), 'Scoped fieldless removal events']
+    ] as const) {
+        it(`should reject ${name} with its specific boundary rather than a compiler failure`, async () => {
+            const eventTypes = name === 'fieldless removal' ? [Claim, Fieldless] : [Claim, Flag, Removed];
+            new EventScenario({ artifacts: { eventTypes, constraints: [definition(configure)] } }).should.be.instanceOf(EventScenario);
+            await unsupported(() => new EventScenario({ artifacts: { eventTypes,
+                constraints: [definition(builder => { builder.perEventSourceType(); configure(builder); })] } }), reason);
+        });
+    }
+
+    it('should reject a scoped definition alongside another nonoverlapping definition', async () => {
+        const other = definition(builder => builder.unique(value => value.on(Flag, event => event.key)), 'OtherGuard');
+        await unsupported(() => new EventScenario({ artifacts: { eventTypes: [Claim, Flag, Removed], constraints: [scopedConstraint, other] } }),
+            'Scoped constraints alongside other definitions');
+    });
+
+    it('should retain the production compiler conflict between scoped fluent and unscoped unique decorators', async () => {
+        @eventType('ScopedDecoratedConflict')
+        class Decorated { @field(String) @unique('Conflict') key = 'key'; }
+        const scoped = definition(builder => builder.perEventStreamId().unique(value => value.on(Decorated, event => event.key)), 'Conflict');
+        await unsupported(() => new EventScenario({ artifacts: { eventTypes: [Decorated], constraints: [scoped] } }),
+            "Conflicting scopes for constraint 'Conflict'");
+    });
+});
+
+describe('when a scoped append uses unsupported routes or metadata', () => {
+    it('should preserve claims, history, results, notifications and sequence after unsupported input', async () => {
+        const scenario = create();
+        (await scenario.append('A', new Claim('Alpha'), { streamId: 'West' })).isSuccess.should.be.true;
+        const before = scenario.appendedEvents;
+        const results = scenario.results;
+        const notifications = scenario.eventLog.appendOperations[Symbol.asyncIterator]();
+        const pending = notifications.next();
+        try {
+            for (const dimension of ['sourceType', 'streamType', 'streamId'] as const) {
+                for (const value of [' ', 'a|estt:b', '*', 'a:b', 'é', 'a\u0000b']) {
+                    const options = { [dimension]: value };
+                    await unsupported(() => scenario.append('B', new Claim('Beta'), options), `append.${dimension}`);
+                    await unsupported(() => scenario.appendMany('B', [new Claim('Beta')], options), `appendMany.${dimension}`);
+                }
+            }
+            for (const options of [{ tags: [] }, { subject: '' }, { occurred: new Date() }, { correlationId: '00000000-0000-0000-0000-000000000001' },
+                { concurrencyScopes: {} }, { eventSourceId: 'other' }, { arbitrary: true }]) {
+                await unsupported(() => scenario.append('B', new Claim('Beta'), options as AppendOptions), 'append.options');
+            }
+            await unsupported(() => scenario.appendMany([
+                { eventSourceId: 'A', event: new Removed(), eventStreamId: 'West' },
+                { eventSourceId: 'B', event: new Claim('Alpha'), eventStreamId: 'bad|route' }
+            ]), 'appendMany.streamId');
+            scenario.appendedEvents.should.deep.equal(before);
+            scenario.results.should.deep.equal(results);
+            (await scenario.eventLog.getNextSequenceNumber()).value.should.equal(1n);
+            const rejected = await scenario.append('B', new Claim('Alpha'), { streamId: 'West' });
+            rejected.isSuccess.should.be.false;
+            (await pending).value![0].result.should.equal(rejected);
+            (await scenario.append('B', new Claim('Beta'), { streamId: 'West' })).sequenceNumber.value.should.equal(1n);
+        } finally { await notifications.return?.(); }
+    });
+
+    it('should roll back default-route setup without disturbing another scope', async () => {
+        const scenario = create();
+        await scenario.append('A', new Claim('Alpha'), { streamId: 'West' });
+        await scenario.given.forEventSource('A').events(new Claim('DefaultKey'));
+        const before = scenario.appendedEvents;
+        const results = scenario.results;
+        await scenario.given.forEventSource('B').events(new Claim('Temporary'), new Claim('DefaultKey'))
+            .then(() => { throw new Error('Invalid setup succeeded'); }, error => {
+                (error as Error).message.should.include('EventScenario given setup failed');
+            });
+        scenario.appendedEvents.should.deep.equal(before);
+        scenario.results.should.deep.equal(results);
+        (await scenario.append('C', new Claim('Temporary'))).isSuccess.should.be.true;
+        (await scenario.append('C', new Claim('Alpha'), { streamId: 'West' })).isSuccess.should.be.false;
+    });
+});

package/testing/for_ReactorScenario/when_enforcing_scoped_constraints/with_default_input_routes.spec.ts

@@ -0,0 +1,70 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import { removeConstraint } from '../../../events/constraints/removeConstraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import type { EventContext } from '../../../events/EventContext.js';
+import { reactor } from '../../../reactors/reactor.js';
+import { ReactorScenario } from '../../ReactorScenario.js';
+
+chai.should();
+@eventType('ScopedReactorFirst')
+class First { @field(String) label = 'First'; }
+@eventType('ScopedReactorSibling')
+class Sibling { @field(String) label = 'Sibling'; }
+@eventType('ScopedReactorRemoved')
+@removeConstraint('ScopedReactorCycle')
+class Removed { @field(String) label = 'Removed'; }
+@eventType('ScopedReactorExpired')
+@removeConstraint('ScopedReactorCycle')
+class Expired { @field(String) label = 'Expired'; }
+@eventType('ScopedReactorEffect')
+class Effect { @field(String) label: string; constructor(label: string) { this.label = label; } }
+@constraint('ScopedReactorFirstCycle')
+class FirstCycle {
+    define(builder: IConstraintBuilder) { builder.perEventSourceType().perEventStreamType().perEventStreamId().uniqueFor(First, 'Occupied', 'ScopedReactorCycle'); }
+}
+@constraint('ScopedReactorSiblingCycle')
+class SiblingCycle {
+    define(builder: IConstraintBuilder) { builder.perEventSourceType().perEventStreamType().perEventStreamId().uniqueFor(Sibling, 'Occupied', 'ScopedReactorCycle'); }
+}
+
+describe('when enforcing scoped reactor constraints on default-route input', () => {
+    it('should deliver only accepted cycles and retain no effects or deliveries from rejected actions', async () => {
+        const calls: EventContext[] = [];
+        @reactor('ScopedReactor')
+        class Reactor {
+            first(event: First, context: EventContext) { calls.push(context); return new Effect(event.label); }
+            sibling(event: Sibling, context: EventContext) { calls.push(context); return new Effect(event.label); }
+        }
+        const scenario = new ReactorScenario(Reactor, { artifacts: {
+            eventTypes: [First, Sibling, Removed, Expired, Effect], constraints: [FirstCycle, SiblingCycle]
+        } });
+        await scenario.given.forEventSource('A').events(new First());
+        await scenario.when.forEventSource('A').events(new Sibling()).then(
+            () => { throw new Error('Conflicting cycle delivered'); }, error => {
+                (error as Error).message.should.include('ReactorScenario action append failed');
+                (error as Error).message.should.include('ScopedReactorCycle');
+            });
+        calls.length.should.equal(1);
+        scenario.produced.length.should.equal(1);
+        scenario.results.length.should.equal(1);
+        scenario.appendedEvents.length.should.equal(1);
+        await scenario.when.forEventSource('A').events(new Removed(), new Sibling());
+        await scenario.when.forEventSource('A').events(new Expired(), new First(), new Sibling()).then(
+            () => { throw new Error('Invalid batch delivered'); }, error => {
+                (error as Error).message.should.include('ReactorScenario action append failed');
+            });
+        calls.length.should.equal(2);
+        scenario.produced.length.should.equal(2);
+        scenario.results.length.should.equal(2);
+        scenario.appendedEvents.length.should.equal(3);
+        calls.map(context => [context.eventSourceType, context.eventStreamType, context.eventStreamId])
+            .should.deep.equal([['Default', 'All', 'Default'], ['Default', 'All', 'Default']]);
+    });
+});

package/testing/for_ReactorScenario/when_enforcing_scoped_constraints/with_routed_service_appends.spec.ts

@@ -0,0 +1,65 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import type { EventContext } from '../../../events/EventContext.js';
+import { reactor } from '../../../reactors/reactor.js';
+import type { ReactorServices } from '../../../reactors/ReactorServices.js';
+import { ReactorScenario } from '../../ReactorScenario.js';
+import { UnsupportedEventSequenceOperation } from '../../UnsupportedEventSequenceOperation.js';
+
+chai.should();
+@eventType('ScopedServiceRequested')
+class Requested { @field(String) stream: string; constructor(stream: string) { this.stream = stream; } }
+@eventType('ScopedServiceClaimed')
+class Claimed { @field(String) key = 'Key'; }
+@eventType('ScopedServiceReturned')
+class Returned { @field(String) label = 'returned'; }
+@constraint('ScopedServiceKey')
+class Key { define(builder: IConstraintBuilder) { builder.perEventStreamId().unique(key => key.on(Claimed, event => event.key)); } }
+
+describe('when a reactor explicitly appends into a constraint scope', () => {
+    it('should preserve routed service appends without routing or recursively delivering the input', async () => {
+        const successes: boolean[] = [];
+        @reactor('ScopedServiceWriter')
+        class Writer {
+            async requested(event: Requested, context: EventContext, services: ReactorServices) {
+                successes.push((await services.eventStore.eventLog.append(context.eventSourceId, new Claimed(), { streamId: event.stream })).isSuccess);
+            }
+        }
+        const scenario = new ReactorScenario(Writer, { artifacts: { eventTypes: [Requested, Claimed], constraints: [Key] } });
+        await scenario.when.forEventSource('A').events(new Requested('West'));
+        await scenario.when.forEventSource('B').events(new Requested('East'));
+        await scenario.when.forEventSource('C').events(new Requested('West'));
+        successes.should.deep.equal([true, true, false]);
+        scenario.appendedEvents.map(event => event.context.eventStreamId).should.deep.equal(['Default', 'West', 'Default', 'East', 'Default']);
+        scenario.results.length.should.equal(3);
+        scenario.produced.length.should.equal(0);
+    });
+
+    it('should fail a delivery that swallows an unsupported route and record no returned effect', async () => {
+        @reactor('ScopedServiceUnsupportedWriter')
+        class Writer {
+            async requested(_event: Requested, context: EventContext, services: ReactorServices) {
+                try { await services.eventStore.eventLog.append(context.eventSourceId, new Claimed(), { streamId: 'bad|route' }); }
+                catch { /* The harness must latch unsupported appends even if the handler swallows them. */ }
+                return new Returned();
+            }
+        }
+        const scenario = new ReactorScenario(Writer, { artifacts: { eventTypes: [Requested, Claimed, Returned], constraints: [Key] } });
+        await scenario.when.forEventSource('A').events(new Requested('West')).then(
+            () => { throw new Error('Unsupported route was swallowed'); }, error => {
+                (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+                (error as Error).message.should.include('append.streamId');
+            });
+        scenario.appendedEvents.length.should.equal(1);
+        scenario.produced.length.should.equal(0);
+        scenario.sideEffects.length.should.equal(0);
+        scenario.results[0].completed.should.be.false;
+    });
+});