bullmq 4.0.0-beta.1 → 4.0.0

package/src/test/test_connection.ts

@@ -1,159 +0,0 @@
-import IORedis from 'ioredis';
-import { Queue, QueueEvents, Job, Worker } from '@src/classes';
-
-import { v4 } from 'node-uuid';
-import { expect } from 'chai';
-
-describe('connection', () => {
-  let queue: Queue;
-  let queueName: string;
-  let client: IORedis.Redis;
-
-  beforeEach(function() {
-    client = new IORedis();
-    return client.flushdb();
-  });
-
-  beforeEach(function() {
-    queueName = 'test-' + v4();
-    queue = new Queue(queueName, {
-      connection: { port: 6379, host: '127.0.0.1' },
-    });
-  });
-
-  afterEach(async () => {
-    await client.quit();
-    await queue.close();
-  });
-
-  it('should recover from a connection loss', async () => {
-    let processor;
-    queue.on('error', () => {
-      // error event has to be observed or the exception will bubble up
-    });
-
-    const processing = new Promise(resolve => {
-      processor = async (job: Job) => {
-        expect(job.data.foo).to.be.equal('bar');
-        resolve();
-      };
-    });
-
-    const worker = new Worker(queueName, processor);
-
-    await worker.waitUntilReady();
-    await queue.waitUntilReady();
-
-    // Simulate disconnect
-    (<any>queue.client).stream.end();
-    queue.client.emit('error', new Error('ECONNRESET'));
-
-    (<any>worker.client).stream.end();
-    worker.client.emit('error', new Error('ECONNRESET'));
-
-    // add something to the queue
-    await queue.add('test', { foo: 'bar' });
-
-    await processing;
-
-    await worker.close();
-  });
-
-  it('should handle jobs added before and after a redis disconnect', async () => {
-    let count = 0;
-    let processor;
-
-    const processing = new Promise((resolve, reject) => {
-      processor = async (job: Job) => {
-        try {
-          if (count == 0) {
-            expect(job.data.foo).to.be.equal('bar');
-          } else {
-            resolve();
-          }
-          count++;
-        } catch (err) {
-          reject(err);
-        }
-      };
-    });
-
-    const worker = new Worker(queueName, processor);
-    await worker.waitUntilReady();
-
-    worker.on('completed', async () => {
-      if (count === 1) {
-        (<any>queue.client).stream.end();
-        queue.client.emit('error', new Error('ECONNRESET'));
-
-        (<any>worker.client).stream.end();
-        worker.client.emit('error', new Error('ECONNRESET'));
-
-        await queue.add('test', { foo: 'bar' });
-      }
-    });
-
-    await queue.waitUntilReady();
-    await queue.add('test', { foo: 'bar' });
-
-    await processing;
-
-    await worker.close();
-  });
-
-  /*
-  it('should not close external connections', () => {
-    const client = new redis();
-    const subscriber = new redis();
-
-    const opts = {
-      createClient(type) {
-        switch (type) {
-          case 'client':
-            return client;
-          case 'subscriber':
-            return subscriber;
-          default:
-            return new redis();
-        }
-      },
-    };
-
-    const testQueue = utils.buildQueue('external connections', opts);
-
-    return testQueue
-      .isReady()
-      .then(() => {
-        return testQueue.add({ foo: 'bar' });
-      })
-      .then(() => {
-        expect(testQueue.client).to.be.eql(client);
-        expect(testQueue.eclient).to.be.eql(subscriber);
-
-        return testQueue.close();
-      })
-      .then(() => {
-        expect(client.status).to.be.eql('ready');
-        expect(subscriber.status).to.be.eql('ready');
-        return Promise.all([client.quit(), subscriber.quit()]);
-      });
-  });
-  */
-
-  it('should fail if redis connection fails', async () => {
-    const queueFail = new Queue('connection fail port', {
-      connection: { port: 1234, host: '127.0.0.1' },
-    });
-
-    return new Promise(async (resolve, reject) => {
-      try {
-        await queueFail.waitUntilReady();
-        reject(new Error('Did not fail connecting to invalid redis instance'));
-      } catch (err) {
-        expect(err.code).to.be.eql('ECONNREFUSED');
-        await queueFail.close();
-        resolve();
-      }
-    });
-  });
-});

