feat(core-kernel): dispatch schedule events

__tests__/unit/core-kernel/services/schedule/block-job.test.ts

@@ -1,22 +1,43 @@
 import "jest-extended";
 
-import { BlockEvent } from "@packages/core-kernel/src/enums/events";
-import { Container, Identifiers, interfaces } from "@packages/core-kernel/src/ioc";
+import { BlockEvent, ScheduleEvent } from "@packages/core-kernel/src/enums/events";
+import { Identifiers } from "@packages/core-kernel/src/ioc";
 import { MemoryEventDispatcher } from "@packages/core-kernel/src/services/events/drivers/memory";
 import { BlockJob } from "@packages/core-kernel/src/services/schedule/block-job";
+import { Sandbox } from "@packages/core-test-framework";
 
+let sandbox: Sandbox;
 let job: BlockJob;
 let eventDispatcher: MemoryEventDispatcher;
+
+const delay = async (timeout) => {
+    await new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, timeout);
+    });
+};
+
+const expectFinishedEventData = () => {
+    return expect.objectContaining({
+        executionTime: expect.toBeNumber(),
+        blockCount: expect.toBeNumber(),
+    });
+};
+
 beforeEach(() => {
-    const container: interfaces.Container = new Container();
-    eventDispatcher = container.resolve<MemoryEventDispatcher>(MemoryEventDispatcher);
-    container.bind(Identifiers.EventDispatcherService).toConstantValue(eventDispatcher);
+    sandbox = new Sandbox();
+    eventDispatcher = sandbox.app.resolve<MemoryEventDispatcher>(MemoryEventDispatcher);
+
+    sandbox.app.bind(Identifiers.EventDispatcherService).toConstantValue(eventDispatcher);
 
-    job = container.resolve(BlockJob);
+    job = sandbox.app.resolve<BlockJob>(BlockJob);
 });
 
 describe("BlockJob", () => {
-    it("should execute on cron", () => {
+    it("should execute on cron", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.cron(3).execute(fn);
@@ -31,10 +52,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 9 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 10 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every block", () => {
+    it("should execute every block", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyBlock().execute(fn);
@@ -45,10 +73,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 1 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 1 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every five blocks", () => {
+    it("should execute every five blocks", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyFiveBlocks().execute(fn);
@@ -63,10 +98,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 15 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 16 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every ten blocks", () => {
+    it("should execute every ten blocks", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyTenBlocks().execute(fn);
@@ -81,10 +123,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 30 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 31 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every fifteen blocks", () => {
+    it("should execute every fifteen blocks", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyFifteenBlocks().execute(fn);
@@ -99,10 +148,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 45 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 46 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every thirty blocks", () => {
+    it("should execute every thirty blocks", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyThirtyBlocks().execute(fn);
@@ -117,10 +173,17 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 90 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 91 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 
-    it("should execute every round", () => {
+    it("should execute every round", async () => {
+        const spyOnDispatch = jest.spyOn(eventDispatcher, "dispatch");
+
         const fn: Function = jest.fn();
 
         job.everyRound().execute(fn);
@@ -135,6 +198,11 @@ describe("BlockJob", () => {
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 153 });
         eventDispatcher.dispatchSync(BlockEvent.Received, { height: 154 });
 
+        await delay(100);
+
         expect(fn).toHaveBeenCalledTimes(3);
+
+        expect(spyOnDispatch).toHaveBeenCalledTimes(3);
+        expect(spyOnDispatch).toHaveBeenCalledWith(ScheduleEvent.BlockJobFinished, expectFinishedEventData());
     });
 });

__tests__/unit/core-kernel/services/schedule/cron-job.test.ts

@@ -1,9 +1,18 @@
 import "jest-extended";
 
+import { Container, Enums } from "@packages/core-kernel";
 import { CronJob } from "@packages/core-kernel/src/services/schedule/cron-job";
+import { Sandbox } from "@packages/core-test-framework";
 import moment from "moment-timezone";
 import { useFakeTimers } from "sinon";
 
+let sandbox: Sandbox;
+let job: CronJob;
+let clock;
+const mockEventDispatcher = {
+    dispatch: jest.fn(),
+};
+
 const days: Record<string, string> = {
     monday: "2019-08-19 00:00:00",
     tuesday: "2019-08-20 00:00:00",
@@ -31,6 +40,14 @@ const expectExecutionAfterDelay = (callback: CronJob, minutes: number): void =>
     }
 
     expect(fn).toHaveBeenCalledTimes(3);
+
+    expect(mockEventDispatcher.dispatch).toHaveBeenCalledWith(
+        Enums.ScheduleEvent.CronJobFinished,
+        expect.objectContaining({
+            executionTime: expect.toBeNumber(),
+            expression: expect.toBeString(),
+        }),
+    );
 };
 
 const expectExecutionOnDate = (callback: CronJob, day: string): void => {
@@ -49,11 +66,23 @@ const expectExecutionOnDate = (callback: CronJob, day: string): void => {
     }
 
     expect(fn).toHaveBeenCalledTimes(1);
+
+    expect(mockEventDispatcher.dispatch).toHaveBeenCalledWith(
+        Enums.ScheduleEvent.CronJobFinished,
+        expect.objectContaining({
+            executionTime: expect.toBeNumber(),
+            expression: expect.toBeString(),
+        }),
+    );
 };
 
-let job: CronJob;
-let clock;
-beforeEach(() => (job = new CronJob()));
+beforeEach(() => {
+    sandbox = new Sandbox();
+
+    sandbox.app.bind(Container.Identifiers.EventDispatcherService).toConstantValue(mockEventDispatcher);
+
+    job = sandbox.app.resolve<CronJob>(CronJob);
+});
 
 afterEach(() => clock.restore());
 

packages/core-kernel/src/enums/events.ts

@@ -109,6 +109,15 @@ export enum TransactionEvent {
     Reverted = "transaction.reverted",
 }
 
+/**
+ * @export
+ * @enum {number}
+ */
+export enum ScheduleEvent {
+    BlockJobFinished = "schedule.blockJob.finished",
+    CronJobFinished = "schedule.cronJob.finished",
+}
+
 /**
  * @export
  * @enum {number}

packages/core-kernel/src/services/schedule/block-job.ts

@@ -1,7 +1,9 @@
 import { Managers } from "@arkecosystem/crypto";
+import { performance } from "perf_hooks";
 
+import { Application } from "../../contracts/kernel";
 import { EventDispatcher } from "../../contracts/kernel/events";
-import { BlockEvent } from "../../enums";
+import { BlockEvent, ScheduleEvent } from "../../enums";
 import { Identifiers, inject, injectable } from "../../ioc";
 import { Job } from "./interfaces";
 import { ExecuteCallbackWhenReady } from "./listeners";
@@ -20,6 +22,9 @@ export class BlockJob implements Job {
      */
     protected blockCount: number = 1;
 
+    @inject(Identifiers.Application)
+    protected readonly app!: Application;
+
     /**
      * @private
      * @type {EventDispatcher}
@@ -33,7 +38,18 @@ export class BlockJob implements Job {
      * @memberof BlockJob
      */
     public execute(callback: Function): void {
-        this.events.listen(BlockEvent.Received, new ExecuteCallbackWhenReady(callback, this.blockCount));
+        const onCallback = async () => {
+            const start = performance.now();
+
+            await callback();
+
+            await this.app.events.dispatch(ScheduleEvent.BlockJobFinished, {
+                executionTime: performance.now() - start,
+                blockCount: this.blockCount,
+            });
+        };
+
+        this.events.listen(BlockEvent.Received, new ExecuteCallbackWhenReady(onCallback, this.blockCount));
     }
 
     /**

packages/core-kernel/src/services/schedule/cron-job.ts

@@ -1,6 +1,9 @@
 import { CronCommand, CronJob as Cron } from "cron";
+import { performance } from "perf_hooks";
 
-import { injectable } from "../../ioc";
+import { Application } from "../../contracts/kernel";
+import { ScheduleEvent } from "../../enums";
+import { Identifiers, inject, injectable } from "../../ioc";
 import { Job } from "./interfaces";
 
 /**
@@ -14,6 +17,9 @@ import { Job } from "./interfaces";
  */
 @injectable()
 export class CronJob implements Job {
+    @inject(Identifiers.Application)
+    protected readonly app!: Application;
+
     /**
      * @private
      * @type {string}
@@ -26,7 +32,18 @@ export class CronJob implements Job {
      * @memberof CronJob
      */
     public execute(callback: CronCommand): void {
-        new Cron(this.expression, callback).start();
+        const onCallback: CronCommand = () => {
+            const start = performance.now();
+            // @ts-ignore
+            callback();
+
+            this.app.events.dispatch(ScheduleEvent.CronJobFinished, {
+                executionTime: performance.now() - start,
+                expression: this.expression,
+            });
+        };
+
+        new Cron(this.expression, onCallback).start();
     }
 
     /**