def testGetPointsRecurUntil(self):
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
event = eventcalendar.Event(
'uid',
start,
end,
'content',
rrules=[
"FREQ=DAILY;UNTIL=20071224T073000Z;WKST=MO",
])
set = eventcalendar.EventSet('uid')
set.addEvent(event)
p = set.getPoints(start, end - start)
self.assertEquals(p[0].dt, start)
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].which, 'end')
p = set.getPoints(start, end - start + timedelta(days=4))
self.assertEquals(len(p), 4)
self.assertEquals(p[0].dt, start)
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[3].dt, end + timedelta(days=1))
self.assertEquals(p[3].which, 'end')
p = set.getPoints(start + timedelta(hours=1),
end - start + timedelta(hours=22))
self.assertEquals(len(p), 4)
self.assertEquals(p[0].dt, start + timedelta(hours=1))
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].dt, start + timedelta(hours=2))
self.assertEquals(p[1].which, 'end')
self.assertEquals(p[3].dt,
end + timedelta(days=1) - timedelta(hours=1))
self.assertEquals(p[3].which, 'end')
p = set.getPoints(start + timedelta(days=3), end - start)
self.assertEquals(len(p), 0)
def testRecurrenceOverMidnight(self):
"""
Test weekly recurrence rules that starts on one day and spawns to
the day after, even though they were not planned for the next day.
"""
def yesterdayDayOfTheWeek(now):
yesterday = now - timedelta(days=1)
day = calendar.weekday(yesterday.year, yesterday.month,
yesterday.day)
return _dayOfTheWeek[day]
now = datetime.now().replace(microsecond=0)
start = now - timedelta(days=1) - timedelta(weeks=1)
end = now + timedelta(hours=1) - timedelta(weeks=1)
rrules = [
"FREQ=WEEKLY;BYDAY=" + yesterdayDayOfTheWeek(now) + ";WKST=MO",
]
uid = 'uid'
content = 'content'
event = eventcalendar.Event(uid, start, end, content, rrules=rrules)
eventSet = eventcalendar.EventSet(uid)
eventSet.addEvent(event)
p = eventSet.getPoints(event.start + timedelta(weeks=1),
event.end - event.start)
self.assertEquals(p[0].dt, event.start + timedelta(weeks=1))
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].dt, event.end + timedelta(weeks=1))
self.assertEquals(p[1].which, 'end')
def testExWithRecurrence(self):
"""
Exception to a recurrence rule.
"""
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
uid = 'uid'
content = 'content'
rrules = [
"FREQ=DAILY;WKST=MO",
]
exdate = datetime(2007, 12, 23, 9, 0, 0, 0, LOCAL)
exdates = [exdate]
event = eventcalendar.Event(uid,
start,
end,
content,
rrules=rrules,
exdates=exdates)
set = eventcalendar.EventSet(uid)
set.addEvent(event)
p = set.getPoints(start, end - start)
self.assertEquals(p[0].dt, start)
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].which, 'end')
p = set.getPoints(exdate, timedelta(days=1))
self.failIf(p)
def testSimple(self):
"""
Test that the object contains the data. Very simple test.
"""
now = _now()
start = now - timedelta(hours=1)
end = now + timedelta(minutes=1)
rrules = [
"FREQ=HOURLY;INTERVAL=2;COUNT=5",
]
exdates = [now + timedelta(hours=2)]
uid = 'uid'
e = eventcalendar.Event(uid,
start,
end,
'foo',
rrules=rrules,
exdates=exdates)
self.assertEquals(e.start, start)
self.assertEquals(e.end, end)
self.assertEquals(e.content, 'foo')
self.assertEquals(e.rrules, [
"FREQ=HOURLY;INTERVAL=2;COUNT=5",
])
self.assertEquals(e.exdates, exdates)
def testScheduledNotACallbackWhenCancelled(self):
now = _now()
start = now
end = now + timedelta(hours=1)
calendar = eventcalendar.Calendar()
calendar.addEvent(eventcalendar.Event('uid', start, end, 'content'))
self._scheduler.setCalendar(calendar)
def testScheduledEndCallbackWhenEndInWindowSize(self):
now = _now()
start = now - timedelta(hours=1)
end = now + timedelta(hours=1)
calendar = eventcalendar.Calendar()
calendar.addEvent(eventcalendar.Event('uid', start, end, 'content'))
self._scheduler.setCalendar(calendar)
resultSeconds = self._scheduler._nextStart
expectedSeconds = _toSeconds(end - now)
self.assertEquals(round(resultSeconds / 10.0),
round(expectedSeconds / 10.0))
def testDefaultScheduledCallbackWhenBeforeAndAfterTheWindowSize(self):
now = _now()
start = now - timedelta(days=1)
end = now + timedelta(days=2)
calendar = eventcalendar.Calendar()
calendar.addEvent(eventcalendar.Event('uid', start, end, 'content'))
self._scheduler.setCalendar(calendar)
resultSeconds = self._scheduler._nextStart
expectedSeconds = _toSeconds(self._scheduler.windowSize) / 2
self.assertEquals(round(resultSeconds / 10.0),
round(expectedSeconds / 10.0))
def testGetPoints(self):
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
eventSet1 = eventcalendar.EventSet('uid1')
eventSet2 = eventcalendar.EventSet('uid2')
event1 = eventcalendar.Event('uid1', start, end, 'content')
eventSet1.addEvent(event1)
event2 = eventcalendar.Event('uid2', start, end, 'content')
eventSet2.addEvent(event2)
rid = self._events[0].get('RECURRENCE-ID')
self.failUnless(rid)
riddatetime = parser.parse(str(rid))
self.failUnless(str(rid).endswith('Z'))
start = self._events[1].decoded('dtstart')
self.failUnless(start)
if start.tzinfo is None:
tzinfo = tz.gettz(self._events[1]['dtstart'].params['TZID'])
start = datetime(start.year, start.month, start.day, start.hour,
start.minute, start.second, start.microsecond,
tzinfo)
rrulestr = str(self._events[1].get('RRULE'))
self.failUnless(rrulestr)
r = rrule.rrulestr(rrulestr, dtstart=start)
self.failUnless(riddatetime in r)
def testGetPointSingle(self):
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
uid = 'uid'
content = 'content'
event = eventcalendar.Event(uid, start, end, content)
set = eventcalendar.EventSet(uid)
set.addEvent(event)
p = set.getPoints(start, end - start)
self.assertEquals(p[0].dt, start)
self.assertEquals(p[1].dt, end)
p = set.getPoints(start - timedelta(hours=1), timedelta(hours=3))
self.assertEquals(p[0].dt, start)
self.assertEquals(p[1].dt, end)
p = set.getPoints(start + timedelta(minutes=30), timedelta(minutes=60))
self.assertEquals(p[0].dt, start + timedelta(minutes=30))
self.assertEquals(p[1].dt, end - timedelta(minutes=30))
def testTimeZones(self):
"""
Test that when no timezone given to the init parameters,
the LOCAL timezone is added to them.
"""
now = datetime.now()
hour = timedelta(hours=1)
self.assertEquals(now.tzinfo, None)
start = now
end = now + hour
exdates = [start]
event = eventcalendar.Event('uid', start, end, 'foo', exdates=exdates)
self.assertEquals(event.start.tzinfo, UTC)
self.assertEquals(event.start, start.replace(tzinfo=UTC))
self.assertEquals(event.end.tzinfo, UTC)
self.assertEquals(event.end, end.replace(tzinfo=UTC))
self.assertEquals(event.exdates[0].tzinfo, UTC)
self.assertEquals(event.exdates[0], exdates[0].replace(tzinfo=UTC))
def testComparison(self):
"""
Test the operators: < > ==
"""
now = _now()
hour = timedelta(hours=1)
self.failUnless(
eventcalendar.Event('uid', now, now + hour, 'foo') <
eventcalendar.Event('uid', now + hour, now + 2 * hour, 'foo'))
self.failUnless(
eventcalendar.Event('uid', now, now + hour, 'foo') ==
eventcalendar.Event('uid', now, now + hour, 'foo'))
self.failUnless(
eventcalendar.Event('uid', now + hour, now + 2 * hour, 'foo') >
eventcalendar.Event('uid', now, now + hour, 'foo'))
def testUnsubscribe(self):
# create a list to store subscription call results
calls = []
started = lambda c: calls.append(('started', c.content))
ended = lambda c: calls.append(('ended', c.content))
sid = self._scheduler.subscribe(started, ended)
self._scheduler.unsubscribe(sid)
now = _now()
start = now - timedelta(hours=1)
end = now + timedelta(minutes=1)
calendar = eventcalendar.Calendar()
self.assertEquals(calls, [])
calendar.addEvent(eventcalendar.Event('uid', start, end, 'content'))
self._scheduler.setCalendar(calendar)
self.assertEquals(calls, [])
eis = self._scheduler.getCalendar().getActiveEventInstances()
self.failUnless(eis)
self.assertEquals(eis[0].event.content, 'content')
def testGetPointsRecur(self):
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
uid = 'uid'
content = 'content'
rrules = [
"FREQ=DAILY;WKST=MO",
]
event = eventcalendar.Event(uid, start, end, content, rrules=rrules)
set = eventcalendar.EventSet(uid)
set.addEvent(event)
p = set.getPoints(start, end - start)
self.assertEquals(p[0].dt, start)
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].which, 'end')
p = set.getPoints(start + timedelta(days=2), end - start)
self.assertEquals(p[0].dt, start + timedelta(days=2))
self.assertEquals(p[0].which, 'start')
self.assertEquals(p[1].which, 'end')
p = set.getPoints(end, timedelta(days=1))
self.assertEquals(len(p), 2)
self.assertNotEquals(p[0].dt, end)
def testExAsStartDateWithRecurrence(self):
"""
Exception to a recurrence rule.
"""
start = datetime(2007, 12, 22, 9, 0, 0, 0, LOCAL)
end = datetime(2007, 12, 22, 11, 0, 0, 0, LOCAL)
uid = 'uid'
content = 'content'
rrules = [
"FREQ=DAILY;WKST=MO",
]
exdate = start
exdates = [exdate]
event = eventcalendar.Event(uid,
start,
end,
content,
rrules=rrules,
exdates=exdates)
set = eventcalendar.EventSet(uid)
set.addEvent(event)
p = set.getPoints(start, end - start)
self.failIf(p)
def testSubscribe(self):
# create a list to store subscription call results
calls = []
started = lambda ei: calls.append(('started', ei.event.content))
ended = lambda ei: calls.append(('ended', ei.event.content))
sid = self._scheduler.subscribe(started, ended)
self.assertEquals(calls, [])
# create a calendar and put a currently active event on it
calendar = eventcalendar.Calendar()
now = _now()
start = now - timedelta(hours=1)
end = now + timedelta(minutes=1)
calendar.addEvent(eventcalendar.Event('uid', start, end, 'foo'))
self._scheduler.setCalendar(calendar)
# verify that we gat a start call for the active event instance
self.assertEquals(calls, [('started', 'foo')])
eis = self._scheduler.getCalendar().getActiveEventInstances()
self.assertEventAttribsEqual(eis[0].event, start, end, 'foo',
None, None)
# now set a new empty calendar on the scheduler
calendar = eventcalendar.Calendar()
self._scheduler.setCalendar(calendar)
# make sure we got an end call for the previously active event instance
self.assertEquals(calls, [('started', 'foo'),
('ended', 'foo')])
eis = self._scheduler.getCalendar().getActiveEventInstances()
self.failIf(eis,
'Empty calendar so should not have active event instances')
self._scheduler.unsubscribe(sid)
