fix(EnqueuerAsNodeChildRunner): Add new messages to exchange with node parent process

Author: virgs

output/examples.json

@@ -1,22 +1,38 @@
-import {RequisitionRunner} from './requisition-runners/requisition-runner';
 import {NotificationEmitter} from './notifications/notification-emitter';
-import {EnqueuerAsNodeChildRunner} from "./enqueuer-as-node-child-runner";
-import {Notifications} from "./notifications/notifications";
+import {EnqueuerAsNodeChildRunner} from './enqueuer-as-node-child-runner';
+import {Notifications} from './notifications/notifications';
+import {ChildRequisitionRunner} from './run-as-child/child-requisition-runner';
+import {AssertDescriber} from './run-as-child/assert-describer';
+import {ModuleAdder} from './run-as-child/module-adder';
+import {ProtocolDescriber} from './run-as-child/protocol-describer';
+import {StoreCleaner} from './run-as-child/store-cleaner';
 
 
-jest.mock('./requisition-runners/requisition-runner');
 jest.mock('./notifications/notification-emitter');
+jest.mock('./run-as-child/child-requisition-runner');
+jest.mock('./run-as-child/assert-describer');
+jest.mock('./run-as-child/module-adder');
+jest.mock('./run-as-child/protocol-describer');
+jest.mock('./run-as-child/store-cleaner');
 
 const processOnMock = jest.fn();
 process.on = processOnMock;
 
 const processSendMock = jest.fn();
 process.send = processSendMock;
 
-const runMock = jest.fn();
-const requisitionRunnerConstructorMock = jest.fn(() => ({run: runMock}));
+const replierProcessMock = jest.fn();
+const replierConstructorMock = jest.fn(() => ({process: replierProcessMock}));
 // @ts-ignore
-RequisitionRunner.mockImplementation(requisitionRunnerConstructorMock);
+ChildRequisitionRunner.mockImplementation(replierConstructorMock);
+// @ts-ignore
+AssertDescriber.mockImplementation(replierConstructorMock);
+// @ts-ignore
+ModuleAdder.mockImplementation(replierConstructorMock);
+// @ts-ignore
+ProtocolDescriber.mockImplementation(replierConstructorMock);
+// @ts-ignore
+StoreCleaner.mockImplementation(replierConstructorMock);
 
 let notificationEmitterOnMock = jest.fn();
 // @ts-ignore
