delegate refinement stack to TraceState

Author: JFoederer

atest/robotMBT tests/05__repeating_scenarios/08__repetition_caused_by_refinement.robot

@@ -0,0 +1,29 @@
+*** Settings ***
+Documentation     This suite has more low-level scenarios than high-level scenarios,
+...               meaning that the high-level scenario must be repeated in order for
+...               the second low-level scenario to be reached.
+Suite Setup       Treat this test suite Model-based
+Resource          ../../resources/birthday_cards_composed.resource
+Library           robotmbt
+
+*** Test Cases ***
+Buying a card
+    When someone buys a birthday card
+    then there is a blank birthday card available
+
+high-level scenario
+    Given there is a birthday card
+    when Someone writes their name on the birthday card
+    then the birthday card has 'Someone' written on it
+
+low-level scenario A
+    Given there is a birthday card
+    when Someone writes their name in pen on the birthday card
+    then the birthday card has 'Someone' written on it
+    and there is text added in ink on the birthday card
+
+low-level scenario B
+    Given there is a birthday card
+    when Someone writes their name in pen on the birthday card
+    then the birthday card has 'Someone' written on it
+    and there is text added in ink on the birthday card

…ing_scenarios/08__impossible_trace.robot …ing_scenarios/09__impossible_trace.robotatest/robotMBT tests/05__repeating_scenarios/08__impossible_trace.robot renamed to atest/robotMBT tests/05__repeating_scenarios/09__impossible_trace.robot atest/robotMBT tests/05__repeating_scenarios/08__impossible_trace.robot renamed to atest/robotMBT tests/05__repeating_scenarios/09__impossible_trace.robot

@@ -107,7 +107,6 @@ def process_test_suite(self, in_suite, *, seed='new'):
 
     def _try_to_reach_full_coverage(self, allow_duplicate_scenarios):
         tracestate = TraceState(self.shuffled)
-        refinement_stack = []
         while not tracestate.coverage_reached():
             candidate_id = tracestate.next_candidate(retry=allow_duplicate_scenarios)
             if candidate_id is None:  # No more candidates remaining for this level
@@ -122,7 +121,7 @@ def _try_to_reach_full_coverage(self, allow_duplicate_scenarios):
                     tracestate.reject_scenario(candidate_id)
                     continue
                 previous_len = len(tracestate)
-                self._try_to_fit_in_scenario(candidate, tracestate, refinement_stack)
+                self._try_to_fit_in_scenario(candidate, tracestate)
                 if len(tracestate) > previous_len:
                     self.DROUGHT_LIMIT = 50
                     if self.__last_candidate_changed_nothing(tracestate):
@@ -146,11 +145,10 @@ def __last_candidate_changed_nothing(tracestate):
 
     def _select_scenario_variant(self, candidate_id, tracestate):
         candidate = self._scenario_with_repeat_counter(candidate_id, tracestate)
-        scenarios_in_refinement = tracestate.find_scenarios_with_active_refinement()
-        if candidate_id in [s.src_id for s in scenarios_in_refinement]:
+        if candidate_id in tracestate.active_refinements:
             # reuse previous solution for all parts in split-up scenario
             candidate = candidate.copy()
-            candidate.data_choices = scenarios_in_refinement[candidate_id].data_choices.copy()
+            candidate.data_choices = tracestate.get_remainder(candidate_id).data_choices.copy()
         else:
             candidate = self._generate_scenario_variant(candidate, tracestate.model or ModelSpace())
         return candidate
@@ -176,38 +174,36 @@ def _fail_on_step_errors(suite):
                                   for s in error_list])
             raise Exception(err_msg)
 
-    def _try_to_fit_in_scenario(self, candidate, tracestate, refinement_stack):
+    def _try_to_fit_in_scenario(self, candidate, tracestate):
         """
         Tries to insert the candidate scenario into the trace (in full or partial) and
-        updates tracestate and refinement_stack accordingly.
+        updates tracestate accordingly.
         """
         model = tracestate.model if tracestate.model else ModelSpace()
         model.new_scenario_scope()
         inserted, remainder, new_model, extra_data = self._process_scenario(candidate, model)
         if not inserted:  # insertion failed
-            model.end_scenario_scope()  # redundant??
             tracestate.reject_scenario(candidate.src_id)
             logger.debug(extra_data['fail_msg'])
             self._report_tracestate_to_user(tracestate)
         elif not remainder:  # the scenario processed in full
             new_model.end_scenario_scope()
             tracestate.confirm_full_scenario(inserted.src_id, inserted, new_model)
             logger.debug(f"Inserted scenario {inserted.src_id}, {inserted.name}")
-            if refinement_stack:
-                self._handle_refinement_exit(inserted, tracestate, refinement_stack)
+            if tracestate.is_refinement_active():
+                self._handle_refinement_exit(inserted, tracestate)
             self._report_tracestate_to_user(tracestate)
             logger.debug(f"last state:\n{tracestate.model.get_status_text()}")
         else:  # the scenario is split into two parts, ready for refinement
             logger.debug(f"Partially inserted scenario {inserted.src_id}, {inserted.name}\n"
                          f"Refinement needed at step: {remainder.steps[1]}")
             inserted.name = f"{inserted.name} (part {tracestate.highest_part(inserted.src_id)+1})"
