528 lines
19 KiB
Python
Executable File
528 lines
19 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import unittest
|
|
from datetime import datetime
|
|
from time import sleep
|
|
import pytz
|
|
from croniter import croniter
|
|
|
|
from croniter.tests import base
|
|
|
|
|
|
class CroniterTest(base.TestCase):
|
|
|
|
def testSecond(self):
|
|
base = datetime(2012, 4, 6, 13, 26, 10)
|
|
itr = croniter('*/1 * * * * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(base.year, n1.year)
|
|
self.assertEqual(base.month, n1.month)
|
|
self.assertEqual(base.day, n1.day)
|
|
self.assertEqual(base.hour, n1.hour)
|
|
self.assertEqual(base.minute, n1.minute)
|
|
self.assertEqual(base.second + 1, n1.second)
|
|
|
|
def testSecondRepeat(self):
|
|
base = datetime(2012, 4, 6, 13, 26, 36)
|
|
itr = croniter('* * * * * */15', base)
|
|
n1 = itr.get_next(datetime)
|
|
n2 = itr.get_next(datetime)
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(base.year, n1.year)
|
|
self.assertEqual(base.month, n1.month)
|
|
self.assertEqual(base.day, n1.day)
|
|
self.assertEqual(base.hour, n1.hour)
|
|
self.assertEqual(base.minute, n1.minute)
|
|
self.assertEqual(45, n1.second)
|
|
self.assertEqual(base.year, n2.year)
|
|
self.assertEqual(base.month, n2.month)
|
|
self.assertEqual(base.day, n2.day)
|
|
self.assertEqual(base.hour, n2.hour)
|
|
self.assertEqual(base.minute + 1, n2.minute)
|
|
self.assertEqual(0, n2.second)
|
|
self.assertEqual(base.year, n3.year)
|
|
self.assertEqual(base.month, n3.month)
|
|
self.assertEqual(base.day, n3.day)
|
|
self.assertEqual(base.hour, n3.hour)
|
|
self.assertEqual(base.minute + 1, n3.minute)
|
|
self.assertEqual(15, n3.second)
|
|
|
|
def testMinute(self):
|
|
# minute asterisk
|
|
base = datetime(2010, 1, 23, 12, 18)
|
|
itr = croniter('*/1 * * * *', base)
|
|
n1 = itr.get_next(datetime) # 19
|
|
self.assertEqual(base.year, n1.year)
|
|
self.assertEqual(base.month, n1.month)
|
|
self.assertEqual(base.day, n1.day)
|
|
self.assertEqual(base.hour, n1.hour)
|
|
self.assertEqual(base.minute, n1.minute - 1)
|
|
for i in range(39): # ~ 58
|
|
itr.get_next()
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.minute, 59)
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(n3.minute, 0)
|
|
self.assertEqual(n3.hour, 13)
|
|
|
|
itr = croniter('*/5 * * * *', base)
|
|
n4 = itr.get_next(datetime)
|
|
self.assertEqual(n4.minute, 20)
|
|
for i in range(6):
|
|
itr.get_next()
|
|
n5 = itr.get_next(datetime)
|
|
self.assertEqual(n5.minute, 55)
|
|
n6 = itr.get_next(datetime)
|
|
self.assertEqual(n6.minute, 0)
|
|
self.assertEqual(n6.hour, 13)
|
|
|
|
def testHour(self):
|
|
base = datetime(2010, 1, 24, 12, 2)
|
|
itr = croniter('0 */3 * * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.hour, 15)
|
|
self.assertEqual(n1.minute, 0)
|
|
for i in range(2):
|
|
itr.get_next()
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.hour, 0)
|
|
self.assertEqual(n2.day, 25)
|
|
|
|
def testDay(self):
|
|
base = datetime(2010, 2, 24, 12, 9)
|
|
itr = croniter('0 0 */3 * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
# 1 4 7 10 13 16 19 22 25 28
|
|
self.assertEqual(n1.day, 25)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.day, 28)
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(n3.day, 1)
|
|
self.assertEqual(n3.month, 3)
|
|
|
|
# test leap year
|
|
base = datetime(1996, 2, 27)
|
|
itr = croniter('0 0 * * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.day, 28)
|
|
self.assertEqual(n1.month, 2)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.day, 29)
|
|
self.assertEqual(n2.month, 2)
|
|
|
|
base2 = datetime(2000, 2, 27)
|
|
itr2 = croniter('0 0 * * *', base2)
|
|
n3 = itr2.get_next(datetime)
|
|
self.assertEqual(n3.day, 28)
|
|
self.assertEqual(n3.month, 2)
|
|
n4 = itr2.get_next(datetime)
|
|
self.assertEqual(n4.day, 29)
|
|
self.assertEqual(n4.month, 2)
|
|
|
|
def testWeekDay(self):
|
|
base = datetime(2010, 2, 25)
|
|
itr = croniter('0 0 * * sat', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.isoweekday(), 6)
|
|
self.assertEqual(n1.day, 27)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.isoweekday(), 6)
|
|
self.assertEqual(n2.day, 6)
|
|
self.assertEqual(n2.month, 3)
|
|
|
|
base = datetime(2010, 1, 25)
|
|
itr = croniter('0 0 1 * wed', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.month, 1)
|
|
self.assertEqual(n1.day, 27)
|
|
self.assertEqual(n1.year, 2010)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.month, 2)
|
|
self.assertEqual(n2.day, 1)
|
|
self.assertEqual(n2.year, 2010)
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(n3.month, 2)
|
|
self.assertEqual(n3.day, 3)
|
|
self.assertEqual(n3.year, 2010)
|
|
|
|
def testMonth(self):
|
|
base = datetime(2010, 1, 25)
|
|
itr = croniter('0 0 1 * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.month, 2)
|
|
self.assertEqual(n1.day, 1)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.month, 3)
|
|
self.assertEqual(n2.day, 1)
|
|
for i in range(8):
|
|
itr.get_next()
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(n3.month, 12)
|
|
self.assertEqual(n3.year, 2010)
|
|
n4 = itr.get_next(datetime)
|
|
self.assertEqual(n4.month, 1)
|
|
self.assertEqual(n4.year, 2011)
|
|
|
|
def testLastDayOfMonth(self):
|
|
base = datetime(2015, 9, 4)
|
|
itr = croniter('0 0 l * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.month, 9)
|
|
self.assertEqual(n1.day, 30)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.month, 10)
|
|
self.assertEqual(n2.day, 31)
|
|
n3 = itr.get_next(datetime)
|
|
self.assertEqual(n3.month, 11)
|
|
self.assertEqual(n3.day, 30)
|
|
n4 = itr.get_next(datetime)
|
|
self.assertEqual(n4.month, 12)
|
|
self.assertEqual(n4.day, 31)
|
|
|
|
def testPrevLastDayOfMonth(self):
|
|
base = datetime(2009, 12, 31, hour=20)
|
|
itr = croniter('0 0 l * *', base)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 12)
|
|
self.assertEqual(n1.day, 31)
|
|
|
|
base = datetime(2009, 12, 31)
|
|
itr = croniter('0 0 l * *', base)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 11)
|
|
self.assertEqual(n1.day, 30)
|
|
|
|
base = datetime(2010, 1, 5)
|
|
itr = croniter('0 0 l * *', base)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 12)
|
|
self.assertEqual(n1.day, 31)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 11)
|
|
self.assertEqual(n1.day, 30)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 10)
|
|
self.assertEqual(n1.day, 31)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 9)
|
|
self.assertEqual(n1.day, 30)
|
|
|
|
base = datetime(2010, 1, 31, minute=2)
|
|
itr = croniter('* * l * *', base)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 1)
|
|
self.assertEqual(n1.day, 31)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 1)
|
|
self.assertEqual(n1.day, 31)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 12)
|
|
self.assertEqual(n1.day, 31)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.month, 12)
|
|
self.assertEqual(n1.day, 31)
|
|
|
|
def testError(self):
|
|
itr = croniter('* * * * *')
|
|
self.assertRaises(TypeError, itr.get_next, str)
|
|
self.assertRaises(ValueError, croniter, '* * * *')
|
|
self.assertRaises(ValueError, croniter, '* * 5-1 * *')
|
|
self.assertRaises(ValueError, croniter, '-90 * * * *')
|
|
self.assertRaises(ValueError, croniter, 'a * * * *')
|
|
self.assertRaises(ValueError, croniter, '* * * janu-jun *')
|
|
|
|
def testSundayToThursdayWithAlphaConversion(self):
|
|
base = datetime(2010, 8, 25, 15, 56) #wednesday
|
|
itr = croniter("30 22 * * sun-thu", base)
|
|
next = itr.get_next(datetime)
|
|
|
|
self.assertEqual(base.year, next.year)
|
|
self.assertEqual(base.month, next.month)
|
|
self.assertEqual(base.day, next.day)
|
|
self.assertEqual(22, next.hour)
|
|
self.assertEqual(30, next.minute)
|
|
|
|
def testPrevMinute(self):
|
|
base = datetime(2010, 8, 25, 15, 56)
|
|
itr = croniter('*/1 * * * *', base)
|
|
prev = itr.get_prev(datetime)
|
|
self.assertEqual(base.year, prev.year)
|
|
self.assertEqual(base.month, prev.month)
|
|
self.assertEqual(base.day, prev.day)
|
|
self.assertEqual(base.hour, prev.hour)
|
|
self.assertEqual(base.minute, prev.minute + 1)
|
|
|
|
base = datetime(2010, 8, 25, 15, 0)
|
|
itr = croniter('*/1 * * * *', base)
|
|
prev = itr.get_prev(datetime)
|
|
self.assertEqual(base.year, prev.year)
|
|
self.assertEqual(base.month, prev.month)
|
|
self.assertEqual(base.day, prev.day)
|
|
self.assertEqual(base.hour, prev.hour + 1)
|
|
self.assertEqual(59, prev.minute)
|
|
|
|
base = datetime(2010, 8, 25, 0, 0)
|
|
itr = croniter('*/1 * * * *', base)
|
|
prev = itr.get_prev(datetime)
|
|
self.assertEqual(base.year, prev.year)
|
|
self.assertEqual(base.month, prev.month)
|
|
self.assertEqual(base.day, prev.day + 1)
|
|
self.assertEqual(23, prev.hour)
|
|
self.assertEqual(59, prev.minute)
|
|
|
|
def testPrevDayOfMonthWithCrossing(self):
|
|
"""
|
|
Test getting previous occurrence that crosses into previous month.
|
|
"""
|
|
base = datetime(2012, 3, 15, 0, 0)
|
|
itr = croniter('0 0 22 * *', base)
|
|
prev = itr.get_prev(datetime)
|
|
self.assertEqual(prev.year, 2012)
|
|
self.assertEqual(prev.month, 2)
|
|
self.assertEqual(prev.day, 22)
|
|
self.assertEqual(prev.hour, 0)
|
|
self.assertEqual(prev.minute, 0)
|
|
|
|
def testPrevWeekDay(self):
|
|
base = datetime(2010, 8, 25, 15, 56)
|
|
itr = croniter('0 0 * * sat,sun', base)
|
|
prev1 = itr.get_prev(datetime)
|
|
self.assertEqual(prev1.year, base.year)
|
|
self.assertEqual(prev1.month, base.month)
|
|
self.assertEqual(prev1.day, 22)
|
|
self.assertEqual(prev1.hour, 0)
|
|
self.assertEqual(prev1.minute, 0)
|
|
|
|
prev2 = itr.get_prev(datetime)
|
|
self.assertEqual(prev2.year, base.year)
|
|
self.assertEqual(prev2.month, base.month)
|
|
self.assertEqual(prev2.day, 21)
|
|
self.assertEqual(prev2.hour, 0)
|
|
self.assertEqual(prev2.minute, 0)
|
|
|
|
prev3 = itr.get_prev(datetime)
|
|
self.assertEqual(prev3.year, base.year)
|
|
self.assertEqual(prev3.month, base.month)
|
|
self.assertEqual(prev3.day, 15)
|
|
self.assertEqual(prev3.hour, 0)
|
|
self.assertEqual(prev3.minute, 0)
|
|
|
|
def testPrevWeekDay2(self):
|
|
base = datetime(2010, 8, 25, 15, 56)
|
|
itr = croniter('10 0 * * 0', base)
|
|
prev = itr.get_prev(datetime)
|
|
self.assertEqual(prev.day, 22)
|
|
self.assertEqual(prev.hour, 0)
|
|
self.assertEqual(prev.minute, 10)
|
|
|
|
def testISOWeekday(self):
|
|
base = datetime(2010, 2, 25)
|
|
itr = croniter('0 0 * * 7', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.isoweekday(), 7)
|
|
self.assertEqual(n1.day, 28)
|
|
n2 = itr.get_next(datetime)
|
|
self.assertEqual(n2.isoweekday(), 7)
|
|
self.assertEqual(n2.day, 7)
|
|
self.assertEqual(n2.month, 3)
|
|
|
|
def testBug1(self):
|
|
base = datetime(2012, 2, 24)
|
|
itr = croniter('5 0 */2 * *', base)
|
|
n1 = itr.get_prev(datetime)
|
|
self.assertEqual(n1.hour, 0)
|
|
self.assertEqual(n1.minute, 5)
|
|
self.assertEqual(n1.month, 2)
|
|
# month starts from 1, 3 .... then 21, 23
|
|
# so correct is not 22 but 23
|
|
self.assertEqual(n1.day, 23)
|
|
|
|
def testBug2(self):
|
|
base = datetime(2012, 1, 1, 0, 0)
|
|
iter = croniter('0 * * 3 *', base)
|
|
n1 = iter.get_next(datetime)
|
|
self.assertEqual(n1.year, base.year)
|
|
self.assertEqual(n1.month, 3)
|
|
self.assertEqual(n1.day, base.day)
|
|
self.assertEqual(n1.hour, base.hour)
|
|
self.assertEqual(n1.minute, base.minute)
|
|
|
|
n2 = iter.get_next(datetime)
|
|
self.assertEqual(n2.year, base.year)
|
|
self.assertEqual(n2.month, 3)
|
|
self.assertEqual(n2.day, base.day)
|
|
self.assertEqual(n2.hour, base.hour + 1)
|
|
self.assertEqual(n2.minute, base.minute)
|
|
|
|
n3 = iter.get_next(datetime)
|
|
self.assertEqual(n3.year, base.year)
|
|
self.assertEqual(n3.month, 3)
|
|
self.assertEqual(n3.day, base.day)
|
|
self.assertEqual(n3.hour, base.hour + 2)
|
|
self.assertEqual(n3.minute, base.minute)
|
|
|
|
def testBug3(self):
|
|
base = datetime(2013, 3, 1, 12, 17, 34, 257877)
|
|
c = croniter('00 03 16,30 * *', base)
|
|
|
|
n1 = c.get_next(datetime)
|
|
self.assertEqual(n1.month, 3)
|
|
self.assertEqual(n1.day, 16)
|
|
|
|
n2 = c.get_next(datetime)
|
|
self.assertEqual(n2.month, 3)
|
|
self.assertEqual(n2.day, 30)
|
|
|
|
n3 = c.get_next(datetime)
|
|
self.assertEqual(n3.month, 4)
|
|
self.assertEqual(n3.day, 16)
|
|
|
|
n4 = c.get_prev(datetime)
|
|
self.assertEqual(n4.month, 3)
|
|
self.assertEqual(n4.day, 30)
|
|
|
|
n5 = c.get_prev(datetime)
|
|
self.assertEqual(n5.month, 3)
|
|
self.assertEqual(n5.day, 16)
|
|
|
|
n6 = c.get_prev(datetime)
|
|
self.assertEqual(n6.month, 2)
|
|
self.assertEqual(n6.day, 16)
|
|
|
|
def test_bug34(self):
|
|
base = datetime(2012, 2, 24, 0, 0, 0)
|
|
itr = croniter('* * 31 2 *', base)
|
|
n1 = itr.get_next(datetime)
|
|
|
|
def test_rangeGenerator(self):
|
|
base = datetime(2013, 3, 4, 0, 0)
|
|
itr = croniter('1-9/2 0 1 * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
n2 = itr.get_next(datetime)
|
|
n3 = itr.get_next(datetime)
|
|
n4 = itr.get_next(datetime)
|
|
n5 = itr.get_next(datetime)
|
|
self.assertEqual(n1.minute, 1)
|
|
self.assertEqual(n2.minute, 3)
|
|
self.assertEqual(n3.minute, 5)
|
|
self.assertEqual(n4.minute, 7)
|
|
self.assertEqual(n5.minute, 9)
|
|
|
|
def testPreviousHour(self):
|
|
base = datetime(2012, 6, 23, 17, 41)
|
|
itr = croniter('* 10 * * *', base)
|
|
prev1 = itr.get_prev(datetime)
|
|
self.assertEqual(prev1.year, base.year)
|
|
self.assertEqual(prev1.month, base.month)
|
|
self.assertEqual(prev1.day, base.day)
|
|
self.assertEqual(prev1.hour, 10)
|
|
self.assertEqual(prev1.minute, 59)
|
|
|
|
def testPreviousDay(self):
|
|
base = datetime(2012, 6, 27, 0, 15)
|
|
itr = croniter('* * 26 * *', base)
|
|
prev1 = itr.get_prev(datetime)
|
|
self.assertEqual(prev1.year, base.year)
|
|
self.assertEqual(prev1.month, base.month)
|
|
self.assertEqual(prev1.day, 26)
|
|
self.assertEqual(prev1.hour, 23)
|
|
self.assertEqual(prev1.minute, 59)
|
|
|
|
def testPreviousMonth(self):
|
|
base = datetime(2012, 6, 18, 0, 15)
|
|
itr = croniter('* * * 5 *', base)
|
|
prev1 = itr.get_prev(datetime)
|
|
self.assertEqual(prev1.year, base.year)
|
|
self.assertEqual(prev1.month, 5)
|
|
self.assertEqual(prev1.day, 31)
|
|
self.assertEqual(prev1.hour, 23)
|
|
self.assertEqual(prev1.minute, 59)
|
|
|
|
def testPreviousDow(self):
|
|
base = datetime(2012, 5, 13, 18, 48)
|
|
itr = croniter('* * * * sat', base)
|
|
prev1 = itr.get_prev(datetime)
|
|
self.assertEqual(prev1.year, base.year)
|
|
self.assertEqual(prev1.month, base.month)
|
|
self.assertEqual(prev1.day, 12)
|
|
self.assertEqual(prev1.hour, 23)
|
|
self.assertEqual(prev1.minute, 59)
|
|
|
|
def testGetCurrent(self):
|
|
base = datetime(2012, 9, 25, 11, 24)
|
|
itr = croniter('* * * * *', base)
|
|
res = itr.get_current(datetime)
|
|
self.assertEqual(base.year, res.year)
|
|
self.assertEqual(base.month, res.month)
|
|
self.assertEqual(base.day, res.day)
|
|
self.assertEqual(base.hour, res.hour)
|
|
self.assertEqual(base.minute, res.minute)
|
|
|
|
def testTimezone(self):
|
|
base = datetime(2013, 3, 4, 12, 15)
|
|
itr = croniter('* * * * *', base)
|
|
n1 = itr.get_next(datetime)
|
|
self.assertEqual(n1.tzinfo, None)
|
|
|
|
tokyo = pytz.timezone('Asia/Tokyo')
|
|
itr2 = croniter('* * * * *', tokyo.localize(base))
|
|
n2 = itr2.get_next(datetime)
|
|
self.assertEqual(n2.tzinfo.zone, 'Asia/Tokyo')
|
|
|
|
def testInitNoStartTime(self):
|
|
itr = croniter('* * * * *')
|
|
sleep(.01)
|
|
itr2 = croniter('* * * * *')
|
|
self.assertGreater(itr2.cur, itr.cur)
|
|
|
|
def assertScheduleTimezone(self, callback, expected_schedule):
|
|
for expected_date, expected_offset in expected_schedule:
|
|
d = callback()
|
|
self.assertEqual(expected_date, d.replace(tzinfo=None))
|
|
self.assertEqual(expected_offset, croniter._timedelta_to_seconds(d.utcoffset()))
|
|
|
|
def testTimezoneWinterTime(self):
|
|
tz = pytz.timezone('Europe/Athens')
|
|
|
|
expected_schedule = [
|
|
(datetime(2013, 10, 27, 2, 30, 0), 10800),
|
|
(datetime(2013, 10, 27, 3, 0, 0), 10800),
|
|
(datetime(2013, 10, 27, 3, 30, 0), 10800),
|
|
(datetime(2013, 10, 27, 3, 0, 0), 7200),
|
|
(datetime(2013, 10, 27, 3, 30, 0), 7200),
|
|
(datetime(2013, 10, 27, 4, 0, 0), 7200),
|
|
(datetime(2013, 10, 27, 4, 30, 0), 7200),
|
|
]
|
|
|
|
start = datetime(2013, 10, 27, 2, 0, 0)
|
|
ct = croniter('*/30 * * * *', tz.localize(start))
|
|
self.assertScheduleTimezone(lambda: ct.get_next(datetime), expected_schedule)
|
|
|
|
start = datetime(2013, 10, 27, 5, 0, 0)
|
|
ct = croniter('*/30 * * * *', tz.localize(start))
|
|
self.assertScheduleTimezone(lambda: ct.get_prev(datetime), reversed(expected_schedule))
|
|
|
|
def testTimezoneSummerTime(self):
|
|
tz = pytz.timezone('Europe/Athens')
|
|
|
|
expected_schedule = [
|
|
(datetime(2013, 3, 31, 1, 30, 0), 7200),
|
|
(datetime(2013, 3, 31, 2, 0, 0), 7200),
|
|
(datetime(2013, 3, 31, 2, 30, 0), 7200),
|
|
(datetime(2013, 3, 31, 4, 0, 0), 10800),
|
|
(datetime(2013, 3, 31, 4, 30, 0), 10800),
|
|
]
|
|
|
|
start = datetime(2013, 3, 31, 1, 0, 0)
|
|
ct = croniter('*/30 * * * *', tz.localize(start))
|
|
self.assertScheduleTimezone(lambda: ct.get_next(datetime), expected_schedule)
|
|
|
|
start = datetime(2013, 3, 31, 5, 0, 0)
|
|
ct = croniter('*/30 * * * *', tz.localize(start))
|
|
self.assertScheduleTimezone(lambda: ct.get_prev(datetime), reversed(expected_schedule))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|