@emartech/program-executor 3.11.0 → 3.12.0

package/src/program-executor-processor/{index.spec.js → index.test.js}

@@ -1,10 +1,13 @@
 'use strict';
 
-const ProgramExecutorProcessor = require('./');
+const ProgramExecutorProcessor = require('.');
 
 const ProgramHandler = require('../program-handler');
 const JobDataHandler = require('../job-data-handler');
 const QueueManager = require('../queue-manager');
+const JobHandler = require('../job-data-handler');
+
+jest.mock('../job-data-handler');
 
 describe('ProgramExecutorProcessor', function () {
   let programHandler;
@@ -16,6 +19,9 @@ describe('ProgramExecutorProcessor', function () {
   let failingJobExecuteWithIgnorableErrorStub;
   let failingJobExecuteWithRetryableErrorStub;
   let programHandlerIsProgramFinishedWithErrorStub;
+  let mockProgramHandler;
+  let setProgramToErrorStub;
+  let mockQueueProgram;
 
   beforeEach(async function () {
     const ignorableError = new Error('Something wrong happened, but ignore this!');
@@ -25,56 +31,63 @@ describe('ProgramExecutorProcessor', function () {
     const executionTimeExceededError = new Error('Timeout exceeded, but please retry!');
     executionTimeExceededError.executionTimeExceeded = true;
 
-    testJobExecuteStub = this.sandbox.stub();
-    failingJobExecuteStub = this.sandbox.stub().rejects(new Error('Something wrong happened!'));
-    failingJobExecuteWithIgnorableErrorStub = this.sandbox.stub().rejects(ignorableError);
-    failingJobExecuteWithRetryableErrorStub = this.sandbox.stub().rejects(retryableError);
+    testJobExecuteStub = jest.fn();
+    failingJobExecuteStub = jest.fn().mockRejectedValue(new Error('Something wrong happened!'));
+    failingJobExecuteWithIgnorableErrorStub = jest.fn().mockRejectedValue(ignorableError);
+    failingJobExecuteWithRetryableErrorStub = jest.fn().mockRejectedValue(retryableError);
     jobLibrary = {
       testJob: {
-        create: this.sandbox.stub().returns({
+        create: jest.fn().mockReturnValue({
           execute: testJobExecuteStub
         })
       },
       currentJob: {
-        create: this.sandbox.stub().returns({ execute() {} })
+        create: jest.fn().mockReturnValue({ execute() {} })
       },
       nextJob: {
-        create: this.sandbox.stub().returns({ execute() {} })
+        create: jest.fn().mockReturnValue({ execute() {} })
       },
       failingJob: {
-        create: this.sandbox.stub().returns({
+        create: jest.fn().mockReturnValue({
           execute: failingJobExecuteStub
         })
       },
       failingJobWithIgnorableError: {
-        create: this.sandbox.stub().returns({
+        create: jest.fn().mockReturnValue({
           execute: failingJobExecuteWithIgnorableErrorStub
         })
       },
       failingJobWithRetryableError: {
-        create: this.sandbox.stub().returns({
+        create: jest.fn().mockReturnValue({
           execute: failingJobExecuteWithRetryableErrorStub
         })
       },
       failingJobWithExecutionTimeExceededError: {
-        create: this.sandbox.stub().returns({
-          execute: this.sandbox.stub().rejects(executionTimeExceededError)
+        create: jest.fn().mockReturnValue({
+          execute: jest.fn().mockRejectedValue(executionTimeExceededError)
         })
       }
     };
+    mockQueueProgram = jest.fn().mockResolvedValue(true);
+    programHandlerIsProgramFinishedWithErrorStub = jest.fn().mockResolvedValue(false);
+    setProgramToErrorStub = jest.fn().mockResolvedValue(true);
+
+    mockProgramHandler = {
+      finishProgram: jest.fn().mockResolvedValue(true),
+      setProgramToError: jest.fn().mockResolvedValue(true),
+      setJobRetriableErrorMessage: jest.fn().mockResolvedValue(true),
+      incrementStep: jest.fn().mockResolvedValue(true),
+      incrementStepRetryCount: jest.fn().mockResolvedValue(true),
+      isProgramFinishedWithError: programHandlerIsProgramFinishedWithErrorStub,
+      setProgramToError: setProgramToErrorStub
+    };
+    ProgramHandler.create = jest.fn().mockReturnValue(mockProgramHandler);
 
-    this.sandbox.spy(JobDataHandler, 'create');
-    this.sandbox.stub(ProgramHandler.prototype, 'finishProgram').resolves(true);
-    this.sandbox.stub(ProgramHandler.prototype, 'setProgramToError').resolves(true);
-    this.sandbox.stub(ProgramHandler.prototype, 'setJobRetriableErrorMessage').resolves(true);
-    this.sandbox.stub(ProgramHandler.prototype, 'incrementStep').resolves(true);
-    this.sandbox.stub(ProgramHandler.prototype, 'incrementStepRetryCount').resolves(true);
-    programHandlerIsProgramFinishedWithErrorStub = this.sandbox
-      .stub(ProgramHandler.prototype, 'isProgramFinishedWithError')
-      .resolves(false);
-
-    this.sandbox.stub(QueueManager.prototype, 'queueProgram').resolves(true);
+    QueueManager.create = jest.fn().mockReturnValue({
+      queueProgram: mockQueueProgram
+    });
 
+    JobHandler.create = jest.fn().mockReturnValue(new JobHandler());
     programHandler = ProgramHandler.create();
     queueManager = QueueManager.create();
   });
@@ -92,12 +105,12 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      expect(jobLibrary.testJob.create).to.be.calledWithExactly(programData);
-      expect(testJobExecuteStub).to.be.calledWith({
+      expect(jobLibrary.testJob.create).toHaveBeenCalledWith(programData);
+      expect(testJobExecuteStub).toHaveBeenCalledWith(({
         programData,
         jobs: ['testJob'],
         runId: '1'
-      });
+      }), expect.any(JobDataHandler));
     });
 
     it('should pass job data handler for the given job and runId pair', async function () {
@@ -107,22 +120,20 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      const jobDataHandler = testJobExecuteStub.getCall(0).args[1];
-
-      expect(JobDataHandler.create).to.be.calledWith(this.sinon.match.instanceOf(ProgramHandler), '1', 'testJob');
-      expect(jobDataHandler).to.be.an.instanceOf(JobDataHandler);
+      const jobDataHandler = testJobExecuteStub.mock.calls[0][1];
+      expect(jobDataHandler).toBeInstanceOf(JobDataHandler);
     });
 
     it('should cancel execution if program already encountered an error', async function () {
-      programHandlerIsProgramFinishedWithErrorStub.resolves(true);
+      programHandlerIsProgramFinishedWithErrorStub.mockResolvedValue(true)(true);
       await ProgramExecutorProcessor.create(programHandler, queueManager, jobLibrary).process({
         jobs: ['testJob'],
         programData: {},
         runId: '1'
       });
 
-      expect(testJobExecuteStub).not.to.have.been.called;
-      expect(QueueManager.prototype.queueProgram).not.to.have.been.called;
+      expect(testJobExecuteStub).not.toHaveBeenCalled();
+      expect(mockQueueProgram).not.toHaveBeenCalled();
     });
 
     it('should throw an error if a job fails with non-ignorable error', async function () {
@@ -137,8 +148,8 @@ describe('ProgramExecutorProcessor', function () {
         caughtError = error;
       }
 
-      expect(caughtError).not.to.be.undefined;
-      expect(failingJobExecuteStub).to.be.called;
+      expect(caughtError).not.toBe(undefined);
+      expect(failingJobExecuteStub).toHaveBeenCalled();
     });
 
     it('should throw a retryable error if a job fails with ExecutionTimeExceededError', async function () {
@@ -153,7 +164,7 @@ describe('ProgramExecutorProcessor', function () {
         caughtError = error;
       }
 
-      expect(caughtError.retryable).to.be.true;
+      expect(caughtError.retryable).toBe(true);
     });
 
     it('should not throw an error if a job fails with an ignorable error', async function () {
@@ -162,7 +173,7 @@ describe('ProgramExecutorProcessor', function () {
         programData: {},
         runId: '1'
       });
-      expect(ProgramHandler.prototype.setProgramToError).to.be.calledWith(
+      expect(mockProgramHandler.setProgramToError).toHaveBeenCalledWith(
         '1',
         'Something wrong happened, but ignore this!'
       );
@@ -175,9 +186,10 @@ describe('ProgramExecutorProcessor', function () {
           programData: {},
           runId: '1'
         });
+      // eslint-disable-next-line no-unused-vars
       } catch (error) {
-        expect(ProgramHandler.prototype.setProgramToError).to.be.calledWith('1', 'Something wrong happened!');
-        expect(ProgramHandler.prototype.setJobRetriableErrorMessage).not.have.been.called;
+        expect(mockProgramHandler.setProgramToError).toHaveBeenCalledWith('1', 'Something wrong happened!');
+        expect(mockProgramHandler.setJobRetriableErrorMessage).not.toHaveBeenCalled();
       }
     });
 
@@ -188,10 +200,10 @@ describe('ProgramExecutorProcessor', function () {
           programData: {},
           runId: '1'
         });
-        // eslint-disable-next-line no-empty
+        // eslint-disable-next-line no-empty, no-unused-vars
       } catch (_error) {}
 
-      expect(ProgramHandler.prototype.incrementStepRetryCount).to.have.been.calledWith('1');
+      expect(mockProgramHandler.incrementStepRetryCount).toHaveBeenCalledWith('1');
     });
 
     it('should update error message only if job fails with retriable error', async function () {
@@ -201,9 +213,10 @@ describe('ProgramExecutorProcessor', function () {
           programData: {},
           runId: '1'
         });
+      // eslint-disable-next-line no-unused-vars
       } catch (error) {
-        expect(ProgramHandler.prototype.setProgramToError).not.have.been.called;
-        expect(ProgramHandler.prototype.setJobRetriableErrorMessage).to.be.calledWith(
+        expect(mockProgramHandler.setProgramToError).not.toHaveBeenCalled();
+        expect(mockProgramHandler.setJobRetriableErrorMessage).toHaveBeenCalledWith(
           '1',
           'Something wrong happened, but please retry!'
         );
@@ -219,7 +232,7 @@ describe('ProgramExecutorProcessor', function () {
         }
       });
 
-      expect(QueueManager.prototype.queueProgram).to.have.been.calledWith({
+      expect(mockQueueProgram).toHaveBeenCalledWith({
         jobs: ['nextJob'],
         programData: {
           customerId: 123,
@@ -235,7 +248,7 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      expect(ProgramHandler.prototype.incrementStep).to.have.been.calledWith('1');
+      expect(mockProgramHandler.incrementStep).toHaveBeenCalledWith('1');
     });
 
     it('should not requeue when it was the last job', async function () {
@@ -245,7 +258,7 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      expect(QueueManager.prototype.queueProgram).not.to.have.been.called;
+      expect(mockQueueProgram).not.toHaveBeenCalled();
     });
 
     it('should set program to finished when it was the last job', async function () {
@@ -255,7 +268,7 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      expect(ProgramHandler.prototype.finishProgram).to.have.been.calledWith('1');
+      expect(mockProgramHandler.finishProgram).toHaveBeenCalledWith('1');
     });
 
     it('should not set job to finished when it was not the last job', async function () {
@@ -265,7 +278,7 @@ describe('ProgramExecutorProcessor', function () {
         runId: '1'
       });
 
-      expect(ProgramHandler.prototype.finishProgram).not.to.have.been.called;
+      expect(mockProgramHandler.finishProgram).not.toHaveBeenCalled();
     });
   });
 });

package/src/program-handler/index.js

@@ -52,7 +52,13 @@ class ProgramHandler {
 
     jobData[jobName] = merge ? { ...jobData[jobName], ...payload } : payload;
 
-    devLogger.info('db update job data', { run_id: runId, jobName, payload: JSON.stringify(payload), merge, OSPID: process.pid });
+    devLogger.info('db update job data', {
+      run_id: runId,
+      jobName,
+      payload: JSON.stringify(payload),
+      merge,
+      OSPID: process.pid
+    });
     return this._programsRepository.setJobDataByRunId(runId, jobData);
   }
 

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

@@ -1,8 +1,11 @@
 'use strict';
 
-const ProgramHandler = require('./');
+const ProgramHandler = require('.');
 const QueueManager = require('../queue-manager');
 const ProgramsRepository = require('../repositories/programs');
+const knex = require('knex');
+const DbCleaner = require('../test-helper/db-cleaner');
+const { db } = require('../test-helper/get-test-db-config');
 
 const hostname = 'yolo.myshopify.com';
 const customerId = 123;
@@ -10,15 +13,36 @@ const customerId = 123;
 describe('ProgramHandler', function () {
   let programsRepository;
   let queueManager;
-  let queueProgramStub;
+  let mockQueueProgram;
+  let dbConnection;
+
+  beforeAll(function () {
+
+    dbConnection = knex({
+      client: 'pg',
+      connection: db.connection.connString
+    });
+  });
+
+    afterAll(async function () {
+    await DbCleaner.create(dbConnection).tearDown();
+    dbConnection.destroy();
+  });
+
 
   beforeEach(async function () {
-    programsRepository = ProgramsRepository.create(this.db, 'programs');
+    await DbCleaner.create(dbConnection).tearDown();
+    mockQueueProgram = jest.fn().mockResolvedValue(true);
+    QueueManager.create = jest.fn().mockReturnValue({
+      queueProgram: mockQueueProgram
+    });
+
+
+    programsRepository = ProgramsRepository.create(dbConnection, 'programs');
     queueManager = QueueManager.create('amqp://guest:guest@localhost:9999', 'program-executor');
-    queueProgramStub = this.sandbox.stub(QueueManager.prototype, 'queueProgram').resolves(true);
   });
 
-  describe('#createProgram', async function () {
+  describe('#createProgram', function () {
     it('should create a program with the given jobs and program data', async function () {
       const programData = { test: 'data' };
 
@@ -27,10 +51,10 @@ describe('ProgramHandler', function () {
         jobs: ['current_program', 'next_program']
       });
 
-      expect(QueueManager.prototype.queueProgram).to.have.been.calledWithMatch({
+      expect(mockQueueProgram).toHaveBeenCalledWith(expect.objectContaining({
         jobs: ['current_program', 'next_program'],
         programData
-      });
+      }));
     });
 
     it('should save program in db', async function () {
@@ -39,7 +63,7 @@ describe('ProgramHandler', function () {
       });
       const program = await programsRepository.getProgramByRunId(runId);
 
-      expect(program.jobs).to.have.members(['current_program', 'next_program']);
+      expect(program.jobs).toEqual(['current_program', 'next_program']);
     });
 
     it('should save program data in db', async function () {
@@ -53,7 +77,7 @@ describe('ProgramHandler', function () {
       });
       const program = await programsRepository.getProgramByRunId(runId);
 
-      expect(program.programData).to.eql({ hostname, customerId });
+      expect(program.programData).toEqual({ hostname, customerId });
     });
 
     it('should save job data in db', async function () {
@@ -69,7 +93,7 @@ describe('ProgramHandler', function () {
       });
       const program = await programsRepository.getProgramByRunId(runId);
 
-      expect(program.jobData).to.eql(jobData);
+      expect(program.jobData).toEqual(jobData);
     });
 
     it('should generate a runid for the program', async function () {
@@ -77,7 +101,7 @@ describe('ProgramHandler', function () {
         jobs: ['current_program', 'next_program']
       });
 
-      expect(queueProgramStub.lastCall.lastArg.runId).not.to.be.undefined;
+      expect(mockQueueProgram.mock.calls[0][0].runId).not.toBe(undefined);
     });
 
     it('should return the generated runid', async function () {
@@ -85,12 +109,12 @@ describe('ProgramHandler', function () {
         jobs: ['current_program', 'next_program']
       });
 
-      const generatedRunId = queueProgramStub.lastCall.lastArg.runId;
-      expect(generatedRunId).to.eql(result);
+      const generatedRunId = mockQueueProgram.mock.calls[0][0].runId;
+      expect(generatedRunId).toEqual(result);
     });
   });
 
-  describe('#finishProgram', async function () {
+  describe('#finishProgram', function () {
     it('should set job to finished in db', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -101,11 +125,11 @@ describe('ProgramHandler', function () {
       await programHandler.finishProgram(runId);
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.finishedAt).not.to.be.undefined;
+      expect(program.finishedAt).not.toBe(undefined);
     });
   });
 
-  describe('#getJobData', async function () {
+  describe('#getJobData', function () {
     it('should get program data for runid and program name', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
       const runId = await programHandler.createProgram({
@@ -114,11 +138,11 @@ describe('ProgramHandler', function () {
       await programHandler.updateJobData(runId, 'product_sync', { page: 123 });
 
       const jobData = await programHandler.getJobData(runId, 'product_sync');
-      expect(jobData).to.eql({ page: 123 });
+      expect(jobData).toEqual({ page: 123 });
     });
   });
 
-  describe('#setProgramToError', async function () {
+  describe('#setProgramToError', function () {
     it('should set job to errored in db', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -128,12 +152,12 @@ describe('ProgramHandler', function () {
       await programHandler.setProgramToError(runId, 'Something wrong happened!');
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.erroredAt).not.to.be.undefined;
-      expect(program.errorMessage).to.equal('Something wrong happened!');
+      expect(program.erroredAt).not.toBe(undefined);
+      expect(program.errorMessage).toEqual('Something wrong happened!');
     });
   });
 
-  describe('#isProgramFinishedWithError', async function () {
+  describe('#isProgramFinishedWithError', function () {
     it('should return true if erroredAt is not null', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -143,7 +167,7 @@ describe('ProgramHandler', function () {
       await programHandler.setProgramToError(runId, 'Something wrong happened!');
 
       const result = await programHandler.isProgramFinishedWithError(runId);
-      expect(result).to.be.true;
+      expect(result).toBe(true);
     });
 
     it('should return false if erroredAt is null', async function () {
@@ -154,11 +178,11 @@ describe('ProgramHandler', function () {
       });
 
       const result = await programHandler.isProgramFinishedWithError(runId);
-      expect(result).to.be.false;
+      expect(result).toBe(false);
     });
   });
 
-  describe('#setJobRetriableErrorMessage', async function () {
+  describe('#setJobRetriableErrorMessage', function () {
     it('should set program to errored in db', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -168,13 +192,13 @@ describe('ProgramHandler', function () {
       await programHandler.setJobRetriableErrorMessage(runId, 'Something wrong happened!');
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.finishedAt).to.eql(null);
-      expect(program.erroredAt).to.eql(null);
-      expect(program.errorMessage).to.eql('Something wrong happened!');
+      expect(program.finishedAt).toEqual(null);
+      expect(program.erroredAt).toEqual(null);
+      expect(program.errorMessage).toEqual('Something wrong happened!');
     });
   });
 
-  describe('#incrementStep', async function () {
+  describe('#incrementStep', function () {
     it('should increment step', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -184,11 +208,11 @@ describe('ProgramHandler', function () {
       await programHandler.incrementStep(runId);
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.step).to.eql(1);
+      expect(program.step).toEqual(1);
     });
   });
 
-  describe('#incrementStepRetryCount', async function () {
+  describe('#incrementStepRetryCount', function () {
     it('should increment StepRetryCount', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
 
@@ -198,11 +222,11 @@ describe('ProgramHandler', function () {
       await programHandler.incrementStepRetryCount(runId);
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.stepRetryCount).to.eql(1);
+      expect(program.stepRetryCount).toEqual(1);
     });
   });
 
-  describe('#updateJobData', async function () {
+  describe('#updateJobData', function () {
     it('should update job data related to jobName overwriting the full payload', async function () {
       const programHandler = ProgramHandler.create(programsRepository, queueManager);
       const runId = await programHandler.createProgram({
@@ -213,7 +237,7 @@ describe('ProgramHandler', function () {
       await programHandler.updateJobData(runId, 'contact-sync', { page: 10 });
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.jobData).to.eql({
+      expect(program.jobData).toEqual({
         'contact-sync': { page: 10 }
       });
     });
@@ -228,7 +252,7 @@ describe('ProgramHandler', function () {
       await programHandler.updateJobData(runId, 'contact-sync', { page: 10 }, true);
 
       const program = await programsRepository.getProgramByRunId(runId);
-      expect(program.jobData).to.eql({
+      expect(program.jobData).toEqual({
         'contact-sync': { this_wont_be_gone: ':)', page: 10 }
       });
     });

package/src/queue-manager/{index.spec.js → index.test.js}

@@ -1,27 +1,26 @@
 'use strict';
 
-const QueueManager = require('./');
+const QueueManager = require('.');
 const RabbitMq = require('@emartech/rabbitmq-client').RabbitMq;
-
+const Logger = require('@emartech/json-logger').Logger;
 const testAmqpUrl = 'amqp://guest:guest@localhost:5672';
 const testChannelName = 'program-executor';
 
 describe('Queue-Manager', function () {
   describe('queueProgram', function () {
     it('should add proper queue item to the given channel', async function () {
-      const rabbitMock = {
-        insert: this.sandbox.stub().resolves(true),
-        waitForConfirms: this.sandbox.stub().resolves(true)
-      };
-
-      this.sandbox.stub(RabbitMq, 'create').resolves(rabbitMock);
+      const insertMock = jest.fn();
+      RabbitMq.create = jest.fn().mockResolvedValue({
+        insert: insertMock,
+        waitForConfirms: jest.fn().mockResolvedValue(true)
+      });
 
       const queueManager = new QueueManager(testAmqpUrl, testChannelName);
       const queueData = { test_data: 123 };
 
       await queueManager.queueProgram(queueData);
 
-      expect(RabbitMq.create).to.have.been.calledWith(
+      expect(RabbitMq.create).toHaveBeenCalledWith(
         { programExecutor: { url: testAmqpUrl, useConfirmChannel: true } },
         testChannelName,
         'programExecutor',
@@ -30,24 +29,22 @@ describe('Queue-Manager', function () {
           deadLetterRoutingKey: `${testChannelName}-retry-1000`
         }
       );
-      expect(rabbitMock.insert).to.have.been.calledWith(queueData);
+      expect(insertMock).toHaveBeenCalledWith(queueData, expect.anything());
     });
 
     it('should log if confirmation fails instead of throwing', async function () {
       const errorToThrow = new Error('Boom!');
-      const rabbitMock = {
-        insert: this.sandbox.stub().resolves(true),
-        waitForConfirms: this.sandbox.stub().rejects(errorToThrow)
-      };
-
-      this.sandbox.stub(RabbitMq, 'create').resolves(rabbitMock);
+      Logger.prototype.fromError = jest.fn();
+      const insertMock = jest.fn();
+      RabbitMq.create = jest.fn().mockResolvedValue({
+        insert: insertMock,
+        waitForConfirms: jest.fn(() => { throw errorToThrow; })
+      });
 
       const queueManager = new QueueManager(testAmqpUrl, testChannelName);
       const queueData = { test_data: 123 };
-
       await queueManager.queueProgram(queueData);
-
-      expect(this.formErrorStub).to.have.been.calledWith('confirm-error', errorToThrow);
+      expect(Logger.prototype.fromError ).toHaveBeenCalledWith('confirm-error', errorToThrow, {queue_data: JSON.stringify(queueData)});
     });
   });
 });

package/src/queue-manager-pubsub/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const PubSubClient = require('@emartech/pubsub-client-js').PubSubClient;
+const logger = require('@emartech/json-logger')('program-executor-queue-manager-pubsub');
+
+class QueueManager {
+  constructor(topicName, projectId, gcpKeyFileName) {
+    this._gcpKeyFileName = gcpKeyFileName;
+    this._projectId = projectId;
+    this._topicName = topicName;
+  }
+
+  async queueProgram(queueData) {
+    try {
+      const pubsub = await PubSubClient.create(
+        this._topicName, this._projectId, this._gcpKeyFileName
+      );
+
+      await pubsub.insert(queueData);
+
+    } catch (error) {
+      logger.fromError('queue-error', error, { queue_data: JSON.stringify(queueData) });
+      PubSubClient.clearPublisherCache();
+      throw error;
+    }
+  }
+
+  static create(topicName, projectId, gcpKeyFileName) {
+    return new QueueManager(topicName, projectId, gcpKeyFileName);
+  }
+}
+
+module.exports = QueueManager;

package/src/queue-manager-pubsub/index.test.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const QueueManager = require('.');
+const PubSubClient = require('@emartech/pubsub-client-js').PubSubClient;
+const Logger = require('@emartech/json-logger').Logger;
+const testProjectId = 'test-project';
+const testGcpKeyFileName = { key: 'test-key-file.json' };
+const testTopicName = 'program-executor';
+
+describe('Queue-Manager', function () {
+  describe('queueProgram', function () {
+    it('should add proper queue item to the given topic', async function () {
+      const insertMock = jest.fn();
+      PubSubClient.create = jest.fn().mockResolvedValue({
+        insert: insertMock
+      });
+
+      const queueManager = new QueueManager(testTopicName, testProjectId, testGcpKeyFileName);
+      const queueData = { test_data: 123 };
+
+      await queueManager.queueProgram(queueData);
+
+      expect(PubSubClient.create).toHaveBeenCalledWith(
+        testTopicName, testProjectId, testGcpKeyFileName
+      );
+      expect(insertMock).toHaveBeenCalledWith(queueData);
+    });
+
+    it('should log if confirmation fails instead of throwing', async function () {
+      const errorToThrow = new Error('Boom!');
+      Logger.prototype.fromError = jest.fn();
+      const insertMock = jest.fn().mockRejectedValue(errorToThrow);
+      PubSubClient.create = jest.fn().mockResolvedValue({
+        insert: insertMock
+      });
+
+      const queueManager = new QueueManager(testTopicName, testProjectId, testGcpKeyFileName);
+      const queueData = { test_data: 123 };
+      await expect(queueManager.queueProgram(queueData)).rejects.toThrow(errorToThrow);
+      expect(Logger.prototype.fromError)
+        .toHaveBeenCalledWith('queue-error', errorToThrow, { queue_data: JSON.stringify(queueData) });
+    });
+  });
+});