Refactor Process/ProcessStep setting and saving.

[plomtask] / tests / processes.py

diff --git a/tests/processes.py b/tests/processes.py
index 390b1302932dce72da1ebc375a5f1ec6f59d8eec..960fd707eee4345cb4350c065d9dcc974e94405f 100644 (file)
--- a/tests/processes.py
+++ b/tests/processes.py
@@ -28,61 +28,71 @@ class TestsWithDB(TestCaseWithDB):
     def setUp(self) -> None:
         super().setUp()
         self.proc1 = Process(None)
-        self.proc1.save_without_steps(self.db_conn)
+        self.proc1.save(self.db_conn)
         self.proc2 = Process(None)
-        self.proc2.save_without_steps(self.db_conn)
+        self.proc2.save(self.db_conn)
         self.proc3 = Process(None)
-        self.proc3.save_without_steps(self.db_conn)
+        self.proc3.save(self.db_conn)
 
     def test_Process_ids(self) -> None:
-        """Test Process.save_without_steps() re Process.id_."""
+        """Test Process.save() re Process.id_."""
         self.assertEqual(self.proc1.id_,
                          Process.by_id(self.db_conn, 1, create=False).id_)
         self.assertEqual(self.proc2.id_,
                          Process.by_id(self.db_conn, 2, create=False).id_)
         proc5 = Process(5)
-        proc5.save_without_steps(self.db_conn)
+        proc5.save(self.db_conn)
         self.assertEqual(proc5.id_,
                          Process.by_id(self.db_conn, 5, create=False).id_)
 
     def test_Process_steps(self) -> None:
         """Test addition, nesting, and non-recursion of ProcessSteps"""
+        def add_step(proc: Process,
+                     steps_proc: list[tuple[int | None, int, int | None]],
+                     step_tuple: tuple[int | None, int, int | None],
+                     expected_id: int) -> None:
+            steps_proc += [step_tuple]
+            proc.set_steps(self.db_conn, steps_proc)
+            steps_proc[-1] = (expected_id, step_tuple[1], step_tuple[2])
         assert self.proc2.id_ is not None
         assert self.proc3.id_ is not None
-        self.proc1.add_step(self.db_conn, None, self.proc2.id_, None)
+        steps_proc1: list[tuple[int | None, int, int | None]] = []
+        add_step(self.proc1, steps_proc1, (None, self.proc2.id_, None), 1)
         p_1_dict: dict[int, dict[str, Any]] = {1: {
             'process': self.proc2, 'parent_id': None,
             'is_explicit': True, 'steps': {}, 'seen': False
         }}
         self.assertEqual(self.proc1.get_steps(self.db_conn, None), p_1_dict)
-        s_b = self.proc1.add_step(self.db_conn, None, self.proc3.id_, None)
+        add_step(self.proc1, steps_proc1, (None, self.proc3.id_, None), 2)
+        step_2 = self.proc1.explicit_steps[-1]
         p_1_dict[2] = {
             'process': self.proc3, 'parent_id': None,
             'is_explicit': True, 'steps': {}, 'seen': False
         }
         self.assertEqual(self.proc1.get_steps(self.db_conn, None), p_1_dict)
-        s_c = self.proc2.add_step(self.db_conn, None, self.proc3.id_, None)
-        assert s_c.id_ is not None
+        steps_proc2: list[tuple[int | None, int, int | None]] = []
+        add_step(self.proc2, steps_proc2, (None, self.proc3.id_, None), 3)
         p_1_dict[1]['steps'] = {3: {
             'process': self.proc3, 'parent_id': None,
             'is_explicit': False, 'steps': {}, 'seen': False
         }}
         self.assertEqual(self.proc1.get_steps(self.db_conn, None), p_1_dict)
-        self.proc1.add_step(self.db_conn, None, self.proc2.id_, s_b.id_)
+        add_step(self.proc1, steps_proc1, (None, self.proc2.id_, step_2.id_),
+                 4)
         p_1_dict[2]['steps'][4] = {
-            'process': self.proc2, 'parent_id': s_b.id_, 'seen': False,
+            'process': self.proc2, 'parent_id': step_2.id_, 'seen': False,
             'is_explicit': True, 'steps': {3: {
                 'process': self.proc3, 'parent_id': None,
                 'is_explicit': False, 'steps': {}, 'seen': True
                 }}}
         self.assertEqual(self.proc1.get_steps(self.db_conn, None), p_1_dict)
-        self.proc1.add_step(self.db_conn, None, self.proc3.id_, 999)
+        add_step(self.proc1, steps_proc1, (None, self.proc3.id_, 999), 5)
         p_1_dict[5] = {
             'process': self.proc3, 'parent_id': None,
             'is_explicit': True, 'steps': {}, 'seen': False
         }
         self.assertEqual(self.proc1.get_steps(self.db_conn, None), p_1_dict)
-        self.proc1.add_step(self.db_conn, None, self.proc3.id_, 3)
+        add_step(self.proc1, steps_proc1, (None, self.proc3.id_, 3), 6)
         p_1_dict[6] = {
             'process': self.proc3, 'parent_id': None,
             'is_explicit': True, 'steps': {}, 'seen': False
@@ -133,7 +143,8 @@ class TestsWithDB(TestCaseWithDB):
     def test_ProcessStep_singularity(self) -> None:
         """Test pointers made for single object keep pointing to it."""
         assert self.proc2.id_ is not None
-        step = self.proc1.add_step(self.db_conn, None, self.proc2.id_, None)
+        self.proc1.set_steps(self.db_conn, [(None, self.proc2.id_, None)])
+        step = self.proc1.explicit_steps[-1]
         assert step.id_ is not None
         step_retrieved = ProcessStep.by_id(self.db_conn, step.id_)
         step.parent_step_id = 99
@@ -142,7 +153,7 @@ class TestsWithDB(TestCaseWithDB):
     def test_Process_singularity(self) -> None:
         """Test pointers made for single object keep pointing to it."""
         assert self.proc2.id_ is not None
-        self.proc1.add_step(self.db_conn, None, self.proc2.id_, None)
+        self.proc1.set_steps(self.db_conn, [(None, self.proc2.id_, None)])
         p_retrieved = Process.by_id(self.db_conn, self.proc1.id_)
         self.assertEqual(self.proc1.explicit_steps, p_retrieved.explicit_steps)