node-schedule 1.0.0 → 1.1.0

package/.npmignore

@@ -1,6 +1,2 @@
-coverage
-node_modules
-node-schedule.tmproj
-.DS_Store
-npm-debug.log
-
+*.sublime*
+.npmrc

package/README.md

@@ -164,10 +164,10 @@ var j = schedule.scheduleJob(rule, function(){
 });
 ```
 
-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
+> **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.
+5:00pm, 5:01pm, 5:02pm, ..., 5:59pm.* Probably not what you want.
 
 #### Object Literal Syntax
 

package/lib/schedule.js

@@ -25,6 +25,9 @@ function Job(name, job, callback) {
   // setup a private pendingInvocations variable
   var pendingInvocations = [];
 
+  //setup a private number of invocations variable
+  var triggeredJobs = 0;
+
   // Set scope vars
   var jobName = name && typeof name === 'string' ? name : '<Anonymous Job ' + (++anonJobCounter) + '>';
   this.job = name && typeof name === 'function' ? name : job;
@@ -73,6 +76,12 @@ function Job(name, job, callback) {
 
     return false;
   };
+  this.triggeredJobs = function() {
+    return triggeredJobs;
+  };
+  this.setTriggeredJobs = function(triggeredJob) {
+    triggeredJobs = triggeredJob;
+  };
   this.cancel = function(reschedule) {
     reschedule = (typeof reschedule == 'boolean') ? reschedule : false;
 
@@ -100,7 +109,7 @@ function Job(name, job, callback) {
     // remove from scheduledJobs if reschedule === false
     if (!reschedule) {
       if (this.name) {
-        scheduledJobs[this.name] = null;
+        delete scheduledJobs[this.name];
       }
     }
 
@@ -127,6 +136,26 @@ function Job(name, job, callback) {
 
     return true;
   };
+  this.reschedule = function(spec) {
+    var inv;
+    var cInvs = pendingInvocations.slice();
+
+    for (var j = 0; j < cInvs.length; j++) {
+      inv = cInvs[j];
+
+      cancelInvocation(inv);
+    }
+
+    pendingInvocations = [];
+
+    if (this.schedule(spec)) {
+      this.setTriggeredJobs(0);
+      return true;
+    } else {
+      pendingInvocations = cInvs;
+      return false;
+    }
+  };
   this.nextInvocation = function() {
     if (!pendingInvocations.length) {
       return null;
@@ -142,6 +171,7 @@ util.inherits(Job, events.EventEmitter);
 
 Job.prototype.invoke = function() {
   if (typeof this.job == 'function') {
+    this.setTriggeredJobs(this.triggeredJobs() + 1);
     this.job();
   } else {
     this.job.execute();
@@ -367,7 +397,7 @@ function runOnDate(date, job) {
   var then = date.getTime();
 
   if (then < now) {
-    process.nextTick(job);
+    setImmediate(job);
     return null;
   }
 
@@ -478,6 +508,21 @@ function scheduleJob() {
   return null;
 }
 
+function rescheduleJob(job, spec) {
+  if (job instanceof Job) {
+    if (job.reschedule(spec)) {
+      return job;
+    }
+  } else if (typeof job == 'string' || job instanceof String) {
+    if (job in scheduledJobs && scheduledJobs.hasOwnProperty(job)) {
+      if (scheduledJobs[job].reschedule(spec)) {
+        return scheduledJobs[job];
+      }
+    }
+  }
+  return null;
+}
+
 function cancelJob(job) {
   var success = false;
   if (job instanceof Job) {
@@ -497,5 +542,6 @@ module.exports.Range = Range;
 module.exports.RecurrenceRule = RecurrenceRule;
 module.exports.Invocation = Invocation;
 module.exports.scheduleJob = scheduleJob;
+module.exports.rescheduleJob = rescheduleJob;
 module.exports.scheduledJobs = scheduledJobs;
 module.exports.cancelJob = cancelJob;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-schedule",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A cron-like and not-cron-like job scheduler for Node.",
   "keywords": [
     "schedule",

package/test/convenience-method-test.js

@@ -199,6 +199,362 @@ module.exports = {
       clock.tick(3250);
     }
   },
+  ".rescheduleJob(job, {...})": {
+    "Reschedule jobs from object based to object based": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    },
+    "Reschedule jobs from every minutes to every second": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var job = new schedule.scheduleJob({
+        minute: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          second: null
+        });
+      }, timeout);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    }
+  },
+  ".rescheduleJob(job, Date)": {
+    "Reschedule jobs from Date to Date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 3000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 5000));
+      }, 1000);
+
+      setTimeout(function() {
+        test.done();
+      }, 6150);
+
+      clock.tick(6150);
+    },
+    "Reschedule jobs that has been executed": function(test) {
+      test.expect(2);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 1000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 2000));
+      }, 2000);
+
+      setTimeout(function() {
+        test.done();
+      }, 5150);
+
+      clock.tick(5150);
+    }
+  },
+  ".rescheduleJob(job, RecurrenceRule)": {
+    "Reschedule jobs from RecurrenceRule to RecurrenceRule": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      var newRule = new schedule.RecurrenceRule();
+      newRule.minute = null;
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, newRule);
+      }, 2250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    },
+    "Reschedule jobs from RecurrenceRule to Date": function(test) {
+      test.expect(3);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    },
+    "Reschedule jobs from RecurrenceRule to {...}": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2150);
+
+      clock.tick(timeout + 2150);
+    },
+    "Reschedule jobs that is not available": function(test) {
+      test.expect(4);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(null, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    }
+  },
+  '.rescheduleJob("job name", {...})': {
+    "Reschedule jobs from object based to object based": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    },
+    "Reschedule jobs from every minutes to every second": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var job = new schedule.scheduleJob({
+        minute: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          second: null
+        });
+      }, timeout);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    }
+  },
+  '.rescheduleJob("job name", Date)': {
+    "Reschedule jobs from Date to Date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 3000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 5000));
+      }, 1000);
+
+      setTimeout(function() {
+        test.done();
+      }, 6150);
+
+      clock.tick(6150);
+    },
+    "Reschedule jobs that has been executed": function(test) {
+      test.expect(2);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 1000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 2000));
+      }, 2000);
+
+      setTimeout(function() {
+        test.done();
+      }, 5150);
+
+      clock.tick(5150);
+    }
+  },
+  '.rescheduleJob("job name", RecurrenceRule)': {
+    "Reschedule jobs from RecurrenceRule to RecurrenceRule": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      var newRule = new schedule.RecurrenceRule();
+      newRule.minute = null;
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, newRule);
+      }, 2250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    },
+    "Reschedule jobs from RecurrenceRule to Date": function(test) {
+      test.expect(3);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    },
+    "Reschedule jobs from RecurrenceRule to {...}": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          minute: null
+        });
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2150);
+
+      clock.tick(timeout + 2150);
+    },
+    "Reschedule jobs that is not available": function(test) {
+      test.expect(4);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob("Blah", new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    }
+  },
   ".cancelJob(Job)": {
     "Prevents all future invocations of Job passed in": function(test) {
       test.expect(2);

package/test/job-test.js

@@ -417,19 +417,42 @@ module.exports = {
                                       function() {},
                                       function() {});
 
-      test.equal(schedule.scheduledJobs.cancelJob, job1);
-      test.equal(schedule.scheduledJobs.second, job2);
+      test.strictEqual(schedule.scheduledJobs.cancelJob, job1);
+      test.strictEqual(schedule.scheduledJobs.second, job2);
       setTimeout(function() {
         job1.cancel();
         job2.cancel();
-        test.equal(schedule.scheduledJobs.cancelJob, null);
-        test.equal(schedule.scheduledJobs.second, null);
+        test.strictEqual(schedule.scheduledJobs.cancelJob, undefined);
+        test.strictEqual(schedule.scheduledJobs.second, undefined);
         test.done();
       }, 1250);
 
       clock.tick(1250);
     }
   },
+  "#reschedule": {
+    "When rescheduled counter will be reset to zero": function(test) {
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {});
+
+      setTimeout(function() {
+        test.equal(job.triggeredJobs(), 3);
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.equal(job.triggeredJobs(), 0);
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    }
+  },
   "When invoked": {
     "Job emits 'run' event": function(test) {
       test.expect(1);
@@ -447,6 +470,21 @@ module.exports = {
       }, 3250);
 
       clock.tick(3250);
+    },
+    "Job counter increase properly": function(test) {
+      var job = new schedule.Job(function() {});
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.equal(job.triggeredJobs(), 2);
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
     }
   },
   tearDown: function(cb) {