node-schedule 1.2.0 → 1.2.4

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

@@ -3,6 +3,13 @@ node_js:
   - "0.12"
   - "0.10"
   - "4"
-  - "5"
-before_script: npm run lint
+  - "6"
+  - "7"
+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

@@ -7,11 +7,6 @@
 
 [![NPM](https://nodei.co/npm/node-schedule.png?downloads=true)](https://nodei.co/npm/node-schedule/)
 
->__Announcement:__ Node Schedule is looking for add additional collaborators
-with commit access. If you are actively involved in open source,
-ping [Tejas Manohar] via [email](mailto:me@tejas.io) to express interest.
-Those who already contribute to the project are preferred.
-
 Node Schedule is a flexible cron-like and not-cron-like job scheduler for Node.js.
 It allows you to schedule jobs (arbitrary functions) for execution at
 specific dates, with optional recurrence rules. It only uses a single timer
@@ -53,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
 
@@ -81,6 +77,8 @@ var j = schedule.scheduleJob('42 * * * *', function(){
 });
 ```
 
+Execute a cron job when the minute is 42 (e.g. 19:42, 20:42, etc.).
+
 And:
 
 ```js
@@ -113,12 +111,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
@@ -164,10 +156,20 @@ var j = schedule.scheduleJob(rule, function(){
 });
 ```
 
+#### RecurrenceRule properties
+
+- `second`
+- `minute`
+- `hour`
+- `date`
+- `month`
+- `year`
+- `dayOfWeek`
+
 > **Note**: It's worth noting that the default value of a component of a recurrence rule is
-`null` (except for seconds, which is 0 for familiarity with cron). *If we did not
-explicitly set `minute` to 0 above, the message would have instead been logged at
-5:00pm, 5:01pm, 5:02pm, ..., 5:59pm.* Probably not what you want.
+> `null` (except for second, which is 0 for familiarity with cron). *If we did not
+> explicitly set `minute` to 0 above, the message would have instead been logged at
+> 5:00pm, 5:01pm, 5:02pm, ..., 5:59pm.* Probably not what you want.
 
 #### Object Literal Syntax
 
@@ -187,12 +189,38 @@ The ruledat supports the above.
 
 ```js
 let startTime = new Date(Date.now() + 5000);
-let endTime = new Date(now.getTime() + 5000);
+let endTime = new Date(startTime.getTime() + 5000);
 var j = schedule.scheduleJob({ start: startTime, end: endTime, rule: '*/1 * * * * *' }, function(){
   console.log('Time for tea!');
 });
 ```
 
+### 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

@@ -10,10 +10,12 @@ var events = require('events'),
   util = require('util'),
   cronParser = require('cron-parser'),
   CronDate = require('cron-parser/lib/date'),
-  lt = require('long-timeout');
+  lt = require('long-timeout'),
+  sorted = require('sorted-array-functions');
 
 /* Job object */
 var anonJobCounter = 0;
+var scheduledJobs = {};
 
 function isValidDate(date) {
   // Taken from http://stackoverflow.com/a/12372720/1562178
@@ -60,11 +62,7 @@ function Job(name, job, callback) {
   // method that require private access
   this.trackInvocation = function(invocation) {
     // add to our invocation list
-    pendingInvocations.push(invocation);
-
-    // and sort
-    pendingInvocations.sort(sorter);
-
+    sorted.add(pendingInvocations, invocation, sorter);
     return true;
   };
   this.stopTrackingInvocation = function(invocation) {
@@ -188,33 +186,40 @@ Job.prototype.schedule = function(spec) {
   var inv;
   var start;
   var end;
+  var tz;
 
   if (typeof spec === 'object' && spec.rule) {
-    start = spec.start || null;
-    end = spec.end || null;
+    start = spec.start || undefined;
+    end = spec.end || undefined;
+    tz = spec.tz;
     spec = spec.rule;
 
-    if (start != null) {
+    if (start) {
       if (!(start instanceof Date)) {
         start = new Date(start);
       }
+
+      start = new CronDate(start, tz);
       if (!isValidDate(start) || start.getTime() < Date.now()) {
-        start = null;
+        start = undefined;
       }
     }
 
-    if (end != null && !(end instanceof Date) && !isValidDate(end = new Date(end))) {
-      end = null;
+    if (end && !(end instanceof Date) && !isValidDate(end = new Date(end))) {
+      end = undefined;
+    }
+
+    if (end) {
+      end = new CronDate(end, tz);
     }
   }
 
   try {
-    var res = cronParser.parseExpression(spec, { currentDate: start });
+    var res = cronParser.parseExpression(spec, { currentDate: start, tz: tz });
     inv = scheduleNextRecurrence(res, self, start, end);
     if (inv !== null) {
       success = self.trackInvocation(inv);
     }
-
   } catch (err) {
     var type = typeof spec;
     if ((type === 'string') || (type === 'number')) {
@@ -222,6 +227,7 @@ Job.prototype.schedule = function(spec) {
     }
 
     if ((spec instanceof Date) && (isValidDate(spec))) {
+      spec = new CronDate(spec);
       if (spec.getTime() >= Date.now()) {
         inv = new Invocation(self, spec);
         scheduleInvocation(inv);
@@ -255,6 +261,7 @@ Job.prototype.schedule = function(spec) {
         spec = r;
       }
 
+      spec.tz = tz;
       inv = scheduleNextRecurrence(spec, self, start, end);
       if (inv !== null) {
         success = self.trackInvocation(inv);
@@ -339,13 +346,68 @@ 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 Date) ? base : (new Date());
+  base = ((base instanceof CronDate) || (base instanceof Date)) ? base : (new Date());
   if (!this.recurs) {
     return null;
   }
 
-  var now = new Date();
+  if(!this.isValid()) {
+    return null;
+  }
+
+  var now = new CronDate(Date.now(), this.tz);
   var fullYear = now.getFullYear();
   if ((this.year !== null) &&
       (typeof this.year == 'number') &&
@@ -353,7 +415,7 @@ RecurrenceRule.prototype.nextInvocationDate = function(base) {
     return null;
   }
 
-  var next = new CronDate(base.getTime());
+  var next = new CronDate(base.getTime(), this.tz);
   next.addSecond();
 
   while (true) {
@@ -402,7 +464,7 @@ RecurrenceRule.prototype.nextInvocationDate = function(base) {
     break;
   }
 
-  return next;
+  return next ? next.toDate() : null;
 };
 
 function recurMatch(val, matcher) {
@@ -410,8 +472,10 @@ function recurMatch(val, matcher) {
     return true;
   }
 
-  if (typeof matcher === 'number' || typeof matcher === 'string') {
+  if (typeof matcher === 'number') {
     return (val === matcher);
+  } else if(typeof matcher === 'string') {
+    return (val === Number(matcher));
   } else if (matcher instanceof Range) {
     return matcher.contains(val);
   } else if (Array.isArray(matcher) || (matcher instanceof Array)) {
@@ -442,10 +506,10 @@ var invocations = [];
 var currentInvocation = null;
 
 function scheduleInvocation(invocation) {
-  invocations.push(invocation);
-  invocations.sort(sorter);
+  sorted.add(invocations, invocation, sorter);
   prepareNextInvocation();
-  invocation.job.emit('scheduled', invocation.fireDate);
+  var date = invocation.fireDate instanceof CronDate ? invocation.fireDate.toDate() : invocation.fireDate;
+  invocation.job.emit('scheduled', date);
 }
 
 function prepareNextInvocation() {
@@ -508,14 +572,14 @@ function cancelInvocation(invocation) {
 /* Recurrence scheduler */
 function scheduleNextRecurrence(rule, job, prevDate, endDate) {
 
-  prevDate = (prevDate instanceof Date) ? prevDate : (new Date());
+  prevDate = (prevDate instanceof CronDate) ? prevDate : new CronDate();
 
   var date = (rule instanceof RecurrenceRule) ? rule.nextInvocationDate(prevDate) : rule.next();
   if (date === null) {
     return null;
   }
 
-  if ((endDate instanceof Date) && date.getTime() > endDate.getTime()) {
+  if ((endDate instanceof CronDate) && date.getTime() > endDate.getTime()) {
     return null;
   }
 
@@ -526,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.0",
+  "version": "1.2.4",
   "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",
@@ -24,14 +24,15 @@
     "url": "https://github.com/node-schedule/node-schedule.git"
   },
   "dependencies": {
-    "cron-parser": "1.1.0",
-    "long-timeout": "0.0.2"
+    "cron-parser": "^2.4.0",
+    "long-timeout": "0.1.1",
+    "sorted-array-functions": "^1.0.0"
   },
   "devDependencies": {
     "coveralls": "^2.11.2",
-    "eslint": "^0.15.1",
-    "istanbul": "^0.3.8",
-    "nodeunit": "^0.9.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/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

@@ -154,7 +154,7 @@ module.exports = {
       });
 
       job.on('scheduled', function(runAtDate) {
-        test.equal(runAtDate, date);
+        test.equal(runAtDate.getTime(), date.getTime());
       });
 
       job.schedule(date);
@@ -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) {

package/test/recurrence-rule-test.js

@@ -288,6 +288,87 @@ module.exports = {
       next = rule.nextInvocationDate(next);
       test.equal(next, null);
 
+      test.done();
+    },
+    "using rule with string properties": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      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/schedule-cron-jobs.js

@@ -10,9 +10,7 @@ var clock;
 module.exports = {
   ".scheduleJob(cron_expr, fn)": {
     setUp: function(cb) {
-      var now = Date.now();
       clock = sinon.useFakeTimers();
-      clock.tick(now);
       cb();
     },
     "Runs job every second": function(test) {
@@ -34,7 +32,7 @@ module.exports = {
     "Runs job every minute": function(test) {
       test.expect(3);
 
-      var timeout = 3 * 60 * 1000;
+      var timeout = 3 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 * * * * *', function() {
         test.ok(true);
@@ -50,7 +48,7 @@ module.exports = {
     "Runs job every hour": function(test) {
       test.expect(3);
 
-      var timeout = 3 * 60 * 60 * 1000;
+      var timeout = 3 * 60 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 0 * * * *', function() {
         test.ok(true);
@@ -66,7 +64,7 @@ module.exports = {
     "Runs job every day": function(test) {
       test.expect(3);
 
-      var timeout = 3 * 24 * 60 * 60 * 1000;
+      var timeout = 3 * 24 * 60 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 0 0 * * *', function() {
         test.ok(true);
@@ -82,7 +80,7 @@ module.exports = {
     "Runs job every week": function(test) {
       test.expect(3);
 
-      var timeout = 3 * 7 * 24 * 60 * 60 * 1000;
+      var timeout = 3 * 7 * 24 * 60 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 0 0 * * 1', function() {
         test.ok(true);
@@ -98,7 +96,7 @@ module.exports = {
     "Runs job every month": function(test) {
       test.expect(48);
 
-      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000;
+      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 0 0 1 * *', function() {
         test.ok(true);
@@ -115,7 +113,7 @@ module.exports = {
     "Runs job every year": function(test) {
       test.expect(4);
 
-      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000;
+      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000 + 150;
 
       var job = schedule.scheduleJob('0 0 0 1 1 *', function() {
         test.ok(true);

package/fff.js

@@ -1,18 +0,0 @@
-var schedule = require('./');
-
-// Create new cron for each iteration (creating 1-10 mins)
-//for (var x = 1; x<10; x++){
-//      var rule = new schedule.RecurrenceRule();
-//      rule.minute = new schedule.Range(0, 59, x);
-//      schedule.scheduleJob(rule, function() {
-//     // Can I access the RULE which is being executed NOW somehow?!
-//        console.log(this);
-//     });
-//}
-
-var job = schedule.scheduleJob('* * * * * *', function() {
-  console.log(this.spec);
-});
-
-job.spec = '* * * * * *';
-