-            tracestate.push_partial_scenario(inserted.src_id, inserted, new_model)
-            refinement_stack.append(remainder)
+            tracestate.push_partial_scenario(inserted.src_id, inserted, new_model, remainder)
             self._report_tracestate_to_user(tracestate)
             logger.debug(f"last state:\n{new_model.get_status_text()}")
 
-    def _handle_refinement_exit(self, inserted_refinement, tracestate, refinement_stack):
-        refinement_tail = refinement_stack.pop()
+    def _handle_refinement_exit(self, inserted_refinement, tracestate):
+        refinement_tail = tracestate.get_remainder(tracestate.active_refinements[-1])
         exit_conditions = refinement_tail.steps[1].model_info['OUT']
         exit_conditions_processed = False
         for expr in exit_conditions:
@@ -221,7 +217,6 @@ def _handle_refinement_exit(self, inserted_refinement, tracestate, refinement_st
 
         if not exit_conditions_processed:
             self._rewind(tracestate)  # Reject insterted scenario. Even though it fits, it is not a refinement.
-            refinement_stack.append(refinement_tail)
             logger.debug(f"Reconsidering scenario {inserted_refinement.src_id}, {inserted_refinement.name}, "
                          f"did not meet refinement conditions: {exit_conditions}")
             return
@@ -238,14 +233,13 @@ def _handle_refinement_exit(self, inserted_refinement, tracestate, refinement_st
             new_model.end_scenario_scope()
             tracestate.confirm_full_scenario(tail_inserted.src_id, tail_inserted, new_model)
             logger.debug(f"Scenario '{tail_inserted.name}' completed after refinement")
-            if refinement_stack:
-                self._handle_refinement_exit(tail_inserted, tracestate, refinement_stack)
+            if tracestate.is_refinement_active():
+                self._handle_refinement_exit(tail_inserted, tracestate)
         else:
             logger.debug(f"Partially inserted remainder of scenario {tail_inserted.src_id}, {tail_inserted.name}\n"
                          f"refinement needed at step: {remainder.steps[1]}")
             tail_inserted.name = f"{tail_inserted.name} (part {tracestate.highest_part(tail_inserted.src_id)+1})"
-            tracestate.push_partial_scenario(tail_inserted.src_id, tail_inserted, new_model)
-            refinement_stack.append(remainder)
+            tracestate.push_partial_scenario(tail_inserted.src_id, tail_inserted, new_model, remainder)
 
     @staticmethod
     def _split_for_refinement(scenario, step):
@@ -264,7 +258,9 @@ def _split_for_refinement(scenario, step):
         return (front, back)
 
     def _rewind(self, tracestate, drought_recovery=False):
-        # Todo: Rewind needs to consider refinement stack.
+        if tracestate[-1].remainder and tracestate.highest_part(tracestate[-1].remainder.src_id) > 1:
+            # When rewinding an 'in between' part, rewind both the part and the refinement
+            tracestate.rewind()
         tail = tracestate.rewind()
         while drought_recovery and tracestate.coverage_drought:
             tail = tracestate.rewind()
@@ -278,24 +274,23 @@ def _escape_robot_vars(text):
 
     @staticmethod
     def _process_scenario(scenario, model):
-        m = model.copy()
         for step in scenario.steps:
             if 'error' in step.model_info:
-                return None, None, m, dict(fail_masg=f"Error in scenario {scenario.name} "
-                                           f"at step {step}: {step.model_info['error']}")
+                return None, None, model, dict(fail_masg=f"Error in scenario {scenario.name} "
+                                               f"at step {step}: {step.model_info['error']}")
             for expr in SuiteProcessors._relevant_expressions(step):
                 try:
-                    if m.process_expression(expr, step.args) is False:
+                    if model.process_expression(expr, step.args) is False:
                         if step.gherkin_kw in ['when', None] and expr in step.model_info['OUT']:
                             part1, part2 = SuiteProcessors._split_for_refinement(scenario, step)
-                            return part1, part2, m, dict()
+                            return part1, part2, model, dict()
                         else:
-                            return None, None, m, dict(fail_msg=f"Unable to insert scenario {scenario.src_id}, "
-                                                       f"{scenario.name}, due to step '{step}': [{expr}] is False")
+                            return None, None, model, dict(fail_msg=f"Unable to insert scenario {scenario.src_id}, "
+                                                           f"{scenario.name}, due to step '{step}': [{expr}] is False")
                 except Exception as err:
-                    return None, None, m, dict(fail_msg=f"Unable to insert scenario {scenario.src_id}, {scenario.name},"
-                                               f" due to step '{step}': [{expr}] {err}")
-        return scenario.copy(), None, m, dict()
+                    return None, None, model, dict(fail_msg=f"Unable to insert scenario {scenario.src_id}, "
+                                                   f"{scenario.name}, due to step '{step}': [{expr}] {err}")
+        return scenario.copy(), None, model, dict()
 
     @staticmethod
     def _relevant_expressions(step):

robotmbt/suiteprocessors.py

@@ -49,9 +49,6 @@ def tried(self):
         """returns the indices that were rejected or previously inserted at the current position"""
         return tuple(self._tried[-1])
 
-    def coverage_reached(self):
-        return all(self.c_pool.values())
-
     @property
     def coverage_drought(self):
         """Number of scenarios since last new coverage"""
@@ -61,44 +58,64 @@ def coverage_drought(self):
     def id_trace(self):
         return [snap.id for snap in self._snapshots]
 
+    @property
+    def active_refinements(self):
+        return self._open_refinements[:]
+
+    def coverage_reached(self):
+        return all(self.c_pool.values())
+
     def get_trace(self):
         return [snap.scenario for snap in self._snapshots]
 
     def next_candidate(self, retry=False):
         for i in self.c_pool:
-            if i not in self._tried[-1] and not self._is_refinement_active(i) and self.count(i) == 0:
+            if i not in self._tried[-1] and not self.is_refinement_active(i) and self.count(i) == 0:
                 return i
         if not retry:
             return None
         for i in self.c_pool:
-            if i not in self._tried[-1] and not self._is_refinement_active(i):
+            if i not in self._tried[-1] and not self.is_refinement_active(i):
                 return i
         return None
 
     def count(self, index):
-        """Count the number of times the index is present in the trace.
-        unfinished partial scenarios are excluded."""
+        """
+        Count the number of times the index is present in the trace.
+        unfinished partial scenarios are excluded.
+        """
         return self.c_pool[index]
 
     def highest_part(self, index):
-        """Given the current trace and an index, returns the highest part number of an ongoing
-        refinement for the related scenario. Returns 0 when there is no refinement active."""
+        """
+        Given the current trace and an index, returns the highest part number of an ongoing
+        refinement for the related scenario. Returns 0 when there is no refinement active.
+        """
         for i in range(1, len(self.id_trace)+1):
             if self.id_trace[-i] == f'{index}':
                 return 0
             if self.id_trace[-i].startswith(f'{index}.'):
                 return int(self.id_trace[-i].split('.')[1])
         return 0
 
-    def _is_refinement_active(self, index):
-        return self.highest_part(index) != 0
+    def is_refinement_active(self, index=None):
+        """
+        When called with an index, returns True if that scenario is currently being refined
+        When index is ommitted, return True if any refinement is active
+        """
+        if index is None:
+            return self._open_refinements != []
+        else:
+            return self.highest_part(index) != 0
 
-    def find_scenarios_with_active_refinement(self):
-        scenarios = []
-        for i in self._open_refinements:
-            index = -self.id_trace[::-1].index(f'{i}.1')-1
-            scenarios.append(self._snapshots[index].scenario)
-        return scenarios
+    def get_remainder(self, index):
+        """
+        When pushing a partial scenario, the remainder can be passed along for safe keeping.
+        This method retrieves the remainder for the last part that was pushed.
+        """
+        last_part = self.highest_part(index)
+        index = -self.id_trace[::-1].index(f'{index}.{last_part}')-1
+        return self._snapshots[index].remainder
 
     def reject_scenario(self, i_scenario):
         """Trying a scenario excludes it from further cadidacy on this level"""
@@ -107,24 +124,24 @@ def reject_scenario(self, i_scenario):
     def confirm_full_scenario(self, index, scenario, model):
         c_drought = 0 if self.c_pool[index] == 0 else self.coverage_drought+1
         self.c_pool[index] += 1
-        if self._is_refinement_active(index):
+        if self.is_refinement_active(index):
             id = f"{index}.0"
             self._open_refinements.pop()
         else:
             id = str(index)
             self._tried[-1].append(index)
             self._tried.append([])
-        self._snapshots.append(TraceSnapShot(id, scenario, model, c_drought))
+        self._snapshots.append(TraceSnapShot(id, scenario, model, drought=c_drought))
 
-    def push_partial_scenario(self, index, scenario, model):
-        if self._is_refinement_active(index):
+    def push_partial_scenario(self, index, scenario, model, remainder=None):
+        if self.is_refinement_active(index):
             id = f"{index}.{self.highest_part(index)+1}"
         else:
             id = f"{index}.1"
             self._tried[-1].append(index)
             self._tried.append([])
             self._open_refinements.append(index)
-        self._snapshots.append(TraceSnapShot(id, scenario, model, self.coverage_drought))
+        self._snapshots.append(TraceSnapShot(id, scenario, model, remainder, self.coverage_drought))
 
     def can_rewind(self):
         return len(self._snapshots) > 0
@@ -159,9 +176,10 @@ def __len__(self):
 
 
 class TraceSnapShot:
-    def __init__(self, id, inserted_scenario, model_state, drought=0):
+    def __init__(self, id, inserted_scenario, model_state, remainder=None, drought=0):
         self.id = id
         self.scenario = inserted_scenario
+        self.remainder = remainder
         self._model = model_state.copy()
         self.coverage_drought = drought