@emartech/program-executor 3.11.0 → 3.12.0

package/src/index-pubsub.test.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const ProgramExecutor = require('./index-pubsub');
+const ProgramHandler = require('./program-handler');
+const ProgramsRepository = require('./repositories/programs');
+const QueueManager = require('./queue-manager-pubsub');
+const ProgramExecutorProcessor = require('./program-executor-processor');
+const Consumer = require('@emartech/pubsub-client-js').Consumer;
+
+const testJobLibrary = {
+  firstJob: {},
+  secondJob: {}
+};
+
+describe('ProgramExecutor', function () {
+  let config;
+
+  beforeEach(async function () {
+    config = {
+      knex: this.db,
+      tableName: 'programs',
+      topicName: 'program-executor',
+      projectId: 'amqp://guest:guest@localhost:9999'
+    };
+
+
+    jest.spyOn(ProgramHandler, 'create');
+    ProgramHandler.prototype.createProgram = jest.fn().mockReturnValue(true);
+
+    jest.spyOn(ProgramsRepository, 'create');
+    jest.spyOn(QueueManager, 'create');
+    jest.spyOn(ProgramExecutorProcessor, 'create');
+
+    ProgramExecutorProcessor.prototype.process = jest.fn().mockReturnValue(true);
+    jest.spyOn(Consumer, 'create');
+    Consumer.prototype.process = jest.fn().mockReturnValue(true);
+
+
+  });
+
+  describe('#createProgram', function () {
+    it('should create program handler and call createProgram with given data', async function () {
+      await ProgramExecutor.create(config).createProgram({
+        jobs: ['current_program', 'next_program']
+      });
+
+      expect(ProgramHandler.create).toHaveBeenCalledWith(
+        expect.any(ProgramsRepository),
+        expect.any(QueueManager)
+      );
+      expect(ProgramsRepository.create).toHaveBeenCalledWith(config.knex, config.tableName);
+      expect(QueueManager.create).toHaveBeenCalledWith(config.topicName, config.projectId);
+      expect(ProgramHandler.prototype.createProgram).toHaveBeenCalledWith({
+        jobs: ['current_program', 'next_program']
+      });
+    });
+  });
+
+  describe('#processPrograms', function () {
+    it('should create program executor processor with job library', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(ProgramExecutorProcessor.create).toHaveBeenCalledWith(
+        expect.any(Object), //TODO check
+        expect.any(QueueManager),
+        testJobLibrary
+      );
+
+      expect(ProgramsRepository.create).toHaveBeenCalledWith(config.knex, config.tableName);
+      expect(QueueManager.create).toHaveBeenCalledWith(config.topicName, config.projectId);
+    });
+
+    it('should create consumer with the given pubsub config', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(Consumer.create.mock.calls[0][0]).toEqual(config.topicName);
+    });
+
+    it('should create consumer to consume the given topic', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(Consumer.create.mock.calls[0][1]).toEqual(expect.objectContaining({
+        MaxMessages: 1,
+        MaxStreams: 1,
+        logger: 'program-executor-consumer' }));
+    });
+
+    it('should create consumer with a logger based on the given topic name', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(Consumer.create.mock.calls[0][1]).toEqual(
+        expect.objectContaining({ logger: `${config.topicName}-consumer` }));
+    });
+
+    it('should config consumer with given flow control settings', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(Consumer.create.mock.calls[0][1]).toEqual(
+        expect.objectContaining({ MaxMessages: 1,
+          MaxStreams: 1 }));
+    });
+
+    it('should call the created executor when message callback fires', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
+
+      await onMessageFunction({ random: 'message' });
+
+      expect(ProgramExecutorProcessor.prototype.process).toHaveBeenCalledWith({ random: 'message' });
+    });
+
+    it('should truncate log message to avoid splitting by heroku', async function () {
+      const veryLongError = new Error('1'.repeat(100000));
+
+      ProgramExecutorProcessor.prototype.process = jest.fn().mockRejectedValue(veryLongError);
+
+      let caughtError;
+      try {
+        await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+        const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
+        await onMessageFunction({ random: 'message' });
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError).not.toBe(undefined);
+      expect(caughtError.message.length).toEqual(255);
+    });
+
+    it('should emit an error event', function (done) {
+      const sampleError = new Error('Error to be emitted');
+      ProgramExecutorProcessor.prototype.process = jest.fn().mockRejectedValue(sampleError);
+
+      const programExecutor = ProgramExecutor.create(config);
+
+      programExecutor.on('programError', function ({ error, message }) {
+        expect(message).toEqual({ random: 'message' });
+        expect(error.message).toEqual('Error to be emitted');
+        done();
+      });
+
+      programExecutor.processPrograms(testJobLibrary);
+      const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
+      onMessageFunction({ random: 'message' }).catch(() => {});
+    });
+
+    it('should start processing', async function () {
+      await ProgramExecutor.create(config).processPrograms(testJobLibrary);
+
+      expect(Consumer.prototype.process).toHaveBeenCalled();
+    });
+  });
+});

