From dddde78b8a28971f6a90690cfee2c25900594f0d Mon Sep 17 00:00:00 2001 From: Dmitry Date: Sun, 15 Apr 2018 23:41:50 +0300 Subject: [PATCH 1/6] autopep8 --- tests/test_converter.py | 136 ++++++++++++++++++++-------------------- tests/test_imports.py | 18 +++--- 2 files changed, 79 insertions(+), 75 deletions(-) diff --git a/tests/test_converter.py b/tests/test_converter.py index ff31d26..696dec7 100644 --- a/tests/test_converter.py +++ b/tests/test_converter.py @@ -70,85 +70,87 @@ END:VEVENT END:VCALENDAR """ + class TestCalendarConverter(unittest.TestCase): def test_empty_calendar(self): - converter = CalendarConverter() - converter.loads(ics_empty) - evnts = converter.events_to_gcal() - self.assertEqual(len(evnts), 0) - + converter = CalendarConverter() + converter.loads(ics_empty) + evnts = converter.events_to_gcal() + self.assertEqual(len(evnts), 0) + def test_empty_event(self): - converter = CalendarConverter() - converter.loads(ics_empty_event) - with self.assertRaises(KeyError): - converter.events_to_gcal() - + converter = CalendarConverter() + converter.loads(ics_empty_event) + with self.assertRaises(KeyError): + converter.events_to_gcal() + def test_event_no_end(self): - converter = CalendarConverter() - converter.loads(ics_event_no_end) - with self.assertRaises(ValueError): - converter.events_to_gcal() + converter = CalendarConverter() + converter.loads(ics_event_no_end) + with self.assertRaises(ValueError): + converter.events_to_gcal() def test_event_date_values(self): - converter = CalendarConverter() - converter.loads(ics_event_date_val) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'date': '2018-02-15' - }) - self.assertEqual(event['end'], { - 'date': '2018-02-17' - }) + converter = CalendarConverter() + converter.loads(ics_event_date_val) + events = converter.events_to_gcal() + self.assertEqual(len(events), 1) + event = events[0] + self.assertEqual(event['start'], { + 'date': '2018-02-15' + }) + self.assertEqual(event['end'], { + 'date': '2018-02-17' + }) def test_event_datetime_utc_values(self): - converter = CalendarConverter() - converter.loads(ics_event_datetime_utc_val) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'dateTime': '2018-03-19T09:20:01.000001Z' - }) - self.assertEqual(event['end'], { - 'dateTime': '2018-03-19T10:20:01.000001Z' - }) - + converter = CalendarConverter() + converter.loads(ics_event_datetime_utc_val) + events = converter.events_to_gcal() + self.assertEqual(len(events), 1) + event = events[0] + self.assertEqual(event['start'], { + 'dateTime': '2018-03-19T09:20:01.000001Z' + }) + self.assertEqual(event['end'], { + 'dateTime': '2018-03-19T10:20:01.000001Z' + }) + def test_event_date_duration(self): - converter = CalendarConverter() - converter.loads(ics_event_date_duration) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'date': '2018-02-15' - }) - self.assertEqual(event['end'], { - 'date': '2018-02-18' - }) + converter = CalendarConverter() + converter.loads(ics_event_date_duration) + events = converter.events_to_gcal() + self.assertEqual(len(events), 1) + event = events[0] + self.assertEqual(event['start'], { + 'date': '2018-02-15' + }) + self.assertEqual(event['end'], { + 'date': '2018-02-18' + }) def test_event_datetime_utc_duration(self): - converter = CalendarConverter() - converter.loads(ics_event_datetime_utc_duration) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'dateTime': '2018-03-19T09:20:01.000001Z' - }) - self.assertEqual(event['end'], { - 'dateTime': '2018-03-21T10:25:01.000001Z' - }) + converter = CalendarConverter() + converter.loads(ics_event_datetime_utc_duration) + events = converter.events_to_gcal() + self.assertEqual(len(events), 1) + event = events[0] + self.assertEqual(event['start'], { + 'dateTime': '2018-03-19T09:20:01.000001Z' + }) + self.assertEqual(event['end'], { + 'dateTime': '2018-03-21T10:25:01.000001Z' + }) def test_event_created_updated(self): - converter = CalendarConverter() - converter.loads(ics_event_created_updated) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['created'], '2018-03-20T07:11:55.000001Z') - self.assertEqual(event['updated'], '2018-03-26T12:02:35.000001Z') + converter = CalendarConverter() + converter.loads(ics_event_created_updated) + events = converter.events_to_gcal() + self.assertEqual(len(events), 1) + event = events[0] + self.assertEqual(event['created'], '2018-03-20T07:11:55.000001Z') + self.assertEqual(event['updated'], '2018-03-26T12:02:35.000001Z') + if __name__ == '__main__': - unittest.main() \ No newline at end of file + unittest.main() diff --git a/tests/test_imports.py b/tests/test_imports.py index 3bf507a..26ac187 100644 --- a/tests/test_imports.py +++ b/tests/test_imports.py @@ -1,14 +1,16 @@ import unittest + class TestImports(unittest.TestCase): def test_imports(self): - from gcal_sync import ( - CalendarConverter, - EventConverter, - GoogleCalendarService, - GoogleCalendar, - CalendarSync - ) + from gcal_sync import ( + CalendarConverter, + EventConverter, + GoogleCalendarService, + GoogleCalendar, + CalendarSync + ) + if __name__ == '__main__': - unittest.main() \ No newline at end of file + unittest.main() From ec45665a4cc088b45492bb415d837f165bc07e2b Mon Sep 17 00:00:00 2001 From: Dmitry Date: Sun, 15 Apr 2018 23:44:00 +0300 Subject: [PATCH 2/6] test_imports removed --- tests/test_imports.py | 16 ---------------- 1 file changed, 16 deletions(-) delete mode 100644 tests/test_imports.py diff --git a/tests/test_imports.py b/tests/test_imports.py deleted file mode 100644 index 26ac187..0000000 --- a/tests/test_imports.py +++ /dev/null @@ -1,16 +0,0 @@ -import unittest - - -class TestImports(unittest.TestCase): - def test_imports(self): - from gcal_sync import ( - CalendarConverter, - EventConverter, - GoogleCalendarService, - GoogleCalendar, - CalendarSync - ) - - -if __name__ == '__main__': - unittest.main() From 7aa3e754eacb689fc48d2df075d740eff8b85ecc Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 17 Apr 2018 16:01:21 +0300 Subject: [PATCH 3/6] test_converter rewrite using pytest event start/end tests united, using pytest.fixture --- tests/test_converter.py | 154 ++++++++++++++++------------------------ 1 file changed, 62 insertions(+), 92 deletions(-) diff --git a/tests/test_converter.py b/tests/test_converter.py index 696dec7..f30583f 100644 --- a/tests/test_converter.py +++ b/tests/test_converter.py @@ -1,4 +1,5 @@ -import unittest +import pytest + from gcal_sync import CalendarConverter ics_empty = """BEGIN:VCALENDAR @@ -32,20 +33,20 @@ END:VEVENT END:VCALENDAR """ -ics_event_datetime_utc_val = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com -DTSTART;VALUE=DATE-TIME:20180319T092001Z -DTEND:20180319T102001Z -END:VEVENT -END:VCALENDAR -""" - ics_event_date_duration = """BEGIN:VCALENDAR BEGIN:VEVENT UID:uisgtr8tre93wewe0yr8wqy@test.com DTSTART;VALUE=DATE:20180215 -DURATION:P3D +DURATION:P2D +END:VEVENT +END:VCALENDAR +""" + +ics_event_datetime_utc_val = """BEGIN:VCALENDAR +BEGIN:VEVENT +UID:uisgtr8tre93wewe0yr8wqy@test.com +DTSTART;VALUE=DATE-TIME:20180319T092001Z +DTEND:20180321T102501Z END:VEVENT END:VCALENDAR """ @@ -71,86 +72,55 @@ END:VCALENDAR """ -class TestCalendarConverter(unittest.TestCase): - def test_empty_calendar(self): - converter = CalendarConverter() - converter.loads(ics_empty) - evnts = converter.events_to_gcal() - self.assertEqual(len(evnts), 0) - - def test_empty_event(self): - converter = CalendarConverter() - converter.loads(ics_empty_event) - with self.assertRaises(KeyError): - converter.events_to_gcal() - - def test_event_no_end(self): - converter = CalendarConverter() - converter.loads(ics_event_no_end) - with self.assertRaises(ValueError): - converter.events_to_gcal() - - def test_event_date_values(self): - converter = CalendarConverter() - converter.loads(ics_event_date_val) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'date': '2018-02-15' - }) - self.assertEqual(event['end'], { - 'date': '2018-02-17' - }) - - def test_event_datetime_utc_values(self): - converter = CalendarConverter() - converter.loads(ics_event_datetime_utc_val) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'dateTime': '2018-03-19T09:20:01.000001Z' - }) - self.assertEqual(event['end'], { - 'dateTime': '2018-03-19T10:20:01.000001Z' - }) - - def test_event_date_duration(self): - converter = CalendarConverter() - converter.loads(ics_event_date_duration) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'date': '2018-02-15' - }) - self.assertEqual(event['end'], { - 'date': '2018-02-18' - }) - - def test_event_datetime_utc_duration(self): - converter = CalendarConverter() - converter.loads(ics_event_datetime_utc_duration) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['start'], { - 'dateTime': '2018-03-19T09:20:01.000001Z' - }) - self.assertEqual(event['end'], { - 'dateTime': '2018-03-21T10:25:01.000001Z' - }) - - def test_event_created_updated(self): - converter = CalendarConverter() - converter.loads(ics_event_created_updated) - events = converter.events_to_gcal() - self.assertEqual(len(events), 1) - event = events[0] - self.assertEqual(event['created'], '2018-03-20T07:11:55.000001Z') - self.assertEqual(event['updated'], '2018-03-26T12:02:35.000001Z') +def test_empty_calendar(): + converter = CalendarConverter() + converter.loads(ics_empty) + evnts = converter.events_to_gcal() + assert evnts == [] -if __name__ == '__main__': - unittest.main() +def test_empty_event(): + converter = CalendarConverter() + converter.loads(ics_empty_event) + with pytest.raises(KeyError): + converter.events_to_gcal() + + +def test_event_no_end(): + converter = CalendarConverter() + converter.loads(ics_event_no_end) + with pytest.raises(ValueError): + converter.events_to_gcal() + +@pytest.fixture(params=[ +("date", ics_event_date_val, '2018-02-15', '2018-02-17'), +("date", ics_event_date_duration, '2018-02-15', '2018-02-17'), +("dateTime", ics_event_datetime_utc_val, '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z'), +("dateTime", ics_event_datetime_utc_duration, '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z')], +ids=['date values', 'date duration', 'datetime utc values', 'datetime utc duration'] +) +def param_events_start_end(request): + return request.param + +def test_event_start_end(param_events_start_end): + (date_type, ics_str, start, end) = param_events_start_end + converter = CalendarConverter() + converter.loads(ics_str) + events = converter.events_to_gcal() + assert len(events) == 1 + event = events[0] + assert event['start'] == { + date_type: start + } + assert event['end'] == { + date_type: end + } + +def test_event_created_updated(): + converter = CalendarConverter() + converter.loads(ics_event_created_updated) + events = converter.events_to_gcal() + assert len(events) == 1 + event = events[0] + assert event['created'] == '2018-03-20T07:11:55.000001Z' + assert event['updated'] == '2018-03-26T12:02:35.000001Z' From 508ddedb2cb43221b50808b97d0c24e116d956cc Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 17 Apr 2018 16:20:24 +0300 Subject: [PATCH 4/6] min data in test_converter --- tests/test_converter.py | 91 +++++++++++++---------------------------- 1 file changed, 29 insertions(+), 62 deletions(-) diff --git a/tests/test_converter.py b/tests/test_converter.py index f30583f..c5bb563 100644 --- a/tests/test_converter.py +++ b/tests/test_converter.py @@ -2,106 +2,72 @@ import pytest from gcal_sync import CalendarConverter -ics_empty = """BEGIN:VCALENDAR -VERSION:2.0 -PRODID:-//test//test//ES -CALSCALE:GREGORIAN -METHOD:PUBLISH -END:VCALENDAR -""" - -ics_empty_event = """BEGIN:VCALENDAR -BEGIN:VEVENT -END:VEVENT -END:VCALENDAR -""" - -ics_event_no_end = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com +uid = "UID:uisgtr8tre93wewe0yr8wqy@test.com" +only_start_date = uid + """ DTSTART;VALUE=DATE:20180215 -END:VEVENT -END:VCALENDAR """ - -ics_event_date_val = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com -DTSTART;VALUE=DATE:20180215 +date_val = only_start_date + """ DTEND;VALUE=DATE:20180217 -END:VEVENT -END:VCALENDAR """ - -ics_event_date_duration = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com -DTSTART;VALUE=DATE:20180215 +date_duration = only_start_date + """ DURATION:P2D -END:VEVENT -END:VCALENDAR """ - -ics_event_datetime_utc_val = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com +datetime_utc_val = uid + """ DTSTART;VALUE=DATE-TIME:20180319T092001Z DTEND:20180321T102501Z -END:VEVENT -END:VCALENDAR """ - -ics_event_datetime_utc_duration = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com +datetime_utc_duration = uid + """ DTSTART;VALUE=DATE-TIME:20180319T092001Z DURATION:P2DT1H5M -END:VEVENT -END:VCALENDAR """ - -ics_event_created_updated = """BEGIN:VCALENDAR -BEGIN:VEVENT -UID:uisgtr8tre93wewe0yr8wqy@test.com -DTSTART:20180215 -DTEND:20180217 +created_updated = date_val + """ CREATED:20180320T071155Z LAST-MODIFIED:20180326T120235Z -END:VEVENT -END:VCALENDAR """ +def ics_test_cal(content): + return "BEGIN:VCALENDAR\r\n{}END:VCALENDAR\r\n".format(content) + + +def ics_test_event(content): + return ics_test_cal("BEGIN:VEVENT\r\n{}END:VEVENT\r\n".format(content)) + + def test_empty_calendar(): converter = CalendarConverter() - converter.loads(ics_empty) + converter.loads(ics_test_cal("")) evnts = converter.events_to_gcal() assert evnts == [] def test_empty_event(): converter = CalendarConverter() - converter.loads(ics_empty_event) + converter.loads(ics_test_event("")) with pytest.raises(KeyError): converter.events_to_gcal() def test_event_no_end(): converter = CalendarConverter() - converter.loads(ics_event_no_end) + converter.loads(ics_test_event(only_start_date)) with pytest.raises(ValueError): converter.events_to_gcal() + @pytest.fixture(params=[ -("date", ics_event_date_val, '2018-02-15', '2018-02-17'), -("date", ics_event_date_duration, '2018-02-15', '2018-02-17'), -("dateTime", ics_event_datetime_utc_val, '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z'), -("dateTime", ics_event_datetime_utc_duration, '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z')], -ids=['date values', 'date duration', 'datetime utc values', 'datetime utc duration'] + ("date", ics_test_event(date_val), '2018-02-15', '2018-02-17'), + ("date", ics_test_event(date_duration), '2018-02-15', '2018-02-17'), + ("dateTime", ics_test_event(datetime_utc_val), + '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z'), + ("dateTime", ics_test_event(datetime_utc_duration), '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z')], + ids=['date values', 'date duration', + 'datetime utc values', 'datetime utc duration'] ) def param_events_start_end(request): return request.param + def test_event_start_end(param_events_start_end): (date_type, ics_str, start, end) = param_events_start_end converter = CalendarConverter() @@ -116,9 +82,10 @@ def test_event_start_end(param_events_start_end): date_type: end } + def test_event_created_updated(): converter = CalendarConverter() - converter.loads(ics_event_created_updated) + converter.loads(ics_test_event(created_updated)) events = converter.events_to_gcal() assert len(events) == 1 event = events[0] From c38a3afe00ab9cb5289c45720efe1df89b286cc5 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 17 Apr 2018 22:41:14 +0300 Subject: [PATCH 5/6] test_sync rewrite using pytest --- tests/test_sync.py | 318 ++++++++++++++++++++++----------------------- 1 file changed, 153 insertions(+), 165 deletions(-) diff --git a/tests/test_sync.py b/tests/test_sync.py index bdf03b5..840db85 100644 --- a/tests/test_sync.py +++ b/tests/test_sync.py @@ -1,185 +1,173 @@ import datetime import hashlib import operator -import unittest from copy import deepcopy from random import shuffle import dateutil.parser +import pytest from pytz import timezone, utc from gcal_sync import CalendarSync -class TestCalendarSync(unittest.TestCase): - @staticmethod - def sha1(string): - if isinstance(string, str): - string = string.encode('utf8') - h = hashlib.sha1() - h.update(string) - return h.hexdigest() +def sha1(string): + if isinstance(string, str): + string = string.encode('utf8') + h = hashlib.sha1() + h.update(string) + return h.hexdigest() - @staticmethod - def gen_events(start, stop, start_time, no_time=False): - if no_time: - start_time = datetime.date( - start_time.year, start_time.month, start_time.day) - duration = datetime.date(1, 1, 2) - datetime.date(1, 1, 1) - date_key = "date" - suff = '' - else: - start_time = utc.normalize( - start_time.astimezone(utc)).replace(tzinfo=None) - duration = datetime.datetime( - 1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1) - date_key = "dateTime" - suff = 'Z' - - result = [] - for i in range(start, stop): - event_start = start_time + (duration * i) - event_end = event_start + duration - - updated = event_start - if no_time: - updated = datetime.datetime( - updated.year, updated.month, updated.day, 0, 0, 0, 1, tzinfo=utc) - - event = { - 'summary': 'test event __ {}'.format(i), - 'location': 'la la la {}'.format(i), - 'description': 'test TEST -- test event {}'.format(i), - "iCalUID": "{}@test.com".format(TestCalendarSync.sha1("test - event {}".format(i))), - "updated": updated.isoformat() + 'Z', - "created": updated.isoformat() + 'Z' - } - event['start'] = {date_key: event_start.isoformat() + suff} - event['end'] = {date_key: event_end.isoformat() + suff} - result.append(event) - return result - - @staticmethod - def gen_list_to_compare(start, stop): - result = [] - for i in range(start, stop): - result.append({'iCalUID': 'test{:06d}'.format(i)}) - return result - - @staticmethod - def get_start_date(event): - event_start = event['start'] - start_date = None - is_date = False - if 'date' in event_start: - start_date = event_start['date'] - is_date = True - if 'dateTime' in event_start: - start_date = event_start['dateTime'] - - result = dateutil.parser.parse(start_date) - if is_date: - result = datetime.date(result.year, result.month, result.day) - - return result - - def test_compare(self): - part_len = 20 - # [1..2n] - lst_src = TestCalendarSync.gen_list_to_compare(1, 1 + part_len * 2) - # [n..3n] - lst_dst = TestCalendarSync.gen_list_to_compare( - 1 + part_len, 1 + part_len * 3) - - lst_src_rnd = deepcopy(lst_src) - lst_dst_rnd = deepcopy(lst_dst) - - shuffle(lst_src_rnd) - shuffle(lst_dst_rnd) - - to_ins, to_upd, to_del = CalendarSync._events_list_compare( - lst_src_rnd, lst_dst_rnd) - - self.assertEqual(len(to_ins), part_len) - self.assertEqual(len(to_upd), part_len) - self.assertEqual(len(to_del), part_len) - - self.assertEqual( - sorted(to_ins, key=lambda x: x['iCalUID']), lst_src[:part_len]) - self.assertEqual( - sorted(to_del, key=lambda x: x['iCalUID']), lst_dst[part_len:]) - - to_upd_ok = list(zip(lst_src[part_len:], lst_dst[:part_len])) - self.assertEqual(len(to_upd), len(to_upd_ok)) - for item in to_upd_ok: - self.assertIn(item, to_upd) - - def test_filter_events_by_date(self, no_time=False): - msk = timezone('Europe/Moscow') - now = utc.localize(datetime.datetime.utcnow()) - msk_now = msk.normalize(now.astimezone(msk)) - - part_len = 5 - - if no_time: - duration = datetime.date( - 1, 1, 2) - datetime.date(1, 1, 1) - else: - duration = datetime.datetime( - 1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1) - - date_cmp = msk_now + (duration * part_len) - - if no_time: - date_cmp = datetime.date( - date_cmp.year, date_cmp.month, date_cmp.day) - - events = TestCalendarSync.gen_events( - 1, 1 + (part_len * 2), msk_now, no_time) - shuffle(events) - - events_pending = CalendarSync._filter_events_by_date( - events, date_cmp, operator.ge) - events_past = CalendarSync._filter_events_by_date( - events, date_cmp, operator.lt) - - self.assertEqual(len(events_pending), 1 + part_len) - self.assertEqual(len(events_past), part_len - 1) - - for event in events_pending: - self.assertGreaterEqual( - TestCalendarSync.get_start_date(event), date_cmp) - - for event in events_past: - self.assertLess(TestCalendarSync.get_start_date(event), date_cmp) - - def test_filter_events_by_date_no_time(self): - self.test_filter_events_by_date(no_time=True) - - def test_filter_events_to_update(self): - msk = timezone('Europe/Moscow') - now = utc.localize(datetime.datetime.utcnow()) - msk_now = msk.normalize(now.astimezone(msk)) - - one_hour = datetime.datetime( +def gen_events(start, stop, start_time, no_time=False): + if no_time: + start_time = datetime.date( + start_time.year, start_time.month, start_time.day) + duration = datetime.date(1, 1, 2) - datetime.date(1, 1, 1) + date_key = "date" + suff = '' + else: + start_time = utc.normalize( + start_time.astimezone(utc)).replace(tzinfo=None) + duration = datetime.datetime( 1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1) - date_upd = msk_now + (one_hour * 5) + date_key = "dateTime" + suff = 'Z' - count = 10 - events_old = TestCalendarSync.gen_events(1, 1 + count, msk_now) - events_new = TestCalendarSync.gen_events(1, 1 + count, date_upd) + result = [] + for i in range(start, stop): + event_start = start_time + (duration * i) + event_end = event_start + duration - sync1 = CalendarSync(None, None) - sync1.to_update = list(zip(events_new, events_old)) - sync1._filter_events_to_update() + updated = event_start + if no_time: + updated = datetime.datetime( + updated.year, updated.month, updated.day, 0, 0, 0, 1, tzinfo=utc) - sync2 = CalendarSync(None, None) - sync2.to_update = list(zip(events_old, events_new)) - sync2._filter_events_to_update() + event = { + 'summary': 'test event __ {}'.format(i), + 'location': 'la la la {}'.format(i), + 'description': 'test TEST -- test event {}'.format(i), + "iCalUID": "{}@test.com".format(sha1("test - event {}".format(i))), + "updated": updated.isoformat() + 'Z', + "created": updated.isoformat() + 'Z' + } + event['start'] = {date_key: event_start.isoformat() + suff} + event['end'] = {date_key: event_end.isoformat() + suff} + result.append(event) + return result - self.assertEqual(len(sync1.to_update), count) - self.assertEqual(len(sync2.to_update), 0) +def gen_list_to_compare(start, stop): + result = [] + for i in range(start, stop): + result.append({'iCalUID': 'test{:06d}'.format(i)}) + return result +def get_start_date(event): + event_start = event['start'] + start_date = None + is_date = False + if 'date' in event_start: + start_date = event_start['date'] + is_date = True + if 'dateTime' in event_start: + start_date = event_start['dateTime'] -if __name__ == '__main__': - unittest.main() + result = dateutil.parser.parse(start_date) + if is_date: + result = datetime.date(result.year, result.month, result.day) + + return result + +def test_compare(): + part_len = 20 + # [1..2n] + lst_src = gen_list_to_compare(1, 1 + part_len * 2) + # [n..3n] + lst_dst = gen_list_to_compare( + 1 + part_len, 1 + part_len * 3) + + lst_src_rnd = deepcopy(lst_src) + lst_dst_rnd = deepcopy(lst_dst) + + shuffle(lst_src_rnd) + shuffle(lst_dst_rnd) + + to_ins, to_upd, to_del = CalendarSync._events_list_compare( + lst_src_rnd, lst_dst_rnd) + + assert len(to_ins) == part_len + assert len(to_upd) == part_len + assert len(to_del) == part_len + + assert sorted(to_ins, key=lambda x: x['iCalUID']) == lst_src[:part_len] + assert sorted(to_del, key=lambda x: x['iCalUID']) == lst_dst[part_len:] + + to_upd_ok = list(zip(lst_src[part_len:], lst_dst[:part_len])) + assert len(to_upd) == len(to_upd_ok) + for item in to_upd_ok: + assert item in to_upd + +def test_filter_events_by_date(no_time=False): + msk = timezone('Europe/Moscow') + now = utc.localize(datetime.datetime.utcnow()) + msk_now = msk.normalize(now.astimezone(msk)) + + part_len = 5 + + if no_time: + duration = datetime.date( + 1, 1, 2) - datetime.date(1, 1, 1) + else: + duration = datetime.datetime( + 1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1) + + date_cmp = msk_now + (duration * part_len) + + if no_time: + date_cmp = datetime.date( + date_cmp.year, date_cmp.month, date_cmp.day) + + events = gen_events( + 1, 1 + (part_len * 2), msk_now, no_time) + shuffle(events) + + events_pending = CalendarSync._filter_events_by_date( + events, date_cmp, operator.ge) + events_past = CalendarSync._filter_events_by_date( + events, date_cmp, operator.lt) + + assert len(events_pending) == 1 + part_len + assert len(events_past) == part_len - 1 + + for event in events_pending: + assert get_start_date(event) >= date_cmp + + for event in events_past: + assert get_start_date(event) < date_cmp + +def test_filter_events_by_date_no_time(): + test_filter_events_by_date(no_time=True) + +def test_filter_events_to_update(): + msk = timezone('Europe/Moscow') + now = utc.localize(datetime.datetime.utcnow()) + msk_now = msk.normalize(now.astimezone(msk)) + + one_hour = datetime.datetime( + 1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1) + date_upd = msk_now + (one_hour * 5) + + count = 10 + events_old = gen_events(1, 1 + count, msk_now) + events_new = gen_events(1, 1 + count, date_upd) + + sync1 = CalendarSync(None, None) + sync1.to_update = list(zip(events_new, events_old)) + sync1._filter_events_to_update() + + sync2 = CalendarSync(None, None) + sync2.to_update = list(zip(events_old, events_new)) + sync2._filter_events_to_update() + + assert len(sync1.to_update) == count + assert sync2.to_update == [] From 94edbf1849b321778a23fde16018d7b6546cff63 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Tue, 17 Apr 2018 22:53:56 +0300 Subject: [PATCH 6/6] parametrize test_filter_events_by_date --- tests/test_sync.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/tests/test_sync.py b/tests/test_sync.py index 840db85..52c2099 100644 --- a/tests/test_sync.py +++ b/tests/test_sync.py @@ -18,6 +18,7 @@ def sha1(string): h.update(string) return h.hexdigest() + def gen_events(start, stop, start_time, no_time=False): if no_time: start_time = datetime.date( @@ -56,12 +57,14 @@ def gen_events(start, stop, start_time, no_time=False): result.append(event) return result + def gen_list_to_compare(start, stop): result = [] for i in range(start, stop): result.append({'iCalUID': 'test{:06d}'.format(i)}) return result + def get_start_date(event): event_start = event['start'] start_date = None @@ -78,6 +81,7 @@ def get_start_date(event): return result + def test_compare(): part_len = 20 # [1..2n] @@ -95,19 +99,21 @@ def test_compare(): to_ins, to_upd, to_del = CalendarSync._events_list_compare( lst_src_rnd, lst_dst_rnd) - assert len(to_ins) == part_len - assert len(to_upd) == part_len - assert len(to_del) == part_len + assert len(to_ins) == part_len + assert len(to_upd) == part_len + assert len(to_del) == part_len assert sorted(to_ins, key=lambda x: x['iCalUID']) == lst_src[:part_len] assert sorted(to_del, key=lambda x: x['iCalUID']) == lst_dst[part_len:] to_upd_ok = list(zip(lst_src[part_len:], lst_dst[:part_len])) - assert len(to_upd) == len(to_upd_ok) + assert len(to_upd) == len(to_upd_ok) for item in to_upd_ok: assert item in to_upd -def test_filter_events_by_date(no_time=False): + +@pytest.mark.parametrize("no_time", [True, False], ids=['date', 'dateTime']) +def test_filter_events_by_date(no_time): msk = timezone('Europe/Moscow') now = utc.localize(datetime.datetime.utcnow()) msk_now = msk.normalize(now.astimezone(msk)) @@ -136,8 +142,8 @@ def test_filter_events_by_date(no_time=False): events_past = CalendarSync._filter_events_by_date( events, date_cmp, operator.lt) - assert len(events_pending) == 1 + part_len - assert len(events_past) == part_len - 1 + assert len(events_pending) == 1 + part_len + assert len(events_past) == part_len - 1 for event in events_pending: assert get_start_date(event) >= date_cmp @@ -145,8 +151,6 @@ def test_filter_events_by_date(no_time=False): for event in events_past: assert get_start_date(event) < date_cmp -def test_filter_events_by_date_no_time(): - test_filter_events_by_date(no_time=True) def test_filter_events_to_update(): msk = timezone('Europe/Moscow') @@ -169,5 +173,5 @@ def test_filter_events_to_update(): sync2.to_update = list(zip(events_old, events_new)) sync2._filter_events_to_update() - assert len(sync1.to_update) == count + assert len(sync1.to_update) == count assert sync2.to_update == []