test: fix flaky tests

tests/test_events.ts

@@ -367,14 +367,14 @@ describe('events', function () {
       const worker = new Worker(
         queueName,
         async () => {
-          await delay(100);
+          await delay(50);
+          await queue.add(testName, { foo: 'bar' }, { jobId: 'a1' });
+          await delay(50);
         },
-        { connection, prefix },
+        { autorun: false, connection, prefix },
       );
       await worker.waitUntilReady();
 
-      let duplicatedEvent = false;
-
       const completed = new Promise<void>(resolve => {
         worker.on('completed', async function () {
           resolve();
@@ -383,17 +383,17 @@ describe('events', function () {
 
       await queue.add(testName, { foo: 'bar' }, { jobId: 'a1' });
 
-      queueEvents.once('duplicated', ({ jobId }) => {
-        expect(jobId).to.be.equal('a1');
-        duplicatedEvent = true;
-      });
+      worker.run();
 
-      await queue.add(testName, { foo: 'bar' }, { jobId: 'a1' });
+      await new Promise<void>(resolve => {
+        queueEvents.once('duplicated', ({ jobId }) => {
+          expect(jobId).to.be.equal('a1');
+          resolve();
+        });
+      });
 
       await completed;
 
-      expect(duplicatedEvent).to.be.true;
-
       await worker.close();
     });
   });

tests/test_metrics.ts

@@ -305,6 +305,7 @@ describe('metrics', function () {
         throw new Error('test');
       },
       {
+        autorun: false,
         connection,
         prefix,
         metrics: {
@@ -329,11 +330,10 @@ describe('metrics', function () {
       await queue.add('test', { index: i });
     }
 
+    worker.run();
     await completing;
 
-    const closing = worker.close();
-
-    await closing;
+    await worker.close();
 
     const metrics = await queue.getMetrics('failed');
 

tests/test_pause.ts

@@ -356,8 +356,6 @@ describe('Pause', function () {
 
   describe('when backoff is 0', () => {
     it('moves job into paused queue', async () => {
-      await queue.add('test', { foo: 'bar' }, { attempts: 2, backoff: 0 });
-
       let worker: Worker;
       const processing = new Promise<void>(resolve => {
         worker = new Worker(
@@ -372,6 +370,7 @@ describe('Pause', function () {
             resolve();
           },
           {
+            autorun: false,
             connection,
             prefix,
           },
@@ -389,6 +388,9 @@ describe('Pause', function () {
         });
       });
 
+      await queue.add('test', { foo: 'bar' }, { attempts: 2, backoff: 0 });
+
+      worker!.run();
       await waitingEvent;
       await processing;
 

tests/test_repeat.ts

@@ -50,6 +50,7 @@ describe('repeat', function () {
     queue = new Queue(queueName, { connection, prefix });
     repeat = new Repeat(queueName, { connection, prefix });
     queueEvents = new QueueEvents(queueName, { connection, prefix });
+    await queue.waitUntilReady();
     await queueEvents.waitUntilReady();
   });
 
@@ -183,13 +184,13 @@ describe('repeat', function () {
     delayStub.restore();
   });
 
-  it('should create multiple jobs if they have the same cron pattern', async function () {
+  it('should create multiple jobs if they have the same cron pattern and different name', async function () {
     const cron = '*/10 * * * * *';
 
     await Promise.all([
       queue.add('test1', {}, { repeat: { pattern: cron } }),
       queue.add('test2', {}, { repeat: { pattern: cron } }),
-      queue.add('test3', {}),
+      queue.add('test3', {}, { repeat: { pattern: cron } }),
     ]);
 
     const count = await queue.count();

tests/test_worker.ts

@@ -857,7 +857,7 @@ describe('workers', function () {
 
       await delay(100);
       /* Try to gracefully close while having a job that will be failed running */
-      worker.close();
+      const closing = worker.close();
 
       await new Promise<void>(resolve => {
         worker.once('failed', async (job, err) => {
@@ -871,6 +871,7 @@ describe('workers', function () {
       const count = await queue.getJobCounts('active', 'failed');
       expect(count.active).to.be.eq(0);
       expect(count.failed).to.be.eq(1);
+      await closing;
     });
 
     it('process a job that complete after worker close', async () => {
@@ -1732,6 +1733,7 @@ describe('workers', function () {
       const processing = new Promise<void>((resolve, reject) => {
         processor = async (job: Job) => {
           try {
+            await delay(10);
             expect(job.data.num).to.be.equal(counter);
             expect(job.data.foo).to.be.equal('bar');
             if (counter === maxJobs) {
@@ -2716,13 +2718,14 @@ describe('workers', function () {
       const worker = new Worker(
         queueName,
         async job => {
+          await delay(10);
           expect(job.attemptsMade).to.be.eql(tries);
           tries++;
           if (job.attemptsMade < 1) {
             throw new Error('Not yet!');
           }
         },
-        { connection, prefix },
+        { autorun: false, connection, prefix },
       );
 
       await worker.waitUntilReady();
@@ -2735,6 +2738,8 @@ describe('workers', function () {
         },
       );
 
+      worker.run();
+
       await new Promise(resolve => {
         worker.on('completed', resolve);
       });