1

nodejs/node_modules/node-schedule/test/.eslintrc

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

nodejs/node_modules/node-schedule/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);
+    }
+  }
+};

nodejs/node_modules/node-schedule/test/convenience-method-test.js

@@ -0,0 +1,713 @@
+
+'use strict';
+
+var sinon = require('sinon');
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+var clock;
+
+module.exports = {
+  setUp: function(cb) {
+    clock = sinon.useFakeTimers();
+    cb();
+  },
+  ".scheduleJob": {
+    "Returns Job instance": function(test) {
+      var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
+
+      test.ok(job instanceof schedule.Job);
+
+      job.cancel();
+      test.done();
+    }
+  },
+  ".scheduleJob(Date, fn)": {
+    "Runs job once at some date": function(test) {
+      test.expect(1);
+
+      schedule.scheduleJob(new Date(Date.now() + 3000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Job doesn't emit initial 'scheduled' event": function(test) {
+      var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
+
+      job.on('scheduled', function() {
+        test.ok(false);
+      });
+
+      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);
+      });
+
+      test.equal(job, null);
+
+      setTimeout(function() {
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    }
+  },
+  ".scheduleJob(RecurrenceRule, fn)": {
+    "Runs job at interval based on recur rule, repeating indefinitely": 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() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      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);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = new schedule.scheduleJob(rule, function() {});
+
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
+
+      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;
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(false);
+      });
+      
+      test.equal(job, null);
+
+      setTimeout(function() {
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    }
+  },
+  ".scheduleJob({...}, fn)": {
+    "Runs job at interval based on object, repeating indefinitely": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null // Fire every second
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      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);
+      });
+
+      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);
+      });
+      
+      test.equal(job, null);
+
+      setTimeout(function() {
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    }
+  },
+  ".scheduleJob({...}, {...}, fn)": {
+    "Callback called for each job if callback is provided": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null // Fire every second
+      }, function() {}, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      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);
+
+      var job = schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.cancelJob(job);
+      }, 2250);
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Can cancel Jobs scheduled with Job#schedule": function(test) {
+      test.expect(2);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null
+      });
+
+      setTimeout(function() {
+        schedule.cancelJob(job);
+      }, 2250);
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Job emits 'canceled' event": function(test) {
+      test.expect(1);
+
+      var job = schedule.scheduleJob({
+        second: null
+      }, function() {});
+
+      job.on('canceled', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.cancelJob(job);
+        test.done();
+      }, 1250);
+
+      clock.tick(1250);
+    }
+  },
+  '.cancelJob("job name")': {
+    "Prevents all future invocations of Job identified by name": function(test) {
+      test.expect(2);
+
+      var job = schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.cancelJob(job.name);
+      }, 2250);
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    /*
+    "Can cancel Jobs scheduled with Job#schedule": function(test) {
+      test.expect(2);
+
+      var job = new schedule.Job(function() {
+      test.ok(true);
+      });
+
+      job.schedule({
+      second: null
+      });
+
+      setTimeout(function() {
+      schedule.cancelJob(job.name);
+      }, 2250);
+
+      setTimeout(function() {
+      test.done();
+      }, 3250);
+    },*/
+    "Job emits 'canceled' event": function(test) {
+      test.expect(1);
+
+      var job = schedule.scheduleJob({
+        second: null
+      }, function() {});
+
+      job.on('canceled', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.cancelJob(job.name);
+        test.done();
+      }, 1250);
+
+      clock.tick(1250);
+    },
+    "Does nothing if no job found by that name": function(test) {
+      test.expect(3);
+
+      var job = schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        // This cancel should not affect anything
+        schedule.cancelJob('blah');
+      }, 2250);
+
+      setTimeout(function() {
+        job.cancel(); // prevent tests from hanging
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  '.pendingInvocations()': {
+    "Retrieves pendingInvocations of the job": function(test) {
+      var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
+
+      test.ok(job instanceof schedule.Job);
+      test.ok(job.pendingInvocations()[0].job);
+
+      job.cancel();
+      test.done();
+    }
+  },
+  tearDown: function(cb) {
+    clock.restore();
+    cb();
+  }
+};

nodejs/node_modules/node-schedule/test/date-convenience-methods-test.js

@@ -0,0 +1,59 @@
+
+'use strict';
+
+var sinon = require('sinon');
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+var clock;
+
+module.exports = {
+  setUp: function(cb) {
+    clock = sinon.useFakeTimers();
+    cb();
+  },
+  "Date string": {
+    "Should accept a valid date string": function(test) {
+      test.expect(1);
+
+      schedule.scheduleJob(new Date(Date.now() + 1000).toString(), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        test.done();
+      }, 1250);
+
+      clock.tick(1250);
+    },
+    "Should not accept invalid string as valid date": function(test) {
+      test.expect(1);
+
+      var job = schedule.scheduleJob("hello!!", function() {
+      });
+
+      test.equal(job, null);
+      test.done();
+
+    }
+  },
+  "UTC": {
+    "Should accept a valid UTC date in milliseconds": function(test) {
+      test.expect(1);
+
+      schedule.scheduleJob(new Date(Date.now() + 1000).getTime(), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        test.done();
+      }, 1250);
+
+      clock.tick(1250);
+    }
+  },
+  tearDown: function(cb) {
+    clock.restore();
+    cb();
+  }
+};

