node-resque/test/plugins/jobLock.js

an opinionated implementation of resque in node

var specHelper = require(__dirname + "/../_specHelper.js").specHelper;
var should = require('should');

describe('plugins', function(){

  var jobDelay = 1000;

  var jobs = {
    "slowAdd": {
      plugins: [ 'jobLock' ],
      pluginOptions: { jobLock: {}, },
      perform: function(a,b,callback){
        var answer = a + b;
        setTimeout(function(){
          callback(null, answer);
        }, jobDelay);
      },
    },
    "uniqueJob": {
      plugins: [ 'queueLock', 'delayQueueLock' ],
      pluginOptions: { queueLock: {}, delayQueueLock: {} },
      perform: function(a,b,callback){
        var answer = a + b;
        callback(null, answer);
      },
    }
  };

  before(function(done){
    specHelper.connect(function(){
      specHelper.cleanup(function(){
        queue = new specHelper.NR.queue({connection: specHelper.cleanConnectionDetails(), queue: specHelper.queue}, jobs, function(){
          done();
        });
      });
    });
  });

  afterEach(function(done){
    specHelper.cleanup(function(){
      done();
    });
  });

  describe('jobLock',function(){
    it('will not lock jobs since arg objects are different', function(done){
      worker1 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
        worker2 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
          var startTime = new Date().getTime();
          var completed = 0;

          var onComplete = function(q, job, result){
            completed++;
            if(completed == 2){
              worker1.end();
              worker2.end();
              (new Date().getTime() - startTime).should.be.below(jobDelay * 2);
              done();
            }
          };

          worker1.on('success', onComplete);
          worker2.on('success', onComplete);
          queue.enqueue(specHelper.queue, "slowAdd", [{name: 'Walter White'},2], function(){
            queue.enqueue(specHelper.queue, "slowAdd", [{name: 'Jesse Pinkman'},2], function(){
              worker1.start();
              worker2.start();
            });
          });

          worker1.on('error', function(queue, job, error){ console.log(error.stack); });
          worker2.on('error', function(queue, job, error){ console.log(error.stack); });
        });
      });
    });

    it('allows the key to be specified as a function', function(done) {
      var calls = 0;
      var jobs = {
        jobLockAdd: {
          plugins: [ 'jobLock' ],
          pluginOptions: {
            jobLock: {
              key: function(){
                // Once to create, once to delete
                if (++calls == 2) {
                  done();
                  worker1.end();
                }
                return this.worker.connection.key('customKey', Math.max.apply(Math.max, this.args));
              }
            }
          },
          perform: function(a,b,callback){
            callback(null, a + b);
          }
        }
      };

      worker1 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
        queue.enqueue(specHelper.queue, "jobLockAdd", [1,2], function(){
          worker1.start();
        });
      });

      worker1.on('error', function(queue, job, error){ console.log(error.stack); });
    });

    it('will not run 2 jobs with the same args at the same time', function(done){
      worker1 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
        worker2 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
          var startTime = new Date().getTime();
          var completed = 0;

          var onComplete = function(q, job, result){
            completed++;
            if(completed == 2){
              worker1.end();
              worker2.end();
              (new Date().getTime() - startTime).should.be.above(jobDelay * 2);
              done();
            }
          };

          worker1.on('success', onComplete);
          worker2.on('success', onComplete);
          queue.enqueue(specHelper.queue, "slowAdd", [1,2], function(){
            queue.enqueue(specHelper.queue, "slowAdd", [1,2], function(){
              worker1.start();
              worker2.start();
            });
          });

          worker1.on('error', function(queue, job, error){ console.log(error.stack); });
          worker2.on('error', function(queue, job, error){ console.log(error.stack); });
        });
      });
    });

    it('will run 2 jobs with the different args at the same time', function(done){
      worker1 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
        worker2 = new specHelper.NR.worker({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout, queues: specHelper.queue}, jobs, function(){
          var startTime = new Date().getTime();
          var completed = 0;

          var onComplete = function(q, job, result){
            completed++;
            if(completed == 2){
              worker1.end();
              worker2.end();
              var delta = (new Date().getTime() - startTime);
              delta.should.be.below(jobDelay * 2);
              done();
            }
          };

          worker1.on('success', onComplete);
          worker2.on('success', onComplete);
          queue.enqueue(specHelper.queue, "slowAdd", [1,2], function(){
            queue.enqueue(specHelper.queue, "slowAdd", [3,4], function(){
              worker1.start();
              worker2.start();
            });
          });

          worker1.on('error', function(queue, job, error){ console.log(error.stack); });
          worker2.on('error', function(queue, job, error){ console.log(error.stack); });
        });
      });
    });
  });

});