@@ -26,21 +42,22 @@ describe('EnqueuerAsNodeChildRunner', () => {
     beforeEach(() => {
         processOnMock.mockClear();
         processSendMock.mockClear();
-        requisitionRunnerConstructorMock.mockClear();
-        runMock.mockClear();
+        replierConstructorMock.mockClear();
+        replierProcessMock.mockClear();
         notificationEmitterOnMock.mockClear();
     });
 
     it('should listen to message', async () => {
-        const statusCode = await new EnqueuerAsNodeChildRunner().execute(true);
+        const enqueuerAsNodeChildRunner = new EnqueuerAsNodeChildRunner();
+        const statusCode = await enqueuerAsNodeChildRunner.execute();
 
         expect(statusCode).toBe(0);
         expect(processOnMock.mock.calls[0][0]).toBe('message');
     });
 
     it('should send exit message', async () => {
         const statusCode = 0;
-        await new EnqueuerAsNodeChildRunner().execute(true);
+        await new EnqueuerAsNodeChildRunner().execute();
 
         expect(processOnMock.mock.calls[1][0]).toBe('exit');
 
@@ -53,38 +70,73 @@ describe('EnqueuerAsNodeChildRunner', () => {
         });
     });
 
-    it('should run enqueuer runner when a message arrives', async () => {
-        const requisition = 'value';
-        await new EnqueuerAsNodeChildRunner().execute(true);
+    it('should do nothing when message is unknown', async () => {
+        const message = {event: 'UNKNOWN'};
+
+        await new EnqueuerAsNodeChildRunner().execute();
 
         const onMessageCallback = processOnMock.mock.calls[0][1];
-        onMessageCallback({event: 'runRequisition', value: requisition});
-        expect(requisitionRunnerConstructorMock).toHaveBeenCalledWith(requisition);
-        expect(runMock).toHaveBeenCalled();
+        onMessageCallback(message);
+        expect(replierProcessMock).not.toHaveBeenCalled();
     });
 
-    it('should not run enqueuer when a message arrives but is not a requisitions', async () => {
-        await new EnqueuerAsNodeChildRunner().execute(true);
+    it('should add modules list when requested', async () => {
+        const message = {event: 'ADD_MODULE', value: 'value'};
+
+        await new EnqueuerAsNodeChildRunner().execute();
+
+        const onMessageCallback = processOnMock.mock.calls[0][1];
+        onMessageCallback(message);
+        expect(replierConstructorMock).toHaveBeenCalled();
+        expect(replierProcessMock).toHaveBeenCalledWith(message);
+    });
+
+    it('should get protocols list when requested', async () => {
+        const message = {event: 'GET_PROTOCOLS', value: 'value'};
+
+        await new EnqueuerAsNodeChildRunner().execute();
+
+        const onMessageCallback = processOnMock.mock.calls[0][1];
+        onMessageCallback(message);
+        expect(replierConstructorMock).toHaveBeenCalled();
+        expect(replierProcessMock).toHaveBeenCalledWith(message);
+    });
+
+    it('should get asserters list when requested', async () => {
+        const message = {event: 'GET_ASSERTERS', value: 'value'};
+
+        await new EnqueuerAsNodeChildRunner().execute();
+
+        const onMessageCallback = processOnMock.mock.calls[0][1];
+        onMessageCallback(message);
+        expect(replierConstructorMock).toHaveBeenCalled();
+        expect(replierProcessMock).toHaveBeenCalledWith(message);
+    });
+
+    it('should run enqueuer runner when a message arrives', async () => {
+        const message = {event: 'RUN_REQUISITION', value: 'value'};
+
+        await new EnqueuerAsNodeChildRunner().execute();
 
         const onMessageCallback = processOnMock.mock.calls[0][1];
-        onMessageCallback({event: 'NOT_A REQUISITION'});
-        expect(requisitionRunnerConstructorMock).not.toHaveBeenCalled();
-        expect(runMock).not.toHaveBeenCalled();
+        onMessageCallback(message);
+        expect(replierConstructorMock).toHaveBeenCalled();
+        expect(replierProcessMock).toHaveBeenCalledWith(message);
     });
 
     it('should register senders to every notification', async () => {
-        await new EnqueuerAsNodeChildRunner().execute(true);
+        await new EnqueuerAsNodeChildRunner().execute();
 
         const everyNotificationKey = Object.keys(Notifications)
             .map((key: any) => Notifications[key])
-            .filter((key: any) => typeof key === 'number')
+            .filter((key: any) => typeof key === 'number');
 
         expect(notificationEmitterOnMock.mock.calls.map((call: any) => call[0]))
             .toEqual(everyNotificationKey);
     });
 
-    it('should send when notification is emitted', async () => {
-        await new EnqueuerAsNodeChildRunner().execute(true);
+    it('should proxy message when notification is emitted', async () => {
+        await new EnqueuerAsNodeChildRunner().execute();
 
         const report = {cycle: {}};
         report.cycle = report;

output/examples.yml

@@ -1,37 +1,42 @@
-import {RequisitionRunner} from './requisition-runners/requisition-runner';
 import {NotificationEmitter} from './notifications/notification-emitter';
 import {ObjectDecycler} from './object-parser/object-decycler';
 import {Notifications} from './notifications/notifications';
+import {ParentReplier} from './run-as-child/parent-replier';
+import {ChildReceivingEvents} from './run-as-child/child-receiving-events';
+import {ChildRequisitionRunner} from './run-as-child/child-requisition-runner';
+import {ModuleAdder} from './run-as-child/module-adder';
+import {ProtocolDescriber} from './run-as-child/protocol-describer';
+import {AssertDescriber} from './run-as-child/assert-describer';
+import {StoreCleaner} from './run-as-child/store-cleaner';
+import {ChildSendingEvents} from './run-as-child/child-sending-events';
 
 export class EnqueuerAsNodeChildRunner {
+    private readonly processors: {
+        [key: string]: ParentReplier
+    };
 
-    public execute(shouldEnd: boolean = false): Promise<number> {
-        console.log('Rocking and rolling');
-        this.registerSenders();
+    public constructor() {
+        this.processors = {
+            [ChildReceivingEvents.ADD_MODULE]: new ModuleAdder(),
+            [ChildReceivingEvents.CLEAN_STORE]: new StoreCleaner(),
+            [ChildReceivingEvents.GET_ASSERTERS]: new AssertDescriber(),
+            [ChildReceivingEvents.GET_PROTOCOLS]: new ProtocolDescriber(),
+            [ChildReceivingEvents.RUN_REQUISITION]: new ChildRequisitionRunner(),
+        };
+    }
+
+    public execute(): Promise<number> {
+        console.log('Child is rocking and rolling');
+        this.registerInternProxies();
         this.registerListeners();
         return new Promise<number>(resolve => {
-            if (shouldEnd) {
+            if (process.env.NODE_ENV && process.env.NODE_ENV.toUpperCase() === 'TEST') {
                 resolve(0);
             }
         });
     }
 
-    private registerListeners() {
-        process.on('message', async message => {
-            if (message.event === 'runRequisition') {
-                await new RequisitionRunner(message.value).run();
-            }
-        });
-        process.on('exit', (code) => {
-            process.send!({
-                event: 'PROCESS_EXIT',
-                value: code
-            });
-        });
-    }
-
-    private registerSenders() {
-
+    private registerInternProxies() {
         Object.keys(Notifications)
             .map((key: any) => Notifications[key])
             .filter((key: any) => typeof key === 'number')
@@ -49,4 +54,19 @@ export class EnqueuerAsNodeChildRunner {
             });
     }
 
+    public registerListeners(): void {
+        process.on('message', async message => {
+            const processor = this.processors[message.event];
+            if (processor) {
+                await processor.process(message);
+            }
+        });
+        process.on('exit', (code) => {
+            process.send!({
+                event: ChildSendingEvents.PROCESS_EXIT,
+                value: code
+            });
+        });
+    }
+
 }

src/enqueuer-as-node-child-runner.test.ts

@@ -6,7 +6,7 @@ import {SummaryTestOutput} from './outputs/summary-test-output';
 import {NotificationEmitter} from './notifications/notification-emitter';
 import {Logger} from './loggers/logger';
 import {LogLevel} from './loggers/log-level';
-import {Notifications} from "./notifications/notifications";
+import {Notifications} from './notifications/notifications';
 
 jest.mock('./outputs/summary-test-output');
 jest.mock('./configurations/configuration');

src/enqueuer-as-node-child-runner.ts

@@ -99,7 +99,7 @@ export class SubscriptionReporter {
     public async receiveMessage(): Promise<any> {
         if (!this.subscription.ignore) {
             try {
-                const messageReceived = await this.processMessage(await this.subscription.receiveMessage());
+                const messageReceived = this.processMessage(await this.subscription.receiveMessage());
                 this.subscription.messageReceived = messageReceived;
                 Logger.debug(`${this.subscription.name} received its message`);
                 this.handleMessageArrival();

src/enqueuer-runner.test.ts

@@ -0,0 +1,26 @@
+import {DynamicModulesManager} from '../plugins/dynamic-modules-manager';
+import {AssertDescriber} from './assert-describer';
+
+jest.mock('../plugins/dynamic-modules-manager');
+
+const processSendMock = jest.fn();
+process.send = processSendMock;
+
+// @ts-ignore
+DynamicModulesManager.getInstance.mockImplementation(() => {
+    return {
+        getAsserterManager: () => ({getMatchingAsserters: () => 'mockedAsserter'})
+    };
+});
+
+describe('AssertDescriber', () => {
+
+    it('should describe asserters when a message arrives', async () => {
+        const message = {value: 'value'};
+        await new AssertDescriber().process(message);
+
+        expect(processSendMock).toHaveBeenCalledWith({event: 'ASSERTERS_LIST', value: 'mockedAsserter'});
+    });
+
+
+});

src/reporters/subscription/subscription-reporter.ts

@@ -0,0 +1,15 @@
+import {DynamicModulesManager} from '../plugins/dynamic-modules-manager';
+import {ChildSendingEvents} from './child-sending-events';
+import {ParentReplier} from './parent-replier';
+
+export class AssertDescriber implements ParentReplier {
+    public async process(message: any): Promise<boolean> {
+        const asserters = DynamicModulesManager.getInstance().getAsserterManager().getMatchingAsserters('');
+        process.send!(
+            {
+                event: ChildSendingEvents.ASSERTERS_LIST,
+                value: asserters
+            });
+        return true;
+    }
+}

src/run-as-child/assert-describer.test.ts

@@ -0,0 +1,7 @@
+export enum ChildReceivingEvents {
+    RUN_REQUISITION = 'RUN_REQUISITION',
+    ADD_MODULE = 'ADD_MODULE',
+    GET_PROTOCOLS = 'GET_PROTOCOLS',
+    GET_ASSERTERS = 'GET_ASSERTERS',
+    CLEAN_STORE = 'CLEAN_STORE',
+}

src/run-as-child/assert-describer.ts

@@ -0,0 +1,31 @@
+import {ChildRequisitionRunner} from './child-requisition-runner';
+import {RequisitionRunner} from '../requisition-runners/requisition-runner';
+
+jest.mock('../requisition-runners/requisition-runner');
+
+const processSendMock = jest.fn();
+process.send = processSendMock;
+
+const runMock = jest.fn();
+const requisitionRunnerConstructorMock = jest.fn(() => ({run: runMock}));
+// @ts-ignore
+RequisitionRunner.mockImplementation(requisitionRunnerConstructorMock);
+
+describe('ChildRequisitionRunner', () => {
+    beforeEach(() => {
+        processSendMock.mockClear();
+        requisitionRunnerConstructorMock.mockClear();
+        runMock.mockClear();
+    });
+
+    it('should run enqueuer runner when a message arrives', async () => {
+        const requisition = 'value';
+        const message = {value: 'value'};
+        await new ChildRequisitionRunner().process(message);
+
+        expect(requisitionRunnerConstructorMock).toHaveBeenCalledWith('value');
+        expect(runMock).toHaveBeenCalled();
+    });
+
+
+});

src/run-as-child/child-receiving-events.ts

@@ -0,0 +1,9 @@
+import {RequisitionRunner} from '../requisition-runners/requisition-runner';
+import {ParentReplier} from './parent-replier';
+
+export class ChildRequisitionRunner implements ParentReplier {
+    public async process(message: any): Promise<boolean> {
+        await new RequisitionRunner(message.value).run();
+        return true;
+    }
+}

src/run-as-child/child-requisition-runner.test.ts

@@ -0,0 +1,5 @@
+export enum ChildSendingEvents {
+    PROTOCOLS_LIST = 'PROTOCOLS_LIST',
+    ASSERTERS_LIST = 'ASSERTERS_LIST',
+    PROCESS_EXIT = 'PROCESS_EXIT'
+}

src/run-as-child/child-requisition-runner.ts

@@ -0,0 +1,23 @@
+import {Configuration} from '../configurations/configuration';
+import {ModuleAdder} from './module-adder';
+
+jest.mock('../configurations/configuration');
+
+const addPluginMock = jest.fn();
+// @ts-ignore
+Configuration.getInstance.mockImplementation(() => {
+    return {
+        addPlugin: addPluginMock
+    };
+});
+describe('ModuleAdder', () => {
+
+    it('should add module when a message arrives', async () => {
+        const message = {value: 'value'};
+        await new ModuleAdder().process(message);
+
+        expect(addPluginMock).toHaveBeenCalledWith('value');
+    });
+
+
+});

src/run-as-child/child-sending-events.ts

@@ -0,0 +1,10 @@
+import {Configuration} from '../configurations/configuration';
+import {ParentReplier} from './parent-replier';
+
+export class ModuleAdder implements ParentReplier {
+    public async process(message: any): Promise<boolean> {
+        Configuration.getInstance().addPlugin(message.value);
+        return true;
+    }
+
+}