[DEV-2766] NetworkTrace/Traversal now correctly respects can_stop_on_start when providing multiple start items.

Signed-off-by: Max Chesterfield <max.chesterfield@zepben.com>

Author: chestm007

changelog.md

@@ -23,12 +23,14 @@
 ### Fixes
 * When finding `LvFeeders` in the `Site` we will now exclude `LvFeeders` that start with an open `Switch`
 * The follow fixes were added to Traversal and NetworkTrace:
-  * `canStopAtStartItem` now works for branching traversals.
+  * `can_stop_on_start_item` now works for branching traversals.
   * Traversal start items are added to the queue before traversal starts, so that the start items honour the queue type order.
-  * Stop conditions on the `NetworkTrace` now are checked based on a step type, like `QueueCondition` does, rather than by checking `canActionItem`.
+  * Stop conditions on the `NetworkTrace` now are checked based on a step type, like `QueueCondition` does, rather than by checking `can_action_item`.
   * `Cut` and `Clamp` are now correctly supported in `SetDirection` and `DirectionCondition`.
   * `NetworkTrace` now handles starting on `Cut` , `Clamp`, and `AcLineSegment` and their terminals in a explicit / sensible way.
   * `NetworkTracePathProvider` now correctly handles next paths when starting on a `Clamp` terminal.
+* `NetworkTrace`/`Traversal` now correctly respects `can_stop_on_start_item` when providing multiple start items.
+
 
 ### Notes
 * None.

src/zepben/evolve/__init__.py

@@ -436,6 +436,5 @@
 from zepben.evolve.services.network.tracing.phases.set_phases import *
 
 from zepben.evolve.testing.test_network_builder import *
-from zepben.evolve.testing.test_traversal import *
 
 # @formatter:on

src/zepben/evolve/services/network/tracing/traversal/traversal.py

@@ -280,7 +280,7 @@ def add_step_action(self, action: Union[StepActionFunc, StepAction[T]]) -> D:
 
         raise RuntimeError(f'Condition [{action.__class__.__name__}] does not match expected: [StepAction | StepActionWithContextValue | Callable]')
 
-    def if_not_stopping(self, action: Callable) -> D:
+    def if_not_stopping(self, action: Callable[[T, StepContext], None]) -> D:
         """
         Adds an action to be performed on each item that does not match any stop condition.
 
@@ -291,7 +291,7 @@ def if_not_stopping(self, action: Callable) -> D:
         return self
 
 
-    def if_stopping(self, action: Callable) -> D:
+    def if_stopping(self, action: Callable[[T, StepContext], None]) -> D:
         """
         Adds an action to be performed on each item that matches a stop condition.
 
@@ -449,10 +449,10 @@ async def _traverse(self, can_stop_on_start_item: bool):
             else:
                 self.queue.append(start_item)
 
-        can_stop = can_stop_on_start_item
         while self.queue.has_next():
             current = self.queue.pop()
             context = self._get_step_context(current)
+            can_stop = can_stop_on_start_item or (not context.is_start_item)
             if self.can_visit_item(current, context):
                 context.is_stopping = can_stop and self.matches_any_stop_condition(current, context)
 
@@ -464,7 +464,6 @@ async def _traverse(self, can_stop_on_start_item: bool):
                 if not context.is_stopping:
                     self.queue_next(current, context)
 
-                can_stop = True
 
     def _get_step_context(self, item: T) -> StepContext:
         try:

src/zepben/evolve/testing/test_traversal.py

@@ -11,7 +11,7 @@
 import pytest
 
 from services.network.tracing.networktrace.test_network_trace_step_path_provider import PathTerminal, _verify_paths
-from zepben.evolve import AcLineSegment, Clamp, Terminal, NetworkTraceStep, Cut, ConductingEquipment, TraversalQueue, Junction, ngen
+from zepben.evolve import AcLineSegment, Clamp, Terminal, NetworkTraceStep, Cut, ConductingEquipment, TraversalQueue, Junction, ngen, NetworkTraceActionType
 from zepben.evolve.services.network.tracing.networktrace.tracing import Tracing
 from zepben.evolve.testing.test_network_builder import TestNetworkBuilder
 
@@ -178,8 +178,7 @@ async def test_can_Stop_on_start_item_when_running_from_conducting_equipment_bra
         assert set(map(lambda it: (it.num_equipment_steps, it.path.to_equipment.mrid), steps)) \
                == {(0, 'b0')}
 
-    if 'TOX_ENV_NAME' not in os.environ:
-
+    if 'TOX_ENV_NAME' not in os.environ:  # Skips the test during tox runs as variable hardware will affect speed
         @pytest.mark.asyncio
         async def test_can_run_large_branching_traces(self):
             try:
@@ -202,3 +201,27 @@ async def test_can_run_large_branching_traces(self):
             except Exception as e:
                 sys.setrecursionlimit(1000)  # back to default
                 raise e
+
+    @pytest.mark.asyncio
+    async def test_multiple_start_items_can_stop_on_start_doesnt_prevent_stop_checks_when_visiting_via_loop(self):
+        ns = (TestNetworkBuilder()
+              .from_acls()  # c0
+              .to_acls()  # c1
+              .to_acls()  # c2
+              .connect_to('c0')
+              ).network
+
+        stop_checks: List[str] = []
+        steps: List[str] = []
+
+        def stop_condition(item, _):
+            stop_checks.append(item.path.to_terminal.mrid)
+            return item.path.to_equipment.mrid == 'c1'
+
+        trace = Tracing.network_trace(action_step_type=NetworkTraceActionType.ALL_STEPS) \
+            .add_stop_condition(stop_condition) \
+            .if_not_stopping(lambda item, _: steps.append(item.path.to_terminal.mrid))
+        await trace.run(ns.get('c1', ConductingEquipment), can_stop_on_start_item=False)
+
+        assert stop_checks == ['c2-t1', 'c2-t2', 'c0-t1', 'c0-t2', 'c1-t1']
+        assert steps == ['c1-t2', 'c2-t1', 'c2-t2', 'c0-t1', 'c0-t2']

test/services/network/tracing/networktrace/test_network_trace.py

@@ -363,3 +363,16 @@ async def test_start_items_are_queued_before_traversal_starts_so_queue_type_is_h
                ).run()
 
         assert steps == [-1, 1, -2, 2]
+
+    @pytest.mark.asyncio
+    async def test_multiple_start_items_respect_can_stop_on_start(self):
+        steps = []
+        traversal = (_create_traversal(queue=TraversalQueue.breadth_first())
+                    .add_stop_condition(lambda item, x: True)
+                    .add_step_action(lambda item, x: steps.append(item))
+                    .add_start_item(1)
+                    .add_start_item(11)
+                    )
+        await traversal.run(can_stop_on_start_item=False)
+
+        assert steps == [1, 11, 2, 12]