node-schedule 1.2.2 → 1.3.0

package/.eslintrc

@@ -1,16 +1,17 @@
 {
   "env": {
-    "node": true
+    "node": true,
+    "es6": true
   },
   "rules": {
-    "eqeqeq": [2, "smart"],
-    "indent": [2, 2],
-    "no-constant-condition": false,
-    "no-redeclare": 1,
-    "no-underscore-dangle": false,
-    "no-use-before-define": [true,"nofunc"],
-    "quotes": [2, "single"],
-    "space-before-blocks": 2,
-    "strict": 2
+    "eqeqeq": ["error", "smart"],
+    "indent": ["error", 2, { "SwitchCase": 1 }],
+    "no-constant-condition": "off",
+    "no-redeclare": "warn",
+    "no-underscore-dangle": "off",
+    "no-use-before-define": ["warn","nofunc"],
+    "quotes": ["error", "single"],
+    "space-before-blocks": "error",
+    "strict": "error"
   }
 }

package/.travis.yml

@@ -5,5 +5,11 @@ node_js:
   - "4"
   - "6"
   - "7"
-before_script: npm run lint
+before_script: >
+  if nvm ls-remote --lts | grep "$(nvm current)"; then
+    echo "running on a LTS node version, linting"
+    npm test
+  else
+    echo "running on a non-LTS node version, skipping linting"
+  fi
 script: ./node_modules/.bin/istanbul cover ./node_modules/.bin/nodeunit test && cat ./coverage/lcov.info | ./node_modules/.bin/coveralls && rm -rf ./coverage

package/README.md

@@ -48,8 +48,9 @@ They also emit a `scheduled` event each time they're scheduled to run, and a
 `canceled` event when an invocation is canceled before it's executed (both events
 receive a JavaScript date object as a parameter). Note that jobs are scheduled the
 first time immediately, so if you create a job using the `scheduleJob()`
-convenience method, you'll miss the first `scheduled` event. Also note that
-`canceled` is the single-L American spelling.
+convenience method, you'll miss the first `scheduled` event, but you can query the
+invocation manually (see below). Also note that `canceled` is the single-L American
+spelling.
 
 ### Cron-style Scheduling
 
@@ -57,7 +58,7 @@ The cron format consists of:
 ```
 *    *    *    *    *    *
 ┬    ┬    ┬    ┬    ┬    ┬
-│    │    │    │    │    |
+│    │    │    │    │    │
 │    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)
 │    │    │    │    └───── month (1 - 12)
 │    │    │    └────────── day of month (1 - 31)
@@ -88,6 +89,13 @@ var j = schedule.scheduleJob('0 17 ? * 0,4-6', function(){
 
 Execute a cron job every 5 Minutes = */5 * * * *
 
+You can also get when it is scheduled to run for every invocation of the job:
+```js
+var j = schedule.scheduleJob('0 1 * * *', function(fireDate){
+  console.log('This job was supposed to run at ' + fireDate + ', but actually ran at ' + new Date());
+});
+```
+This is useful when you need to check if there is a delay of the job invocation when the system is busy, or save a record of all invocations of a job for audit purpose.
 #### Unsupported Cron Features
 
 Currently, `W` (nearest weekday), `L` (last day of month/week), and `#` (nth weekday
@@ -110,12 +118,6 @@ var j = schedule.scheduleJob(date, function(){
 });
 ```
 
-You can invalidate the job with the `cancel()` method:
-
-```js
-j.cancel();
-```
-
 To use current data in the future you can use binding:
 
 ```js