nodejs/node_modules/node-schedule/test/es6/job-test.js

@@ -0,0 +1,33 @@
+
+'use strict';
+
+module.exports = function(schedule) {
+  return {
+    jobInGenerator: function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function*() {
+        test.ok(true);
+      });
+
+      job.runOnDate(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+    },
+    jobContextInGenerator: function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job('name of job', function*() {
+        test.ok(this.name === 'name of job');
+      });
+
+      job.runOnDate(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+    }
+  }
+}

nodejs/node_modules/node-schedule/test/job-test.js

@@ -0,0 +1,517 @@
+
+'use strict';
+
+var sinon = require('sinon');
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+var es6;
+try {
+  eval('(function* () {})()');
+  es6 = require('./es6/job-test')(schedule);
+} catch (e) {}
+
+var clock;
+
+module.exports = {
+  setUp: function(cb) {
+    clock = sinon.useFakeTimers();
+    cb();
+  },
+  "Job constructor": {
+    "Accepts Job name and function to run": function(test) {
+      var job = new schedule.Job('the job', function() {});
+
+      test.equal(job.name, 'the job');
+      test.done();
+    },
+    "Job name is optional and will be auto-generated": function(test) {
+      var job = new schedule.Job();
+
+      test.ok(job.name);
+      test.done();
+    },
+    "Uses unique names across auto-generated Job names": function(test) {
+      var job1 = new schedule.Job();
+      var job2 = new schedule.Job();
+
+      test.notEqual(job1.name, job2.name);
+      test.done();
+    }
+  },
+  "#schedule(Date)": {
+    "Runs job once at some date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Cancel next job before it runs": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule(new Date(Date.now() + 1500));
+      job.schedule(new Date(Date.now() + 3000));
+      job.cancelNext();
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Run job on specified date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.runOnDate(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Run job in generator": function(test) {
+      if (!es6) {
+        test.expect(0);
+        test.done();
+        return;
+      }
+
+      es6.jobInGenerator(test);
+
+      clock.tick(3250);
+    },
+    "Context is passed into generator correctly": function(test) {
+      if (!es6) {
+        test.expect(0);
+        test.done();
+        return;
+      }
+
+      es6.jobContextInGenerator(test);
+
+      clock.tick(3250);
+    },
+    "Won't run job if scheduled in the past": function(test) {
+      test.expect(0);
+
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
+
+      job.schedule(new Date(Date.now() - 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    },
+    "Jobs still run after scheduling a Job in the past": function(test) {
+      test.expect(1);
+
+      var pastJob = new schedule.Job(function() {
+      // Should not run, blow up if it does
+        test.ok(false);
+      });
+
+      pastJob.schedule(new Date(Date.now() - 3000));
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Job emits 'scheduled' event with 'run at' Date": function(test) {
+      test.expect(1);
+
+      var date = new Date(Date.now() + 3000);
+      var job = new schedule.Job(function() {
+        test.done();
+      });
+
+      job.on('scheduled', function(runAtDate) {
+        test.equal(runAtDate.getTime(), date.getTime());
+      });
+
+      job.schedule(date);
+      clock.tick(3250);
+    }
+  },
+  "#schedule(Date, fn)": {
+    "Runs job once at some date, calls callback when done": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {}, function() {
+        test.ok(true);
+      });
+
+      job.schedule(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  "#schedule(RecurrenceRule)": {
+    "Runs job at interval based on recur rule, repeating indefinitely": function(test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      job.schedule(rule);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      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);
+
+      var job = new schedule.Job(function() {});
+
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      job.schedule(rule);
+
+      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);
+
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2000;
+
+      job.schedule(rule);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    }
+  },
+  "#schedule({...})": {
+    "Runs job at interval based on object, repeating indefinitely": function(test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      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);
+
+      var job = new schedule.Job(function() {});
+
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null // Fire every second
+      });
+
+      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);
+
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
+
+      job.schedule({
+        year: 2000
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
+
+      clock.tick(1000);
+    }
+  },
+  "#schedule('jobName', {...})": {
+    "Runs job with a custom name input": function(test) {
+      test.expect(3);
+
+      var job = new schedule.Job('jobName', function() {
+        test.equal(job.name, 'jobName');
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  "#schedule({...}, {...})": {
+    "Runs job and run callback when job is done if callback is provided": function(test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function() {}, function() {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    "Runs job with a custom name input and run callback when job is done": function(test) {
+      test.expect(3);
+
+      var job = new schedule.Job('MyJob', function() {}, function() {
+        test.equal(job.name, 'MyJob');
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  "#cancel": {
+    "Prevents all future invocations": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+      }, 1250);
+
+      setTimeout(function() {
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
+    },
+    "Job emits 'canceled' event": function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function() {});
+
+      job.on('canceled', function() {
+        test.ok(true);
+      });
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+      }, 1250);
+
+      setTimeout(function() {
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
+    },
+    "Job is added to scheduledJobs when created and removed when cancelled": function(test) {
+      test.expect(4);
+
+      var job1 = new schedule.Job('cancelJob', function() {});
+      job1.schedule({
+        second: null // fire every second
+      });
+
+      var job2 = schedule.scheduleJob('second',
+                                      { second: null },
+                                      function() {},
+                                      function() {});
+
+      test.strictEqual(schedule.scheduledJobs.cancelJob, job1);
+      test.strictEqual(schedule.scheduledJobs.second, job2);
+      setTimeout(function() {
+        job1.cancel();
+        job2.cancel();
+        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);
+
+      var job = new schedule.Job(function() {});
+
+      job.on('run', function() {
+        test.ok(true);
+      });
+
+      job.schedule(new Date(Date.now() + 3000));
+
+      setTimeout(function() {
+        test.done();
+      }, 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);
+    },
+    "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);
+    }
+  },
+  tearDown: function(cb) {
+    clock.restore();
+    cb();
+  }
+};

nodejs/node_modules/node-schedule/test/range-test.js

@@ -0,0 +1,77 @@
+
+'use strict';
+
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+module.exports = {
+  "step defaults to 1": function(test) {
+    var range = new schedule.Range(2, 6);
+
+    test.equals(1, range.step);
+
+    test.done();
+  },
+  "when step is 1": {
+    "setUp": function(done) {
+      this.range = new schedule.Range(2, 6, 1);
+
+      done();
+    },
+    "includes start value": function(test) {
+      test.ok(this.range.contains(2));
+
+      test.done();
+    },
+    "includes end value": function(test) {
+      test.ok(this.range.contains(6));
+
+      test.done();
+    },
+    "includes value between start and end": function(test) {
+      test.ok(this.range.contains(3));
+
+      test.done();
+    },
+    "excludes values outside of start and end": function(test) {
+      test.ok(!this.range.contains(1));
+      test.ok(!this.range.contains(7));
+
+      test.done();
+    }
+  },
+  "when step > 1": {
+    "setUp": function(done) {
+      this.range = new schedule.Range(2, 6, 2);
+
+      done();
+    },
+    "includes start value": function(test) {
+      test.ok(this.range.contains(2));
+
+      test.done();
+    },
+    "excludes end value": function(test) {
+      test.ok(!this.range.contains(6));
+
+      test.done();
+    },
+    "includes value between start and end that is evenly divisible by step": function(test) {
+      test.ok(this.range.contains(4));
+
+      test.done();
+    },
+    "excludes value between start and end that is not evenly divisible by step": function(test) {
+      test.ok(!this.range.contains(5));
+
+      test.done();
+    },
+    "excludes values outside of start and end": function(test) {
+      test.ok(!this.range.contains(1));
+      test.ok(!this.range.contains(7));
+
+      test.done();
+    }
+  }
+
+};

nodejs/node_modules/node-schedule/test/recurrence-rule-test.js

@@ -0,0 +1,375 @@
+
+'use strict';
+
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+var sinon = require('sinon');
+var clock;
+
+// 12:30:15 pm Thursday 29 April 2010 in the timezone this code is being run in
+var base = new Date(2010, 3, 29, 12, 30, 15, 0);
+var baseMs = base.getTime();
+
+module.exports = {
+  "setUp": function(cb) {
+    clock = sinon.useFakeTimers(baseMs);
+    cb();
+  },
+  "tearDown": function(cb) {
+    clock.restore();
+    cb();
+  },
+  "#nextInvocationDate(Date)": {
+    "next second": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 12, 30, 16, 0), next);
+      test.done();
+    },
+    "next 25th second": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = 25;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 12, 30, 25, 0), next);
+      test.done();
+    },
+    "next 5th second (minutes incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = 5;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 12, 31, 5, 0), next);
+      test.done();
+    },
+    "next 40th minute": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.minute = 40;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 12, 40, 0, 0), next);
+      test.done();
+    },
+    "next 1st minute (hours incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.minute = 1;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 13, 1, 0, 0), next);
+      test.done();
+    },
+    "next 23rd hour": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.hour = 23;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 29, 23, 0, 0, 0), next);
+      test.done();
+    },
+    "next 3rd hour (days incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.hour = 3;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 30, 3, 0, 0, 0), next);
+      test.done();
+    },
+    "next Friday": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.dayOfWeek = 5;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 30, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "next Monday (months incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.dayOfWeek = 1;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 4, 3, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "next 30th date": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.date = 30;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 30, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "next 5th date (months incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.date = 5;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 4, 5, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "next October": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.month = 9;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 9, 1, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "next February (years incremented)": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.month = 1;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2011, 1, 1, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "in the year 2040": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2040;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2040, 0, 1, 0, 0, 0, 0), next);
+      test.done();
+    },
+    "using past year": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2000;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.equal(null, next);
+      test.done();
+    },
+    "using mixed time components": 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();
+    },
+    /*
+    "using date and dayOfWeek together": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.dayOfWeek = 4; // This is Thursday April 1st
+      rule.date = 10;   // This is Saturday April 10th
+
+      var next = rule.nextInvocationDate(base);
+
+      test.deepEqual(new Date(2010, 3, 1, 0, 0, 0, 0), next);
+      test.done();
+    }*/
+    "returns null when no invocations left": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2000;
+
+      var next = rule.nextInvocationDate(base);
+
+      test.strictEqual(null, next);
+      test.done();
+    },
+    "specify span of components using Range": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.minute = new schedule.Range(4, 6);
+
+      var next;
+
+      next = rule.nextInvocationDate(base);
+      test.deepEqual(new Date(2010, 3, 29, 13, 4, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 5, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 6, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 14, 4, 0, 0), next);
+
+      test.done();
+    },
+    "specify intervals within span of components using Range with step": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.minute = new schedule.Range(4, 8, 2);
+
+      var next;
+
+      next = rule.nextInvocationDate(base);
+      test.deepEqual(new Date(2010, 3, 29, 13, 4, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 6, 0, 0), next);
+
+      /* Should Range stay inclusive on both ends when step > 1
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 8, 0, 0), next);
+      */
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 14, 4, 0, 0), next);
+
+      test.done();
+    },
+    "specify span and explicit components using Array of Ranges and Numbers": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.minute = [2, new schedule.Range(4, 6)];
+
+      var next;
+
+      next = rule.nextInvocationDate(base);
+      test.deepEqual(new Date(2010, 3, 29, 13, 2, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 4, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 5, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 13, 6, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2010, 3, 29, 14, 2, 0, 0), next);
+
+      test.done();
+    },
+    "From 31th May schedule the 1st of every June": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = 0;
+      rule.minute = 0;
+      rule.hour = 0;
+      rule.date = 1;
+      rule.month = 5;
+
+      var next;
+      var base1 = new Date(2010, 4, 31, 12, 30, 15, 0);
+
+      next = rule.nextInvocationDate(base1);
+      test.deepEqual(new Date(2010, 5, 1, 0, 0, 0, 0), next);
+
+      next = rule.nextInvocationDate(next);
+      test.deepEqual(new Date(2011, 5, 1, 0, 0, 0, 0), next);
+
+      test.done();
+    },
+    "With the year set should not loop indefinetely": function(test) {
+      var rule = new schedule.RecurrenceRule();
+      rule.second = 0;
+      rule.minute = 0;
+      rule.hour = 0;
+      rule.date = 1;
+      rule.month = 5;
+      rule.year = 2010;
+
+      var next;
+      var base1 = new Date(2010, 4, 31, 12, 30, 15, 0);
+
+      next = rule.nextInvocationDate(base1);
+      test.deepEqual(new Date(2010, 5, 1, 0, 0, 0, 0), next);
+
+      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();
+    }
+  }
+};