package/src/{index.spec.js → index.test.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const ProgramExecutor = require('./');
+const ProgramExecutor = require('.');
 const ProgramHandler = require('./program-handler');
 const ProgramsRepository = require('./repositories/programs');
 const QueueManager = require('./queue-manager');
@@ -23,125 +23,129 @@ describe('ProgramExecutor', function () {
       amqpUrl: 'amqp://guest:guest@localhost:9999'
     };
 
-    this.sandbox.spy(ProgramHandler, 'create');
-    this.sandbox.stub(ProgramHandler.prototype, 'createProgram');
 
-    this.sandbox.spy(ProgramsRepository, 'create');
-    this.sandbox.spy(QueueManager, 'create');
+    jest.spyOn(ProgramHandler, 'create');
+    ProgramHandler.prototype.createProgram = jest.fn().mockReturnValue(true);
+
+    jest.spyOn(ProgramsRepository, 'create');
+    jest.spyOn(QueueManager, 'create');
+    jest.spyOn(ProgramExecutorProcessor, 'create');
+
+    ProgramExecutorProcessor.prototype.process = jest.fn().mockReturnValue(true);
+    jest.spyOn(Consumer, 'create');
+    Consumer.prototype.process = jest.fn().mockReturnValue(true);
 
-    this.sandbox.spy(ProgramExecutorProcessor, 'create');
-    this.sandbox.stub(ProgramExecutorProcessor.prototype, 'process');
 
-    this.sandbox.spy(Consumer, 'create');
-    this.sandbox.stub(Consumer.prototype, 'process');
   });
 