package/src/test/test_delay.ts

@@ -1,220 +0,0 @@
-import { Queue, Job } from '@src/classes';
-import { describe, beforeEach, it } from 'mocha';
-import { expect } from 'chai';
-import IORedis from 'ioredis';
-import { v4 } from 'node-uuid';
-import { Worker } from '@src/classes/worker';
-import { QueueEvents } from '@src/classes/queue-events';
-import { QueueScheduler } from '@src/classes/queue-scheduler';
-
-describe('Delayed jobs', function() {
-  this.timeout(15000);
-
-  let queue: Queue;
-  let queueName: string;
-  let client: IORedis.Redis;
-
-  beforeEach(function() {
-    client = new IORedis();
-    return client.flushdb();
-  });
-
-  beforeEach(async function() {
-    queueName = 'test-' + v4();
-    queue = new Queue(queueName);
-  });
-
-  afterEach(async function() {
-    await queue.close();
-    return client.quit();
-  });
-
-  it('should process a delayed job only after delayed time', async function() {
-    const delay = 500;
-    const queueScheduler = new QueueScheduler(queueName);
-    await queueScheduler.waitUntilReady();
-
-    const queueEvents = new QueueEvents(queueName);
-    await queueEvents.waitUntilReady();
-
-    const worker = new Worker(queueName, async job => {});
-
-    const timestamp = Date.now();
-    let publishHappened = false;
-
-    queueEvents.on('delayed', () => (publishHappened = true));
-
-    const completed = new Promise((resolve, reject) => {
-      queueEvents.on('completed', async function() {
-        try {
-          expect(Date.now() > timestamp + delay);
-          const jobs = await queue.getWaiting();
-          expect(jobs.length).to.be.equal(0);
-
-          const delayedJobs = await queue.getDelayed();
-          expect(delayedJobs.length).to.be.equal(0);
-          expect(publishHappened).to.be.eql(true);
-          await worker.close();
-          resolve();
-        } catch (err) {
-          reject(err);
-        }
-      });
-    });
-
-    const job = await queue.add('test', { delayed: 'foobar' }, { delay });
-
-    expect(job.id).to.be.ok;
-    expect(job.data.delayed).to.be.eql('foobar');
-    expect(job.opts.delay).to.be.eql(delay);
-
-    await completed;
-    await queueScheduler.close();
-  });
-
-  it('should process delayed jobs in correct order', async function() {
-    let order = 0;
-    let processor;
-    const queueScheduler = new QueueScheduler(queueName);
-    await queueScheduler.waitUntilReady();
-
-    const processing = new Promise((resolve, reject) => {
-      processor = async (job: Job) => {
-        order++;
-        try {
-          expect(order).to.be.equal(job.data.order);
-          if (order === 10) {
-            resolve();
-          }
-        } catch (err) {
-          reject(err);
-        }
-      };
-    });
-
-    const worker = new Worker(queueName, processor);
-
-    worker.on('failed', function(job, err) {
-      err.job = job;
-    });
-
-    await Promise.all([
-      queue.add('test', { order: 1 }, { delay: 100 }),
-      queue.add('test', { order: 6 }, { delay: 600 }),
-      queue.add('test', { order: 10 }, { delay: 1000 }),
-      queue.add('test', { order: 2 }, { delay: 200 }),
-      queue.add('test', { order: 9 }, { delay: 900 }),
-      queue.add('test', { order: 5 }, { delay: 500 }),
-      queue.add('test', { order: 3 }, { delay: 300 }),
-      queue.add('test', { order: 7 }, { delay: 700 }),
-      queue.add('test', { order: 4 }, { delay: 400 }),
-      queue.add('test', { order: 8 }, { delay: 800 }),
-    ]);
-
-    await processing;
-
-    await queueScheduler.close();
-    await worker.close();
-  });
-
-  /*
-  it('should process delayed jobs in correct order even in case of restart', function(done) {
-    this.timeout(15000);
-
-    var QUEUE_NAME = 'delayed queue multiple' + uuid();
-    var order = 1;
-
-    queue = new Queue(QUEUE_NAME);
-
-    var fn = function(job, jobDone) {
-      expect(order).to.be.equal(job.data.order);
-      jobDone();
-
-      if (order === 4) {
-        queue.close().then(done, done);
-      }
-
-      order++;
-    };
-
-    Bluebird.join(
-      queue.add({ order: 2 }, { delay: 300 }),
-      queue.add({ order: 4 }, { delay: 500 }),
-      queue.add({ order: 1 }, { delay: 200 }),
-      queue.add({ order: 3 }, { delay: 400 }),
-    )
-      .then(function() {
-        //
-        // Start processing so that jobs get into the delay set.
-        //
-        queue.process(fn);
-        return Bluebird.delay(20);
-      })
-      .then(function() {
-        //We simulate a restart
-        // console.log('RESTART');
-        // return queue.close().then(function () {
-        //   console.log('CLOSED');
-        //   return Promise.delay(100).then(function () {
-        //     queue = new Queue(QUEUE_NAME);
-        //     queue.process(fn);
-        //   });
-        // });
-      });
-  });
-*/
-
-  it('should process delayed jobs with exact same timestamps in correct order (FIFO)', async function() {
-    let order = 1;
-
-    const queueScheduler = new QueueScheduler(queueName);
-    await queueScheduler.waitUntilReady();
-
-    let processor;
-
-    const processing = new Promise((resolve, reject) => {
-      processor = async (job: Job) => {
-        try {
-          expect(order).to.be.equal(job.data.order);
-
-          if (order === 12) {
-            resolve();
-          }
-        } catch (err) {
-          reject(err);
-        }
-
-        order++;
-      };
-    });
-
-    const now = Date.now();
-    const promises = [];
-    let i = 1;
-    for (i; i <= 12; i++) {
-      promises.push(
-        queue.add(
-          'test',
-          { order: i },
-          {
-            delay: 1000,
-            timestamp: now,
-          },
-        ),
-      );
-    }
-    await Promise.all(promises);
-
-    const worker = new Worker(queueName, processor);
-
-    worker.on('failed', function(job, err) {
-      err.job = job;
-    });
-
-    await processing;
-
-    await queueScheduler.close();
-
-    await worker.close();
-  });
-});