nodejs/node_modules/node-schedule/test/schedule-cron-jobs.js

@@ -0,0 +1,134 @@
+
+'use strict';
+
+var sinon = require('sinon');
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+var clock;
+
+module.exports = {
+  ".scheduleJob(cron_expr, fn)": {
+    setUp: function(cb) {
+      clock = sinon.useFakeTimers();
+      cb();
+    },
+    "Runs job every second": function(test) {
+      test.expect(3);
+
+      var timeout = 3 * 1000 + 150;
+
+      var job = schedule.scheduleJob('* * * * * *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    "Runs job every minute": function(test) {
+      test.expect(3);
+
+      var timeout = 3 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 * * * * *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    "Runs job every hour": function(test) {
+      test.expect(3);
+
+      var timeout = 3 * 60 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 0 * * * *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    "Runs job every day": function(test) {
+      test.expect(3);
+
+      var timeout = 3 * 24 * 60 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 0 0 * * *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    "Runs job every week": function(test) {
+      test.expect(3);
+
+      var timeout = 3 * 7 * 24 * 60 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 0 0 * * 1', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    "Runs job every month": function(test) {
+      test.expect(48);
+
+      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 0 0 1 * *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+
+    },
+    "Runs job every year": function(test) {
+      test.expect(4);
+
+      var timeout = 4 * 365.25 * 24 * 60 * 60 * 1000 + 150;
+
+      var job = schedule.scheduleJob('0 0 0 1 1 *', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout);
+
+      clock.tick(timeout);
+    },
+    tearDown: function(cb) {
+      clock.restore();
+      cb();
+    }
+  }
+};

nodejs/node_modules/node-schedule/test/start-end-test.js

@@ -0,0 +1,327 @@
+'use strict';
+
+var sinon = require('sinon');
+var main = require('../package.json').main;
+var schedule = require('../' + main);
+
+var clock;
+
+module.exports = {
+  setUp: function (cb) {
+    clock = sinon.useFakeTimers();
+    cb();
+  },
+  'RecurrenceRule': {
+    'no endTime , startTime less than now': function (test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // every second
+
+      job.schedule({
+        start: new Date(Date.now() - 2000),
+        rule: rule
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no endTime , startTime greater than now': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // every second
+
+      job.schedule({
+        start: new Date(Date.now() + 2000),
+        rule: rule
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime less than now': function (test) {
+      test.expect(0);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // every second
+
+      job.schedule({
+        end: new Date(Date.now() - 2000),
+        rule: rule
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime greater than now': function (test) {
+      test.expect(2);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // every second
+
+      job.schedule({
+        end: new Date(Date.now() + 2000),
+        rule: rule
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'has startTime and endTime': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // every second
+
+      job.schedule({
+        start: new Date(Date.now() + 1000),
+        end: new Date(Date.now() + 2000),
+        rule: rule
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  'Object Literal': {
+    'no endTime , startTime less than now': function (test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() - 2000),
+        rule: { second: null }
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no endTime , startTime greater than now': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() + 2000),
+        rule: { second: null }
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime less than now': function (test) {
+      test.expect(0);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        end: new Date(Date.now() - 2000),
+        rule: { second: null }
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime greater than now': function (test) {
+      test.expect(2);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        end: new Date(Date.now() + 2000),
+        rule: { second: null }
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'has startTime and endTime': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() + 1000),
+        end: new Date(Date.now() + 2000),
+        rule: { second: null }
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  'cron-style': {
+    'no endTime , startTime less than now': function (test) {
+      test.expect(3);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() - 2000),
+        rule: '*/1 * * * * *'
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no endTime , startTime greater than now': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() + 2000),
+        rule: '*/1 * * * * *'
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime less than now': function (test) {
+      test.expect(0);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        end: new Date(Date.now() - 2000),
+        rule: '*/1 * * * * *'
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'no startTime , endTime greater than now': function (test) {
+      test.expect(2);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        end: new Date(Date.now() + 2000),
+        rule: '*/1 * * * * *'
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    },
+    'has startTime and endTime': function (test) {
+      test.expect(1);
+
+      var job = new schedule.Job(function () {
+        test.ok(true);
+      });
+
+      job.schedule({
+        start: new Date(Date.now() + 1000),
+        end: new Date(Date.now() + 2000),
+        rule: '*/1 * * * * *'
+      });
+
+      setTimeout(function () {
+        job.cancel();
+        test.done();
+      }, 3250);
+
+      clock.tick(3250);
+    }
+  },
+  tearDown: function (cb) {
+    clock.restore();
+    cb();
+  }
+};