Add suppression of implicit ProcessSteps to Process configuration.

[plomtask] / tests / processes.py

diff --git a/tests/processes.py b/tests/processes.py
index 930e56032191feb047f4662f96a0d8d68a2dfe48..7701aa0a64658d61da490669dc6d56cf9f79eb54 100644 (file)
--- a/tests/processes.py
+++ b/tests/processes.py
@@ -84,6 +84,7 @@ class TestsWithDB(TestCaseWithDB):
     def test_Process_steps(self) -> None:
         """Test addition, nesting, and non-recursion of ProcessSteps"""
         # pylint: disable=too-many-locals
+        # pylint: disable=too-many-statements
         p1, p2, p3 = self.three_processes()
         assert isinstance(p1.id_, int)
         assert isinstance(p2.id_, int)
@@ -94,13 +95,13 @@ class TestsWithDB(TestCaseWithDB):
         steps_p1 += [s_p2_to_p1]
         p1.set_steps(self.db_conn, steps_p1)
         p1_dict: dict[int, ProcessStepsNode] = {}
-        p1_dict[1] = ProcessStepsNode(p2, None, True, {}, False)
+        p1_dict[1] = ProcessStepsNode(p2, None, True, {})
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         # add step of process p3 as second (top-level) step to p1
         s_p3_to_p1 = ProcessStep(None, p1.id_, p3.id_, None)
         steps_p1 += [s_p3_to_p1]
         p1.set_steps(self.db_conn, steps_p1)
-        p1_dict[2] = ProcessStepsNode(p3, None, True, {}, False)
+        p1_dict[2] = ProcessStepsNode(p3, None, True, {})
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         # add step of process p3 as first (top-level) step to p2,
         steps_p2: list[ProcessStep] = []
@@ -108,7 +109,7 @@ class TestsWithDB(TestCaseWithDB):
         steps_p2 += [s_p3_to_p2]
         p2.set_steps(self.db_conn, steps_p2)
         # expect it as implicit sub-step of p1's second (p3) step
-        p2_dict = {3: ProcessStepsNode(p3, None, False, {}, False)}
+        p2_dict = {3: ProcessStepsNode(p3, None, False, {})}
         p1_dict[1].steps[3] = p2_dict[3]
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         # add step of process p2 as explicit sub-step to p1's second sub-step
@@ -117,21 +118,21 @@ class TestsWithDB(TestCaseWithDB):
         p1.set_steps(self.db_conn, steps_p1)
         seen_3 = ProcessStepsNode(p3, None, False, {}, True)
         p1_dict[2].steps[4] = ProcessStepsNode(p2, s_p3_to_p1.id_, True,
-                                               {3: seen_3}, False)
+                                               {3: seen_3})
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         # add step of process p3 as explicit sub-step to non-existing p1
         # sub-step (of id=999), expect it to become another p1 top-level step
         s_p3_to_p1_999 = ProcessStep(None, p1.id_, p3.id_, 999)
         steps_p1 += [s_p3_to_p1_999]
         p1.set_steps(self.db_conn, steps_p1)
-        p1_dict[5] = ProcessStepsNode(p3, None, True, {}, False)
+        p1_dict[5] = ProcessStepsNode(p3, None, True, {})
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         # add step of process p3 as explicit sub-step to p1's implicit p3
         # sub-step, expect it to become another p1 top-level step
         s_p3_to_p1_impl_p3 = ProcessStep(None, p1.id_, p3.id_, s_p3_to_p2.id_)
         steps_p1 += [s_p3_to_p1_impl_p3]
         p1.set_steps(self.db_conn, steps_p1)
-        p1_dict[6] = ProcessStepsNode(p3, None, True, {}, False)
+        p1_dict[6] = ProcessStepsNode(p3, None, True, {})
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
         self.assertEqual(p1.used_as_step_by(self.db_conn), [])
         self.assertEqual(p2.used_as_step_by(self.db_conn), [p1])
@@ -140,7 +141,7 @@ class TestsWithDB(TestCaseWithDB):
         # # expect it to eliminate implicit p3 sub-step
         # s_p3_to_p1_first_explicit = ProcessStep(None, p1.id_, p3.id_,
         #                                         s_p2_to_p1.id_)
-        # p1_dict[1].steps = {7: ProcessStepsNode(p3, 1, True, {}, False)}
+        # p1_dict[1].steps = {7: ProcessStepsNode(p3, 1, True, {})}
         # p1_dict[2].steps[4].steps[3].seen = False
         # steps_p1 += [s_p3_to_p1_first_explicit]
         # p1.set_steps(self.db_conn, steps_p1)
@@ -149,11 +150,18 @@ class TestsWithDB(TestCaseWithDB):
         s_p3_to_p2_first = ProcessStep(None, p2.id_, p3.id_, s_p3_to_p2.id_)
         steps_p2 += [s_p3_to_p2_first]
         p2.set_steps(self.db_conn, steps_p2)
-        p1_dict[1].steps[3].steps[7] = ProcessStepsNode(p3, 3, False, {},
-                                                        False)
+        p1_dict[1].steps[3].steps[7] = ProcessStepsNode(p3, 3, False, {})
         p1_dict[2].steps[4].steps[3].steps[7] = ProcessStepsNode(p3, 3, False,
                                                                  {}, True)
         self.assertEqual(p1.get_steps(self.db_conn, None), p1_dict)
+        # ensure suppressed step nodes are hidden
+        assert isinstance(s_p3_to_p2.id_, int)
+        p1.set_step_suppressions(self.db_conn, [s_p3_to_p2.id_])
+        p1_dict[1].steps[3].steps = {}
+        p1_dict[1].steps[3].is_suppressed = True
+        p1_dict[2].steps[4].steps[3].steps = {}
+        p1_dict[2].steps[4].steps[3].is_suppressed = True
+        self.assertEqual(p1.get_steps(self.db_conn), p1_dict)
 
     def test_Process_conditions(self) -> None:
         """Test setting Process.conditions/enables/disables."""