-  describe('#createProgram', async function () {
+  describe('#createProgram', function () {
     it('should create program handler and call createProgram with given data', async function () {
       await ProgramExecutor.create(config).createProgram({
         jobs: ['current_program', 'next_program']
       });
 
-      expect(ProgramHandler.create).to.have.been.calledWith(
-        this.sinon.match.instanceOf(ProgramsRepository),
-        this.sinon.match.instanceOf(QueueManager)
+      expect(ProgramHandler.create).toHaveBeenCalledWith(
+        expect.any(ProgramsRepository),
+        expect.any(QueueManager)
       );
-      expect(ProgramsRepository.create).to.have.been.calledWith(config.knex, config.tableName);
-      expect(QueueManager.create).to.have.been.calledWith(config.amqpUrl, config.queueName);
-      expect(ProgramHandler.prototype.createProgram).to.have.been.calledWith({
+      expect(ProgramsRepository.create).toHaveBeenCalledWith(config.knex, config.tableName);
+      expect(QueueManager.create).toHaveBeenCalledWith(config.amqpUrl, config.queueName);
+      expect(ProgramHandler.prototype.createProgram).toHaveBeenCalledWith({
         jobs: ['current_program', 'next_program']
       });
     });
   });
 
-  describe('#processPrograms', async function () {
+  describe('#processPrograms', function () {
     it('should create program executor processor with job library', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(ProgramExecutorProcessor.create).to.have.been.calledWith(
-        this.sinon.match.instanceOf(ProgramHandler),
-        this.sinon.match.instanceOf(QueueManager),
+      expect(ProgramExecutorProcessor.create).toHaveBeenCalledWith(
+        expect.any(Object), //TODO check
+        expect.any(QueueManager),
         testJobLibrary
       );
 
-      expect(ProgramsRepository.create).to.have.been.calledWith(config.knex, config.tableName);
-      expect(QueueManager.create).to.have.been.calledWith(config.amqpUrl, config.queueName);
+      expect(ProgramsRepository.create).toHaveBeenCalledWith(config.knex, config.tableName);
+      expect(QueueManager.create).toHaveBeenCalledWith(config.amqpUrl, config.queueName);
     });
 
     it('should create consumer with the given rabbitMq config', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(Consumer.create.lastCall.args[0]).to.eql({ default: { url: config.amqpUrl } });
+      expect(Consumer.create.mock.calls[0][0]).toEqual({ default: { url: config.amqpUrl } });
     });
 
     it('should create consumer to consume the given queue', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(Consumer.create.lastCall.args[1]).to.containSubset({ channel: config.queueName });
+      expect(Consumer.create.mock.calls[0][1]).toEqual(
+        expect.objectContaining({ channel: config.queueName }));
     });
 
     it('should create consumer with a logger based on the given queue name', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(Consumer.create.lastCall.args[1]).to.containSubset({ logger: `${config.queueName}-consumer` });
+      expect(Consumer.create.mock.calls[0][1]).toEqual(
+        expect.objectContaining({ logger: `${config.queueName}-consumer` }));
     });
 
     it('should config consumer with prefecth count and a retry time', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(Consumer.create.lastCall.args[1]).to.containSubset({ prefetchCount: 1, retryTime: 1000 });
+      expect(Consumer.create.mock.calls[0][1]).toEqual(
+        expect.objectContaining({ prefetchCount: 1, retryTime: 1000 }));
     });
 
     it('should call the created executor when message callback fires', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      const onMessageFunction = Consumer.create.lastCall.args[1].onMessage;
+      const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
 
       await onMessageFunction({ random: 'message' });
 
-      expect(ProgramExecutorProcessor.prototype.process).to.have.been.calledWith({ random: 'message' });
+      expect(ProgramExecutorProcessor.prototype.process).toHaveBeenCalledWith({ random: 'message' });
     });
 
     it('should truncate log message to avoid splitting by heroku', async function () {
       const veryLongError = new Error('1'.repeat(100000));
 
-      ProgramExecutorProcessor.prototype.process.rejects(veryLongError);
+      ProgramExecutorProcessor.prototype.process = jest.fn().mockRejectedValue(veryLongError);
 
       let caughtError;
       try {
         await ProgramExecutor.create(config).processPrograms(testJobLibrary);
-        const onMessageFunction = Consumer.create.lastCall.args[1].onMessage;
+        const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
         await onMessageFunction({ random: 'message' });
       } catch (error) {
         caughtError = error;
       }
 
-      expect(caughtError).not.to.be.undefined;
-      expect(caughtError.message.length).to.eql(255);
+      expect(caughtError).not.toBe(undefined);
+      expect(caughtError.message.length).toEqual(255);
     });
 
     it('should emit an error event', function (done) {
       const sampleError = new Error('Error to be emitted');
-
-      ProgramExecutorProcessor.prototype.process.rejects(sampleError);
+      ProgramExecutorProcessor.prototype.process = jest.fn().mockRejectedValue(sampleError);
 
       const programExecutor = ProgramExecutor.create(config);
 
       programExecutor.on('programError', function ({ error, message }) {
-        expect(message).to.eql({ random: 'message' });
-        expect(error.message).to.eql('Error to be emitted');
+        expect(message).toEqual({ random: 'message' });
+        expect(error.message).toEqual('Error to be emitted');
         done();
       });
 
       programExecutor.processPrograms(testJobLibrary);
-      const onMessageFunction = Consumer.create.lastCall.args[1].onMessage;
+      const onMessageFunction = Consumer.create.mock.calls[0][1].onMessage;
       onMessageFunction({ random: 'message' }).catch(() => {});
     });
 
     it('should start processing', async function () {
       await ProgramExecutor.create(config).processPrograms(testJobLibrary);
 
-      expect(Consumer.prototype.process).to.have.been.called;
+      expect(Consumer.prototype.process).toHaveBeenCalled();
     });
   });
 });

package/src/job-data-handler/{index.spec.js → index.test.js}

@@ -1,15 +1,16 @@
 'use strict';
 
-const JobHandler = require('./');
+const JobHandler = require('.');
 const ExecutionTimeExceededError = require('../execution-time-exceeded-error');
