From 8c04dfb85e29c7bb68f1bfafdd3093493a7c5063 Mon Sep 17 00:00:00 2001 From: Christian Heller Date: Mon, 17 Jun 2024 22:29:25 +0200 Subject: [PATCH] Refactor Conditions GET/POST testing. --- tests/conditions.py | 153 +++++++++++++++++++++++++++----------------- tests/utils.py | 38 +++++++---- 2 files changed, 120 insertions(+), 71 deletions(-) diff --git a/tests/conditions.py b/tests/conditions.py index 2b522e6..53a75b8 100644 --- a/tests/conditions.py +++ b/tests/conditions.py @@ -1,5 +1,4 @@ """Test Conditions module.""" -from json import loads as json_loads from tests.utils import TestCaseWithDB, TestCaseWithServer, TestCaseSansDB from plomtask.conditions import Condition from plomtask.processes import Process @@ -66,75 +65,127 @@ 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.""" - - def check(path: str, expected: dict[str, object]) -> None: - self.conn.request('GET', path) - response = self.conn.getresponse() - self.assertEqual(response.status, 200) - retrieved = json_loads(response.read().decode()) - self.blank_history_keys_in(retrieved) - self.assertEqual(expected, retrieved) + @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, + 'title': {'history': {}, 'parent_id': id_}, + 'description': {'history': {}, 'parent_id': id_}} + titles = titles if titles else [] + descriptions = descriptions if descriptions else [] + for i, title in enumerate(titles): + assert isinstance(d['title'], dict) + d['title']['history'][f'[{i}]'] = title + for i, description in enumerate(descriptions): + assert isinstance(d['description'], dict) + d['description']['history'][f'[{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': [], + 'title': {'history': {'[0]': title}, 'parent_id': id_}, + 'effort': {'history': {'[0]': 1.0}, 'parent_id': id_}, + 'description': {'history': {'[0]': ''}, 'parent_id': id_}, + '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_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 = {'id': 1, 'is_active': False, - 'title': {'parent_id': 1, 'history': {'[0]': 'foo'}}, - 'description': {'parent_id': 1, 'history': {'[0]': 'oof'}}} + 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} - check('/condition?id=1', expected_single) + self.check_json_get('/condition?id=1', expected_single) # … full /conditions - expected_all = {'conditions': [cond], 'sort_by': 'title', 'pattern': ''} - check('/conditions', expected_all) + 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) - check('/condition?id=1', expected_single) + 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) + expected_single['condition']['title']['history']['[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['title']['history'] = {} - cond['description']['history'] = {} - check('/condition?id=1', expected_single) + cond = self.cond_as_dict() + expected_single['condition'] = cond + self.check_json_get('/condition?id=1', expected_single) # … full /conditions expected_all['conditions'] = [] - check('/conditions', expected_all) + self.check_json_get('/conditions', expected_all) def test_do_GET_condition(self) -> None: - """Test GET /condition.""" - form_data = {'title': 'foo', 'description': 'foo', 'is_active': False} - self.check_post(form_data, '/condition', 302, '/condition?id=1') + """More GET /condition testing, especially for Process relations.""" + # check expected default status codes self.check_get_defaults('/condition') + # 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.""" - - def check(params: str, expected_json: dict[str, object]) -> None: - self.conn.request('GET', f'/conditions{params}') - response = self.conn.getresponse() - self.assertEqual(response.status, 200) - retrieved_json = json_loads(response.read().decode()) - self.blank_history_keys_in(retrieved_json) - self.assertEqual(expected_json, retrieved_json) - # test empty result on empty DB, default-settings on empty params expected_json: dict[str, object] = {'conditions': [], 'sort_by': 'title', 'pattern': ''} - check('', expected_json) + 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 - check('?sort_by=foo&pattern=bar&foo=x', expected_json) + 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') @@ -142,41 +193,29 @@ class TestsWithServer(TestCaseWithServer): 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 = {'id': 1, 'is_active': False, - 'title': {'history': {'[0]': 'foo'}, - 'parent_id': 1}, - 'description': {'history': {'[0]': 'oof'}, - 'parent_id': 1}} - cond_2 = {'id': 2, 'is_active': False, - 'title': {'history': {'[0]': 'bar'}, - 'parent_id': 2}, - 'description': {'history': {'[0]': 'rab'}, - 'parent_id': 2}} - cond_3 = {'id': 3, 'is_active': True, - 'title': {'history': {'[0]': 'baz'}, - 'parent_id': 3}, - 'description': {'history': {'[0]': 'zab'}, - 'parent_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': ''} - check('', expected_json) + 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' - check('?sort_by=-title', expected_json) + 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' - check('?sort_by=is_active', expected_json) + 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' - check('?sort_by=-is_active', expected_json) + 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'} - check('?pattern=ba', expected_json) + self.check_json_get('/conditions?pattern=ba', expected_json) # test pattern matching on description expected_json['conditions'] = [cond_1] expected_json['pattern'] = 'oo' - check('?pattern=oo', expected_json) + self.check_json_get('/conditions?pattern=oo', expected_json) diff --git a/tests/utils.py b/tests/utils.py index 13e4f94..86d049d 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -2,6 +2,7 @@ from unittest import TestCase from threading import Thread from http.client import HTTPConnection +from json import loads as json_loads from urllib.parse import urlencode from uuid import uuid4 from os import remove as remove_file @@ -269,20 +270,29 @@ class TestCaseWithServer(TestCaseWithDB): f'/process?id={id_}') return form_data - @staticmethod - def blank_history_keys_in(d: dict[str, object]) -> None: - """Re-write "history" object keys to bracketed integer strings.""" - def walk_tree(d: Any) -> Any: - if isinstance(d, dict): - if 'history' in d.keys(): - vals = d['history'].values() + def check_json_get(self, path: str, expected: dict[str, object]) -> None: + """Compare JSON on GET path with expected. + + To simplify comparison of VersionedAttribute histories, transforms + keys under "history"-named dicts into bracketed integer strings + counting upwards in chronology. + """ + def rewrite_history_keys_in(item: Any) -> Any: + if isinstance(item, dict): + if 'history' in item.keys(): + vals = item['history'].values() history = {} for i, val in enumerate(vals): history[f'[{i}]'] = val - d['history'] = history - for k in list(d.keys()): - walk_tree(d[k]) - elif isinstance(d, list): - d[:] = [walk_tree(i) for i in d] - return d - walk_tree(d) + item['history'] = history + for k in list(item.keys()): + rewrite_history_keys_in(item[k]) + elif isinstance(item, list): + item[:] = [rewrite_history_keys_in(i) for i in item] + return item + self.conn.request('GET', path) + response = self.conn.getresponse() + self.assertEqual(response.status, 200) + retrieved = json_loads(response.read().decode()) + rewrite_history_keys_in(retrieved) + self.assertEqual(expected, retrieved) -- 2.30.2