diff --git a/node-schedule/node-schedule-tests.ts b/node-schedule/node-schedule-tests.ts index bc4dbbd743..bc8626767d 100644 --- a/node-schedule/node-schedule-tests.ts +++ b/node-schedule/node-schedule-tests.ts @@ -6,12 +6,85 @@ import nodeSchedule = require("node-schedule"); * Test for {@link Job} class. */ function testJob() { - var name: string = ''; - var job: Function = null; + var name:string = ''; + var jc:nodeSchedule.JobCallback = null; var callback: Function = null; - new nodeSchedule.Job(job, callback); - new nodeSchedule.Job(name, job, callback); + var jobSpec:nodeSchedule.Job = new nodeSchedule.Job(jc); + var job:nodeSchedule.Job = new nodeSchedule.Job(jc, callback); + var job:nodeSchedule.Job = new nodeSchedule.Job(name, jc, callback); + + var jobName:string = job.name; +} + +function testTrackInvocation() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success:boolean = job.trackInvocation( + new nodeSchedule.Invocation(job, new Date(), new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0)) + ); +} + +function testStopTrackingInvocation() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success = job.stopTrackingInvocation( + new nodeSchedule.Invocation(job, new Date(), new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0)) + ); +} + +function testTriggeredJobs() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var triggeredJobs:number = job.triggeredJobs(); +} + +function testSetTriggeredJobs() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + job.setTriggeredJobs(19); +} + +function testCancel() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success:boolean = job.cancel(); + var success:boolean = job.cancel(true); +} + +function testCancelNext() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success:boolean = job.cancelNext(); + var success:boolean = job.cancelNext(true); +} + +function testReschedule() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success:boolean = job.reschedule(''); + var success:boolean = job.reschedule(1234); + var success:boolean = job.reschedule(new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0)); +} + +function testNextInvocation() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var nextInvocation:Date = job.nextInvocation(); +} + +function testPendingInvocations() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var pendingInvocations:nodeSchedule.Invocation[] = job.pendingInvocations(); +} + +function testInvoke() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + job.invoke(); +} + +function testRunOnDate() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + job.runOnDate(new Date()); +} + +function testSchedule() { + var job:nodeSchedule.Job = new nodeSchedule.Job(() => {}); + var success:boolean = job.schedule(new Date()); + success = job.schedule(''); + success = job.schedule(1234); } /** @@ -19,10 +92,10 @@ function testJob() { */ function testRange() { var range = new nodeSchedule.Range(0); - var twoParametersRange = new nodeSchedule.Range(0, 0); - var threeParametersRange = new nodeSchedule.Range(0, 0, 0); + var twoParametersRange:nodeSchedule.Range = new nodeSchedule.Range(0, 0); + var threeParametersRange:nodeSchedule.Range = new nodeSchedule.Range(0, 0, 0); - var contained: boolean = range.contains(0); + var contained:boolean = range.contains(0); } /** @@ -30,50 +103,51 @@ function testRange() { */ function testRecurrenceRule() { var range = new nodeSchedule.Range(0, 0, 0); - var rule: nodeSchedule.RecurrenceRule = { - date: 0, - dayOfWeek: [0, range], - hour: 0, - minute: 0, - month: 0, - second: 0, - year: 0 - } + var rule:nodeSchedule.RecurrenceRule = new nodeSchedule.RecurrenceRule(0, 0, 0, [0, range], 0, 0, 0); + var rule:nodeSchedule.RecurrenceRule = new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0); + + var nextInvocation:Date = rule.nextInvocationDate(new Date()); } /** * Test for {@link Invocation} class. */ function testInvocation() { - var job = new nodeSchedule.Job(); + var job = new nodeSchedule.Job(() => {}); var fireDate = new Date(); - var rule: nodeSchedule.RecurrenceRule = {}; + var rule: nodeSchedule.RecurrenceRule = new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0); var invocation = new nodeSchedule.Invocation(job, fireDate, rule); invocation.timerID = 0; } /** - * Test for {@link ScheduleJob} class. + * Test for {@link scheduleJob} class. */ function testScheduleJob() { - var callback: Function = null; - nodeSchedule.scheduleJob('', callback); + var callback: nodeSchedule.JobCallback = null; + var job:nodeSchedule.Job = nodeSchedule.scheduleJob('', callback); - var rule: nodeSchedule.RecurrenceRule = {}; - nodeSchedule.scheduleJob(rule, callback); + var rule: nodeSchedule.RecurrenceRule = new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0); + var job:nodeSchedule.Job = nodeSchedule.scheduleJob(rule, callback); var date: Date = new Date(); - nodeSchedule.scheduleJob(date, callback); + var job:nodeSchedule.Job = nodeSchedule.scheduleJob(date, callback); +} - var date: Date = new Date(); - nodeSchedule.scheduleJob(date, callback); +function testRescheduleJob() { + var job:nodeSchedule.Job = nodeSchedule.rescheduleJob(new nodeSchedule.Job(() => {}), new Date()); + job = nodeSchedule.rescheduleJob(new nodeSchedule.Job(() => {}), new nodeSchedule.RecurrenceRule(0, 0, 0, 0, 0, 0, 0)); + job = nodeSchedule.rescheduleJob(new nodeSchedule.Job(() => {}), ''); + job = nodeSchedule.rescheduleJob('', ''); } /** * Test for {@link cancelJob} function. */ function testCancelJob() { - var job = new nodeSchedule.Job(); - nodeSchedule.cancelJob(job); + var job = new nodeSchedule.Job(() => {}); + var success:boolean = nodeSchedule.cancelJob(job); + + success = nodeSchedule.cancelJob('jobName'); } diff --git a/node-schedule/node-schedule.d.ts b/node-schedule/node-schedule.d.ts index 17dbb8402a..5127eafb40 100644 --- a/node-schedule/node-schedule.d.ts +++ b/node-schedule/node-schedule.d.ts @@ -1,70 +1,120 @@ -// Type definitions for node-schedule +// Type definitions for node-schedule 1.1.0 // Project: https://github.com/tejasmanohar/node-schedule/ -// Definitions by: Cyril Schumacher +// Definitions by: Cyril Schumacher , Florian Plattner // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -declare module "node-schedule" { +/// + +declare module 'node-schedule' { import nodeSchedule = require('node-schedule'); + import {EventEmitter} from 'events'; /** - * Recurrence rules. + * The callback executed by a Job */ - export interface RecurrenceRule { + export interface JobCallback { + ():void; + } + + /** + * Scheduler jobs. + * + * @class + */ + export class Job extends EventEmitter { /** - * Day of the month. - * - * @public - * @type {number} + * This Job's name. read-only. */ - date?: number; + name:string; /** - * Day of the week. + * Use the function scheduleJob() to create new Job objects. * - * @public - * @type {number|Array} + * @constructor + * @internal + * @param {string|JobCallback} name either an optional name for this Job or this Job's callback + * @param {JobCallback|Function} job either this Job's callback or an optional callback function + * @param {Function} callback optional callback that is executed right before the JobCallback */ - dayOfWeek?: number|Array; + constructor(name: string|JobCallback, job?: JobCallback|Function, callback?: Function); /** - * Hour. - * - * @public - * @type {number} + * Adds an Invocation to this job. For internal use. + * @internal + * @param {Invocation} invokation + * @return {boolean} whether the invocation could be added */ - hour?: number; + trackInvocation(invokation:Invocation):boolean; /** - * Minute. - * - * @public - * @type {number} + * removes an Invocation from this Job's tracking list. For internal use. + * @internal + * @param invocation {Invocation} + * @return boolean whether the invocation was successful. Removing an Invocation that doesn't exist, returns false. */ - minute?: number; + stopTrackingInvocation(invocation:Invocation):boolean; /** - * Month. - * - * @public - * @type {number} + * @internal + * @return {number} the number of currently running instances of this Job. */ - month?: number; + triggeredJobs():number; /** - * Second. - * - * @public - * @type {number} + * set the number of currently running Jobs. + * @internal + * @param triggeredJobs */ - second?: number; + setTriggeredJobs(triggeredJobs:number):void; /** - * Year. - * - * @public - * @type {number} + * cancel all pending Invocations of this Job. + * @param reschedule {boolean} whether to reschedule the canceled Invocations. */ - year?: number; + cancel(reschedule?:boolean):boolean; + + /** + * cancel the next Invocation of this Job. + * @param reschedule {boolean} whether to reschedule the canceled Invocation. + * @return {boolean} whether cancelation was successful + */ + cancelNext(reschedule?:boolean):boolean; + + /** + * Changes the scheduling information for this Job. + * @param spec {RecurrenceRule|string|number} the + * @return {boolean} whether the reschedule was successful + */ + reschedule(spec:RecurrenceRule|string|number):boolean; + + /** + * Returns the Date on which this Job will be run next. + * @return {Date} + */ + nextInvocation():Date; + + /** + * @return Invocation[] a list of all pending Invocations + */ + pendingInvocations():Invocation[]; + + /** + * run this Job immediately. + */ + invoke():void; + + /** + * schedule this Job to be run on the specified date. + * @param date {Date} + */ + runOnDate(date:Date): void; + + /** + * set scheduling information + * @param {Date|string|number} date + * @public + */ + schedule(date: Date|string|number): boolean; } /** @@ -93,43 +143,74 @@ declare module "node-schedule" { } /** - * Scheduler jobs. - * - * @class + * Recurrence rules. */ - export class Job { + export class RecurrenceRule { /** - * Constructor. - * - * @constructor - * @param {RecurrenceRule} rule The rule. - * @param {callback} callback The callback. - */ - constructor(name?: string, job?: Function, callback?: Function); - - /** - * Constructor. - * - * @constructor - * @param {RecurrenceRule} rule The rule. - * @param - */ - constructor(job?: Function, callback?: Function); - - /** - * Attach an event handler function. + * Day of the month. * * @public - * @param {string} eventName The event name. - * @param {Function} handler The function to execute when the event is triggered. + * @type {number} */ - on(eventName: string, handler: Function): void; + date: number; /** + * Day of the week. * * @public + * @type {number|Array} */ - schedule(date: Date): void; + dayOfWeek: number|Array; + + /** + * Hour. + * + * @public + * @type {number} + */ + hour: number; + + /** + * Minute. + * + * @public + * @type {number} + */ + minute: number; + + /** + * Month. + * + * @public + * @type {number} + */ + month: number; + + /** + * Second. + * + * @public + * @type {number} + */ + second: number; + + /** + * Year. + * + * @public + * @type {number} + */ + year: number; + + constructor(year:number, + month:number, + date:number, + dayOfWeek:number|Array, + hour:number, + minute:number, + second:number); + + nextInvocationDate(base:Date):Date; } /** @@ -181,19 +262,34 @@ declare module "node-schedule" { constructor(job: Job, fireDate: Date, recurrenceRule: RecurrenceRule); } + /** + * Create a schedule job. + * + * @param {string|RecurrenceRule|Date} name either an optional name for the new Job or scheduling information + * @param {RecurrenceRule|Date|string} rule either the scheduling info or the JobCallback + * @param {JobCallback} callback The callback to be executed on each invocation. + */ + export function scheduleJob(name:string|RecurrenceRule|Date, rule: RecurrenceRule|Date|string|JobCallback, callback?: JobCallback): Job; + + /** + * Changes the timing of a Job, canceling all pending invocations. + * + * @param job {Job} + * @param spec {JobCallback} the new timing for this Job + * @return {Job} if the job could be rescheduled, {null} otherwise. + */ + export function rescheduleJob(job:Job|string, spec:RecurrenceRule|Date|string):Job; + + /** + * Dictionary of all Jobs, accessible by name. + */ + export let scheduledJobs:{[jobName:string]:Job}; + /** * Cancels the job. * * @param {Job} job The job. * @returns {boolean} {true} if the job has been cancelled with success, otherwise, {false}. */ - export function cancelJob(job: Job): boolean; - - /** - * Create a schedule job. - * - * @param {RecurrenceRule} rule The rule. - * @param {Function} callback The callback. - */ - export function scheduleJob(rule: RecurrenceRule|Date|string, callback: Function): void; + export function cancelJob(job: Job|string): boolean; }