+jest.useFakeTimers();
 
 describe('JobDataHandler', function () {
   let programHandlerStub;
 
   beforeEach(function () {
     programHandlerStub = {
-      getJobData: this.sandbox.stub().resolves(true),
-      updateJobData: this.sandbox.stub().resolves(true)
+      getJobData: jest.fn().mockResolvedValue(true),
+      updateJobData: jest.fn().mockResolvedValue(true)
     };
   });
 
@@ -20,7 +21,7 @@ describe('JobDataHandler', function () {
 
       await JobHandler.create(programHandlerStub, runId, program).get();
 
-      expect(programHandlerStub.getJobData).to.have.been.calledWith(runId, program);
+      expect(programHandlerStub.getJobData).toHaveBeenCalledWith(runId, program);
     });
   });
 
@@ -31,7 +32,7 @@ describe('JobDataHandler', function () {
 
       await JobHandler.create(programHandlerStub, runId, program).set({ test: 'data' });
 
-      expect(programHandlerStub.updateJobData).to.have.been.calledWith(runId, program, { test: 'data' });
+      expect(programHandlerStub.updateJobData).toHaveBeenCalledWith(runId, program, { test: 'data' });
     });
   });
 
@@ -42,7 +43,7 @@ describe('JobDataHandler', function () {
 
       await JobHandler.create(programHandlerStub, runId, program).merge({ test: 'data' });
 
-      expect(programHandlerStub.updateJobData).to.have.been.calledWith(runId, program, { test: 'data' }, true);
+      expect(programHandlerStub.updateJobData).toHaveBeenCalledWith(runId, program, { test: 'data' }, true);
     });
   });
 
@@ -53,18 +54,17 @@ describe('JobDataHandler', function () {
 
       await JobHandler.create(programHandlerStub, runId, program).checkpoint({ test: 'data' });
 
-      expect(programHandlerStub.updateJobData).to.have.been.calledWith(runId, program, { test: 'data' }, true);
+      expect(programHandlerStub.updateJobData).toHaveBeenCalledWith(runId, program, { test: 'data' }, true);
     });
 
     it('should throw an ExecutionTimeExceededError if execution takes longer than given duration', async function () {
-      const clock = this.sandbox.useFakeTimers();
       const runId = '1';
       const program = 'product_sync';
       const maxExecutionTime = 1000;
 
       const jobHandler = JobHandler.create(programHandlerStub, runId, program);
 
-      clock.tick(maxExecutionTime + 1);
+      jest.advanceTimersByTime(maxExecutionTime + 1);
 
       let expectedError;
       try {
@@ -73,20 +73,17 @@ describe('JobDataHandler', function () {
         expectedError = error;
       }
 
-      expect(expectedError).to.be.an.instanceof(ExecutionTimeExceededError);
-      expect(expectedError.executionTimeExceeded).to.be.true;
-      clock.restore();
+      expect(expectedError).toBeInstanceOf(ExecutionTimeExceededError);
+      expect(expectedError.executionTimeExceeded).toBe(true);
     });
 
     it('should not throw an exception if execution time is shorter than given duration', async function () {
-      const clock = this.sandbox.useFakeTimers();
       const runId = '1';
       const program = 'product_sync';
       const maxExecutionTime = 1000;
 
       const jobHandler = JobHandler.create(programHandlerStub, runId, program);
-
-      clock.tick(maxExecutionTime - 1);
+      jest.advanceTimersByTime(maxExecutionTime - 1);
 
       let expectedError;
       try {
@@ -95,19 +92,17 @@ describe('JobDataHandler', function () {
         expectedError = error;
       }
 
-      expect(expectedError).to.be.undefined;
-      clock.restore();
+      expect(expectedError).toBe(undefined);
     });
 
     [0, null, undefined].forEach((executionTime) => {
       it('should not throw an exception if no max execution time given', async function () {
-        const clock = this.sandbox.useFakeTimers();
         const runId = '1';
         const program = 'product_sync';
 
         const jobHandler = JobHandler.create(programHandlerStub, runId, program);
 
-        clock.tick(99999);
+        jest.advanceTimersByTime(99999);
 
         let expectedError;
         try {
@@ -116,8 +111,7 @@ describe('JobDataHandler', function () {
           expectedError = error;
         }
 
-        expect(expectedError).to.be.undefined;
-        clock.restore();
+        expect(expectedError).toBe(undefined);
       });
     });
   });