home · contact · privacy
Clean up and extend /condition[s] GET/POST tests.
authorChristian Heller <c.heller@plomlompom.de>
Fri, 21 Jun 2024 14:29:15 +0000 (16:29 +0200)
committerChristian Heller <c.heller@plomlompom.de>
Fri, 21 Jun 2024 14:29:15 +0000 (16:29 +0200)
.pylintrc
tests/conditions.py

index b4814d17d477dee4ee5ba2f67f52a04c41ba7b5d..50133a08eb3882a3fd34b04e0a208fb255ef4665 100644 (file)
--- a/.pylintrc
+++ b/.pylintrc
@@ -1,3 +1,3 @@
 [BASIC]
 init-hook='import sys; sys.path.append(".")'
-good-names-rgxs=.*_?do_(GET|POST)(_[a-z]+)?,test_[A-Z]+
+good-names-rgxs=(.*_)?(GET|POST)(_.+)?,,test_[A-Z]+
index 25a044fe88d87019334a70a9befd18c8e60818da..9fcb68cea14a0956be1e290e4e189d3ddbf0533c 100644 (file)
@@ -42,32 +42,55 @@ class TestsWithDB(TestCaseWithDB):
 class TestsWithServer(TestCaseWithServer):
     """Module tests against our HTTP server/handler (and database)."""
 
+    @classmethod
+    def GET_condition_dict(cls, cond: dict[str, object]) -> dict[str, object]:
+        """Return JSON of GET /condition to expect."""
+        return {'is_new': False,
+                'enabled_processes': [],
+                'disabled_processes': [],
+                'enabling_processes': [],
+                'disabling_processes': [],
+                'condition': cond['id'],
+                '_library': {'Condition': cls.as_refs([cond])}}
+
+    @classmethod
+    def GET_conditions_dict(cls, conds: list[dict[str, object]]
+                            ) -> dict[str, object]:
+        """Return JSON of GET /conditions to expect."""
+        library = {'Condition': cls.as_refs(conds)} if conds else {}
+        d: dict[str, object] = {'conditions': cls.as_id_list(conds),
+                                'sort_by': 'title',
+                                'pattern': '',
+                                '_library': library}
+        return d
+
+    def test_fail_POST_condition(self) -> None:
+        """Test malformed/illegal POST /condition requests."""
+        # check invalid 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_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'])
         assert isinstance(cond['_versioned'], dict)
-        expected_single: dict[str, object]
-        expected_single = {'is_new': False,
-                           'enabled_processes': [],
-                           'disabled_processes': [],
-                           'enabling_processes': [],
-                           'disabling_processes': [],
-                           'condition': cond['id'],
-                           '_library': {'Condition': self.as_refs([cond])}}
+        expected_single = self.GET_condition_dict(cond)
         self.check_json_get('/condition?id=1', expected_single)
         # … full /conditions
-        expected_all: dict[str, object]
-        expected_all = {'conditions': self.as_id_list([cond]),
-                        'sort_by': 'title', 'pattern': '',
-                        '_library': {'Condition': self.as_refs([cond])}}
+        expected_all = self.GET_conditions_dict([cond])
         self.check_json_get('/conditions', expected_all)
-        # test effect of invalid POST to existing Condition on /condition
+        # 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', expected_single)
         # test effect of POST changing title and activeness
@@ -80,7 +103,6 @@ class TestsWithServer(TestCaseWithServer):
         self.check_post({'delete': ''}, '/condition?id=1', 302, '/conditions')
         cond = self.cond_as_dict()
         assert isinstance(expected_single['_library'], dict)
-        assert isinstance(expected_single['_library']['Condition'], dict)
         expected_single['_library']['Condition'] = self.as_refs([cond])
         self.check_json_get('/condition?id=1', expected_single)
         # … full /conditions
