def test_init(self):
event = Event('Breakfast',
event_id='123',
start=(1 / Feb / 2019)[9:00],
end=(31 / Dec / 2019)[23:59],
timezone=TEST_TIMEZONE,
description='Everyday breakfast',
location='Home',
recurrence=[
Recurrence.rule(freq=DAILY),
Recurrence.exclude_rule(by_week_day=[SU, SA]),
Recurrence.exclude_dates([
19 / Apr / 2019, 22 / Apr / 2019, 12 / May / 2019
])
],
visibility=Visibility.PRIVATE,
minutes_before_popup_reminder=15)
self.assertEqual(event.summary, 'Breakfast')
self.assertEqual(event.id, '123')
self.assertEqual(
event.start,
insure_localisation((1 / Feb / 2019)[9:00], TEST_TIMEZONE))
self.assertEqual(event.description, 'Everyday breakfast')
self.assertEqual(event.location, 'Home')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PRIVATE)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 15)
def test_to_json_updated(self):
e = Event('Good day',
start=(1 / Jul / 2020)[11:22:33],
timezone=TEST_TIMEZONE,
_updated=insure_localisation((25 / Nov / 2020)[11:22:33],
timezone=TEST_TIMEZONE))
expected_event_json = {
'summary': 'Good day',
'start': {
'dateTime': '2020-07-01T11:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2020-07-01T12:22:33+12:00',
'timeZone': TEST_TIMEZONE
},
'recurrence': [],
'visibility': 'default',
'attendees': [],
'reminders': {
'useDefault': False
},
'attachments': [],
'guestsCanInviteOthers': True,
'guestsCanModify': False,
'guestsCanSeeOtherGuests': True,
}
self.assertDictEqual(EventSerializer.to_json(e), expected_event_json)
def test_init_no_end(self):
start = 1 / Jun / 2019
event = Event('Good day', start, timezone=TEST_TIMEZONE)
self.assertEqual(event.end, start + 1 * days)
start = insure_localisation((1 / Jul / 2019)[12:00], TEST_TIMEZONE)
event = Event('Lunch', start, timezone=TEST_TIMEZONE)
self.assertEqual(event.end, start + 1 * hours)
def test_init(self):
event = Event('Breakfast',
event_id='123',
start=(1 / Feb / 2019)[9:00],
end=(31 / Dec / 2019)[23:59],
_created=insure_localisation((20 / Nov / 2020)[16:19],
TEST_TIMEZONE),
_updated=insure_localisation((25 / Nov / 2020)[16:19],
TEST_TIMEZONE),
timezone=TEST_TIMEZONE,
description='Everyday breakfast',
location='Home',
guests_can_invite_others=False,
guests_can_modify=True,
guests_can_see_other_guests=False,
recurrence=[
Recurrence.rule(freq=DAILY),
Recurrence.exclude_rule(by_week_day=[SU, SA]),
Recurrence.exclude_dates([
19 / Apr / 2019, 22 / Apr / 2019, 12 / May / 2019
])
],
visibility=Visibility.PRIVATE,
minutes_before_popup_reminder=15)
self.assertEqual(event.summary, 'Breakfast')
self.assertEqual(event.id, '123')
self.assertEqual(
event.start,
insure_localisation((1 / Feb / 2019)[9:00], TEST_TIMEZONE))
self.assertEqual(
event.end,
insure_localisation((31 / Dec / 2019)[23:59], TEST_TIMEZONE))
self.assertEqual(
event.created,
insure_localisation((20 / Nov / 2020)[16:19], TEST_TIMEZONE))
self.assertEqual(
event.updated,
insure_localisation((25 / Nov / 2020)[16:19], TEST_TIMEZONE))
self.assertEqual(event.description, 'Everyday breakfast')
self.assertEqual(event.location, 'Home')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PRIVATE)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 15)
self.assertFalse(event.guests_can_invite_others)
self.assertTrue(event.guests_can_modify)
self.assertFalse(event.guests_can_see_other_guests)
def test_get_events_time_limits(self):
time_min = insure_localisation(D.today()[:] + 5 * days)
events = list(self.gc.get_events(time_min=time_min))
self.assertEqual(len(events), 6)
self.assertTrue(all(e.start >= time_min for e in events))
time_min = insure_localisation(D.today()[:] + 5 * days)
events = list(self.gc[time_min])
self.assertEqual(len(events), 6)
self.assertTrue(all(e.start >= time_min for e in events))
time_max = insure_localisation(D.today()[:] + 1 * years + 7 * days)
events = list(self.gc.get_events(time_max=time_max))
self.assertEqual(len(events), 11)
self.assertTrue(all(e.end < time_max for e in events))
time_max = insure_localisation(D.today()[:] + 7 * days)
events = list(self.gc.get_events(time_max=time_max))
self.assertEqual(len(events), 7)
self.assertTrue(all(e.end < time_max for e in events))
events = list(self.gc.get_events(time_min=time_min, time_max=time_max))
self.assertEqual(len(events), 2)
self.assertTrue(
all(time_min <= e.start and e.end < time_max for e in events))
events = list(self.gc[time_min:time_max])
self.assertEqual(len(events), 2)
self.assertTrue(
all(time_min <= e.start and e.end < time_max for e in events))
time_min = D.today() + 5 * days
time_max = D.today() + 7 * days
events = list(self.gc.get_events(time_min=time_min, time_max=time_max))
self.assertEqual(len(events), 3)
time_min = insure_localisation(time_min[0:0])
time_max = insure_localisation(time_max[23:59:59])
self.assertTrue(
all(time_min <= e.start and e.end < time_max for e in events))
with self.assertRaises(NotImplementedError):
_ = self.gc[5]
with self.assertRaises(ValueError):
_ = self.gc[5:10]
def test_to_object(self):
event_json = {
'summary':
'Good day',
'description':
'Very good day indeed',
'location':
'Prague',
'start': {
'dateTime': '2019-01-01T11:22:33',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-01-01T12:22:33',
'timeZone': TEST_TIMEZONE
},
'recurrence': [
'RRULE:FREQ=DAILY;WKST=SU',
'EXRULE:FREQ=DAILY;BYDAY=MO;WKST=SU',
'EXDATE:VALUE=DATE:20190419,20190422,20190512'
],
'visibility':
'public',
'attendees': [
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.NEEDS_ACTION
},
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.ACCEPTED
},
],
'reminders': {
'useDefault':
False,
'overrides': [{
'method': 'popup',
'minutes': 30
}, {
'method': 'email',
'minutes': 120
}]
},
'attachments': [{
'title': 'My file1',
'fileUrl': 'https://file.url1',
'mimeType': 'application/vnd.google-apps.document'
}, {
'title': 'My file2',
'fileUrl': 'https://file.url2',
'mimeType': 'application/vnd.google-apps.document'
}]
}
serializer = EventSerializer(event_json)
event = serializer.get_object()
self.assertEqual(event.summary, 'Good day')
self.assertEqual(
event.start,
insure_localisation((1 / Jan / 2019)[11:22:33], TEST_TIMEZONE))
self.assertEqual(
event.end,
insure_localisation((1 / Jan / 2019)[12:22:33], TEST_TIMEZONE))
self.assertEqual(event.description, 'Very good day indeed')
self.assertEqual(event.location, 'Prague')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PUBLIC)
self.assertEqual(len(event.attendees), 2)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 30)
self.assertIsInstance(event.reminders[1], EmailReminder)
self.assertEqual(event.reminders[1].minutes_before_start, 120)
self.assertEqual(len(event.attachments), 2)
self.assertIsInstance(event.attachments[0], Attachment)
self.assertEqual(event.attachments[0].title, 'My file1')
event_json_str = """{
"summary": "Good day",
"description": "Very good day indeed",
"location": "Prague",
"start": {"date": "2020-07-20"},
"end": {"date": "2020-07-22"}
}"""
event = EventSerializer.to_object(event_json_str)
self.assertEqual(event.summary, 'Good day')
self.assertEqual(event.description, 'Very good day indeed')
self.assertEqual(event.location, 'Prague')
self.assertEqual(event.start, 20 / Jul / 2020)
self.assertEqual(event.end, 22 / Jul / 2020)
def test_to_object(self):
event_json = {
'summary':
'Good day',
'description':
'Very good day indeed',
'location':
'Prague',
'start': {
'dateTime': '2019-01-01T11:22:33',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-01-01T12:22:33',
'timeZone': TEST_TIMEZONE
},
'updated':
'2020-11-25T14:53:46.0Z',
'created':
'2020-11-24T14:53:46.0Z',
'recurrence': [
'RRULE:FREQ=DAILY;WKST=SU',
'EXRULE:FREQ=DAILY;BYDAY=MO;WKST=SU',
'EXDATE:VALUE=DATE:20190419,20190422,20190512'
],
'visibility':
'public',
'attendees': [
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.NEEDS_ACTION
},
{
'email': '*****@*****.**',
'responseStatus': ResponseStatus.ACCEPTED
},
],
'reminders': {
'useDefault':
False,
'overrides': [{
'method': 'popup',
'minutes': 30
}, {
'method': 'email',
'minutes': 120
}]
},
'attachments': [{
'title': 'My file1',
'fileUrl': 'https://file.url1',
'mimeType': 'application/vnd.google-apps.document'
}, {
'title': 'My file2',
'fileUrl': 'https://file.url2',
'mimeType': 'application/vnd.google-apps.document'
}],
'conferenceData': {
'entryPoints': [{
'entryPointType': 'video',
'uri': 'https://video.com',
}],
'conferenceSolution': {
'key': {
'type': 'hangoutsMeet'
},
'name': 'Hangout',
'iconUri': 'https://icon.com'
},
'conferenceId':
'aaa-bbbb-ccc',
'signature':
'abc4efg12345',
'notes':
'important notes'
},
'guestsCanInviteOthers':
False,
'guestsCanModify':
True,
'guestsCanSeeOtherGuests':
False,
}
serializer = EventSerializer(event_json)
event = serializer.get_object()
self.assertEqual(event.summary, 'Good day')
self.assertEqual(
event.start,
insure_localisation((1 / Jan / 2019)[11:22:33], TEST_TIMEZONE))
self.assertEqual(
event.end,
insure_localisation((1 / Jan / 2019)[12:22:33], TEST_TIMEZONE))
self.assertEqual(
event.updated,
insure_localisation((25 / Nov / 2020)[14:53:46], 'UTC'))
self.assertEqual(
event.created,
insure_localisation((24 / Nov / 2020)[14:53:46], 'UTC'))
self.assertEqual(event.description, 'Very good day indeed')
self.assertEqual(event.location, 'Prague')
self.assertEqual(len(event.recurrence), 3)
self.assertEqual(event.visibility, Visibility.PUBLIC)
self.assertEqual(len(event.attendees), 2)
self.assertIsInstance(event.reminders[0], PopupReminder)
self.assertEqual(event.reminders[0].minutes_before_start, 30)
self.assertIsInstance(event.reminders[1], EmailReminder)
self.assertEqual(event.reminders[1].minutes_before_start, 120)
self.assertEqual(len(event.attachments), 2)
self.assertIsInstance(event.attachments[0], Attachment)
self.assertEqual(event.attachments[0].title, 'My file1')
self.assertIsInstance(event.conference_solution, ConferenceSolution)
self.assertEqual(event.conference_solution.solution_type,
'hangoutsMeet')
self.assertEqual(event.conference_solution.entry_points[0].uri,
'https://video.com')
self.assertFalse(event.guests_can_invite_others)
self.assertTrue(event.guests_can_modify)
self.assertFalse(event.guests_can_see_other_guests)
event_json = {
'summary': 'Good day',
'description': 'Very good day indeed',
'location': 'Prague',
'start': {
'dateTime': '2019-01-01T11:22:33',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-01-01T12:22:33',
'timeZone': TEST_TIMEZONE
},
'conferenceData': {
'createRequest': {
'requestId': 'hello1234',
'conferenceSolutionKey': {
'type': 'hangoutsMeet'
},
'status': {
'statusCode': 'pending'
}
},
'conferenceId': 'conference-id',
'signature': 'signature',
'notes': 'important notes'
}
}
event = EventSerializer.to_object(event_json)
self.assertIsInstance(event.conference_solution,
ConferenceSolutionCreateRequest)
self.assertEqual(event.conference_solution.solution_type,
'hangoutsMeet')
# with successful conference create request
event_json = {
'summary': 'Good day',
'description': 'Very good day indeed',
'location': 'Prague',
'start': {
'dateTime': '2019-01-01T11:22:33',
'timeZone': TEST_TIMEZONE
},
'end': {
'dateTime': '2019-01-01T12:22:33',
'timeZone': TEST_TIMEZONE
},
'conferenceData': {
'entryPoints': [{
'entryPointType': 'video',
'uri': 'https://video.com',
}],
'conferenceSolution': {
'key': {
'type': 'hangoutsMeet'
},
'name': 'Hangout',
'iconUri': 'https://icon.com'
},
'createRequest': {
'requestId': 'hello1234',
'conferenceSolutionKey': {
'type': 'hangoutsMeet'
},
'status': {
'statusCode': 'success'
}
},
'conferenceId':
'conference-id',
'signature':
'signature',
'notes':
'important notes'
}
}
event = EventSerializer.to_object(event_json)
self.assertIsInstance(event.conference_solution, ConferenceSolution)
self.assertEqual(event.conference_solution.solution_type,
'hangoutsMeet')
self.assertEqual(event.conference_solution.entry_points[0].uri,
'https://video.com')
event_json_str = """{
"summary": "Good day",
"description": "Very good day indeed",
"location": "Prague",
"start": {"date": "2020-07-20"},
"end": {"date": "2020-07-22"}
}"""
event = EventSerializer.to_object(event_json_str)
self.assertEqual(event.summary, 'Good day')
self.assertEqual(event.description, 'Very good day indeed')
self.assertEqual(event.location, 'Prague')
self.assertEqual(event.start, 20 / Jul / 2020)
self.assertEqual(event.end, 22 / Jul / 2020)
event_json_str = {
"id": 'recurring_event_id_20201107T070000Z',
"summary": "Good day",
"description": "Very good day indeed",
"location": "Prague",
"start": {
"date": "2020-07-20"
},
"end": {
"date": "2020-07-22"
},
"recurringEventId": 'recurring_event_id'
}
event = EventSerializer.to_object(event_json_str)
self.assertEqual(event.id, 'recurring_event_id_20201107T070000Z')
self.assertTrue(event.is_recurring_instance)
self.assertEqual(event.recurring_event_id, 'recurring_event_id')
def list(self, **kwargs):
"""Emulates GoogleCalendar.service.events().list().execute()"""
time_min = dateutil.parser.parse(kwargs['timeMin'])
time_max = dateutil.parser.parse(kwargs['timeMax'])
order_by = kwargs['orderBy']
single_events = kwargs['singleEvents']
page_token = kwargs['pageToken'] or 0 # page number in this case
q = kwargs['q']
test_events = [
Event('test{}'.format(i),
start=insure_localisation(D.today()[:] + i * days +
i * hours),
event_id='1',
_updated=insure_localisation(D.today()[:] + (i + 1) * days +
i * hours),
attendees=[
Attendee(email='{}@gmail.com'.format(
attendee_name.lower()),
display_name=attendee_name)
] if attendee_name else None)
for i, attendee_name in zip(range(1, 10), ['John', 'Josh'] +
[''] * 8)
]
recurring_event = Event(
'Recurring event',
start=insure_localisation(D.today()[:] + 2 * days),
event_id='recurring_id',
_updated=insure_localisation(D.today()[:] + 3 * days))
recurring_instances = [
Event(
recurring_event.summary,
start=recurring_event.start + i * days,
event_id=recurring_event.id + '_' +
(recurring_event.start + i * days).isoformat() + 'Z',
_updated=recurring_event.updated,
_recurring_event_id=recurring_event.id,
) for i in range(10)
]
if single_events:
test_events.extend(recurring_instances)
else:
test_events.append(recurring_event)
event_in_a_year = Event(
'test42',
start=insure_localisation(D.today()[:] + 1 * years + 2 * days),
event_id='42',
_updated=insure_localisation(D.today()[:] + 1 * years + 3 * days),
attendees=[
Attendee(email='*****@*****.**', display_name='Frank')
])
test_events.append(event_in_a_year)
def _filter(e):
return ((time_min <= e.start and e.end < time_max)
and (not q or q in e.summary or
(e.description and q in e.description) or
(e.attendees and any(
(a.display_name and q in a.display_name)
for a in e.attendees))))
def _sort_key(e):
if order_by is None:
return e.id
if order_by == 'startTime':
return e.start
if order_by == 'updated':
return e.updated
filtered_events = list(filter(_filter, test_events))
ordered_events = sorted(filtered_events, key=_sort_key)
serialized_events = list(map(self._serialize_event, ordered_events))
current_page_events = ordered_events[page_token *
self.EVENTS_PER_PAGE:(page_token +
1) *
self.EVENTS_PER_PAGE]
return {
'items':
current_page_events,
'nextPageToken':
page_token + 1 if
(page_token + 1) * 3 < len(serialized_events) else None
}
