X-Git-Url: https://plomlompom.com/repos/berlin_corona.txt?a=blobdiff_plain;f=tests%2Fconditions.py;h=468b1e8b13499ea3c6775baf40f68cad1b646a87;hb=bdb93117ce0f2b08b7b70cf43ac086afa4689c0f;hp=51f7cc2d3e5b7a657e5baa96ab290b28cf4fe372;hpb=9ad40c43627334d7294c07bf55d196dd6760cfde;p=plomtask diff --git a/tests/conditions.py b/tests/conditions.py index 51f7cc2..468b1e8 100644 --- a/tests/conditions.py +++ b/tests/conditions.py @@ -1,131 +1,33 @@ """Test Conditions module.""" -from unittest import TestCase -from tests.utils import TestCaseWithDB, TestCaseWithServer +from tests.utils import TestCaseWithDB, TestCaseWithServer, TestCaseSansDB from plomtask.conditions import Condition from plomtask.processes import Process from plomtask.todos import Todo -from plomtask.exceptions import NotFoundException, HandledException +from plomtask.exceptions import HandledException -class TestsSansDB(TestCase): +class TestsSansDB(TestCaseSansDB): """Tests requiring no DB setup.""" - - def test_Condition_id_setting(self) -> None: - """Test .id_ being set and its legal range being enforced.""" - with self.assertRaises(HandledException): - Condition(0) - condition = Condition(5) - self.assertEqual(condition.id_, 5) + checked_class = Condition + versioned_defaults_to_test = {'title': 'UNNAMED', 'description': ''} class TestsWithDB(TestCaseWithDB): """Tests requiring DB, but not server setup.""" + checked_class = Condition + default_init_kwargs = {'is_active': False} + test_versioneds = {'title': str, 'description': str} - def check_storage(self, content: list[Condition]) -> None: - """Test cache and DB equal content.""" - expected_cache = {} - for item in content: - expected_cache[item.id_] = item - self.assertEqual(Condition.get_cache(), expected_cache) - db_found: list[Condition] = [] - for item in content: - assert isinstance(item.id_, int) - for row in self.db_conn.row_where(Condition.table_name, 'id', - item.id_): - db_found += [Condition.from_table_row(self.db_conn, row)] - self.assertEqual(sorted(content), sorted(db_found)) - - def test_Condition_saving_and_caching(self) -> None: - """Test .save/.save_core.""" - c = Condition(None, False) - c.title.set('title1') - c.title.set('title2') - c.description.set('desc1') - c.description.set('desc2') - # check object init itself doesn't store anything yet - self.check_storage([]) - # check saving stores in cache and DB - c.save(self.db_conn) - self.check_storage([c]) - # check attributes set properly (and not unset by saving) - self.assertEqual(c.id_, 1) - self.assertEqual(c.is_active, False) - self.assertEqual(sorted(c.title.history.values()), - ['title1', 'title2']) - self.assertEqual(sorted(c.description.history.values()), - ['desc1', 'desc2']) - - def test_Condition_from_table_row(self) -> None: - """Test .from_table_row() properly reads in class from DB""" - c = Condition(1, True) - c.title.set('title1') - c.title.set('title2') - c.description.set('desc1') - c.description.set('desc2') - c.save(self.db_conn) - assert isinstance(c.id_, int) - for row in self.db_conn.row_where(Condition.table_name, 'id', c.id_): - retrieved = Condition.from_table_row(self.db_conn, row) - assert isinstance(retrieved, Condition) - self.assertEqual(c, retrieved) - self.assertEqual({c.id_: c}, Condition.get_cache()) - # pylint: disable=no-member - self.assertEqual(sorted(retrieved.title.history.values()), - ['title1', 'title2']) - # pylint: disable=no-member - self.assertEqual(sorted(retrieved.description.history.values()), - ['desc1', 'desc2']) - - def test_Condition_by_id(self) -> None: - """Test .by_id(), including creation.""" - # check failure if not yet saved - c = Condition(3, False) - with self.assertRaises(NotFoundException): - Condition.by_id(self.db_conn, 3) - # check identity of saved and retrieved - c.save(self.db_conn) - self.assertEqual(c, Condition.by_id(self.db_conn, 3)) - # check create=True acts like normal instantiation (sans saving) - by_id_created = Condition.by_id(self.db_conn, 4, create=True) - self.assertEqual(Condition(4), by_id_created) - self.check_storage([c]) - - def test_Condition_all(self) -> None: - """Test .all().""" - c_1 = Condition(None, False) - # check pre-save .all() returns empty list - self.assertEqual(Condition.all(self.db_conn), []) - # check .save() fills .all() result - c_1.save(self.db_conn) - self.assertEqual(Condition.all(self.db_conn), [c_1]) - c_2 = Condition(None, True) - c_2.save(self.db_conn) - self.assertEqual(sorted(Condition.all(self.db_conn)), - sorted([c_1, c_2])) - - def test_Condition_singularity(self) -> None: - """Test pointers made for single object keep pointing to it.""" - c = Condition(None, False) - c.save(self.db_conn) - c.is_active = True - retrieved = Condition.by_id(self.db_conn, 1) - self.assertEqual(True, retrieved.is_active) - - def test_Condition_remove(self) -> None: + def test_remove(self) -> None: """Test .remove() effects on DB and cache.""" - # check only saved item can be removed - c = Condition(None, False) - with self.assertRaises(HandledException): - c.remove(self.db_conn) - c.save(self.db_conn) - c.remove(self.db_conn) - self.check_storage([]) - # check guard against deleting dependencies of other classes + super().test_remove() proc = Process(None) + proc.save(self.db_conn) todo = Todo(None, proc, False, '2024-01-01') for depender in (proc, todo): assert hasattr(depender, 'save') assert hasattr(depender, 'set_conditions') + c = Condition(None) c.save(self.db_conn) depender.save(self.db_conn) depender.set_conditions(self.db_conn, [c.id_], 'conditions') @@ -140,20 +42,162 @@ class TestsWithDB(TestCaseWithDB): class TestsWithServer(TestCaseWithServer): """Module tests against our HTTP server/handler (and database).""" - def test_do_POST_condition(self) -> None: - """Test POST /condition and its effect on the database.""" - form_data = {'title': 'foo', 'description': 'foo'} - self.check_post(form_data, '/condition', 302, '/condition?id=1') - self.assertEqual(1, len(Condition.all(self.db_conn))) - form_data['delete'] = '' - self.check_post(form_data, '/condition?id=', 404) - self.check_post(form_data, '/condition?id=2', 404) - self.check_post(form_data, '/condition?id=1', 302, '/conditions') - self.assertEqual(0, len(Condition.all(self.db_conn))) + @staticmethod + def cond_as_dict(id_: int = 1, + is_active: bool = False, + titles: None | list[str] = None, + descriptions: None | list[str] = None + ) -> dict[str, object]: + """Return JSON of Condition to expect.""" + d = {'id': id_, + 'is_active': is_active, + '_versioned': { + 'title': {}, + 'description': {} + } + } + titles = titles if titles else [] + descriptions = descriptions if descriptions else [] + assert isinstance(d['_versioned'], dict) + for i, title in enumerate(titles): + d['_versioned']['title'][i] = title + for i, description in enumerate(descriptions): + d['_versioned']['description'][i] = description + return d + + @staticmethod + def proc_as_dict(id_: int = 1, + title: str = 'A', + enables: None | list[dict[str, object]] = None, + disables: None | list[dict[str, object]] = None, + conditions: None | list[dict[str, object]] = None, + blockers: None | list[dict[str, object]] = None + ) -> dict[str, object]: + """Return JSON of Process to expect.""" + # pylint: disable=too-many-arguments + d = {'id': id_, + 'calendarize': False, + 'suppressed_steps': [], + 'explicit_steps': [], + '_versioned': { + 'title': {0: title}, + 'description': {0: ''}, + 'effort': {0: 1.0} + }, + 'conditions': conditions if conditions else [], + 'disables': disables if disables else [], + 'enables': enables if enables else [], + 'blockers': blockers if blockers else []} + return d - def test_do_GET(self) -> None: - """Test /condition and /conditions response codes.""" - form_data = {'title': 'foo', 'description': 'foo'} - self.check_post(form_data, '/condition', 302, '/condition?id=1') + def test_do_POST_condition(self) -> None: + """Test POST /condition and its effect on GET /condition[s].""" + # check empty POST fails + self.check_post({}, '/condition', 400) + # test valid POST's effect on … + post = {'title': 'foo', 'description': 'oof', 'is_active': False} + self.check_post(post, '/condition', 302, '/condition?id=1') + # … single /condition + cond = self.cond_as_dict(titles=['foo'], descriptions=['oof']) + expected_single: dict[str, object] + expected_single = {'is_new': False, + 'enabled_processes': [], + 'disabled_processes': [], + 'enabling_processes': [], + 'disabling_processes': [], + 'condition': cond} + self.check_json_get('/condition?id=1', expected_single) + # … full /conditions + expected_all: dict[str, object] + expected_all = {'conditions': [cond], + 'sort_by': 'title', 'pattern': ''} + self.check_json_get('/conditions', expected_all) + # test effect of invalid POST to existing Condition on /condition + self.check_post({}, '/condition?id=1', 400) + self.check_json_get('/condition?id=1', expected_single) + # test effect of POST changing title and activeness + post = {'title': 'bar', 'description': 'oof', 'is_active': True} + self.check_post(post, '/condition?id=1', 302) + assert isinstance(expected_single['condition'], dict) + expected_single['condition']['_versioned']['title'][1] = 'bar' + expected_single['condition']['is_active'] = True + self.check_json_get('/condition?id=1', expected_single) + # test deletion POST's effect on … + self.check_post({'delete': ''}, '/condition?id=1', 302, '/conditions') + cond = self.cond_as_dict() + expected_single['condition'] = cond + self.check_json_get('/condition?id=1', expected_single) + # … full /conditions + expected_all['conditions'] = [] + self.check_json_get('/conditions', expected_all) + + def test_do_GET_condition(self) -> None: + """More GET /condition testing, especially for Process relations.""" + # check expected default status codes self.check_get_defaults('/condition') - self.check_get('/conditions', 200) + # check display of process relations + form_data = {'title': 'foo', 'description': 'oof', 'is_active': False} + self.check_post(form_data, '/condition', 302, '/condition?id=1') + proc_1_post = {'title': 'A', 'description': '', 'effort': 1.0, + 'condition': [1], 'disables': [1]} + self.post_process(1, proc_1_post) + proc_2_post = {'title': 'B', 'description': '', 'effort': 1.0, + 'enables': [1], 'blocker': [1]} + self.post_process(2, proc_2_post) + cond = self.cond_as_dict(titles=['foo'], descriptions=['oof']) + proc_1 = self.proc_as_dict(conditions=[cond], disables=[cond]) + proc_2 = self.proc_as_dict(2, 'B', blockers=[cond], enables=[cond]) + expected_single = {'is_new': False, + 'enabled_processes': [proc_1], + 'disabled_processes': [proc_2], + 'enabling_processes': [proc_2], + 'disabling_processes': [proc_1], + 'condition': cond} + self.check_json_get('/condition?id=1', expected_single) + + def test_do_GET_conditions(self) -> None: + """Test GET /conditions.""" + # test empty result on empty DB, default-settings on empty params + expected_json: dict[str, object] = {'conditions': [], + 'sort_by': 'title', + 'pattern': ''} + self.check_json_get('/conditions', expected_json) + # test on meaningless non-empty params (incl. entirely un-used key) + expected_json = {'conditions': [], + 'sort_by': 'title', # nonsense "foo" defaulting + 'pattern': 'bar'} # preserved despite zero effect + self.check_json_get('/conditions?sort_by=foo&pattern=bar&foo=x', + expected_json) + # test non-empty result, automatic (positive) sorting by title + post_1 = {'title': 'foo', 'description': 'oof', 'is_active': False} + self.check_post(post_1, '/condition', 302, '/condition?id=1') + post_2 = {'title': 'bar', 'description': 'rab', 'is_active': False} + self.check_post(post_2, '/condition', 302, '/condition?id=2') + post_3 = {'title': 'baz', 'description': 'zab', 'is_active': True} + self.check_post(post_3, '/condition', 302, '/condition?id=3') + cond_1 = self.cond_as_dict(titles=['foo'], descriptions=['oof']) + cond_2 = self.cond_as_dict(2, titles=['bar'], descriptions=['rab']) + cond_3 = self.cond_as_dict(3, True, ['baz'], ['zab']) + cons = [cond_2, cond_3, cond_1] + expected_json = {'conditions': cons, 'sort_by': 'title', 'pattern': ''} + self.check_json_get('/conditions', expected_json) + # test other sortings + # (NB: by .is_active has two items of =False, their order currently + # is not explicitly made predictable, so mail fail until we do) + expected_json['conditions'] = [cond_1, cond_3, cond_2] + expected_json['sort_by'] = '-title' + self.check_json_get('/conditions?sort_by=-title', expected_json) + expected_json['conditions'] = [cond_1, cond_2, cond_3] + expected_json['sort_by'] = 'is_active' + self.check_json_get('/conditions?sort_by=is_active', expected_json) + expected_json['conditions'] = [cond_3, cond_1, cond_2] + expected_json['sort_by'] = '-is_active' + self.check_json_get('/conditions?sort_by=-is_active', expected_json) + # test pattern matching on title + expected_json = {'conditions': [cond_2, cond_3], + 'sort_by': 'title', 'pattern': 'ba'} + self.check_json_get('/conditions?pattern=ba', expected_json) + # test pattern matching on description + expected_json['conditions'] = [cond_1] + expected_json['pattern'] = 'oo' + self.check_json_get('/conditions?pattern=oo', expected_json)