@emartech/program-executor 3.11.1 → 3.12.1

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);
       });
     });
   });

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!'
       );
@@ -177,8 +188,8 @@ describe('ProgramExecutorProcessor', function () {
         });
       // 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();
       }
     });
 
@@ -192,7 +203,7 @@ describe('ProgramExecutorProcessor', function () {
         // 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 () {
@@ -204,8 +215,8 @@ describe('ProgramExecutorProcessor', function () {
         });
       // 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!'
         );
@@ -221,7 +232,7 @@ describe('ProgramExecutorProcessor', function () {
         }
       });
 
-      expect(QueueManager.prototype.queueProgram).to.have.been.calledWith({
+      expect(mockQueueProgram).toHaveBeenCalledWith({
         jobs: ['nextJob'],
         programData: {
           customerId: 123,
@@ -237,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 () {
@@ -247,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 () {
@@ -257,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 () {
@@ -267,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.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 }
       });
     });