Updated the files.

my-app/node_modules/qjobs/tests/abort.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+var assert = require('assert');
+var qjob = require('../qjobs');
+
+var maxConcurrency = 2;
+var q = new qjob({maxConcurrency:maxConcurrency});
+
+var testExecutedJobs = 0;
+var testStartFired = false;
+var testEndFired = false;
+var testJobsStartFired = 0;
+var testJobsEndFired = 0;
+var testConcurrency = 0;
+var testPause = false;
+var testUnpause = false;
+
+var myjob = function(args,next) {
+    setTimeout(function() {
+        testExecutedJobs++;
+        next();
+    },50);
+}
+
+// Let's add 10 job and add them to the queue
+for (var i = 0; i<10; i++) {
+    q.add(myjob,['test'+i]);
+}
+
+q.on('start',function() {
+    testStartFired = true;
+});
+
+q.on('jobStart',function() {
+    var running = q.stats()._jobsRunning;
+    if (running>testConcurrency) testConcurrency = running;
+    testJobsStartFired++;
+    if (testJobsStartFired == 5) {
+        q.abort();
+    }
+});
+
+q.on('jobEnd',function() {
+    testJobsEndFired++;
+});
+
+q.on('end',function() {
+    testEndFired = true;
+    assert.equal(testExecutedJobs, 5);
+    assert.equal(testJobsStartFired,5);
+    assert.equal(testJobsEndFired,5);
+    assert.equal(testConcurrency,maxConcurrency);
+    assert.ok(testStartFired);
+});
+
+var running = q.stats()._jobsRunning;
+
+assert.equal(testExecutedJobs,0);
+assert.equal(testJobsStartFired,0);
+assert.equal(testJobsEndFired,0);
+assert.equal(running,0);
+assert.ok(!testStartFired);
+assert.ok(!testEndFired);
+
+q.run();

my-app/node_modules/qjobs/tests/basic.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+var assert = require('assert');
+var qjob = require('../qjobs');
+
+// only 2 jobs in the same time
+var q = new qjob({maxConcurrency:2});
+
+var testExecutedJobs = 0;
+
+var myjob = function(args,next) {
+    setTimeout(function() {
+        testExecutedJobs++;
+        next();
+    },50);
+}
+
+// Let's add 10 job and add them to the queue
+for (var i = 0; i<10; i++) {
+    q.add(myjob,['test'+i]);
+}
+
+q.on('end',function() {
+    assert.equal(testExecutedJobs, 10);
+});
+
+q.run();
+
+

my-app/node_modules/qjobs/tests/events.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+var assert = require('assert');
+var qjob = require('../qjobs');
+
+var maxConcurrency = 2;
+var q = new qjob({maxConcurrency:maxConcurrency});
+
+var testExecutedJobs = 0;
+var testStartFired = false;
+var testEndFired = false;
+var testJobsStartFired = 0;
+var testJobsEndFired = 0;
+var testConcurrency = 0;
+
+var myjob = function(args,next) {
+    setTimeout(function() {
+        testExecutedJobs++;
+        next();
+    },50);
+}
+
+// Let's add 10 job and add them to the queue
+for (var i = 0; i<10; i++) {
+    q.add(myjob,['test'+i]);
+}
+
+q.on('start',function() {
+    testStartFired = true;
+});
+
+q.on('jobStart',function() {
+    var running = q.stats()._jobsRunning;
+    if (running>testConcurrency) testConcurrency = running;
+    testJobsStartFired++;
+});
+
+q.on('jobEnd',function() {
+    testJobsEndFired++;
+});
+
+q.on('end',function() {
+    testEndFired = true;
+    assert.equal(testExecutedJobs, 10);
+    assert.equal(testJobsStartFired,10);
+    assert.equal(testJobsEndFired,10);
+    assert.equal(testConcurrency,maxConcurrency);
+    assert.ok(testStartFired);
+});
+
+var running = q.stats()._jobsRunning;
+
+assert.equal(testExecutedJobs,0);
+assert.equal(testJobsStartFired,0);
+assert.equal(testJobsEndFired,0);
+assert.equal(running,0);
+assert.ok(!testStartFired);
+assert.ok(!testEndFired);
+
+q.run();

