Add feature test for courses counter

Author: vilasmaciel

package.json

@@ -13,7 +13,7 @@
   "scripts": {
     "dev": "NODE_ENV=dev ts-node-dev --ignore-watch node_modules --inspect=0.0.0.0:9267 ./src/apps/mooc_backend/server.ts",
     "test": "npm run test:unit && npm run test:features",
-    "test:unit": "NODE_ENV=test jest --watch",
+    "test:unit": "NODE_ENV=test jest",
     "test:features": "NODE_ENV=test cucumber-js -p default",
     "start": "NODE_ENV=production node dist/src/apps/mooc_backend/server",
     "build": "npm run build:clean && npm run build:tsc && npm run build:di",

src/Contexts/Mooc/Courses/domain/CourseCreatedDomainEvent.ts

@@ -37,7 +37,7 @@ export class CourseCreatedDomainEvent extends DomainEvent {
     };
   }
 
-  static fromPrimitive(
+  static fromPrimitives(
     aggregateId: string,
     body: CreateCourseDomainEventBody,
     eventId: string,

src/Contexts/Mooc/CoursesCounter/application/Increment/IncrementCoursesCounterOnCourseCreated.ts

@@ -10,7 +10,7 @@ export class IncrementCoursesCounterOnCourseCreated implements DomainEventSubscr
     return [CourseCreatedDomainEvent.EVENT_NAME];
   }
 
-  on(domainEvent: CourseCreatedDomainEvent): void {
-    this.incrementer.run(new CourseId(domainEvent.aggregateId));
+  async on(domainEvent: CourseCreatedDomainEvent) {
+    await this.incrementer.run(new CourseId(domainEvent.aggregateId));
   }
 }

src/Contexts/Shared/domain/DomainEventSubscriber.ts

@@ -3,5 +3,5 @@ import { DomainEvent } from './DomainEvent';
 export interface DomainEventSubscriber<T extends DomainEvent> {
   subscribedTo(): Array<string>;
 
-  on(domainEvent: T): void;
+  on(domainEvent: T): Promise<void>;
 }

src/Contexts/Shared/domain/EventBus.ts

@@ -1,5 +1,7 @@
 import { DomainEvent } from './DomainEvent';
+import { DomainEventSubscriber } from './DomainEventSubscriber';
 
 export interface EventBus {
-  publish(events: Array<DomainEvent>): void;
+  publish(events: Array<DomainEvent>): Promise<void>;
+  addSubscribers(subscribers: Array<DomainEventSubscriber<DomainEvent>>): void;
 }

src/Contexts/Shared/infrastructure/EventEmitterBus.ts renamed to src/Contexts/Shared/infrastructure/EventBus/EventEmitterBus.ts

@@ -1,5 +1,5 @@
-import { DomainEvent } from '../domain/DomainEvent';
-import { DomainEventSubscriber } from '../domain/DomainEventSubscriber';
+import { DomainEvent } from '../../domain/DomainEvent';
+import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
 import { EventEmitter } from 'events';
 
 export class EventEmitterBus extends EventEmitter {
@@ -9,7 +9,7 @@ export class EventEmitterBus extends EventEmitter {
     this.registerSubscribers(subscribers);
   }
 
-  private registerSubscribers(subscribers?: DomainEventSubscriber<DomainEvent>[]) {
+  registerSubscribers(subscribers?: DomainEventSubscriber<DomainEvent>[]) {
     subscribers?.map(subscriber => {
       this.registerSubscriber(subscriber);
     });

src/Contexts/Shared/infrastructure/EventBus/InMemoryAsyncEventBus.ts

@@ -0,0 +1,20 @@
+import { DomainEvent } from '../../domain/DomainEvent';
+import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
+import { EventBus } from '../../domain/EventBus';
+import { EventEmitterBus } from './EventEmitterBus';
+
+export class InMemoryAsyncEventBus implements EventBus {
+  private bus: EventEmitterBus;
+
+  constructor(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
+    this.bus = new EventEmitterBus(subscribers);
+  }
+
+  async publish(events: DomainEvent[]): Promise<void> {
+    this.bus.publish(events);
+  }
+
+  addSubscribers(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
+    this.bus.registerSubscribers(subscribers);
+  }
+}

src/Contexts/Shared/infrastructure/EventBus/InMemorySyncEventBus.ts

@@ -0,0 +1,42 @@
+import { EventBus } from '../../domain/EventBus';
+import { DomainEvent } from '../../domain/DomainEvent';
+import { DomainEventSubscriber } from '../../domain/DomainEventSubscriber';
+
+type Subscription = {
+  boundedCallback: Function;
+  originalCallback: Function;
+};
+
+export class InMemorySyncEventBus implements EventBus {
+  private subscriptions: Map<string, Array<Subscription>>;
+
+  constructor() {
+    this.subscriptions = new Map();
+  }
+
+  async publish(events: Array<DomainEvent>): Promise<void> {
+    const executions: any = [];
+    events.map(event => {
+      const subscribers = this.subscriptions.get(event.eventName);
+      if (subscribers) {
+        return subscribers.map(subscriber => executions.push(subscriber.boundedCallback(event)));
+      }
+    });
+
+    await Promise.all(executions);
+  }
+
+  addSubscribers(subscribers: Array<DomainEventSubscriber<DomainEvent>>) {
+    subscribers.map(subscriber => subscriber.subscribedTo().map(event => this.subscribe(event, subscriber)));
+  }
+
+  private subscribe(topic: string, subscriber: DomainEventSubscriber<DomainEvent>): void {
+    const currentSubscriptions = this.subscriptions.get(topic);
+    const subscription = { boundedCallback: subscriber.on.bind(subscriber), originalCallback: subscriber.on };
+    if (currentSubscriptions) {
+      currentSubscriptions.push(subscription);
+    } else {
+      this.subscriptions.set(topic, [subscription]);
+    }
+  }
+}

src/Contexts/Shared/infrastructure/InMemoryAsyncEventBus.ts

@@ -3,6 +3,7 @@ import express from 'express';
 import helmet from 'helmet';
 import compress from 'compression';
 import { registerRoutes } from './routes';
+import { registerSubscribers } from './subscribers';
 
 const app: express.Express = express();
 
@@ -17,5 +18,6 @@ app.use(helmet.frameguard({ action: 'deny' }));
 app.use(compress());
 
 registerRoutes(app);
+registerSubscribers();
 
 export default app;