X-Git-Url: https://plomlompom.com/repos/%22https:/validator.w3.org/static/git-logo.png?a=blobdiff_plain;ds=sidebyside;f=tests%2Fconditions.py;h=9b3a40383ad21d959ce8884fd5c180039d317919;hb=HEAD;hp=37a97a5c91a4dcf6a25f26b2110b77e33c91519a;hpb=5afb47e3aaed921997d11abf88a81602700639f3;p=plomtask diff --git a/tests/conditions.py b/tests/conditions.py index 37a97a5..333267f 100644 --- a/tests/conditions.py +++ b/tests/conditions.py @@ -1,5 +1,7 @@ """Test Conditions module.""" -from tests.utils import TestCaseWithDB, TestCaseWithServer, TestCaseSansDB +from typing import Any +from tests.utils import (TestCaseSansDB, TestCaseWithDB, TestCaseWithServer, + Expected) from plomtask.conditions import Condition from plomtask.processes import Process from plomtask.todos import Todo @@ -9,85 +11,161 @@ from plomtask.exceptions import HandledException class TestsSansDB(TestCaseSansDB): """Tests requiring no DB setup.""" checked_class = Condition - do_id_test = True - 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} - def test_Condition_saving_and_caching(self) -> None: - """Test .save/.save_core.""" - kwargs = {'id_': 1, 'is_active': False} - self.check_saving_and_caching(**kwargs) - # check .id_ set if None, and versioned attributes too - c = Condition(None) - c.save(self.db_conn) - self.assertEqual(c.id_, 2) - self.check_saving_of_versioned('title', str) - self.check_saving_of_versioned('description', str) - - def test_Condition_from_table_row(self) -> None: - """Test .from_table_row() properly reads in class from DB""" - self.check_from_table_row() - self.check_versioned_from_table_row('title', str) - self.check_versioned_from_table_row('description', str) - - def test_Condition_by_id(self) -> None: - """Test .by_id(), including creation.""" - self.check_by_id() - - def test_Condition_all(self) -> None: - """Test .all().""" - self.check_all() - - def test_Condition_singularity(self) -> None: - """Test pointers made for single object keep pointing to it.""" - self.check_singularity('is_active', True) - - def test_Condition_versioned_attributes_singularity(self) -> None: - """Test behavior of VersionedAttributes on saving (with .title).""" - self.check_versioned_singularity() - - def test_Condition_remove(self) -> None: + def test_remove(self) -> None: """Test .remove() effects on DB and cache.""" - self.check_remove() - c = Condition(None) + super().test_remove() proc = Process(None) proc.save(self.db_conn) todo = Todo(None, proc, False, '2024-01-01') + todo.save(self.db_conn) + # check condition can only be deleted if not depended upon 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') + assert isinstance(c.id_, int) + depender.set_condition_relations(self.db_conn, [c.id_], [], [], []) depender.save(self.db_conn) with self.assertRaises(HandledException): c.remove(self.db_conn) - depender.set_conditions(self.db_conn, [], 'conditions') + depender.set_condition_relations(self.db_conn, [], [], [], []) depender.save(self.db_conn) c.remove(self.db_conn) +class ExpectedGetConditions(Expected): + """Builder of expectations for GET /conditions.""" + _default_dict = {'sort_by': 'title', 'pattern': ''} + + def recalc(self) -> None: + """Update internal dictionary by subclass-specific rules.""" + super().recalc() + self._fields['conditions'] = self.as_ids(self.lib_all('Condition')) + + +class ExpectedGetCondition(Expected): + """Builder of expectations for GET /condition.""" + _on_empty_make_temp = ('Condition', 'cond_as_dict') + + def __init__(self, id_: int, *args: Any, **kwargs: Any) -> None: + self._fields = {'condition': id_} + super().__init__(*args, **kwargs) + + def recalc(self) -> None: + """Update internal dictionary by subclass-specific rules.""" + super().recalc() + for p_field, c_field in [('conditions', 'enabled_processes'), + ('disables', 'disabling_processes'), + ('blockers', 'disabled_processes'), + ('enables', 'enabling_processes')]: + self._fields[c_field] = self.as_ids([ + p for p in self.lib_all('Process') + if self._fields['condition'] in p[p_field]]) + self._fields['is_new'] = False + + 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))) - - 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_fail_POST_condition(self) -> None: + """Test malformed/illegal POST /condition requests.""" + # check incomplete POST payloads + url = '/condition' + self.check_post({}, url, 400) + self.check_post({'title': ''}, url, 400) + self.check_post({'title': '', 'description': ''}, url, 400) + self.check_post({'title': '', 'is_active': False}, url, 400) + self.check_post({'description': '', 'is_active': False}, url, 400) + # check valid POST payload on bad paths + valid_payload = {'title': '', 'description': '', 'is_active': False} + self.check_post(valid_payload, '/condition?id=foo', 400) + + def test_POST_condition(self) -> None: + """Test (valid) POST /condition and its effect on GET /condition[s].""" + exp_single = ExpectedGetCondition(1) + exp_all = ExpectedGetConditions() + all_exps = [exp_single, exp_all] + # test valid POST's effect on single /condition and full /conditions + post = {'title': 'foo', 'description': 'oof', 'is_active': False} + self.post_exp_cond(all_exps, 1, post, '', '?id=1') + self.check_json_get('/condition?id=1', exp_single) + self.check_json_get('/conditions', exp_all) + # test (no) effect of invalid POST to existing Condition on /condition + self.check_post({}, '/condition?id=1', 400) + self.check_json_get('/condition?id=1', exp_single) + # test effect of POST changing title and activeness + post = {'title': 'bar', 'description': 'oof', 'is_active': True} + self.post_exp_cond(all_exps, 1, post, '?id=1', '?id=1') + self.check_json_get('/condition?id=1', exp_single) + self.check_json_get('/conditions', exp_all) + # test deletion POST's effect, both to return id=1 into empty single, + # full /conditions into empty list + self.post_exp_cond(all_exps, 1, {'delete': ''}, '?id=1', 's') + self.check_json_get('/condition?id=1', exp_single) + self.check_json_get('/conditions', exp_all) + + def test_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) + # make Condition and two Processes that among them establish all + # possible ConditionsRelations to it, check /condition displays all + exp = ExpectedGetCondition(1) + cond_post = {'title': 'foo', 'description': 'oof', 'is_active': False} + self.post_exp_cond([exp], 1, cond_post, '', '?id=1') + proc1_post = {'title': 'A', 'description': '', 'effort': 1.1, + 'conditions': [1], 'disables': [1]} + proc2_post = {'title': 'B', 'description': '', 'effort': 0.9, + 'enables': [1], 'blockers': [1]} + self.post_exp_process([exp], proc1_post, 1) + self.post_exp_process([exp], proc2_post, 2) + self.check_json_get('/condition?id=1', exp) + + def test_GET_conditions(self) -> None: + """Test GET /conditions.""" + # test empty result on empty DB, default-settings on empty params + exp = ExpectedGetConditions() + self.check_json_get('/conditions', exp) + # test ignorance of meaningless non-empty params (incl. unknown key), + # that 'sort_by' default to 'title' (even if set to something else, as + # long as without handler) and 'pattern' get preserved + exp.set('pattern', 'bar') # preserved despite zero effect! + exp.set('sort_by', 'title') # for clarity (already default) + self.check_json_get('/conditions?sort_by=foo&pattern=bar&foo=x', exp) + # test non-empty result, automatic (positive) sorting by title + post_cond1 = {'is_active': False, 'title': 'foo', 'description': 'oof'} + post_cond2 = {'is_active': False, 'title': 'bar', 'description': 'rab'} + post_cond3 = {'is_active': True, 'title': 'baz', 'description': 'zab'} + for i, post in enumerate([post_cond1, post_cond2, post_cond3]): + self.post_exp_cond([exp], i+1, post, '', f'?id={i+1}') + exp.set('pattern', '') + exp.force('conditions', [2, 3, 1]) + self.check_json_get('/conditions', exp) + # test other sortings + exp.set('sort_by', '-title') + exp.force('conditions', [1, 3, 2]) + self.check_json_get('/conditions?sort_by=-title', exp) + exp.set('sort_by', 'is_active') + exp.force('conditions', [1, 2, 3]) + self.check_json_get('/conditions?sort_by=is_active', exp) + exp.set('sort_by', '-is_active') + exp.force('conditions', [3, 2, 1]) + self.check_json_get('/conditions?sort_by=-is_active', exp) + # test pattern matching on title + exp.set('sort_by', 'title') + exp.set('pattern', 'ba') + exp.force('conditions', [2, 3]) + exp.lib_del('Condition', 1) + self.check_json_get('/conditions?pattern=ba', exp) + # test pattern matching on description + exp.set('pattern', 'of') + exp.lib_wipe('Condition') + exp.set_cond_from_post(1, post_cond1) + exp.force('conditions', [1]) + self.check_json_get('/conditions?pattern=of', exp)