@@ -92,84 +114,75 @@ class TestsWithServer(TestCaseWithServer):
         """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,
-                       'conditions': [1], 'disables': [1]}
-        self.post_process(1, proc_1_post)
-        proc_2_post = {'title': 'B', 'description': '', 'effort': 1.0,
-                       'enables': [1], 'blockers': [1]}
-        self.post_process(2, proc_2_post)
+        # make Condition and two Processes that among them establish all
+        # possible ConditionsRelations to it, …
+        cond_post = {'title': 'foo', 'description': 'oof', 'is_active': False}
+        self.check_post(cond_post, '/condition', 302, '/condition?id=1')
+        proc1_post = {'title': 'A', 'description': '', 'effort': 1.0,
+                      'conditions': [1], 'disables': [1]}
+        proc2_post = {'title': 'B', 'description': '', 'effort': 1.0,
+                      'enables': [1], 'blockers': [1]}
+        self.post_process(1, proc1_post)
+        self.post_process(2, proc2_post)
+        # … then check /condition displays all these properly.
         cond = self.cond_as_dict(titles=['foo'], descriptions=['oof'])
         assert isinstance(cond['id'], int)
-        proc_1 = self.proc_as_dict(conditions=[cond['id']],
-                                   disables=[cond['id']])
-        proc_2 = self.proc_as_dict(2, 'B',
-                                   blockers=[cond['id']],
-                                   enables=[cond['id']])
-        expected = {'is_new': False,
-                    'enabled_processes': self.as_id_list([proc_1]),
-                    'disabled_processes': self.as_id_list([proc_2]),
-                    'enabling_processes': self.as_id_list([proc_2]),
-                    'disabling_processes': self.as_id_list([proc_1]),
-                    'condition': cond['id'],
-                    '_library': {'Condition': self.as_refs([cond]),
-                                 'Process': self.as_refs([proc_1, proc_2])}}
+        proc1 = self.proc_as_dict(conditions=[cond['id']],
+                                  disables=[cond['id']])
+        proc2 = self.proc_as_dict(2, 'B',
+                                  blockers=[cond['id']],
+                                  enables=[cond['id']])
+        expected = self.GET_condition_dict(cond)
+        assert isinstance(expected['_library'], dict)
+        expected['enabled_processes'] = self.as_id_list([proc1])
+        expected['disabled_processes'] = self.as_id_list([proc2])
+        expected['enabling_processes'] = self.as_id_list([proc2])
+        expected['disabling_processes'] = self.as_id_list([proc1])
+        expected['_library']['Process'] = self.as_refs([proc1, proc2])
         self.check_json_get('/condition?id=1', expected)
 
     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': '',
-                                            '_library': {}}
-        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
-                         '_library': {}}
-        self.check_json_get('/conditions?sort_by=foo&pattern=bar&foo=x',
-                            expected_json)
+        expected = self.GET_conditions_dict([])
+        self.check_json_get('/conditions', expected)
+        # test on meaningless non-empty params (incl. entirely un-used key),
+        # that 'sort_by' default to 'title' (even if set to something else, as
+        # long as without handler) and 'pattern' get preserved
+        expected['pattern'] = 'bar'  # preserved despite zero effect!
+        url = '/conditions?sort_by=foo&pattern=bar&foo=x'
+        self.check_json_get(url, expected)
         # 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': self.as_id_list(cons),
-                         'sort_by': 'title',
-                         'pattern': '',
-                         '_library': {'Condition': self.as_refs(cons)}}
-        self.check_json_get('/conditions', expected_json)
+        post1 = {'is_active': False, 'title': 'foo', 'description': 'oof'}
+        post2 = {'is_active': False, 'title': 'bar', 'description': 'rab'}
+        post3 = {'is_active': True, 'title': 'baz', 'description': 'zab'}
+        self.check_post(post1, '/condition', 302, '/condition?id=1')
+        self.check_post(post2, '/condition', 302, '/condition?id=2')
+        self.check_post(post3, '/condition', 302, '/condition?id=3')
+        cond1 = self.cond_as_dict(1, False, ['foo'], ['oof'])
+        cond2 = self.cond_as_dict(2, False, ['bar'], ['rab'])
+        cond3 = self.cond_as_dict(3, True, ['baz'], ['zab'])
+        expected = self.GET_conditions_dict([cond2, cond3, cond1])
+        self.check_json_get('/conditions', expected)
         # 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'] = self.as_id_list([cond_1, cond_3, cond_2])
-        expected_json['sort_by'] = '-title'
-        self.check_json_get('/conditions?sort_by=-title', expected_json)
-        expected_json['conditions'] = self.as_id_list([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'] = self.as_id_list([cond_3, cond_1, cond_2])
-        expected_json['sort_by'] = '-is_active'
-        self.check_json_get('/conditions?sort_by=-is_active', expected_json)
+        expected['conditions'] = self.as_id_list([cond1, cond3, cond2])
+        expected['sort_by'] = '-title'
+        self.check_json_get('/conditions?sort_by=-title', expected)
+        expected['conditions'] = self.as_id_list([cond1, cond2, cond3])
+        expected['sort_by'] = 'is_active'
+        self.check_json_get('/conditions?sort_by=is_active', expected)
+        expected['conditions'] = self.as_id_list([cond3, cond1, cond2])
+        expected['sort_by'] = '-is_active'
+        self.check_json_get('/conditions?sort_by=-is_active', expected)
         # test pattern matching on title
-        cons = [cond_2, cond_3]
-        expected_json = {'conditions': self.as_id_list(cons),
-                         'sort_by': 'title', 'pattern': 'ba',
-                         '_library': {'Condition': self.as_refs(cons)}}
-        self.check_json_get('/conditions?pattern=ba', expected_json)
+        expected = self.GET_conditions_dict([cond2, cond3])
+        expected['pattern'] = 'ba'
+        self.check_json_get('/conditions?pattern=ba', expected)
         # test pattern matching on description
-        expected_json['conditions'] = self.as_id_list([cond_1])
-        assert isinstance(expected_json['_library'], dict)
-        expected_json['_library']['Condition'] = self.as_refs([cond_1])
-        expected_json['pattern'] = 'oo'
-        self.check_json_get('/conditions?pattern=oo', expected_json)
+        assert isinstance(expected['_library'], dict)
+        expected['conditions'] = self.as_id_list([cond1])
+        expected['_library']['Condition'] = self.as_refs([cond1])
+        expected['pattern'] = 'oo'
+        self.check_json_get('/conditions?pattern=oo', expected)