my-app/node_modules/qjobs/tests/interval.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+var assert = require('assert');
+var qjob = require('../qjobs');
+
+// maximum number of jobs executed in parallels
+var maxConcurrency = 5;
+
+// delay between each group of maxConcurrency jobs done
+var interval = 1000;
+
+var q = new qjob({
+    maxConcurrency:maxConcurrency,
+    interval:interval
+});
+
+// number of total jobs
+var maxJobs = 20;
+
+// tests dedicated variables
+var testExecutedJobs = 0;
+var testNbSleep = 0;
+
+// warning, if you change maxConcurrency, maxJobs
+// or interval variable, you will have to review
+// the testMaxNbSleep value
+var testMaxNbSleep = 4;
+
+var myjob = function(args,next) {
+    setTimeout(function() {
+        testExecutedJobs++;
+        next();
+    },args[1]);
+}
+
+// Let's add 10 job and add them to the queue
+for (var i = 0; i<maxJobs; i++) {
+    q.add(myjob,['test'+i,Math.random()*1000]);
+}
+
+q.on('end',function() {
+    assert.equal(testExecutedJobs, maxJobs);
+    assert.equal(testNbSleep, testMaxNbSleep);
+    //console.log('Done');
+});
+
+q.on('jobStart',function(args) {
+    //console.log(args[0]+' wait for '+args[1]+' ms');
+});
+
+q.on('sleep',function() {
+    testNbSleep++;
+    //console.log('zzZZzzzz for '+interval+'ms',testNbSleep);
+});
+
+q.on('continu',function() {
+    //console.log('WAKE !');
+});
+
+q.run();
+
+

my-app/node_modules/qjobs/tests/pause.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+var assert = require('assert');
+var qjob = require('../qjobs');
+
+var maxConcurrency = 2;
+var q = new qjob({maxConcurrency:maxConcurrency});
+
+var testExecutedJobs = 0;
+var testStartFired = false;
+var testEndFired = false;
+var testJobsStartFired = 0;
+var testJobsEndFired = 0;
+var testConcurrency = 0;
+var testPause = false;
+var testUnpause = false;
+
+var myjob = function(args,next) {
+    setTimeout(function() {
+        testExecutedJobs++;
+        next();
+    },50);
+}
+
+// Let's add 10 job and add them to the queue
+for (var i = 0; i<10; i++) {
+    q.add(myjob,['test'+i]);
+}
+
+q.on('start',function() {
+    testStartFired = true;
+});
+
+q.on('jobStart',function() {
+    var running = q.stats()._jobsRunning;
+    if (running>testConcurrency) testConcurrency = running;
+    testJobsStartFired++;
+    if (testJobsStartFired == 5) {
+        q.pause(true);
+    }
+});
+
+q.on('jobEnd',function() {
+    testJobsEndFired++;
+});
+
+q.on('end',function() {
+    testEndFired = true;
+    assert.equal(testExecutedJobs, 10);
+    assert.equal(testJobsStartFired,10);
+    assert.equal(testJobsEndFired,10);
+    assert.equal(testConcurrency,maxConcurrency);
+    assert.ok(testStartFired);
+    assert.ok(testPause);
+    assert.ok(testUnpause);
+});
+
+q.on('pause',function(since) {
+    testPause = true;
+    if (since>2000) {
+        q.pause(false);
+    }
+});
+
+q.on('unpause',function() {
+    testUnpause = true;
+});
+
+var running = q.stats()._jobsRunning;
+
+assert.equal(testExecutedJobs,0);
+assert.equal(testJobsStartFired,0);
+assert.equal(testJobsEndFired,0);
+assert.equal(running,0);
+assert.ok(!testStartFired);
+assert.ok(!testEndFired);
+assert.ok(!testPause);
+assert.ok(!testUnpause);
+
+q.run();