Minor refactoring.

[plomtask] / tests / conditions.py

diff --git a/tests/conditions.py b/tests/conditions.py
index bf04f7b674b84ab2dcad9ebe349400809d449187..1a6b08ee1c083acd121644833c096c096e685c8e 100644 (file)
--- a/tests/conditions.py
+++ b/tests/conditions.py
@@ -9,14 +9,12 @@ from plomtask.exceptions import HandledException
 class TestsSansDB(TestCaseSansDB):
     """Tests requiring no DB setup."""
     checked_class = Condition
 class TestsSansDB(TestCaseSansDB):
     """Tests requiring no DB setup."""
     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}
 
 
 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 test_remove(self) -> None:
         """Test .remove() effects on DB and cache."""
 
     def test_remove(self) -> None:
         """Test .remove() effects on DB and cache."""


@@ -24,17 +22,18 @@ class TestsWithDB(TestCaseWithDB):
         proc = Process(None)
         proc.save(self.db_conn)
         todo = Todo(None, proc, False, '2024-01-01')
         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)
         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')
+            depender.set_conditions(self.db_conn, [c.id_])

             depender.save(self.db_conn)
             with self.assertRaises(HandledException):
                 c.remove(self.db_conn)
             depender.save(self.db_conn)
             with self.assertRaises(HandledException):
                 c.remove(self.db_conn)

-            depender.set_conditions(self.db_conn, [], 'conditions')
+            depender.set_conditions(self.db_conn, [])

             depender.save(self.db_conn)
             c.remove(self.db_conn)
 
             depender.save(self.db_conn)
             c.remove(self.db_conn)
 


@@ -66,7 +65,7 @@ class TestsWithServer(TestCaseWithServer):
 
     def test_fail_POST_condition(self) -> None:
         """Test malformed/illegal POST /condition requests."""
 
     def test_fail_POST_condition(self) -> None:
         """Test malformed/illegal POST /condition requests."""

-        # check invalid POST payloads
+        # check incomplete POST payloads

         url = '/condition'
         self.check_post({}, url, 400)
         self.check_post({'title': ''}, url, 400)
         url = '/condition'
         self.check_post({}, url, 400)
         self.check_post({'title': ''}, url, 400)


@@ -77,47 +76,48 @@ class TestsWithServer(TestCaseWithServer):
         valid_payload = {'title': '', 'description': '', 'is_active': False}
         self.check_post(valid_payload, '/condition?id=foo', 400)
 
         valid_payload = {'title': '', 'description': '', 'is_active': False}
         self.check_post(valid_payload, '/condition?id=foo', 400)
 

-    def test_do_POST_condition(self) -> None:
+    def test_POST_condition(self) -> None:

         """Test (valid) POST /condition and its effect on GET /condition[s]."""
         # test valid POST's effect on …
         post = {'title': 'foo', 'description': 'oof', 'is_active': False}
         """Test (valid) POST /condition and its effect on GET /condition[s]."""
         # test valid POST's effect on …
         post = {'title': 'foo', 'description': 'oof', 'is_active': False}

-        self.check_post(post, '/condition', 302, '/condition?id=1')
+        self.check_post(post, '/condition', redir='/condition?id=1')

         # … single /condition
         # … single /condition

-        cond = self.cond_as_dict(titles=['foo'], descriptions=['oof'])
-        assert isinstance(cond['_versioned'], dict)
-        expected_single = self.GET_condition_dict(cond)
+        expected_cond = self.cond_as_dict(titles=['foo'], descriptions=['oof'])
+        assert isinstance(expected_cond['_versioned'], dict)
+        expected_single = self.GET_condition_dict(expected_cond)

         self.check_json_get('/condition?id=1', expected_single)
         # … full /conditions
         self.check_json_get('/condition?id=1', expected_single)
         # … full /conditions