@@ -200,6 +202,32 @@ var j = schedule.scheduleJob({ start: startTime, end: endTime, rule: '*/1 * * *
 });
 ```
 
+### Handle Jobs and Job Invocations
+
+There are some function to get informations for a Job and to handle the Job and
+Invocations.
+
+
+#### job.cancel(reshedule)
+You can invalidate any job with the `cancel()` method:
+
+```js
+j.cancel();
+```
+All planned invocations will be canceled. When you set the parameter ***reschedule***
+to true then the Job is newly scheduled afterwards.
+
+#### job.cancelNext(reshedule)
+This method invalidates the next planned invocation or the job.
+When you set the parameter ***reschedule*** to true then the Job is newly scheduled
+afterwards.
+
+#### job.reschedule(spec)
+This method cancels all pending invocation and registers the Job completely new again using the given specification.
+Return true/false on success/failure.
+
+#### job.nextInvocation()
+This method returns a Date object for the planned next Invocation for this Job. If no invocation is planned the method returns null.
 
 ## Contributing
 

package/lib/schedule.js

@@ -15,6 +15,7 @@ var events = require('events'),
 
 /* Job object */
 var anonJobCounter = 0;
+var scheduledJobs = {};
 
 function isValidDate(date) {
   // Taken from http://stackoverflow.com/a/12372720/1562178
@@ -166,12 +167,12 @@ function Job(name, job, callback) {
 
 util.inherits(Job, events.EventEmitter);
 
-Job.prototype.invoke = function() {
+Job.prototype.invoke = function(fireDate) {
   if (typeof this.job == 'function') {
     this.setTriggeredJobs(this.triggeredJobs() + 1);
-    this.job();
+    this.job(fireDate);
   } else {
-    this.job.execute();
+    this.job.execute(fireDate);
   }
 };
 
@@ -190,8 +191,8 @@ Job.prototype.schedule = function(spec) {
   if (typeof spec === 'object' && spec.rule) {
     start = spec.start || undefined;
     end = spec.end || undefined;
-    spec = spec.rule;
     tz = spec.tz;
+    spec = spec.rule;
 
     if (start) {
       if (!(start instanceof Date)) {
@@ -345,12 +346,67 @@ function RecurrenceRule(year, month, date, dayOfWeek, hour, minute, second) {
   this.second = (second == null) ? 0 : second;
 }
 
+RecurrenceRule.prototype.isValid = function() {
+  function isValidType(num) {
+    if (Array.isArray(num) || (num instanceof Array)) {
+      return num.every(function(e) {
+        return isValidType(e);
+      });
+    }
+    return !(Number.isNaN(Number(num)) && !(num instanceof Range));
+  }
+  if (this.month !== null && (this.month < 0 || this.month > 11 || !isValidType(this.month))) {
+    return false;
+  }
+  if (this.dayOfWeek !== null && (this.dayOfWeek < 0 || this.dayOfWeek > 6 || !isValidType(this.dayOfWeek))) {
+    return false;
+  }
+  if (this.hour !== null && (this.hour < 0 || this.hour > 23 || !isValidType(this.hour))) {
+    return false;
+  }
+  if (this.minute !== null && (this.minute < 0 || this.minute > 59 || !isValidType(this.minute))) {
+    return false;
+  }
+  if (this.second !== null && (this.second < 0 || this.second > 59 || !isValidType(this.second))) {
+    return false;
+  }
+  if (this.date !== null) {
+    if(!isValidType(this.date)) {
+      return false;
+    }
+    switch (this.month) {
+      case 3:
+      case 5:
+      case 8:
+      case 10:
+        if (this.date < 1 || this. date > 30) {
+          return false;
+        }
+        break;
+      case 1:
+        if (this.date < 1 || this. date > 29) {
+          return false;
+        }
+        break;
+      default:
+        if (this.date < 1 || this. date > 31) {
+          return false;
+        }
+    }
+  }
+  return true;
+};
+
 RecurrenceRule.prototype.nextInvocationDate = function(base) {
   base = ((base instanceof CronDate) || (base instanceof Date)) ? base : (new Date());
   if (!this.recurs) {
     return null;
   }
 
+  if(!this.isValid()) {
+    return null;
+  }
+
   var now = new CronDate(Date.now(), this.tz);
   var fullYear = now.getFullYear();
   if ((this.year !== null) &&
@@ -435,15 +491,15 @@ function recurMatch(val, matcher) {
 
 /* Date-based scheduler */
 function runOnDate(date, job) {
-  var now = (new Date()).getTime();
+  var now = Date.now();
   var then = date.getTime();
-
-  if (then < now) {
-    setImmediate(job);
-    return null;
-  }
-
-  return lt.setTimeout(job, (then - now));
+  
+  return lt.setTimeout(function() {
+    if (then > Date.now())
+      runOnDate(date, job);
+    else
+      job();
+  }, (then < now ? 0 : then - now));
 }
 
 var invocations = [];
@@ -484,7 +540,7 @@ function prepareNextInvocation() {
 
       job.stopTrackingInvocation(cinv);
 
-      job.invoke();
+      job.invoke(cinv.fireDate instanceof CronDate ? cinv.fireDate.toDate() : cinv.fireDate);
       job.emit('run');
     });
   }
@@ -534,8 +590,6 @@ function scheduleNextRecurrence(rule, job, prevDate, endDate) {
 }
 
 /* Convenience methods */
-var scheduledJobs = {};
-
 function scheduleJob() {
   if (arguments.length < 2) {
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-schedule",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "A cron-like and not-cron-like job scheduler for Node.",
   "keywords": [
     "schedule",
@@ -12,7 +12,7 @@
   "main": "./lib/schedule.js",
   "scripts": {
     "test": "nodeunit",
-    "lint": "eslint lib"
+    "lint": "eslint lib test"
   },
   "author": {
     "name": "Matt Patenaude",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "coveralls": "^2.11.2",
-    "eslint": "^0.15.1",
+    "eslint": "^3.19.0",
     "istanbul": "^0.4.5",
     "nodeunit": "^0.10.2",
     "sinon": "^1.14.1"

package/test/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "quotes": ["off"]
+  }
+}

package/test/cancel-long-running-jobs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var schedule = require('../lib/schedule');
+
+module.exports = {
+  'Cancel Long Running Job': {
+    'should work even when recurring jobs are to be run on the past': function (test) {
+      var ok = true;
+      var job = schedule.scheduleJob('*/1 * * * * *', function () {
+        test.ok(ok);
+        var time = Date.now();
+        while (ok && (Date.now() - time < 2000)) {
+        }
+      });
+
+      test.ok(job);
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+        ok = false;
+      }, 2100);
+    }
+  }
+};

package/test/convenience-method-test.js

@@ -37,32 +37,32 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
+      var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
 
-        job.on('scheduled', function() {
-          test.ok(false);
-        });
+      job.on('scheduled', function() {
+        test.ok(false);
+      });
 
-        setTimeout(function() {
-          test.done();
-        }, 1250);
+      setTimeout(function() {
+        test.done();
+      }, 1250);
 
-        clock.tick(1250);
-      },
-      "Won't run job if scheduled in the past": function(test) {
-        test.expect(1);
-        var job = schedule.scheduleJob(new Date(Date.now() - 3000), function() {
-          test.ok(false);
-        });
+      clock.tick(1250);
+    },
+    "Won't run job if scheduled in the past": function(test) {
+      test.expect(1);
+      var job = schedule.scheduleJob(new Date(Date.now() - 3000), function() {
+        test.ok(false);
+      });
 
-        test.equal(job, null);
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob(RecurrenceRule, fn)": {
     "Runs job at interval based on recur rule, repeating indefinitely": function(test) {
@@ -83,44 +83,44 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        /*
-         * If this was Job#schedule it'd fire 4 times.
-         */
-        test.expect(3);
+      /*
+        * If this was Job#schedule it'd fire 4 times.
+        */
+      test.expect(3);
 
-        var rule = new schedule.RecurrenceRule();
-        rule.second = null; // fire every second
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
 
-        var job = new schedule.scheduleJob(rule, function() {});
+      var job = new schedule.scheduleJob(rule, function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-        test.expect(1);
-        var rule = new schedule.RecurrenceRule();
-        rule.year = 1960;
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if recur rule schedules it in the past": function(test) {
+      test.expect(1);
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 1960;
 
-        var job = schedule.scheduleJob(rule, function() {
-          test.ok(false);
-        });
-        
-        test.equal(job, null);
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(false);
+      });
+      
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob({...}, fn)": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -140,46 +140,46 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        /*
-         * With Job#schedule this would be 3:
-         *  scheduled at time 0
-         *  scheduled at time 1000
-         *  scheduled at time 2000
-         */
-        test.expect(2);
-
-        var job = schedule.scheduleJob({
-          second: null // fire every second
-        }, function() {});
-
-        job.on('scheduled', function() {
-          test.ok(true);
-        });
+      /*
+        * With Job#schedule this would be 3:
+        *  scheduled at time 0
+        *  scheduled at time 1000
+        *  scheduled at time 2000
+        */
+      test.expect(2);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 2250);
+      var job = schedule.scheduleJob({
+        second: null // fire every second
+      }, function() {});
 
-        clock.tick(2250);
-      },
-      "Doesn't invoke job if object schedules it in the past": function(test) {
-        test.expect(1);
+      job.on('scheduled', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
+    },
+    "Doesn't invoke job if object schedules it in the past": function(test) {
+      test.expect(1);
+    
+      var job = schedule.scheduleJob({
+        year: 1960
+      }, function() {
+        test.ok(false);
+      });
       
-        var job = schedule.scheduleJob({
-          year: 1960
-        }, function() {
-          test.ok(false);
-        });
-        
-        test.equal(job, null);
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob({...}, {...}, fn)": {
     "Callback called for each job if callback is provided": function(test) {

package/test/date-convenience-methods-test.js

@@ -38,7 +38,7 @@ module.exports = {
     }
   },
   "UTC": {
-     "Should accept a valid UTC date in milliseconds": function(test) {
+    "Should accept a valid UTC date in milliseconds": function(test) {
       test.expect(1);
 
       schedule.scheduleJob(new Date(Date.now() + 1000).getTime(), function() {

package/test/job-test.js

@@ -199,47 +199,47 @@ module.exports = {
       clock.tick(3250);
     },
     "Job emits 'scheduled' event for every next invocation": function(test) {
-        // Job will run 3 times but be scheduled 4 times, 4th run never happens
-        // due to cancel.
-        test.expect(4);
+      // Job will run 3 times but be scheduled 4 times, 4th run never happens
+      // due to cancel.
+      test.expect(4);
 
-        var job = new schedule.Job(function() {});
+      var job = new schedule.Job(function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        var rule = new schedule.RecurrenceRule();
-        rule.second = null; // fire every second
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
 
-        job.schedule(rule);
+      job.schedule(rule);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-        test.expect(0);
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if recur rule schedules it in the past": function(test) {
+      test.expect(0);
 
-        var job = new schedule.Job(function() {
-          test.ok(false);
-        });
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
 
-        var rule = new schedule.RecurrenceRule();
-        rule.year = 2000;
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2000;
 
-        job.schedule(rule);
+      job.schedule(rule);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   "#schedule({...})": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -261,45 +261,45 @@ module.exports = {
       clock.tick(3250);
     },
     "Job emits 'scheduled' event for every next invocation": function(test) {
-        // Job will run 3 times but be scheduled 4 times, 4th run never happens
-        // due to cancel.
-        test.expect(4);
+      // Job will run 3 times but be scheduled 4 times, 4th run never happens
+      // due to cancel.
+      test.expect(4);
 
-        var job = new schedule.Job(function() {});
+      var job = new schedule.Job(function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        job.schedule({
-          second: null // Fire every second
-        });
+      job.schedule({
+        second: null // Fire every second
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if object schedules it in the past": function(test) {
-        test.expect(0);
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if object schedules it in the past": function(test) {
+      test.expect(0);
 
-        var job = new schedule.Job(function() {
-          test.ok(false);
-        });
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
 
-        job.schedule({
-          year: 2000
-        });
+      job.schedule({
+        year: 2000
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   "#schedule('jobName', {...})": {
     "Runs job with a custom name input": function(test) {
@@ -484,6 +484,29 @@ module.exports = {
         test.done();
       }, 2250);
 
+      clock.tick(2250);
+    },
+    "Job gets invoked with the fire date": function (test) {
+      test.expect(2);
+      var prevFireDate;
+      var job = new schedule.Job(function (fireDate) {
+        if (!prevFireDate) {
+          test.ok(fireDate instanceof Date);
+        } else {
+          test.equal(fireDate.getTime() - prevFireDate.getTime(), 1000);
+        }
+        prevFireDate = fireDate;
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 2250);
+
       clock.tick(2250);
     }
   },

package/test/recurrence-rule-test.js

@@ -295,10 +295,80 @@ module.exports = {
       rule.second = '50';
       rule.minute = '5';
       rule.hour = '10';
-
       var next = rule.nextInvocationDate(base);
-
       test.deepEqual(new Date(2010, 3, 30, 10, 5, 50, 0), next);
+      test.done();
+    },
+    "nextInvocationDate on an invalid month should return null": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.month = 12;
+      var next = rule.nextInvocationDate();
+      test.equal(next, null);
+
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.month = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate(next);
+      test.equal(next2, null);
+
+      test.done();
+    },
+    "nextInvocationDate on an invalid second should return null": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = 60;
+      var next = rule.nextInvocationDate();
+      test.equal(next, null);
+
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.second = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
+
+      test.done();
+    },
+    "nextInvocationDate on an invalid hour should return null": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.hour = 24;
+      var next = rule.nextInvocationDate();
+      test.equal(next, null);
+
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.hour = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
+
+      test.done();
+    },
+    "nextInvocationDate on an invalid date should return null": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.date = 90;
+      var next = rule.nextInvocationDate();
+      test.equal(next, null);
+
+      // Test February
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.month = 1;
+      rule2.date = 30;
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
+
+      var rule3 = new schedule.RecurrenceRule();
+      rule3.date = 'asdfasdf';
+      var next3 = rule3.nextInvocationDate();
+      test.equal(next3, null);
+
+      test.done();
+    },
+    "nextInvocationDate on an invalid dayOfWeek should return null": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.dayOfWeek = 90;
+      var next = rule.nextInvocationDate();
+      test.equal(next, null);
+
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.dayOfWeek = 'asdfasdf';
+      var next2 = rule.nextInvocationDate();
+      test.equal(next2, null);
+
       test.done();
     }
   }

package/test/start-end-test.js

@@ -28,6 +28,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -49,6 +50,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -70,6 +72,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -91,6 +94,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -113,6 +117,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -133,6 +138,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -151,6 +157,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -169,6 +176,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -187,6 +195,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -206,6 +215,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -226,6 +236,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -244,6 +255,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -262,6 +274,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -280,6 +293,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -299,6 +313,7 @@ module.exports = {
       });
 
       setTimeout(function () {
+        job.cancel();
         test.done();
       }, 3250);
 
@@ -309,4 +324,4 @@ module.exports = {
     clock.restore();
     cb();
   }
-};
+};

package/.npmignore

@@ -1,2 +0,0 @@
-*.sublime*
-.npmrc