Merge pull request #127 from dolittle/fix-aggregate-on-method-when-applying

Author: woksin

Source/aggregates/AggregateRoot.ts

@@ -133,7 +133,7 @@ export class AggregateRoot {
         }
         const onMethod = this.getOnMethodFor(event, eventType);
         if (onMethod) {
-            onMethod.method.call(this, event.content);
+            onMethod.method.call(this, event);
         }
     }
 

Source/aggregates/for_AggregateRoot/given/an_aggregate_root.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EventSourceId } from '@dolittle/sdk.events';
+
+import { AggregateRoot } from '../../AggregateRoot';
+import { on } from '../../onDecorator';
+
+import { EventWithOnMethod, EventWithoutOnMethod } from './events';
+
+export class AnAggregateRoot extends AggregateRoot {
+    readonly onMethodEventsCalled: any[] = [];
+
+    constructor(eventSourceId: EventSourceId) {
+        super(eventSourceId);
+    }
+
+    applyWithOnMethod(event: EventWithOnMethod) {
+        this.apply(event);
+    }
+
+    applyWithoutOnMethod(event: EventWithoutOnMethod) {
+        this.apply(event);
+    }
+
+    applyBoth(first: EventWithOnMethod, second: EventWithoutOnMethod) {
+        this.apply(first);
+        this.apply(second);
+    }
+
+    @on(EventWithOnMethod)
+    onEvent(event: EventWithOnMethod) {
+        this.onMethodEventsCalled.push(event);
+    }
+}

Source/aggregates/for_AggregateRoot/given/events.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EventType, EventTypeId, EventTypes, IEventTypes } from '@dolittle/sdk.events';
+
+export class EventWithOnMethod {
+    constructor(readonly property: number) {}
+}
+
+export class EventWithoutOnMethod {
+    constructor(readonly property: string) {}
+}
+
+export const event_types = (): IEventTypes => {
+    const types = new EventTypes();
+    types.associate(EventWithOnMethod, new EventType(EventTypeId.from('a8881f3f-a34e-4289-9ba9-41f6a79c8d72')));
+    types.associate(EventWithoutOnMethod, new EventType(EventTypeId.from('334b6259-05e6-420d-856e-5f45e3e740f3')));
+    return types;
+};

…egateRoot/when_applying_public_events.ts …gateRoot/when_applying_a_public_event.tsSource/aggregates/for_AggregateRoot/when_applying_public_events.ts renamed to Source/aggregates/for_AggregateRoot/when_applying_a_public_event.ts Source/aggregates/for_AggregateRoot/when_applying_public_events.ts renamed to Source/aggregates/for_AggregateRoot/when_applying_a_public_event.ts

@@ -0,0 +1,49 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describeThis } from '@dolittle/typescript.testing';
+
+import { EventSourceId } from '@dolittle/sdk.events';
+
+import { AnAggregateRoot } from './given/an_aggregate_root';
+import { event_types, EventWithOnMethod, EventWithoutOnMethod } from './given/events';
+
+describeThis(__filename, () => {
+    let event_source: EventSourceId;
+    let aggregate_root: AnAggregateRoot;
+
+    beforeEach(() => {
+        event_source = EventSourceId.from('f77f4484-e683-4971-9b90-4cbfafbd21f2');
+        aggregate_root = new AnAggregateRoot(event_source);
+        aggregate_root.eventTypes = event_types();
+    });
+
+    describe('that does not have an on-method', () => {
+        let event: EventWithoutOnMethod;
+
+        beforeEach(() => {
+            event = new EventWithoutOnMethod('property');
+            aggregate_root.applyWithoutOnMethod(event);
+        });
+
+        it('should have applied one event', () => aggregate_root.appliedEvents.should.have.length(1));
+        it('should have applied the correct event', () => aggregate_root.appliedEvents[0].event.should.equal(event));
+        it('should not apply the event as public', () => aggregate_root.appliedEvents[0].isPublic.should.be.false);
+        it('should not have called an on-method', () => aggregate_root.onMethodEventsCalled.should.have.length(0));
+    });
+
+    describe('that has an on-method', () => {
+        let event: EventWithOnMethod;
+
+        beforeEach(() => {
+            event = new EventWithOnMethod(42);
+            aggregate_root.applyWithOnMethod(event);
+        });
+
+        it('should have applied one event', () => aggregate_root.appliedEvents.should.have.length(1));
+        it('should have applied the correct event', () => aggregate_root.appliedEvents[0].event.should.equal(event));
+        it('should not apply the event as public', () => aggregate_root.appliedEvents[0].isPublic.should.be.false);
+        it('should not have called an on-method', () => aggregate_root.onMethodEventsCalled.should.have.length(1));
+        it('should call the on-method with the correct event', () => aggregate_root.onMethodEventsCalled[0].should.equal(event));
+    });
+});

Source/aggregates/for_AggregateRoot/when_applying_an_event.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describeThis } from '@dolittle/typescript.testing';
+
+import { EventSourceId } from '@dolittle/sdk.events';
+
+import { AnAggregateRoot } from './given/an_aggregate_root';
+import { event_types, EventWithOnMethod, EventWithoutOnMethod } from './given/events';
+
+describeThis(__filename, () => {
+    let event_source: EventSourceId;
+    let aggregate_root: AnAggregateRoot;
+    let first_event: EventWithOnMethod;
+    let second_event: EventWithoutOnMethod;
+
+    beforeEach(() => {
+        event_source = EventSourceId.from('f77f4484-e683-4971-9b90-4cbfafbd21f2');
+        aggregate_root = new AnAggregateRoot(event_source);
+        aggregate_root.eventTypes = event_types();
+
+        first_event = new EventWithOnMethod(1337);
+        second_event = new EventWithoutOnMethod('hello world');
+    });
+
+    beforeEach(() => aggregate_root.applyBoth(first_event, second_event));
+
+    it('should have applied two events', () => aggregate_root.appliedEvents.should.have.length(2));
+    it('should have applied the correct first event', () => aggregate_root.appliedEvents[0].event.should.equal(first_event));
+    it('should have applied the correct second event', () => aggregate_root.appliedEvents[1].event.should.equal(second_event));
+    it('should not apply the first event as public', () => aggregate_root.appliedEvents[0].isPublic.should.be.false);
+    it('should not apply the second event as public', () => aggregate_root.appliedEvents[1].isPublic.should.be.false);
+    it('should have called an on-method', () => aggregate_root.onMethodEventsCalled.should.have.length(1));
+    it('should call the on-method with the correct event', () => aggregate_root.onMethodEventsCalled[0].should.equal(first_event));
+});