stacks 0.58.62 → 0.58.64

package/core/scheduler/tests/cron.test.ts

@@ -1,1243 +1,1243 @@
-/* eslint-disable no-new */
-import { DateTime } from 'luxon'
-
-// @ts-expect-error types aren't there
-import sinon from 'sinon'
-import { CronJob, CronTime } from '../src'
-
-describe('cron', () => {
-  afterEach(() => expect.hasAssertions())
-
-  describe('with seconds', () => {
-    it('should run every second (* * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('* * * * * *', callback, null, true)
-
-      expect(callback).not.toHaveBeenCalled()
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run second with onComplete (* * * * * *)', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      const job = new CronJob(
-        '* * * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(1)
-          done()
-        },
-        true,
-      )
-
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should use standard cron no-seconds syntax (* * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('* * * * *', callback, null, true)
-
-      clock.tick(1000) // tick second
-
-      clock.tick(59 * 1000) // tick minute
-
-      job.stop()
-      clock.restore()
-
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run every second for 5 seconds (* * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('* * * * * *', callback, null, true)
-      for (let i = 0; i < 5; i++) clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(5)
-    })
-
-    it('should run every second for 5 seconds with onComplete (* * * * * *)', (done: any) => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-      const job = new CronJob(
-        '* * * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(5)
-          done()
-        },
-        true,
-      )
-      for (let i = 0; i < 5; i++) clock.tick(1000)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should run every second for 5 seconds (*/1 * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('*/1 * * * * *', callback, null, true)
-      for (let i = 0; i < 5; i++) clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(5)
-    })
-
-    it('should run every 2 seconds for 1 seconds (*/2 * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('*/2 * * * * *', callback, null, true)
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(0)
-    })
-
-    it('should run every 2 seconds for 5 seconds (*/2 * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('*/2 * * * * *', callback, null, true)
-      for (let i = 0; i < 5; i++) clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(2)
-    })
-
-    it('should run every second for 5 seconds with onComplete (*/1 * * * * *)', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob(
-        '*/1 * * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(5)
-          done()
-        },
-        true,
-      )
-      for (let i = 0; i < 5; i++) clock.tick(1000)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should run every second for a range ([start]-[end] * * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('0-8 * * * * *', callback, null, true)
-      clock.tick(10000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(8)
-    })
-
-    it('should run every second for a range ([start]-[end] * * * * *) with onComplete', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob(
-        '0-8 * * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(8)
-          done()
-        },
-        true,
-      )
-      clock.tick(10000)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should default to full range when upper range not provided (1/2 * * * * *)', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob(
-        '1/2 * * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(30)
-          done()
-        },
-        true,
-      )
-      clock.tick(1000 * 60)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should run every second (* * * * * *) using the object constructor', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = CronJob.from({
-        cronTime: '* * * * * *',
-        onTick: callback,
-        start: true,
-      })
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run every second with onComplete (* * * * * *) using the object constructor', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = CronJob.from({
-        cronTime: '* * * * * *',
-        onTick: callback,
-        onComplete: () => {
-          expect(callback).toHaveBeenCalledTimes(1)
-          done()
-        },
-        start: true,
-      })
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-    })
-  })
-
-  describe('with minutes', () => {
-    it('should fire every 60 min', () => {
-      const clock = sinon.useFakeTimers()
-      const m60 = 60 * 60 * 1000
-      const l: number[] = []
-      const job = new CronJob(
-        '00 30 * * * *',
-        () => {
-          l.push(Math.floor(Date.now() / 60000))
-        },
-        null,
-        true,
-      )
-
-      clock.tick(m60 * 10)
-
-      expect(l).toHaveLength(10)
-      expect(l.every(i => i % 30 === 0)).toBe(true)
-
-      job.stop()
-      clock.restore()
-    })
-
-    it('should run every 45 minutes for 2 hours (0 */45 * * * *)', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob('0 */45 * * * *', callback, null, true)
-      for (let i = 0; i < 2; i++) clock.tick(60 * 60 * 1000)
-      job.stop()
-      clock.restore()
-      expect(callback).toHaveBeenCalledTimes(4)
-    })
-
-    it('should run every 45 minutes for 2 hours (0 */45 * * * *) with onComplete', (done: any) => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      const job = new CronJob(
-        '0 */45 * * * *',
-        callback,
-        () => {
-          expect(callback).toHaveBeenCalledTimes(4)
-          done()
-        },
-        true,
-      )
-      for (let i = 0; i < 2; i++) clock.tick(60 * 60 * 1000)
-      job.stop()
-      clock.restore()
-    })
-  })
-
-  it('should start and stop job from outside', (done: any) => {
-    const clock = sinon.useFakeTimers()
-    const callback = jest.fn()
-    const job = new CronJob(
-      '* * * * * *',
-      () => {
-        callback()
-      },
-      () => {
-        expect(callback).toHaveBeenCalledTimes(1)
-        clock.restore()
-        done()
-      },
-      true,
-    )
-    clock.tick(1000)
-    job.stop()
-  })
-
-  it('should start and stop job from inside (default context)', (done: any) => {
-    const clock = sinon.useFakeTimers()
-    const callback = jest.fn()
-    new CronJob(
-      '* * * * * *',
-      function () {
-        callback()
-        this.stop()
-      },
-      () => {
-        expect(callback).toHaveBeenCalledTimes(1)
-        clock.restore()
-        done()
-      },
-      true,
-    )
-    clock.tick(1000)
-  })
-
-  describe('with date', () => {
-    it('should run on a specific date', () => {
-      const d = new Date()
-      const clock = sinon.useFakeTimers(d.getTime())
-      const s = d.getSeconds() + 1
-      d.setSeconds(s)
-      const callback = jest.fn()
-      const job = new CronJob(
-        d,
-        () => {
-          const t = new Date()
-          expect(t.getSeconds()).toBe(d.getSeconds())
-          callback()
-        },
-        null,
-        true,
-      )
-      clock.tick(1000)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run on a specific date and call onComplete from onTick', async () => {
-      const d = new Date()
-      const clock = sinon.useFakeTimers(d.getTime())
-      d.setSeconds(d.getSeconds() + 1)
-      const callback = jest.fn()
-
-      await new Promise<void>((resolve) => {
-        const job = new CronJob(
-          d,
-          (onComplete) => {
-            const t = new Date()
-            expect(t.getSeconds()).toBe(d.getSeconds())
-            void onComplete()
-          },
-          () => {
-            callback()
-            resolve()
-          },
-          true,
-        )
-        clock.tick(1000)
-        clock.restore()
-        job.stop()
-      })
-
-      // onComplete is called 2 times: once in onTick() & once when calling job.stop()
-      expect(callback).toHaveBeenCalledTimes(2)
-    })
-
-    it('should run on a specific date and call onComplete from onTick using the object constructor', async () => {
-      const d = new Date()
-      const clock = sinon.useFakeTimers(d.getTime())
-      d.setSeconds(d.getSeconds() + 1)
-      const callback = jest.fn()
-
-      await new Promise<void>((resolve) => {
-        const job = CronJob.from({
-          cronTime: d,
-          onTick: (onComplete) => {
-            const t = new Date()
-            expect(t.getSeconds()).toBe(d.getSeconds())
-            void onComplete()
-          },
-          onComplete: function () {
-            callback()
-            resolve()
-          } as () => void,
-          start: true,
-        })
-        clock.tick(1000)
-        clock.restore()
-        job.stop()
-      })
-
-      // onComplete is called 2 times: once in onTick() & once when calling job.stop()
-      expect(callback).toHaveBeenCalledTimes(2)
-    })
-
-    it('should not be able to call onComplete from onTick if if wasn\'t provided', () => {
-      expect.assertions(4)
-      const d = new Date()
-      const clock = sinon.useFakeTimers(d.getTime())
-      d.setSeconds(d.getSeconds() + 1)
-
-      const job = new CronJob(
-        d,
-        (onComplete) => {
-          const t = new Date()
-          expect(onComplete).toBeUndefined()
-          try {
-            // @ts-expect-error should be a TS warning and throw
-            onComplete()
-          }
-          catch (e) {
-            // we make sure this isn't skipped with `expect.assertions()`
-            // at the beginning of the test
-            expect(e).toBeInstanceOf(TypeError)
-          }
-          expect(onComplete).toBeUndefined()
-          expect(t.getSeconds()).toBe(d.getSeconds())
-        },
-        null,
-        true,
-      )
-      clock.tick(1000)
-      job.stop()
-      clock.restore()
-    })
-
-    it('should wait and not fire immediately', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      const d = new Date().getTime() + 31 * 86400 * 1000
-
-      const job = new CronJob(new Date(d), callback)
-      job.start()
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(0)
-    })
-
-    it('should wait but fire on init', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      const d = new Date().getTime() + 31 * 86400 * 1000
-
-      const job = CronJob.from({
-        cronTime: new Date(d),
-        onTick: callback,
-        runOnInit: true,
-      })
-
-      expect(callback).toHaveBeenCalledTimes(1)
-
-      job.start()
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should fire on init but not run until started', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      const job = CronJob.from({
-        cronTime: '* * * * * *',
-        onTick: callback,
-        runOnInit: true,
-      })
-
-      expect(callback).toHaveBeenCalledTimes(1)
-
-      job.start()
-
-      clock.tick(3500)
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(4)
-    })
-  })
-
-  describe('with timezone', () => {
-    it('should run a job using cron syntax with a timezone', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      let zone = 'America/Chicago'
-      // New Orleans time
-      let t = DateTime.local().setZone(zone)
-      // Current time
-      const d = DateTime.local()
-
-      // If current time is New Orleans time, switch to Los Angeles..
-      if (t.hour === d.hour) {
-        zone = 'America/Los_Angeles'
-        t = t.setZone(zone)
-      }
-      expect(d.hour).not.toBe(t.hour)
-
-      // If t = 59s12m then t.setSeconds(60)
-      // becomes 00s13m so we're fine just doing
-      // this and no testRun callback.
-      t = t.plus({ seconds: 1 })
-      // Run a job designed to be executed at a given
-      // time in `zone`, making sure that it is a different
-      // hour than local time.
-      const job = new CronJob(
-        `${t.second} ${t.minute} ${t.hour} * * *`,
-        callback,
-        null,
-        true,
-        zone,
-      )
-
-      clock.tick(1000)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run a job using cron syntax with a "UTC+HH:mm" offset as timezone', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      // Current time
-      const d = DateTime.local()
-
-      // Current time with zone offset
-      let zone = 'UTC+5:30'
-      let t = DateTime.local().setZone(zone)
-
-      // If current offset is UTC+5:30, switch to UTC+6:30..
-      if (t.hour === d.hour && t.minute === d.minute) {
-        zone = 'UTC+6:30'
-        t = t.setZone(zone)
-      }
-      expect(`${d.hour}:${d.minute}`).not.toBe(`${t.hour}:${t.minute}`)
-
-      // If t = 59s12m then t.setSeconds(60)
-      // becomes 00s13m so we're fine just doing
-      // this and no testRun callback.
-      t = t.plus({ seconds: 1 })
-      // Run a job designed to be executed at a given
-      // time in `zone`, making sure that it is a different
-      // hour than local time.
-      const job = new CronJob(
-        `${t.second} ${t.minute} ${t.hour} * * *`,
-        callback,
-        null,
-        true,
-        zone,
-      )
-
-      clock.tick(1000)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run a job using a date', () => {
-      let zone = 'America/Chicago'
-      // New Orleans time
-      let t = DateTime.local().setZone(zone)
-      // Current time
-      let d = DateTime.local()
-
-      // If current time is New Orleans time, switch to Los Angeles..
-      if (t.hour === d.hour) {
-        zone = 'America/Los_Angeles'
-        t = t.setZone(zone)
-      }
-
-      expect(d.hour).not.toBe(t.hour)
-      d = d.plus({ seconds: 1 })
-      const clock = sinon.useFakeTimers(d.valueOf())
-      const callback = jest.fn()
-      const job = new CronJob(d.toJSDate(), callback, null, true, zone)
-      clock.tick(1000)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should test if timezone is valid.', () => {
-      expect(() => {
-        CronJob.from({
-          cronTime: '* * * * * *',
-          onTick: () => { },
-          timeZone: 'fake/timezone',
-        })
-      }).toThrow()
-    })
-  })
-
-  describe('onTick scoping', () => {
-    it('should scope onTick to running job', () => {
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob(
-        '* * * * * *',
-        function () {
-          expect(job).toBeInstanceOf(CronJob)
-          expect(job).toEqual(this)
-        },
-        null,
-        true,
-      )
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-    })
-
-    it('should scope onTick to running job using the object constructor', () => {
-      const clock = sinon.useFakeTimers()
-
-      const job = CronJob.from({
-        cronTime: '* * * * * *',
-        onTick() {
-          expect(job).toBeInstanceOf(CronJob)
-          expect(job).toEqual(this)
-        },
-        start: true,
-      })
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-    })
-
-    it('should scope onTick to object', () => {
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob(
-        '* * * * * *',
-        function () {
-          expect(this.hello).toBe('world')
-          expect(job).not.toEqual(this)
-        },
-        null,
-        true,
-        null,
-        { hello: 'world' },
-      )
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-    })
-
-    it('should scope onTick to object using the object constructor', () => {
-      const clock = sinon.useFakeTimers()
-
-      const job = CronJob.from({
-        cronTime: '* * * * * *',
-        onTick() {
-          expect(this.hello).toBe('world')
-          expect(job).not.toEqual(this)
-        },
-        start: true,
-        context: { hello: 'world' },
-      })
-
-      clock.tick(1000)
-
-      clock.restore()
-      job.stop()
-    })
-  })
-
-  it('should not get into an infinite loop on invalid times', () => {
-    expect(() => {
-      new CronJob(
-        '* 60 * * * *',
-        () => {
-          expect(true).toBe(true)
-        },
-        null,
-        true,
-      )
-    }).toThrow()
-
-    expect(() => {
-      new CronJob(
-        '* * 24 * * *',
-        () => {
-          expect(true).toBe(true)
-        },
-        null,
-        true,
-      )
-    }).toThrow()
-  })
-
-  it('should test start of month', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(59)
-    d.setMinutes(59)
-    d.setHours(23)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = new CronJob('0 0 0 1 * *', callback, null, true)
-
-    clock.tick(1001)
-    expect(callback).toHaveBeenCalledTimes(1)
-
-    clock.tick(2678399001)
-    expect(callback).toHaveBeenCalledTimes(1)
-
-    clock.tick(2678400001) // jump over 2 firsts
-    clock.restore()
-    job.stop()
-
-    expect(callback).toHaveBeenCalledTimes(3)
-  })
-
-  it('should not fire if time was adjusted back', () => {
-    const callback = jest.fn()
-    const clock = sinon.useFakeTimers({
-      toFake: ['setTimeout'],
-    })
-
-    const job = new CronJob('0 * * * * *', callback, null, true)
-
-    clock.tick(60000)
-    expect(callback).toHaveBeenCalledTimes(0)
-
-    clock.restore()
-    job.stop()
-  })
-
-  it('should run every day', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(59)
-    d.setMinutes(59)
-    d.setHours(23)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '59 59 3 * * *',
-      onTick: callback,
-      start: true,
-      timeZone: 'America/Los_Angeles',
-    })
-
-    const twoWeeks = 14 * 24 * 60 * 60 * 1000
-    clock.tick(twoWeeks)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(14)
-  })
-
-  it('should run every 2 hours between hours', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(0)
-    d.setMinutes(0)
-    d.setHours(0)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '0 2-6/2 * * * *',
-      onTick: callback,
-      start: true,
-    })
-
-    clock.tick(2 * 60 * 1000)
-    expect(callback).toHaveBeenCalledTimes(1)
-    clock.tick(2 * 60 * 1000)
-    expect(callback).toHaveBeenCalledTimes(2)
-    clock.tick(2 * 60 * 1000)
-    expect(callback).toHaveBeenCalledTimes(3)
-    clock.tick(2 * 60 * 1000)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(3)
-  })
-
-  it('should run every minute', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(0)
-    d.setMinutes(0)
-    d.setHours(0)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '00 * * * * *',
-      onTick: callback,
-      start: true,
-    })
-
-    clock.tick(60 * 1000)
-    expect(callback).toHaveBeenCalledTimes(1)
-    clock.tick(60 * 1000)
-    expect(callback).toHaveBeenCalledTimes(2)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(2)
-  })
-
-  it('should run every day at 12:30', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(0)
-    d.setMinutes(0)
-    d.setHours(0)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '00 30 00 * * *',
-      onTick: callback,
-      start: true,
-    })
-
-    const day = 24 * 60 * 60 * 1000
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(1)
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(2)
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(3)
-    clock.tick(5 * day)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(8)
-  })
-
-  it('should trigger onTick at midnight', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(59)
-    d.setMinutes(59)
-    d.setHours(23)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '00 * * * * *',
-      onTick: callback,
-      start: true,
-      timeZone: 'UTC',
-    })
-
-    clock.tick(1000) // move clock 1 second
-    expect(callback).toHaveBeenCalledTimes(1)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(1)
-  })
-
-  it('should run every day UTC', () => {
-    const callback = jest.fn()
-    const d = new Date('12/31/2014')
-    d.setSeconds(0)
-    d.setMinutes(0)
-    d.setHours(0)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '00 30 00 * * *',
-      onTick: callback,
-      start: true,
-      timeZone: 'UTC',
-    })
-
-    const day = 24 * 60 * 60 * 1000
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(1)
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(2)
-    clock.tick(day)
-    expect(callback).toHaveBeenCalledTimes(3)
-    clock.tick(5 * day)
-
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(8)
-  })
-
-  // from https://github.com/kelektiv/node-cron/issues/180#issuecomment-154108131
-  it('should run once not double', () => {
-    const callback = jest.fn()
-    const d = new Date(2015, 1, 1, 1, 1, 41, 0)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: '* * * * *',
-      onTick: callback,
-      start: true,
-    })
-
-    const minute = 60 * 1000
-    clock.tick(minute)
-    expect(callback).toHaveBeenCalledTimes(1)
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(1)
-  })
-
-  /**
-   * maximum match interval is 8 years:
-   * crontab has '* * 29 2 *' and we are on 1 March 2096:
-   * next matching time will be 29 February 2104
-   * source: https://github.com/cronie-crond/cronie/blob/0d669551680f733a4bdd6bab082a0b3d6d7f089c/src/cronnext.c#L401-L403
-   */
-  it('should work correctly for max match interval', () => {
-    const callback = jest.fn()
-    const d = new Date(2096, 2, 1)
-    const clock = sinon.useFakeTimers(d.getTime())
-
-    const job = CronJob.from({
-      cronTime: ' * * 29 2 *',
-      onTick: callback,
-      start: true,
-    })
-
-    // 7 years, 11 months and 27 days
-    const almostEightYears = 2919 * 24 * 60 * 60 * 1000
-    clock.tick(almostEightYears)
-    expect(callback).toHaveBeenCalledTimes(0)
-
-    // tick by 1 day
-    clock.tick(24 * 60 * 60 * 1000)
-    clock.restore()
-    job.stop()
-    expect(callback).toHaveBeenCalledTimes(1)
-  })
-
-  describe('with utcOffset', () => {
-    it('should run a job using cron syntax with number format utcOffset', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      // Current time
-      const t = DateTime.local()
-      // UTC Offset decreased by an hour
-      const utcOffset = t.offset - 60
-
-      const job = new CronJob(
-        `${t.second} ${t.minute} ${t.hour} * * *`,
-        callback,
-        null,
-        true,
-        null,
-        null,
-        null,
-        utcOffset,
-      )
-
-      // tick 1 sec before an hour
-      clock.tick(1000 * 60 * 60 - 1)
-      expect(callback).toHaveBeenCalledTimes(0)
-
-      clock.tick(1)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run a job using cron syntax with numeric format utcOffset with minute support', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-      // Current time
-      const t = DateTime.local()
-
-      // UTC Offset decreased by 45 minutes
-      const utcOffset = t.offset - 45
-      const job = new CronJob(
-        `${t.second} ${t.minute} ${t.hour} * * *`,
-        callback,
-        null,
-        true,
-        null,
-        null,
-        null,
-        utcOffset,
-      )
-
-      // tick 1 sec before 45 minutes
-      clock.tick(1000 * 45 * 60 - 1)
-      expect(callback).toHaveBeenCalledTimes(0)
-
-      clock.tick(1)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should run a job using cron syntax with number format utcOffset that is 0', () => {
-      const clock = sinon.useFakeTimers()
-      const callback = jest.fn()
-
-      const job = new CronJob(
-        '* * * * * *',
-        callback,
-        null,
-        true,
-        null,
-        null,
-        null,
-        0,
-      )
-
-      clock.tick(999)
-      expect(callback).toHaveBeenCalledTimes(0)
-
-      clock.tick(1)
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should be able to detect out of range days of month', () => {
-      expect(() => {
-        new CronTime('* * 32 FEB *')
-      }).toThrow()
-    })
-  })
-
-  describe('setTime', () => {
-    it('should start, change time, start again', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob('* * * * * *', callback)
-
-      job.start()
-      clock.tick(1000)
-
-      const time = new CronTime('*/2 * * * * *')
-      job.setTime(time)
-
-      clock.tick(4000)
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(3)
-    })
-
-    it('should start, stop, change time, not start again', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob('* * * * * *', callback)
-
-      job.start()
-      clock.tick(1000)
-
-      job.stop()
-      const time = new CronTime('*/2 * * * * *')
-      job.setTime(time)
-
-      clock.tick(4000)
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should setTime with invalid object', () => {
-      const callback = jest.fn()
-      const job = new CronJob('* * * * * *', callback)
-      expect(() => {
-        // @ts-expect-error time parameter cannot be undefined
-        job.setTime(undefined)
-      }).toThrow()
-    })
-
-    it('should start, change time, exception', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob('* * * * * *', callback)
-
-      const time = new Date()
-      job.start()
-
-      clock.tick(1000)
-
-      expect(() => {
-        // @ts-expect-error time parameter but be an instance of CronTime
-        job.setTime(time)
-      }).toThrow()
-
-      clock.restore()
-      job.stop()
-      expect(callback).toHaveBeenCalledTimes(1)
-    })
-
-    it('should create recurring job, setTime with actual date, start and run once (#739)', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-
-      const job = new CronJob('0 0 20 * * *', callback)
-
-      const startDate = new Date(Date.now() + 5000)
-      job.setTime(new CronTime(startDate))
-
-      job.start()
-
-      clock.tick(5000)
-
-      expect(callback).toHaveBeenCalledTimes(1)
-
-      clock.tick(60000)
-
-      clock.restore()
-
-      expect(callback).toHaveBeenCalledTimes(1)
-      expect(job.running).toBe(false)
-    })
-  })
-
-  describe('nextDate(s)', () => {
-    it('should give the next date to run at', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-      const job = new CronJob('* * * * * *', callback)
-      const d = Date.now()
-
-      expect(job.nextDate().toMillis()).toEqual(d + 1000)
-
-      clock.restore()
-    })
-
-    it('should give the next 5 dates to run at', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-      const job = new CronJob('* * * * * *', callback)
-      const d = Date.now()
-
-      expect(job.nextDates(5).map(d => d.toMillis())).toEqual([
-        d + 1000,
-        d + 2000,
-        d + 3000,
-        d + 4000,
-        d + 5000,
-      ])
-
-      clock.restore()
-    })
-
-    it('should give an empty array when called without argument', () => {
-      const callback = jest.fn()
-      const clock = sinon.useFakeTimers()
-      const job = new CronJob('* * * * * *', callback)
-
-      expect(job.nextDates()).toHaveLength(0)
-
-      clock.restore()
-    })
-  })
-
-  it('should automatically setup a new timeout if we roll past the max timeout delay', () => {
-    const callback = jest.fn()
-    const clock = sinon.useFakeTimers()
-    const d = new Date()
-    d.setMilliseconds(2147485647 * 2) // MAXDELAY in `job.js` + 2000.
-    const job = new CronJob(d, callback)
-    job.start()
-    clock.tick(2147483648)
-    expect(callback).toHaveBeenCalledTimes(0)
-    clock.tick(2147489648)
-    expect(callback).toHaveBeenCalledTimes(1)
-    job.stop()
-    clock.restore()
-  })
-
-  it('should give the correct last execution date', () => {
-    const callback = jest.fn()
-    const clock = sinon.useFakeTimers()
-    const job = new CronJob('* * * * * *', callback)
-    job.start()
-    clock.tick(1000)
-    expect(callback).toHaveBeenCalledTimes(1)
-    expect(job.lastDate()?.getTime()).toBe(1000)
-    job.stop()
-    clock.restore()
-  })
-
-  it('should give the correct last execution date for intervals greater than 25 days (#710)', () => {
-    const callback = jest.fn()
-    const clock = sinon.useFakeTimers()
-
-    const job = new CronJob('0 0 0 1 * *', callback) // At 00:00 on day-of-month 1.
-    job.start()
-
-    // tick one tick before nextDate()
-    clock.tick(job.nextDate().toMillis() - 1)
-
-    expect(callback).toHaveBeenCalledTimes(0)
-    expect(job.lastDate()?.getTime()).toBeUndefined()
-
-    job.stop()
-    clock.restore()
-  })
-
-  it('should throw when providing both exclusive parameters timeZone and utcOffset', () => {
-    expect(() => {
-      // @ts-expect-error testing runtime exception
-      new CronJob(
-        `* * * * *`,
-        () => { },
-        null,
-        true,
-        'America/Chicago',
-        null,
-        null,
-        120,
-      )
-    }).toThrow()
-  })
-
-  it('should throw when providing both exclusive parameters timeZone and utcOffset using the object constructor', () => {
-    expect(() => {
-      // @ts-expect-error testing runtime exception
-      CronJob.from({
-        cronTime: '* * * * * *',
-        onTick() { },
-        timeZone: 'America/Chicago',
-        utcOffset: 120,
-      })
-    }).toThrow()
-  })
-
-  it('should support async callback', () => {
-    const clock = sinon.useFakeTimers()
-    const callback = jest.fn()
-    const job = new CronJob(
-      '* * * * * *',
-      async () => {
-        await new Promise<void>((resolve) => {
-          setTimeout(() => {
-            callback()
-            resolve()
-          }, 500)
-        })
-      },
-      null,
-      true,
-    )
-    clock.tick(1500)
-    job.stop()
-    clock.restore()
-    expect(callback).toHaveBeenCalledTimes(1)
-  })
-})
+// /* eslint-disable no-new */
+// import { DateTime } from 'luxon'
+//
+// // @ts-expect-error types aren't there
+// import sinon from 'sinon'
+// import { CronJob, CronTime } from '../src'
+//
+// describe('cron', () => {
+//   afterEach(() => expect.hasAssertions())
+//
+//   describe('with seconds', () => {
+//     it('should run every second (* * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('* * * * * *', callback, null, true)
+//
+//       expect(callback).not.toHaveBeenCalled()
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run second with onComplete (* * * * * *)', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       const job = new CronJob(
+//         '* * * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(1)
+//           done()
+//         },
+//         true,
+//       )
+//
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should use standard cron no-seconds syntax (* * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('* * * * *', callback, null, true)
+//
+//       clock.tick(1000) // tick second
+//
+//       clock.tick(59 * 1000) // tick minute
+//
+//       job.stop()
+//       clock.restore()
+//
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run every second for 5 seconds (* * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('* * * * * *', callback, null, true)
+//       for (let i = 0; i < 5; i++) clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(5)
+//     })
+//
+//     it('should run every second for 5 seconds with onComplete (* * * * * *)', (done: any) => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//       const job = new CronJob(
+//         '* * * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(5)
+//           done()
+//         },
+//         true,
+//       )
+//       for (let i = 0; i < 5; i++) clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should run every second for 5 seconds (*/1 * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('*/1 * * * * *', callback, null, true)
+//       for (let i = 0; i < 5; i++) clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(5)
+//     })
+//
+//     it('should run every 2 seconds for 1 seconds (*/2 * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('*/2 * * * * *', callback, null, true)
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(0)
+//     })
+//
+//     it('should run every 2 seconds for 5 seconds (*/2 * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('*/2 * * * * *', callback, null, true)
+//       for (let i = 0; i < 5; i++) clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(2)
+//     })
+//
+//     it('should run every second for 5 seconds with onComplete (*/1 * * * * *)', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob(
+//         '*/1 * * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(5)
+//           done()
+//         },
+//         true,
+//       )
+//       for (let i = 0; i < 5; i++) clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should run every second for a range ([start]-[end] * * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('0-8 * * * * *', callback, null, true)
+//       clock.tick(10000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(8)
+//     })
+//
+//     it('should run every second for a range ([start]-[end] * * * * *) with onComplete', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob(
+//         '0-8 * * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(8)
+//           done()
+//         },
+//         true,
+//       )
+//       clock.tick(10000)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should default to full range when upper range not provided (1/2 * * * * *)', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob(
+//         '1/2 * * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(30)
+//           done()
+//         },
+//         true,
+//       )
+//       clock.tick(1000 * 60)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should run every second (* * * * * *) using the object constructor', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick: callback,
+//         start: true,
+//       })
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run every second with onComplete (* * * * * *) using the object constructor', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick: callback,
+//         onComplete: () => {
+//           expect(callback).toHaveBeenCalledTimes(1)
+//           done()
+//         },
+//         start: true,
+//       })
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//   })
+//
+//   describe('with minutes', () => {
+//     it('should fire every 60 min', () => {
+//       const clock = sinon.useFakeTimers()
+//       const m60 = 60 * 60 * 1000
+//       const l: number[] = []
+//       const job = new CronJob(
+//         '00 30 * * * *',
+//         () => {
+//           l.push(Math.floor(Date.now() / 60000))
+//         },
+//         null,
+//         true,
+//       )
+//
+//       clock.tick(m60 * 10)
+//
+//       expect(l).toHaveLength(10)
+//       expect(l.every(i => i % 30 === 0)).toBe(true)
+//
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should run every 45 minutes for 2 hours (0 */45 * * * *)', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob('0 */45 * * * *', callback, null, true)
+//       for (let i = 0; i < 2; i++) clock.tick(60 * 60 * 1000)
+//       job.stop()
+//       clock.restore()
+//       expect(callback).toHaveBeenCalledTimes(4)
+//     })
+//
+//     it('should run every 45 minutes for 2 hours (0 */45 * * * *) with onComplete', (done: any) => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       const job = new CronJob(
+//         '0 */45 * * * *',
+//         callback,
+//         () => {
+//           expect(callback).toHaveBeenCalledTimes(4)
+//           done()
+//         },
+//         true,
+//       )
+//       for (let i = 0; i < 2; i++) clock.tick(60 * 60 * 1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//   })
+//
+//   it('should start and stop job from outside', (done: any) => {
+//     const clock = sinon.useFakeTimers()
+//     const callback = jest.fn()
+//     const job = new CronJob(
+//       '* * * * * *',
+//       () => {
+//         callback()
+//       },
+//       () => {
+//         expect(callback).toHaveBeenCalledTimes(1)
+//         clock.restore()
+//         done()
+//       },
+//       true,
+//     )
+//     clock.tick(1000)
+//     job.stop()
+//   })
+//
+//   it('should start and stop job from inside (default context)', (done: any) => {
+//     const clock = sinon.useFakeTimers()
+//     const callback = jest.fn()
+//     new CronJob(
+//       '* * * * * *',
+//       function () {
+//         callback()
+//         this.stop()
+//       },
+//       () => {
+//         expect(callback).toHaveBeenCalledTimes(1)
+//         clock.restore()
+//         done()
+//       },
+//       true,
+//     )
+//     clock.tick(1000)
+//   })
+//
+//   describe('with date', () => {
+//     it('should run on a specific date', () => {
+//       const d = new Date()
+//       const clock = sinon.useFakeTimers(d.getTime())
+//       const s = d.getSeconds() + 1
+//       d.setSeconds(s)
+//       const callback = jest.fn()
+//       const job = new CronJob(
+//         d,
+//         () => {
+//           const t = new Date()
+//           expect(t.getSeconds()).toBe(d.getSeconds())
+//           callback()
+//         },
+//         null,
+//         true,
+//       )
+//       clock.tick(1000)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run on a specific date and call onComplete from onTick', async () => {
+//       const d = new Date()
+//       const clock = sinon.useFakeTimers(d.getTime())
+//       d.setSeconds(d.getSeconds() + 1)
+//       const callback = jest.fn()
+//
+//       await new Promise<void>((resolve) => {
+//         const job = new CronJob(
+//           d,
+//           (onComplete) => {
+//             const t = new Date()
+//             expect(t.getSeconds()).toBe(d.getSeconds())
+//             void onComplete()
+//           },
+//           () => {
+//             callback()
+//             resolve()
+//           },
+//           true,
+//         )
+//         clock.tick(1000)
+//         clock.restore()
+//         job.stop()
+//       })
+//
+//       // onComplete is called 2 times: once in onTick() & once when calling job.stop()
+//       expect(callback).toHaveBeenCalledTimes(2)
+//     })
+//
+//     it('should run on a specific date and call onComplete from onTick using the object constructor', async () => {
+//       const d = new Date()
+//       const clock = sinon.useFakeTimers(d.getTime())
+//       d.setSeconds(d.getSeconds() + 1)
+//       const callback = jest.fn()
+//
+//       await new Promise<void>((resolve) => {
+//         const job = CronJob.from({
+//           cronTime: d,
+//           onTick: (onComplete) => {
+//             const t = new Date()
+//             expect(t.getSeconds()).toBe(d.getSeconds())
+//             void onComplete()
+//           },
+//           onComplete: function () {
+//             callback()
+//             resolve()
+//           } as () => void,
+//           start: true,
+//         })
+//         clock.tick(1000)
+//         clock.restore()
+//         job.stop()
+//       })
+//
+//       // onComplete is called 2 times: once in onTick() & once when calling job.stop()
+//       expect(callback).toHaveBeenCalledTimes(2)
+//     })
+//
+//     it('should not be able to call onComplete from onTick if if wasn\'t provided', () => {
+//       expect.assertions(4)
+//       const d = new Date()
+//       const clock = sinon.useFakeTimers(d.getTime())
+//       d.setSeconds(d.getSeconds() + 1)
+//
+//       const job = new CronJob(
+//         d,
+//         (onComplete) => {
+//           const t = new Date()
+//           expect(onComplete).toBeUndefined()
+//           try {
+//             // @ts-expect-error should be a TS warning and throw
+//             onComplete()
+//           }
+//           catch (e) {
+//             // we make sure this isn't skipped with `expect.assertions()`
+//             // at the beginning of the test
+//             expect(e).toBeInstanceOf(TypeError)
+//           }
+//           expect(onComplete).toBeUndefined()
+//           expect(t.getSeconds()).toBe(d.getSeconds())
+//         },
+//         null,
+//         true,
+//       )
+//       clock.tick(1000)
+//       job.stop()
+//       clock.restore()
+//     })
+//
+//     it('should wait and not fire immediately', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       const d = new Date().getTime() + 31 * 86400 * 1000
+//
+//       const job = new CronJob(new Date(d), callback)
+//       job.start()
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(0)
+//     })
+//
+//     it('should wait but fire on init', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       const d = new Date().getTime() + 31 * 86400 * 1000
+//
+//       const job = CronJob.from({
+//         cronTime: new Date(d),
+//         onTick: callback,
+//         runOnInit: true,
+//       })
+//
+//       expect(callback).toHaveBeenCalledTimes(1)
+//
+//       job.start()
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should fire on init but not run until started', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       const job = CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick: callback,
+//         runOnInit: true,
+//       })
+//
+//       expect(callback).toHaveBeenCalledTimes(1)
+//
+//       job.start()
+//
+//       clock.tick(3500)
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(4)
+//     })
+//   })
+//
+//   describe('with timezone', () => {
+//     it('should run a job using cron syntax with a timezone', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       let zone = 'America/Chicago'
+//       // New Orleans time
+//       let t = DateTime.local().setZone(zone)
+//       // Current time
+//       const d = DateTime.local()
+//
+//       // If current time is New Orleans time, switch to Los Angeles..
+//       if (t.hour === d.hour) {
+//         zone = 'America/Los_Angeles'
+//         t = t.setZone(zone)
+//       }
+//       expect(d.hour).not.toBe(t.hour)
+//
+//       // If t = 59s12m then t.setSeconds(60)
+//       // becomes 00s13m so we're fine just doing
+//       // this and no testRun callback.
+//       t = t.plus({ seconds: 1 })
+//       // Run a job designed to be executed at a given
+//       // time in `zone`, making sure that it is a different
+//       // hour than local time.
+//       const job = new CronJob(
+//         `${t.second} ${t.minute} ${t.hour} * * *`,
+//         callback,
+//         null,
+//         true,
+//         zone,
+//       )
+//
+//       clock.tick(1000)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run a job using cron syntax with a "UTC+HH:mm" offset as timezone', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       // Current time
+//       const d = DateTime.local()
+//
+//       // Current time with zone offset
+//       let zone = 'UTC+5:30'
+//       let t = DateTime.local().setZone(zone)
+//
+//       // If current offset is UTC+5:30, switch to UTC+6:30..
+//       if (t.hour === d.hour && t.minute === d.minute) {
+//         zone = 'UTC+6:30'
+//         t = t.setZone(zone)
+//       }
+//       expect(`${d.hour}:${d.minute}`).not.toBe(`${t.hour}:${t.minute}`)
+//
+//       // If t = 59s12m then t.setSeconds(60)
+//       // becomes 00s13m so we're fine just doing
+//       // this and no testRun callback.
+//       t = t.plus({ seconds: 1 })
+//       // Run a job designed to be executed at a given
+//       // time in `zone`, making sure that it is a different
+//       // hour than local time.
+//       const job = new CronJob(
+//         `${t.second} ${t.minute} ${t.hour} * * *`,
+//         callback,
+//         null,
+//         true,
+//         zone,
+//       )
+//
+//       clock.tick(1000)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run a job using a date', () => {
+//       let zone = 'America/Chicago'
+//       // New Orleans time
+//       let t = DateTime.local().setZone(zone)
+//       // Current time
+//       let d = DateTime.local()
+//
+//       // If current time is New Orleans time, switch to Los Angeles..
+//       if (t.hour === d.hour) {
+//         zone = 'America/Los_Angeles'
+//         t = t.setZone(zone)
+//       }
+//
+//       expect(d.hour).not.toBe(t.hour)
+//       d = d.plus({ seconds: 1 })
+//       const clock = sinon.useFakeTimers(d.valueOf())
+//       const callback = jest.fn()
+//       const job = new CronJob(d.toJSDate(), callback, null, true, zone)
+//       clock.tick(1000)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should test if timezone is valid.', () => {
+//       expect(() => {
+//         CronJob.from({
+//           cronTime: '* * * * * *',
+//           onTick: () => { },
+//           timeZone: 'fake/timezone',
+//         })
+//       }).toThrow()
+//     })
+//   })
+//
+//   describe('onTick scoping', () => {
+//     it('should scope onTick to running job', () => {
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob(
+//         '* * * * * *',
+//         function () {
+//           expect(job).toBeInstanceOf(CronJob)
+//           expect(job).toEqual(this)
+//         },
+//         null,
+//         true,
+//       )
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//     })
+//
+//     it('should scope onTick to running job using the object constructor', () => {
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick() {
+//           expect(job).toBeInstanceOf(CronJob)
+//           expect(job).toEqual(this)
+//         },
+//         start: true,
+//       })
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//     })
+//
+//     it('should scope onTick to object', () => {
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob(
+//         '* * * * * *',
+//         function () {
+//           expect(this.hello).toBe('world')
+//           expect(job).not.toEqual(this)
+//         },
+//         null,
+//         true,
+//         null,
+//         { hello: 'world' },
+//       )
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//     })
+//
+//     it('should scope onTick to object using the object constructor', () => {
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick() {
+//           expect(this.hello).toBe('world')
+//           expect(job).not.toEqual(this)
+//         },
+//         start: true,
+//         context: { hello: 'world' },
+//       })
+//
+//       clock.tick(1000)
+//
+//       clock.restore()
+//       job.stop()
+//     })
+//   })
+//
+//   it('should not get into an infinite loop on invalid times', () => {
+//     expect(() => {
+//       new CronJob(
+//         '* 60 * * * *',
+//         () => {
+//           expect(true).toBe(true)
+//         },
+//         null,
+//         true,
+//       )
+//     }).toThrow()
+//
+//     expect(() => {
+//       new CronJob(
+//         '* * 24 * * *',
+//         () => {
+//           expect(true).toBe(true)
+//         },
+//         null,
+//         true,
+//       )
+//     }).toThrow()
+//   })
+//
+//   it('should test start of month', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(59)
+//     d.setMinutes(59)
+//     d.setHours(23)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = new CronJob('0 0 0 1 * *', callback, null, true)
+//
+//     clock.tick(1001)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//
+//     clock.tick(2678399001)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//
+//     clock.tick(2678400001) // jump over 2 firsts
+//     clock.restore()
+//     job.stop()
+//
+//     expect(callback).toHaveBeenCalledTimes(3)
+//   })
+//
+//   it('should not fire if time was adjusted back', () => {
+//     const callback = jest.fn()
+//     const clock = sinon.useFakeTimers({
+//       toFake: ['setTimeout'],
+//     })
+//
+//     const job = new CronJob('0 * * * * *', callback, null, true)
+//
+//     clock.tick(60000)
+//     expect(callback).toHaveBeenCalledTimes(0)
+//
+//     clock.restore()
+//     job.stop()
+//   })
+//
+//   it('should run every day', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(59)
+//     d.setMinutes(59)
+//     d.setHours(23)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '59 59 3 * * *',
+//       onTick: callback,
+//       start: true,
+//       timeZone: 'America/Los_Angeles',
+//     })
+//
+//     const twoWeeks = 14 * 24 * 60 * 60 * 1000
+//     clock.tick(twoWeeks)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(14)
+//   })
+//
+//   it('should run every 2 hours between hours', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(0)
+//     d.setMinutes(0)
+//     d.setHours(0)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '0 2-6/2 * * * *',
+//       onTick: callback,
+//       start: true,
+//     })
+//
+//     clock.tick(2 * 60 * 1000)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     clock.tick(2 * 60 * 1000)
+//     expect(callback).toHaveBeenCalledTimes(2)
+//     clock.tick(2 * 60 * 1000)
+//     expect(callback).toHaveBeenCalledTimes(3)
+//     clock.tick(2 * 60 * 1000)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(3)
+//   })
+//
+//   it('should run every minute', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(0)
+//     d.setMinutes(0)
+//     d.setHours(0)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '00 * * * * *',
+//       onTick: callback,
+//       start: true,
+//     })
+//
+//     clock.tick(60 * 1000)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     clock.tick(60 * 1000)
+//     expect(callback).toHaveBeenCalledTimes(2)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(2)
+//   })
+//
+//   it('should run every day at 12:30', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(0)
+//     d.setMinutes(0)
+//     d.setHours(0)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '00 30 00 * * *',
+//       onTick: callback,
+//       start: true,
+//     })
+//
+//     const day = 24 * 60 * 60 * 1000
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(2)
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(3)
+//     clock.tick(5 * day)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(8)
+//   })
+//
+//   it('should trigger onTick at midnight', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(59)
+//     d.setMinutes(59)
+//     d.setHours(23)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '00 * * * * *',
+//       onTick: callback,
+//       start: true,
+//       timeZone: 'UTC',
+//     })
+//
+//     clock.tick(1000) // move clock 1 second
+//     expect(callback).toHaveBeenCalledTimes(1)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(1)
+//   })
+//
+//   it('should run every day UTC', () => {
+//     const callback = jest.fn()
+//     const d = new Date('12/31/2014')
+//     d.setSeconds(0)
+//     d.setMinutes(0)
+//     d.setHours(0)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '00 30 00 * * *',
+//       onTick: callback,
+//       start: true,
+//       timeZone: 'UTC',
+//     })
+//
+//     const day = 24 * 60 * 60 * 1000
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(2)
+//     clock.tick(day)
+//     expect(callback).toHaveBeenCalledTimes(3)
+//     clock.tick(5 * day)
+//
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(8)
+//   })
+//
+//   // from https://github.com/kelektiv/node-cron/issues/180#issuecomment-154108131
+//   it('should run once not double', () => {
+//     const callback = jest.fn()
+//     const d = new Date(2015, 1, 1, 1, 1, 41, 0)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: '* * * * *',
+//       onTick: callback,
+//       start: true,
+//     })
+//
+//     const minute = 60 * 1000
+//     clock.tick(minute)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(1)
+//   })
+//
+//   /**
+//    * maximum match interval is 8 years:
+//    * crontab has '* * 29 2 *' and we are on 1 March 2096:
+//    * next matching time will be 29 February 2104
+//    * source: https://github.com/cronie-crond/cronie/blob/0d669551680f733a4bdd6bab082a0b3d6d7f089c/src/cronnext.c#L401-L403
+//    */
+//   it('should work correctly for max match interval', () => {
+//     const callback = jest.fn()
+//     const d = new Date(2096, 2, 1)
+//     const clock = sinon.useFakeTimers(d.getTime())
+//
+//     const job = CronJob.from({
+//       cronTime: ' * * 29 2 *',
+//       onTick: callback,
+//       start: true,
+//     })
+//
+//     // 7 years, 11 months and 27 days
+//     const almostEightYears = 2919 * 24 * 60 * 60 * 1000
+//     clock.tick(almostEightYears)
+//     expect(callback).toHaveBeenCalledTimes(0)
+//
+//     // tick by 1 day
+//     clock.tick(24 * 60 * 60 * 1000)
+//     clock.restore()
+//     job.stop()
+//     expect(callback).toHaveBeenCalledTimes(1)
+//   })
+//
+//   describe('with utcOffset', () => {
+//     it('should run a job using cron syntax with number format utcOffset', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       // Current time
+//       const t = DateTime.local()
+//       // UTC Offset decreased by an hour
+//       const utcOffset = t.offset - 60
+//
+//       const job = new CronJob(
+//         `${t.second} ${t.minute} ${t.hour} * * *`,
+//         callback,
+//         null,
+//         true,
+//         null,
+//         null,
+//         null,
+//         utcOffset,
+//       )
+//
+//       // tick 1 sec before an hour
+//       clock.tick(1000 * 60 * 60 - 1)
+//       expect(callback).toHaveBeenCalledTimes(0)
+//
+//       clock.tick(1)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run a job using cron syntax with numeric format utcOffset with minute support', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//       // Current time
+//       const t = DateTime.local()
+//
+//       // UTC Offset decreased by 45 minutes
+//       const utcOffset = t.offset - 45
+//       const job = new CronJob(
+//         `${t.second} ${t.minute} ${t.hour} * * *`,
+//         callback,
+//         null,
+//         true,
+//         null,
+//         null,
+//         null,
+//         utcOffset,
+//       )
+//
+//       // tick 1 sec before 45 minutes
+//       clock.tick(1000 * 45 * 60 - 1)
+//       expect(callback).toHaveBeenCalledTimes(0)
+//
+//       clock.tick(1)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should run a job using cron syntax with number format utcOffset that is 0', () => {
+//       const clock = sinon.useFakeTimers()
+//       const callback = jest.fn()
+//
+//       const job = new CronJob(
+//         '* * * * * *',
+//         callback,
+//         null,
+//         true,
+//         null,
+//         null,
+//         null,
+//         0,
+//       )
+//
+//       clock.tick(999)
+//       expect(callback).toHaveBeenCalledTimes(0)
+//
+//       clock.tick(1)
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should be able to detect out of range days of month', () => {
+//       expect(() => {
+//         new CronTime('* * 32 FEB *')
+//       }).toThrow()
+//     })
+//   })
+//
+//   describe('setTime', () => {
+//     it('should start, change time, start again', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob('* * * * * *', callback)
+//
+//       job.start()
+//       clock.tick(1000)
+//
+//       const time = new CronTime('*/2 * * * * *')
+//       job.setTime(time)
+//
+//       clock.tick(4000)
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(3)
+//     })
+//
+//     it('should start, stop, change time, not start again', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob('* * * * * *', callback)
+//
+//       job.start()
+//       clock.tick(1000)
+//
+//       job.stop()
+//       const time = new CronTime('*/2 * * * * *')
+//       job.setTime(time)
+//
+//       clock.tick(4000)
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should setTime with invalid object', () => {
+//       const callback = jest.fn()
+//       const job = new CronJob('* * * * * *', callback)
+//       expect(() => {
+//         // @ts-expect-error time parameter cannot be undefined
+//         job.setTime(undefined)
+//       }).toThrow()
+//     })
+//
+//     it('should start, change time, exception', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob('* * * * * *', callback)
+//
+//       const time = new Date()
+//       job.start()
+//
+//       clock.tick(1000)
+//
+//       expect(() => {
+//         // @ts-expect-error time parameter but be an instance of CronTime
+//         job.setTime(time)
+//       }).toThrow()
+//
+//       clock.restore()
+//       job.stop()
+//       expect(callback).toHaveBeenCalledTimes(1)
+//     })
+//
+//     it('should create recurring job, setTime with actual date, start and run once (#739)', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//
+//       const job = new CronJob('0 0 20 * * *', callback)
+//
+//       const startDate = new Date(Date.now() + 5000)
+//       job.setTime(new CronTime(startDate))
+//
+//       job.start()
+//
+//       clock.tick(5000)
+//
+//       expect(callback).toHaveBeenCalledTimes(1)
+//
+//       clock.tick(60000)
+//
+//       clock.restore()
+//
+//       expect(callback).toHaveBeenCalledTimes(1)
+//       expect(job.running).toBe(false)
+//     })
+//   })
+//
+//   describe('nextDate(s)', () => {
+//     it('should give the next date to run at', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//       const job = new CronJob('* * * * * *', callback)
+//       const d = Date.now()
+//
+//       expect(job.nextDate().toMillis()).toEqual(d + 1000)
+//
+//       clock.restore()
+//     })
+//
+//     it('should give the next 5 dates to run at', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//       const job = new CronJob('* * * * * *', callback)
+//       const d = Date.now()
+//
+//       expect(job.nextDates(5).map(d => d.toMillis())).toEqual([
+//         d + 1000,
+//         d + 2000,
+//         d + 3000,
+//         d + 4000,
+//         d + 5000,
+//       ])
+//
+//       clock.restore()
+//     })
+//
+//     it('should give an empty array when called without argument', () => {
+//       const callback = jest.fn()
+//       const clock = sinon.useFakeTimers()
+//       const job = new CronJob('* * * * * *', callback)
+//
+//       expect(job.nextDates()).toHaveLength(0)
+//
+//       clock.restore()
+//     })
+//   })
+//
+//   it('should automatically setup a new timeout if we roll past the max timeout delay', () => {
+//     const callback = jest.fn()
+//     const clock = sinon.useFakeTimers()
+//     const d = new Date()
+//     d.setMilliseconds(2147485647 * 2) // MAXDELAY in `job.js` + 2000.
+//     const job = new CronJob(d, callback)
+//     job.start()
+//     clock.tick(2147483648)
+//     expect(callback).toHaveBeenCalledTimes(0)
+//     clock.tick(2147489648)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     job.stop()
+//     clock.restore()
+//   })
+//
+//   it('should give the correct last execution date', () => {
+//     const callback = jest.fn()
+//     const clock = sinon.useFakeTimers()
+//     const job = new CronJob('* * * * * *', callback)
+//     job.start()
+//     clock.tick(1000)
+//     expect(callback).toHaveBeenCalledTimes(1)
+//     expect(job.lastDate()?.getTime()).toBe(1000)
+//     job.stop()
+//     clock.restore()
+//   })
+//
+//   it('should give the correct last execution date for intervals greater than 25 days (#710)', () => {
+//     const callback = jest.fn()
+//     const clock = sinon.useFakeTimers()
+//
+//     const job = new CronJob('0 0 0 1 * *', callback) // At 00:00 on day-of-month 1.
+//     job.start()
+//
+//     // tick one tick before nextDate()
+//     clock.tick(job.nextDate().toMillis() - 1)
+//
+//     expect(callback).toHaveBeenCalledTimes(0)
+//     expect(job.lastDate()?.getTime()).toBeUndefined()
+//
+//     job.stop()
+//     clock.restore()
+//   })
+//
+//   it('should throw when providing both exclusive parameters timeZone and utcOffset', () => {
+//     expect(() => {
+//       // @ts-expect-error testing runtime exception
+//       new CronJob(
+//         `* * * * *`,
+//         () => { },
+//         null,
+//         true,
+//         'America/Chicago',
+//         null,
+//         null,
+//         120,
+//       )
+//     }).toThrow()
+//   })
+//
+//   it('should throw when providing both exclusive parameters timeZone and utcOffset using the object constructor', () => {
+//     expect(() => {
+//       // @ts-expect-error testing runtime exception
+//       CronJob.from({
+//         cronTime: '* * * * * *',
+//         onTick() { },
+//         timeZone: 'America/Chicago',
+//         utcOffset: 120,
+//       })
+//     }).toThrow()
+//   })
+//
+//   it('should support async callback', () => {
+//     const clock = sinon.useFakeTimers()
+//     const callback = jest.fn()
+//     const job = new CronJob(
+//       '* * * * * *',
+//       async () => {
+//         await new Promise<void>((resolve) => {
+//           setTimeout(() => {
+//             callback()
+//             resolve()
+//           }, 500)
+//         })
+//       },
+//       null,
+//       true,
+//     )
+//     clock.tick(1500)
+//     job.stop()
+//     clock.restore()
+//     expect(callback).toHaveBeenCalledTimes(1)
+//   })
+// })