package/src/test/test_events.ts

@@ -1,198 +0,0 @@
-import { Queue } from '@src/classes';
-import { QueueEvents } from '@src/classes/queue-events';
-import { Worker } from '@src/classes/worker';
-import { expect } from 'chai';
-import IORedis from 'ioredis';
-import { beforeEach, describe, it } from 'mocha';
-import { v4 } from 'node-uuid';
-
-describe('events', function() {
-  this.timeout(4000);
-  let queue: Queue;
-  let queueEvents: QueueEvents;
-  let queueName: string;
-  let client: IORedis.Redis;
-
-  beforeEach(function() {
-    client = new IORedis();
-    return client.flushdb();
-  });
-
-  beforeEach(async function() {
-    queueName = 'test-' + v4();
-    queue = new Queue(queueName);
-    queueEvents = new QueueEvents(queueName);
-    return queueEvents.waitUntilReady();
-  });
-
-  afterEach(async function() {
-    await queue.close();
-    await queueEvents.close();
-    return client.quit();
-  });
-
-  it('should emit waiting when a job has been added', async function() {
-    const waiting = new Promise(resolve => {
-      queue.on('waiting', resolve);
-    });
-
-    await queue.add('test', { foo: 'bar' });
-
-    await waiting;
-  });
-
-  it('should emit global waiting event when a job has been added', async function() {
-    const waiting = new Promise(resolve => {
-      queue.on('waiting', resolve);
-    });
-
-    await queue.add('test', { foo: 'bar' });
-
-    await waiting;
-  });
-
-  it('emits drained global drained event when all jobs have been processed', async function() {
-    const worker = new Worker(queueName, async job => {}, {
-      drainDelay: 1,
-    });
-
-    const drained = new Promise(resolve => {
-      queueEvents.once('drained', resolve);
-    });
-
-    await queue.add('test', { foo: 'bar' });
-    await queue.add('test', { foo: 'baz' });
-
-    await drained;
-
-    const jobs = await queue.getJobCountByTypes('completed');
-    expect(jobs).to.be.equal(2);
-
-    await worker.close();
-  });
-
-  it('emits drained event when all jobs have been processed', async function() {
-    const worker = new Worker(queueName, async job => {}, {
-      drainDelay: 1,
-    });
-
-    const drained = new Promise(resolve => {
-      worker.once('drained', resolve);
-    });
-
-    await queue.add('test', { foo: 'bar' });
-    await queue.add('test', { foo: 'baz' });
-
-    await drained;
-
-    const jobs = await queue.getJobCountByTypes('completed');
-    expect(jobs).to.be.equal(2);
-
-    await worker.close();
-  });
-
-  it('should emit an event when a job becomes active', async () => {
-    const worker = new Worker(queueName, async job => {});
-
-    await queue.add('test', {});
-
-    const completed = new Promise(resolve => {
-      worker.once('active', function() {
-        worker.once('completed', async function() {
-          await worker.close();
-          resolve();
-        });
-      });
-    });
-
-    await completed;
-  });
-
-  it('should listen to global events', async () => {
-    const worker = new Worker(queueName, async job => {});
-
-    let state: string;
-    queueEvents.on('waiting', function() {
-      expect(state).to.be.undefined;
-      state = 'waiting';
-    });
-    queueEvents.once('active', function() {
-      expect(state).to.be.equal('waiting');
-      state = 'active';
-    });
-
-    const completed = new Promise(resolve => {
-      queueEvents.once('completed', async function() {
-        expect(state).to.be.equal('active');
-        resolve();
-      });
-    });
-
-    await queue.add('test', {});
-
-    await completed;
-    await worker.close();
-  });
-
-  it('should trim events automatically', async () => {
-    const worker = new Worker('test', async () => {});
-    const trimmedQueue = new Queue('test', {
-      streams: {
-        events: {
-          maxLen: 0,
-        },
-      },
-    });
-
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-
-    const waitForCompletion = new Promise(resolve => {
-      worker.on('drained', resolve);
-    });
-
-    await waitForCompletion;
-    await worker.close();
-
-    const [[id, [_, event]]] = await trimmedQueue.client.xrange(
-      trimmedQueue.keys.events,
-      '-',
-      '+',
-    );
-
-    expect(event).to.be.equal('drained');
-
-    const eventsLength = await trimmedQueue.client.xlen(
-      trimmedQueue.keys.events,
-    );
-
-    expect(eventsLength).to.be.equal(1);
-
-    await trimmedQueue.close();
-  });
-
-  it('should trim events manually', async () => {
-    const trimmedQueue = new Queue('test-manual');
-
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-    await trimmedQueue.add('test', {});
-
-    await trimmedQueue.waitUntilReady();
-
-    let eventsLength = await trimmedQueue.client.xlen(trimmedQueue.keys.events);
-
-    expect(eventsLength).to.be.equal(4);
-
-    await trimmedQueue.trimEvents(0);
-
-    eventsLength = await trimmedQueue.client.xlen(trimmedQueue.keys.events);
-
-    expect(eventsLength).to.be.equal(0);
-
-    await trimmedQueue.close();
-  });
-});