Refactor Conditions GET/POST testing.

diff --git a/tests/conditions.py b/tests/conditions.py
index 2b522e65abbd4c1ef160f5bd1d9191b21e53d102..53a75b87de137fb2258d7183e94acbb8fab1e158 100644 (file)
--- 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 13e4f949d177a7d73456d2546db9f49de3e33fb1..86d049dac2387b97f441d228ecc3c33e9bfe6552 100644 (file)
--- 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)