X-Git-Url: https://plomlompom.com/repos/%22https:/validator.w3.org/static/git-logo.png?a=blobdiff_plain;f=tests%2Fdays.py;h=8e3768c660937b5ba32078ee13d03cf275aa57fa;hb=refs%2Fheads%2Fmaster;hp=f67c80adfa96d144585af2b59f0f59b0efa7d607;hpb=96a63958d64e4847cd462d12b227ccb4fecd0d9e;p=plomtask diff --git a/tests/days.py b/tests/days.py index f67c80a..78c5552 100644 --- a/tests/days.py +++ b/tests/days.py @@ -1,171 +1,410 @@ """Test Days module.""" -from unittest import TestCase -from datetime import datetime -from tests.utils import TestCaseWithDB, TestCaseWithServer -from plomtask.days import Day, todays_date -from plomtask.exceptions import BadFormatException, NotFoundException +from datetime import datetime, timedelta +from typing import Any +from tests.utils import (TestCaseSansDB, TestCaseWithDB, TestCaseWithServer, + Expected) +from plomtask.dating import date_in_n_days as tested_date_in_n_days +from plomtask.days import Day +# so far the same as plomtask.dating.DATE_FORMAT, but for testing purposes we +# want to explicitly state our expectations here indepedently from that +TESTING_DATE_FORMAT = '%Y-%m-%d' -class TestsSansDB(TestCase): + +def _testing_date_in_n_days(n: int) -> str: + """Return in TEST_DATE_FORMAT date from today + n days. + + As with TESTING_DATE_FORMAT, we assume this equal the original's code + at plomtask.dating.date_in_n_days, but want to state our expectations + explicitly to rule out importing issues from the original. + """ + date = datetime.now() + timedelta(days=n) + return date.strftime(TESTING_DATE_FORMAT) + + +class TestsSansDB(TestCaseSansDB): """Days module tests not requiring DB setup.""" + checked_class = Day + legal_ids = ['2024-01-01', '2024-02-29'] + illegal_ids = ['foo', '2023-02-29', '2024-02-30', '2024-02-01 23:00:00'] - def test_Day_valid_date(self) -> None: - """Test Day's date format validation and parsing.""" - with self.assertRaises(BadFormatException): - Day('foo') - with self.assertRaises(BadFormatException): - Day('2024-02-30') - with self.assertRaises(BadFormatException): - Day('2024-02-01 23:00:00') - self.assertEqual(datetime(2024, 1, 1), Day('2024-01-01').datetime) - - def test_Day_sorting(self) -> None: - """Test sorting by .__lt__ and Day.__eq__.""" - day1 = Day('2024-01-01') - day2 = Day('2024-01-02') - day3 = Day('2024-01-03') - days = [day3, day1, day2] - self.assertEqual(sorted(days), [day1, day2, day3]) - - def test_Day_weekday(self) -> None: - """Test Day.weekday.""" - self.assertEqual(Day('2024-03-17').weekday, 'Sunday') - - def test_Day_neighbor_dates(self) -> None: - """Test Day.prev_date and Day.next_date.""" - self.assertEqual(Day('2024-01-01').prev_date, '2023-12-31') - self.assertEqual(Day('2023-02-28').next_date, '2023-03-01') + def test_date_in_n_days(self) -> None: + """Test dating.date_in_n_days""" + for n in [-100, -2, -1, 0, 1, 2, 1000]: + date = datetime.now() + timedelta(days=n) + self.assertEqual(tested_date_in_n_days(n), + date.strftime(TESTING_DATE_FORMAT)) + + def test_Day_datetime_weekday_neighbor_dates(self) -> None: + """Test Day's date parsing and neighbourhood resolution.""" + self.assertEqual(datetime(2024, 5, 1), Day('2024-05-01').datetime) + self.assertEqual('Sunday', Day('2024-03-17').weekday) + self.assertEqual('March', Day('2024-03-17').month_name) + self.assertEqual('2023-12-31', Day('2024-01-01').prev_date) + self.assertEqual('2023-03-01', Day('2023-02-28').next_date) class TestsWithDB(TestCaseWithDB): """Tests requiring DB, but not server setup.""" + checked_class = Day + default_ids = ('2024-01-01', '2024-01-02', '2024-01-03') - def check_storage(self, content: list[Day]) -> None: - """Test cache and DB equal content.""" - expected_cache = {} - for item in content: - expected_cache[item.id_] = item - self.assertEqual(Day.get_cache(), expected_cache) - db_found: list[Day] = [] - for item in content: - assert isinstance(item.id_, str) - for row in self.db_conn.row_where(Day.table_name, 'id', item.id_): - db_found += [Day.from_table_row(self.db_conn, row)] - self.assertEqual(sorted(content), sorted(db_found)) - - def test_Day_saving_and_caching(self) -> None: - """Test .save/.save_core.""" - date = '2024-01-01' - comment = 'comment' - day = Day(date, comment) - # check object init itself doesn't store anything yet - self.check_storage([]) - # check saving stores in cache and DB - day.save(self.db_conn) - self.check_storage([day]) - # check attributes set properly (and not unset by saving) - self.assertEqual(day.id_, date) - self.assertEqual(day.comment, comment) - - def test_Day_by_id(self) -> None: - """Test .by_id().""" - date1 = '2024-01-01' - date2 = '2024-01-02' - # check failure if not yet saved - day1 = Day(date1) - with self.assertRaises(NotFoundException): - Day.by_id(self.db_conn, date1) - # check identity of saved and retrieved - day1.save(self.db_conn) - self.assertEqual(day1, Day.by_id(self.db_conn, date1)) - # check create=True acts like normal instantiation (sans saving) - by_id_created = Day.by_id(self.db_conn, date2, create=True) - self.assertEqual(Day(date2), by_id_created) - self.check_storage([day1]) - - def test_Day_all(self) -> None: - """Test Day.all(), especially in regards to date range filtering.""" - date1 = '2024-01-01' - date2 = '2024-01-02' - date3 = '2024-01-03' - day1 = Day(date1) - day2 = Day(date2) - day3 = Day(date3) - day1.save(self.db_conn) - day3.save(self.db_conn) - # check that all() shows all saved, but no unsaved items - self.assertEqual(Day.all(self.db_conn), - [day1, day3]) - day2.save(self.db_conn) - self.assertEqual(Day.all(self.db_conn), - [day1, day2, day3]) - # check empty date range values show everything - self.assertEqual(Day.all(self.db_conn, ('', '')), - [day1, day2, day3]) - # check date range is a closed interval - self.assertEqual(Day.all(self.db_conn, (date1, date3)), - [day1, day2, day3]) - # check first date range value excludes what's earlier - self.assertEqual(Day.all(self.db_conn, (date2, date3)), - [day2, day3]) - self.assertEqual(Day.all(self.db_conn, (date3, '')), - [day3]) - # check second date range value excludes what's later - self.assertEqual(Day.all(self.db_conn, ('', date2)), - [day1, day2]) - # check swapped (impossible) date range returns emptiness - self.assertEqual(Day.all(self.db_conn, (date3, date1)), - []) - # check fill_gaps= instantiates unsaved dates within date range - # (but does not store them) - day4 = Day('2024-01-04') - day5 = Day('2024-01-05') - day6 = Day('2024-01-06') - day6.save(self.db_conn) - self.assertEqual(Day.all(self.db_conn, (date2, '2024-01-07'), - fill_gaps=True), - [day2, day3, day4, day5, day6]) - self.check_storage([day1, day2, day3, day6]) - # check 'today' is interpreted as today's date - today = Day(todays_date()) - today.save(self.db_conn) - self.assertEqual(Day.all(self.db_conn, ('today', 'today')), [today]) - - def test_Day_remove(self) -> None: - """Test .remove() effects on DB and cache.""" - date = '2024-01-01' - day = Day(date) - day.save(self.db_conn) - day.remove(self.db_conn) - self.check_storage([]) + def test_Day_by_date_range_with_limits(self) -> None: + """Test .by_date_range_with_limits.""" + self.check_by_date_range_with_limits('id', set_id_field=False) + + def test_Day_with_filled_gaps(self) -> None: + """Test .with_filled_gaps.""" - def test_Day_singularity(self) -> None: - """Test pointers made for single object keep pointing to it.""" - day = Day('2024-01-01') + def test(range_indexes: tuple[int, int], indexes_to_provide: list[int] + ) -> None: + start_i, end_i = range_indexes + days_provided = [] + days_expected = days_sans_comment[:] + for i in indexes_to_provide: + day_with_comment = days_with_comment[i] + days_provided += [day_with_comment] + days_expected[i] = day_with_comment + days_expected = days_expected[start_i:end_i+1] + start, end = dates[start_i], dates[end_i] + days_result = self.checked_class.with_filled_gaps(days_provided, + start, end) + self.assertEqual(days_result, days_expected) + + # for provided Days we use those from days_with_comment, to identify + # them against same-dated mere filler Days by their lack of comment + # (identity with Day at the respective position in days_sans_comment) + dates = [f'2024-02-0{n+1}' for n in range(9)] + days_with_comment = [Day(date, comment=date[-1:]) for date in dates] + days_sans_comment = [Day(date, comment='') for date in dates] + # check provided Days recognizable in (full-range) interval + test((0, 8), [0, 4, 8]) + # check limited range, but limiting Days provided + test((2, 6), [2, 5, 6]) + # check Days within range but beyond provided Days also filled in + test((1, 7), [2, 5]) + # check provided Days beyond range ignored + test((3, 5), [1, 2, 4, 6, 7]) + # check inversion of start_date and end_date returns empty list + test((5, 3), [2, 4, 6]) + # check empty provision still creates filler elements in interval + test((3, 5), []) + # check single-element selection creating only filler beyond provided + test((1, 1), [2, 4, 6]) + # check (un-saved) filler Days don't show up in cache or DB + # dates = [f'2024-02-0{n}' for n in range(1, 6)] + day = Day(dates[3]) day.save(self.db_conn) - retrieved_day = Day.by_id(self.db_conn, '2024-01-01') - day.comment = 'foo' - self.assertEqual(retrieved_day.comment, 'foo') + self.checked_class.with_filled_gaps([day], dates[0], dates[-1]) + self.check_identity_with_cache_and_db([day]) + # check 'today', 'yesterday', 'tomorrow' are interpreted + yesterday = Day('yesterday') + tomorrow = Day('tomorrow') + today = Day('today') + result = self.checked_class.with_filled_gaps([today], 'yesterday', + 'tomorrow') + self.assertEqual(result, [yesterday, today, tomorrow]) + + +class ExpectedGetCalendar(Expected): + """Builder of expectations for GET /calendar.""" + + def __init__(self, start: int, end: int, *args: Any, **kwargs: Any + ) -> None: + self._fields = {'start': _testing_date_in_n_days(start), + 'end': _testing_date_in_n_days(end), + 'today': _testing_date_in_n_days(0)} + self._fields['days'] = [_testing_date_in_n_days(i) + for i in range(start, end+1)] + super().__init__(*args, **kwargs) + for date in self._fields['days']: + self.lib_set('Day', [self.day_as_dict(date)]) + + +class ExpectedGetDay(Expected): + """Builder of expectations for GET /day.""" + _default_dict = {'make_type': ''} + _on_empty_make_temp = ('Day', 'day_as_dict') + + def __init__(self, date: str, *args: Any, **kwargs: Any) -> None: + self._fields = {'day': date} + super().__init__(*args, **kwargs) + + def recalc(self) -> None: + super().recalc() + todos = [t for t in self.lib_all('Todo') + if t['date'] == self._fields['day']] + self.lib_get('Day', self._fields['day'])['todos'] = self.as_ids(todos) + self._fields['top_nodes'] = [ + {'children': [], 'seen': False, 'todo': todo['id']} + for todo in todos] + for todo in todos: + proc = self.lib_get('Process', todo['process_id']) + for title in ['conditions', 'enables', 'blockers', 'disables']: + todo[title] = proc[title] + conds_present = set() + for todo in todos: + for title in ['conditions', 'enables', 'blockers', 'disables']: + for cond_id in todo[title]: + conds_present.add(cond_id) + self._fields['conditions_present'] = list(conds_present) + for prefix in ['en', 'dis']: + blers = {} + for cond_id in conds_present: + blers[str(cond_id)] = self.as_ids( + [t for t in todos if cond_id in t[f'{prefix}ables']]) + self._fields[f'{prefix}ablers_for'] = blers + self._fields['processes'] = self.as_ids(self.lib_all('Process')) class TestsWithServer(TestCaseWithServer): """Tests against our HTTP server/handler (and database).""" - def test_do_GET(self) -> None: - """Test /day and /calendar response codes, and / redirect.""" - self.check_get('/day', 200) - self.check_get('/day?date=3000-01-01', 200) - self.check_get('/day?date=FOO', 400) - self.check_get('/calendar', 200) - self.check_get('/calendar?start=&end=', 200) - self.check_get('/calendar?start=today&end=today', 200) - self.check_get('/calendar?start=2024-01-01&end=2025-01-01', 200) - self.check_get('/calendar?start=foo', 400) + def test_basic_GET_day(self) -> None: + """Test basic (no Processes/Conditions/Todos) GET /day basics.""" + # check illegal date parameters + self.check_get('/day?date=foo', 400) + self.check_get('/day?date=2024-02-30', 400) + # check undefined day + date = _testing_date_in_n_days(0) + exp = ExpectedGetDay(date) + self.check_json_get('/day', exp) + # check defined day, with and without make_type parameter + date = '2024-01-01' + exp = ExpectedGetDay(date) + exp.set('make_type', 'bar') + self.check_json_get(f'/day?date={date}&make_type=bar', exp) + # check parsing of 'yesterday', 'today', 'tomorrow' + for name, dist in [('yesterday', -1), ('today', 0), ('tomorrow', +1)]: + date = _testing_date_in_n_days(dist) + exp = ExpectedGetDay(date) + self.check_json_get(f'/day?date={name}', exp) + + def test_fail_POST_day(self) -> None: + """Test malformed/illegal POST /day requests.""" + # check payloads lacking minimum expecteds + url = '/day?date=2024-01-01' + self.check_post({}, url, 400) + self.check_post({'day_comment': ''}, url, 400) + self.check_post({'make_type': ''}, url, 400) + # to next check illegal new_todo values, we need an actual Process + self.post_exp_process([], {}, 1) + # check illegal new_todo values + post: dict[str, object] + post = {'make_type': '', 'day_comment': '', 'new_todo': ['foo']} + self.check_post(post, url, 400) + post['new_todo'] = [1, 2] # no Process of .id_=2 exists + # to next check illegal old_todo inputs, we need to first post Todo + post['new_todo'] = [1] + self.check_post(post, url, 302, '/day?date=2024-01-01&make_type=') + # check illegal old_todo inputs (equal list lengths though) + post = {'make_type': '', 'day_comment': '', 'comment': ['foo'], + 'effort': [3.3], 'done': [], 'todo_id': [1]} + self.check_post(post, url, 302, '/day?date=2024-01-01&make_type=') + post['todo_id'] = [2] # reference to non-existant Process + self.check_post(post, url, 404) + post['todo_id'] = ['a'] + self.check_post(post, url, 400) + post['todo_id'] = [1] + post['done'] = ['foo'] + self.check_post(post, url, 400) + post['done'] = [2] # reference to non-posted todo_id + self.check_post(post, url, 400) + post['done'] = [] + post['effort'] = ['foo'] + self.check_post(post, url, 400) + post['effort'] = [None] + self.check_post(post, url, 400) + post['effort'] = [3.3] + # check illegal old_todo inputs: unequal list lengths + post['comment'] = [] + self.check_post(post, url, 400) + post['comment'] = ['foo', 'foo'] + self.check_post(post, url, 400) + post['comment'] = ['foo'] + post['effort'] = [] + self.check_post(post, url, 400) + post['effort'] = [3.3, 3.3] + self.check_post(post, url, 400) + post['effort'] = [3.3] + post['todo_id'] = [1, 1] + self.check_post(post, url, 400) + post['todo_id'] = [1] + # # check valid POST payload on bad paths + self.check_post(post, '/day', 400) + self.check_post(post, '/day?date=', 400) + self.check_post(post, '/day?date=foo', 400) + + def test_basic_POST_day(self) -> None: + """Test basic (no Processes/Conditions/Todos) POST /day. + + Check POST requests properly parse 'today', 'tomorrow', 'yesterday', + and actual date strings; + preserve 'make_type' setting in redirect even if nonsensical; + and store 'day_comment'. + """ + for name, dist, test_str in [('2024-01-01', None, 'a'), + ('today', 0, 'b'), + ('yesterday', -1, 'c'), + ('tomorrow', +1, 'd')]: + date = name if dist is None else _testing_date_in_n_days(dist) + post = {'day_comment': test_str, 'make_type': f'x:{test_str}'} + post_url = f'/day?date={name}' + redir_url = f'{post_url}&make_type={post["make_type"]}' + self.check_post(post, post_url, 302, redir_url) + exp = ExpectedGetDay(date) + exp.set_day_from_post(date, post) + self.check_json_get(post_url, exp) + + def test_GET_day_with_processes_and_todos(self) -> None: + """Test GET /day displaying Processes and Todos (no trees).""" + date = '2024-01-01' + exp = ExpectedGetDay(date) + # check Processes get displayed in ['processes'] and ['_library'], + # even without any Todos referencing them + proc_posts = [{'title': 'foo', 'description': 'oof', 'effort': 1.1}, + {'title': 'bar', 'description': 'rab', 'effort': 0.9}] + for i, proc_post in enumerate(proc_posts): + self.post_exp_process([exp], proc_post, i+1) + self.check_json_get(f'/day?date={date}', exp) + # post Todos of either process and check their display + self.post_exp_day([exp], {'new_todo': [1, 2]}) + self.check_json_get(f'/day?date={date}', exp) + # test malformed Todo manipulation posts + post_day = {'day_comment': '', 'make_type': '', 'comment': [''], + 'new_todo': [], 'done': [1], 'effort': [2.3]} + self.check_post(post_day, f'/day?date={date}', 400) # no todo_id + post_day['todo_id'] = [2] # not identifying Todo refered by done + self.check_post(post_day, f'/day?date={date}', 400) + post_day['todo_id'] = [1, 2] # imply range beyond that of effort etc. + self.check_post(post_day, f'/day?date={date}', 400) + post_day['comment'] = ['FOO', ''] + self.check_post(post_day, f'/day?date={date}', 400) + post_day['effort'] = [2.3, ''] + post_day['comment'] = [''] + self.check_post(post_day, f'/day?date={date}', 400) + # add a comment to one Todo and set the other's doneness and effort + post_day['comment'] = ['FOO', ''] + self.post_exp_day([exp], post_day) + self.check_json_get(f'/day?date={date}', exp) + # invert effort and comment between both Todos + # (cannot invert doneness, /day only collects positive setting) + post_day['comment'] = ['', 'FOO'] + post_day['effort'] = ['', 2.3] + self.post_exp_day([exp], post_day) + self.check_json_get(f'/day?date={date}', exp) + + def test_POST_day_todo_make_types(self) -> None: + """Test behavior of POST /todo on 'make_type'='full' and 'empty'.""" + date = '2024-01-01' + exp = ExpectedGetDay(date) + # create two Processes, with second one step of first one + self.post_exp_process([exp], {}, 2) + self.post_exp_process([exp], {'new_top_step': 2}, 1) + exp.lib_set('ProcessStep', [exp.procstep_as_dict(1, 1, 2, None)]) + self.check_json_get(f'/day?date={date}', exp) + # post Todo of adopting Process, with make_type=full + self.post_exp_day([exp], {'make_type': 'full', 'new_todo': [1]}) + exp.lib_get('Todo', 1)['children'] = [2] + exp.lib_set('Todo', [exp.todo_as_dict(2, 2)]) + top_nodes = [{'todo': 1, + 'seen': False, + 'children': [{'todo': 2, + 'seen': False, + 'children': []}]}] + exp.force('top_nodes', top_nodes) + self.check_json_get(f'/day?date={date}', exp) + # post another Todo of adopting Process, expect to adopt existing + self.post_exp_day([exp], {'make_type': 'full', 'new_todo': [1]}) + exp.lib_set('Todo', [exp.todo_as_dict(3, 1, children=[2])]) + top_nodes += [{'todo': 3, + 'seen': False, + 'children': [{'todo': 2, + 'seen': True, + 'children': []}]}] + exp.force('top_nodes', top_nodes) + self.check_json_get(f'/day?date={date}', exp) + # post another Todo of adopting Process, make_type=empty + self.post_exp_day([exp], {'make_type': 'empty', 'new_todo': [1]}) + exp.lib_set('Todo', [exp.todo_as_dict(4, 1)]) + top_nodes += [{'todo': 4, + 'seen': False, + 'children': []}] + exp.force('top_nodes', top_nodes) + self.check_json_get(f'/day?date={date}', exp) + + def test_POST_day_new_todo_order_commutative(self) -> None: + """Check that order of 'new_todo' values in POST /day don't matter.""" + date = '2024-01-01' + exp = ExpectedGetDay(date) + self.post_exp_process([exp], {}, 2) + self.post_exp_process([exp], {'new_top_step': 2}, 1) + exp.lib_set('ProcessStep', [exp.procstep_as_dict(1, 1, 2, None)]) + # make-full-day-post batch of Todos of both Processes in one order …, + self.post_exp_day([exp], {'make_type': 'full', 'new_todo': [1, 2]}) + top_nodes: list[dict[str, Any]] = [{'todo': 1, + 'seen': False, + 'children': [{'todo': 2, + 'seen': False, + 'children': []}]}] + exp.force('top_nodes', top_nodes) + exp.lib_get('Todo', 1)['children'] = [2] + self.check_json_get(f'/day?date={date}', exp) + # … and then in the other, expecting same node tree / relations + exp.lib_del('Day', date) + date = '2024-01-02' + exp.set('day', date) + day_post = {'make_type': 'full', 'new_todo': [2, 1]} + self.post_exp_day([exp], day_post, date) + exp.lib_del('Todo', 1) + exp.lib_del('Todo', 2) + top_nodes[0]['todo'] = 3 # was: 1 + top_nodes[0]['children'][0]['todo'] = 4 # was: 2 + exp.lib_get('Todo', 3)['children'] = [4] + self.check_json_get(f'/day?date={date}', exp) + + def test_GET_day_with_conditions(self) -> None: + """Test GET /day displaying Conditions and their relations.""" + date = '2024-01-01' + exp = ExpectedGetDay(date) + # check non-referenced Conditions not shown + cond_posts = [{'is_active': False, 'title': 'A', 'description': 'a'}, + {'is_active': True, 'title': 'B', 'description': 'b'}] + for i, cond_post in enumerate(cond_posts): + self.check_post(cond_post, f'/condition?id={i+1}') + self.check_json_get(f'/day?date={date}', exp) + # add Processes with Conditions, check Conditions now shown + for i, (c1, c2) in enumerate([(1, 2), (2, 1)]): + post = {'conditions': [c1], 'disables': [c1], + 'blockers': [c2], 'enables': [c2]} + self.post_exp_process([exp], post, i+1) + for i, cond_post in enumerate(cond_posts): + exp.set_cond_from_post(i+1, cond_post) + self.check_json_get(f'/day?date={date}', exp) + # add Todos in relation to Conditions, check consequence relations + self.post_exp_day([exp], {'new_todo': [1, 2]}) + self.check_json_get(f'/day?date={date}', exp) - def test_do_POST_day(self) -> None: - """Test POST /day.""" - form_data = {'comment': ''} - self.check_post(form_data, '/day', 400) - self.check_post(form_data, '/day?date=foo', 400) - self.check_post(form_data, '/day?date=2024-01-01', 302) - self.check_post({'foo': ''}, '/day?date=2024-01-01', 400) + def test_GET_calendar(self) -> None: + """Test GET /calendar responses based on various inputs, DB states.""" + # check illegal date range delimiters + self.check_get('/calendar?start=foo', 400) + self.check_get('/calendar?end=foo', 400) + # check default range for expected selection/order without saved days + exp = ExpectedGetCalendar(-1, 366) + self.check_json_get('/calendar', exp) + self.check_json_get('/calendar?start=&end=', exp) + # check with named days as delimiters + exp = ExpectedGetCalendar(-1, +1) + self.check_json_get('/calendar?start=yesterday&end=tomorrow', exp) + # check zero-element range + exp = ExpectedGetCalendar(+1, 0) + self.check_json_get('/calendar?start=tomorrow&end=today', exp) + # check saved day shows up in results, proven by its comment + start_date = _testing_date_in_n_days(-5) + date = _testing_date_in_n_days(-2) + end_date = _testing_date_in_n_days(+5) + exp = ExpectedGetCalendar(-5, +5) + self.post_exp_day([exp], {'day_comment': 'foo'}, date) + url = f'/calendar?start={start_date}&end={end_date}' + self.check_json_get(url, exp)