More tests refactoring.

[plomtask] / tests / conditions.py

diff --git a/tests/conditions.py b/tests/conditions.py
index 40d7c486fe7b05f2ed7f447e2cf58cd435546ebb..c9b516418f73bf3700f213bc36d0c00235bab5dc 100644 (file)
--- a/tests/conditions.py
+++ b/tests/conditions.py
@@ -1,57 +1,65 @@
 """Test Conditions module."""
-from tests.utils import TestCaseWithDB, TestCaseWithServer
+from tests.utils import TestCaseWithDB, TestCaseWithServer, TestCaseSansDB
 from plomtask.conditions import Condition
 from plomtask.processes import Process
-from plomtask.exceptions import NotFoundException, HandledException
+from plomtask.todos import Todo
+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}
+    test_versioneds = {'title': str, '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 creation and findability."""
-        condition = Condition(None, False)
-        condition.save(self.db_conn)
-        self.assertEqual(Condition.by_id(self.db_conn, 1), condition)
-        with self.assertRaises(NotFoundException):
-            self.assertEqual(Condition.by_id(self.db_conn, 0), condition)
-        with self.assertRaises(NotFoundException):
-            self.assertEqual(Condition.by_id(self.db_conn, 2), condition)
+        """Test .by_id(), including creation."""
+        self.check_by_id()
 
     def test_Condition_all(self) -> None:
         """Test .all()."""
-        self.assertEqual(Condition.all(self.db_conn), [])
-        condition_1 = Condition(None, False)
-        condition_1.save(self.db_conn)
-        self.assertEqual(Condition.all(self.db_conn), [condition_1])
-        condition_2 = Condition(None, False)
-        condition_2.save(self.db_conn)
-        self.assertEqual(Condition.all(self.db_conn), [condition_1,
-                                                       condition_2])
+        self.check_all()
 
     def test_Condition_singularity(self) -> None:
         """Test pointers made for single object keep pointing to it."""
-        condition_1 = Condition(None, False)
-        condition_1.save(self.db_conn)
-        condition_1.is_active = True
-        condition_retrieved = Condition.by_id(self.db_conn, 1)
-        self.assertEqual(True, condition_retrieved.is_active)
+        self.check_singularity('is_active', True)
 
-    def test_Condition_removal(self) -> None:
-        """Test removal of Condition."""
-        cond = Condition(None, False)
-        cond.save(self.db_conn)
-        assert isinstance(cond.id_, int)
+    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:
+        """Test .remove() effects on DB and cache."""
+        self.check_remove()
+        c = Condition(None)
         proc = Process(None)
         proc.save(self.db_conn)
-        proc.set_conditions(self.db_conn, [cond.id_], 'conditions')
-        proc.save(self.db_conn)
-        with self.assertRaises(HandledException):
-            cond.remove(self.db_conn)
-        proc.set_conditions(self.db_conn, [], 'conditions')
-        proc.save(self.db_conn)
-        cond.remove(self.db_conn)
-        self.assertEqual(Condition.all(self.db_conn), [])
+        todo = Todo(None, proc, False, '2024-01-01')
+        for depender in (proc, todo):
+            assert hasattr(depender, 'save')
+            assert hasattr(depender, 'set_conditions')
+            c.save(self.db_conn)
+            depender.save(self.db_conn)
+            depender.set_conditions(self.db_conn, [c.id_], 'conditions')
+            depender.save(self.db_conn)
+            with self.assertRaises(HandledException):
+                c.remove(self.db_conn)
+            depender.set_conditions(self.db_conn, [], 'conditions')
+            depender.save(self.db_conn)
+            c.remove(self.db_conn)
 
 
 class TestsWithServer(TestCaseWithServer):