-        expected_all = self.GET_conditions_dict([cond])
+        expected_all = self.GET_conditions_dict([expected_cond])

         self.check_json_get('/conditions', expected_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', expected_single)
         # test effect of POST changing title and activeness
         post = {'title': 'bar', 'description': 'oof', 'is_active': True}
         self.check_json_get('/conditions', expected_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', 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)
-        cond['_versioned']['title'][1] = 'bar'
-        cond['is_active'] = True
+        self.check_post(post, '/condition?id=1')
+        expected_cond['_versioned']['title'][1] = 'bar'
+        expected_cond['is_active'] = True

         self.check_json_get('/condition?id=1', expected_single)
         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()
+        # test deletion POST's effect, both to return id=1 into empty single, …
+        self.check_post({'delete': ''}, '/condition?id=1', redir='/conditions')
+        expected_cond = self.cond_as_dict()

         assert isinstance(expected_single['_library'], dict)
         assert isinstance(expected_single['_library'], dict)

-        expected_single['_library']['Condition'] = self.as_refs([cond])
+        expected_single['_library']['Condition'] = self.as_refs(
+                [expected_cond])

         self.check_json_get('/condition?id=1', expected_single)
         self.check_json_get('/condition?id=1', expected_single)

-        # … full /conditions
+        # … and full /conditions into empty list

         expected_all['conditions'] = []
         expected_all['_library'] = {}
         self.check_json_get('/conditions', expected_all)
 
         expected_all['conditions'] = []
         expected_all['_library'] = {}
         self.check_json_get('/conditions', expected_all)
 

-    def test_do_GET_condition(self) -> None:
+    def test_GET_condition(self) -> None:

         """More GET /condition testing, especially for Process relations."""
         # check expected default status codes
         self.check_get_defaults('/condition')
         # make Condition and two Processes that among them establish all
         # possible ConditionsRelations to it, …
         cond_post = {'title': 'foo', 'description': 'oof', 'is_active': False}
         """More GET /condition testing, especially for Process relations."""
         # check expected default status codes
         self.check_get_defaults('/condition')
         # 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')
+        self.check_post(cond_post, '/condition', redir='/condition?id=1')

         proc1_post = {'title': 'A', 'description': '', 'effort': 1.0,
                       'conditions': [1], 'disables': [1]}
         proc2_post = {'title': 'B', 'description': '', 'effort': 1.0,
         proc1_post = {'title': 'A', 'description': '', 'effort': 1.0,
                       'conditions': [1], 'disables': [1]}
         proc2_post = {'title': 'B', 'description': '', 'effort': 1.0,


@@ -125,56 +125,56 @@ class TestsWithServer(TestCaseWithServer):
         self.post_process(1, proc1_post)
         self.post_process(2, proc2_post)
         # … then check /condition displays all these properly.
         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)
-        proc1 = self.proc_as_dict(conditions=[cond['id']],
-                                  disables=[cond['id']])
+        cond_expected = self.cond_as_dict(titles=['foo'], descriptions=['oof'])
+        assert isinstance(cond_expected['id'], int)
+        proc1 = self.proc_as_dict(conditions=[cond_expected['id']],
+                                  disables=[cond_expected['id']])

         proc2 = self.proc_as_dict(2, 'B',
         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)
+                                  blockers=[cond_expected['id']],
+                                  enables=[cond_expected['id']])
+        display_expected = self.GET_condition_dict(cond_expected)
+        assert isinstance(display_expected['_library'], dict)
+        display_expected['enabled_processes'] = self.as_id_list([proc1])
+        display_expected['disabled_processes'] = self.as_id_list([proc2])
+        display_expected['enabling_processes'] = self.as_id_list([proc2])
+        display_expected['disabling_processes'] = self.as_id_list([proc1])
+        display_expected['_library']['Process'] = self.as_refs([proc1, proc2])
+        self.check_json_get('/condition?id=1', display_expected)

 
 

-    def test_do_GET_conditions(self) -> None:
+    def test_GET_conditions(self) -> None:

         """Test GET /conditions."""
         # test empty result on empty DB, default-settings on empty params
         expected = self.GET_conditions_dict([])
         self.check_json_get('/conditions', expected)
         """Test GET /conditions."""
         # test empty result on empty DB, default-settings on empty params
         expected = self.GET_conditions_dict([])
         self.check_json_get('/conditions', expected)

-        # test on meaningless non-empty params (incl. entirely un-used key),
+        # 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
         expected['pattern'] = 'bar'  # preserved despite zero effect!
         # 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!

+        expected['sort_by'] = 'title'  # for clarity (actually already set)

         url = '/conditions?sort_by=foo&pattern=bar&foo=x'
         self.check_json_get(url, expected)
         # test non-empty result, automatic (positive) sorting by title
         url = '/conditions?sort_by=foo&pattern=bar&foo=x'
         self.check_json_get(url, expected)
         # test non-empty result, automatic (positive) sorting by title

-        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')
+        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'}
+        self.check_post(post_cond1, '/condition', redir='/condition?id=1')
+        self.check_post(post_cond2, '/condition', redir='/condition?id=2')
+        self.check_post(post_cond3, '/condition', redir='/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
         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['conditions'] = self.as_id_list([cond1, cond3, cond2])

         expected['sort_by'] = '-title'
         expected['sort_by'] = '-title'

+        assert isinstance(expected['conditions'], list)
+        expected['conditions'].reverse()

         self.check_json_get('/conditions?sort_by=-title', expected)
         self.check_json_get('/conditions?sort_by=-title', expected)

-        expected['conditions'] = self.as_id_list([cond1, cond2, cond3])

         expected['sort_by'] = 'is_active'
         expected['sort_by'] = 'is_active'

+        expected['conditions'] = self.as_id_list([cond1, cond2, cond3])

         self.check_json_get('/conditions?sort_by=is_active', expected)
         self.check_json_get('/conditions?sort_by=is_active', expected)

-        expected['conditions'] = self.as_id_list([cond3, cond1, cond2])

         expected['sort_by'] = '-is_active'
         expected['sort_by'] = '-is_active'

+        expected['conditions'].reverse()

         self.check_json_get('/conditions?sort_by=-is_active', expected)
         # test pattern matching on title
         expected = self.GET_conditions_dict([cond2, cond3])
         self.check_json_get('/conditions?sort_by=-is_active', expected)
         # test pattern matching on title
         expected = self.GET_conditions_dict([cond2, cond3])


@@ -182,7 +182,7 @@ class TestsWithServer(TestCaseWithServer):
         self.check_json_get('/conditions?pattern=ba', expected)
         # test pattern matching on description
         assert isinstance(expected['_library'], dict)
         self.check_json_get('/conditions?pattern=ba', expected)
         # test pattern matching on description
         assert isinstance(expected['_library'], dict)

+        expected['pattern'] = 'of'

         expected['conditions'] = self.as_id_list([cond1])
         expected['_library']['Condition'] = self.as_refs([cond1])
         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)
+        self.check_json_get('/conditions?pattern=of', expected)