baldertest 0.1.0b6__py3-none-any.whl → 0.1.0b7__py3-none-any.whl

_balder/_version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.1.0b6'
+__version__ = version = '0.1.0b7'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/balder_session.py

@@ -60,6 +60,8 @@ class BalderSession:
         self.collect_only: Union[bool, None] = None
         #: specifies that the tests should only be collected and resolved but not executed
         self.resolve_only: Union[bool, None] = None
+        #: specifies that all discarded variations should be printed (with information why they were discarded)
+        self.show_discarded: Union[bool, None] = None
         #: contains a number of :class:`Setup` class strings that should only be considered for the execution
         self.only_with_setup: Union[List[str], None] = None
         #: contains a number of :class:`Scenario` class strings that should only be considered for the execution
@@ -246,6 +248,10 @@ class BalderSession:
             '--resolve-only', action='store_true',
             help="specifies that the tests are only collected and resolved but not executed")
 
+        self.cmd_arg_parser.add_argument(
+            '--show-discarded', action='store_true',
+            help="specifies that all discarded variations should be printed (with information why they were discarded)")
+
         self.cmd_arg_parser.add_argument(
             '--only-with-setup', nargs="*",
             help="defines a number of Setup classes which should only be considered for the execution")
@@ -270,6 +276,7 @@ class BalderSession:
         self.working_dir = self.parsed_args.working_dir
         self.collect_only = self.parsed_args.collect_only
         self.resolve_only = self.parsed_args.resolve_only
+        self.show_discarded = self.parsed_args.show_discarded
         self.only_with_setup = self.parsed_args.only_with_setup
         self.only_with_scenario = self.parsed_args.only_with_scenario
         self.force_covered_by_duplicates = self.parsed_args.force_covered_by_duplicates
@@ -298,12 +305,6 @@ class BalderSession:
         self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager)
         self.plugin_manager.execute_filter_executor_tree(executor_tree=self.executor_tree)
 
-    def execute_executor_tree(self):
-        """
-        This method executes the :class:`ExecutorTree`.
-        """
-        self.executor_tree.execute()
-
     def run(self):
         """
         This method executes the whole session
@@ -326,11 +327,14 @@ class BalderSession:
         if not self.collect_only:
             self.solve()
             self.create_executor_tree()
-            print(f"  resolve them to {len(self.executor_tree.get_all_variation_executors())} mapping candidates")
+            count_valid = len(self.executor_tree.get_all_variation_executors())
+            count_discarded = len(self.executor_tree.get_all_variation_executors(return_discarded=True)) - count_valid
+            addon_text = f" ({count_discarded} discarded)" if self.show_discarded else ""
+            print(f"  resolve them to {count_valid} valid variations{addon_text}")
             print("")
             if not self.resolve_only:
-                self.execute_executor_tree()
+                self.executor_tree.execute(show_discarded=self.show_discarded)
             else:
-                self.executor_tree.print_tree()
+                self.executor_tree.print_tree(show_discarded=self.show_discarded)
 
         self.plugin_manager.execute_session_finished(self.executor_tree)

_balder/console/balder.py

@@ -15,6 +15,7 @@ def console_balder(cmd_args: Optional[List[str]] = None, working_dir: Union[str,
     _console_balder_debug(cmd_args=cmd_args, working_dir=working_dir)
 
 
+# pylint: disable-next=too-many-arguments
 def _console_balder_debug(cmd_args: Optional[List[str]] = None, working_dir: Union[str, pathlib.Path, None] = None,
                           cb_session_created: Optional[Callable] = None, cb_run_finished: Optional[Callable] = None,
                           cb_balder_exc: Optional[Callable] = None, cb_unexpected_exc: Optional[Callable] = None):

_balder/controllers/base_device_controller.py

@@ -58,9 +58,8 @@ class BaseDeviceController(Controller, ABC):
         This method returns the original instanced feature objects of the related device
         """
         if self._original_instanced_features is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the original instantiated features before they were set with '
-                                   '`save_all_original_instanced_features`')
+            raise RuntimeError('can not access the original instantiated features before they were set with '
+                               '`save_all_original_instanced_features`')
         return self._original_instanced_features
 
     def save_all_original_instanced_features(self):

_balder/controllers/feature_controller.py

@@ -117,13 +117,14 @@ class FeatureController(Controller):
         if self.get_method_based_for_vdevice() is not None:
             for _, method_dict in self.get_method_based_for_vdevice().items():
                 for _, vdevice_dict in method_dict.items():
-                    if for_vdevice in vdevice_dict.keys():
-                        for cur_cnn in vdevice_dict[for_vdevice]:
-                            if isinstance(cur_cnn, type):
-                                cur_cnn = cur_cnn()
-                            # clean metadata here because this is no connection between real devices
-                            cur_cnn.set_metadata_for_all_subitems(None)
-                            intersection.append(cur_cnn)
+                    if for_vdevice not in vdevice_dict.keys():
+                        continue
+                    for cur_cnn in vdevice_dict[for_vdevice]:
+                        if isinstance(cur_cnn, type):
+                            cur_cnn = cur_cnn()
+                        # clean metadata here because this is no connection between real devices
+                        cur_cnn.set_metadata_for_all_subitems(None)
+                        intersection.append(cur_cnn)
         if len(intersection) == 0:
             return [Connection()]
         return intersection
@@ -151,8 +152,7 @@ class FeatureController(Controller):
         This method returns the absolute calculated class-based-for-vdevice data for this feature.
         """
         if self._abs_cls_for_vdevice is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the absolute class based for-vdevices because they are not set')
+            raise RuntimeError('can not access the absolute class based for-vdevices because they are not set yet')
         return self._abs_cls_for_vdevice
 
     def set_class_based_for_vdevice(
@@ -718,9 +718,8 @@ class FeatureController(Controller):
         This method returns the :class:`VDevice` definitions that are the original definitions for this feature.
         """
         if self._original_vdevice_definitions is None:
-            # todo we should use a balder exception here!!
-            raise EnvironmentError('can not access the original VDevice definitions before they were set with '
-                                   '`save_all_current_vdevice_references_as_originals`')
+            raise RuntimeError('can not access the original VDevice definitions before they were set with '
+                               '`save_all_current_vdevice_references_as_originals`')
         return self._original_vdevice_definitions
 
     def save_all_current_vdevice_references_as_originals(self):

_balder/exceptions.py

@@ -158,7 +158,7 @@ class IllegalVDeviceMappingError(BalderException):
     """
 
 
-class NotApplicableVariationError(BalderException):
+class NotApplicableVariationException(BalderException):
     """
     is thrown internally after the current variation is not applicable
     """

_balder/executor/basic_executor.py

@@ -87,21 +87,21 @@ class BasicExecutor(ABC):
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
     @abstractmethod
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         """
         This method runs before the branch will be executed and before the fixture construction code of this branch
         runs.
         """
 
     @abstractmethod
-    def _body_execution(self):
+    def _body_execution(self, show_discarded):
         """
         This method runs between the fixture construction and teardown code. It should trigger the execution of the
         child branches.
         """
 
     @abstractmethod
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
         """
         This method runs after the branch was executed (also after the fixture teardown code ran)
         """
@@ -137,17 +137,29 @@ class BasicExecutor(ABC):
             if isinstance(cur_child_executor.body_result, TestcaseResult):
                 cur_child_executor.body_result.set_result(result=value, exception=None)
 
-    def has_runnable_elements(self) -> bool:
+    def has_runnable_tests(self, consider_discarded_too=False) -> bool:
         """
         This method returns true if this executor element is runnable. The method returns true if this element has
         `prev_mark=RUNNABLE` and minimum one of its children has `prev_mark=RUNNABLE` too.
+
+        :param consider_discarded_too: True if the method allows DISCARDED elements too
         """
-        if self.prev_mark != PreviousExecutorMark.RUNNABLE:
+        allowed_prev_marks = [PreviousExecutorMark.RUNNABLE]
+
+        if consider_discarded_too:
+            allowed_prev_marks.append(PreviousExecutorMark.DISCARDED)
+
+        if self.prev_mark not in allowed_prev_marks:
             return False
-        for cur_child in self.all_child_executors:
-            if cur_child.prev_mark == PreviousExecutorMark.RUNNABLE:
-                return True
-        return False
+
+        if self.all_child_executors is not None:
+            # the executor has child executors -> check them
+            for cur_child in self.all_child_executors:
+                if cur_child.has_runnable_tests(consider_discarded_too):
+                    return True
+            return False
+        else:
+            return True
 
     def get_all_base_instances_of_this_branch(
             self, with_type: Union[Type[Setup], Type[Scenario], Type[types.FunctionType]],
@@ -165,7 +177,7 @@ class BasicExecutor(ABC):
         # only go through cur_executor == ExecutorTree (do not iterate with this object)
         while cur_executor.parent_executor is not None:
             if isinstance(cur_executor.base_instance, with_type):
-                if not only_runnable_elements or cur_executor.has_runnable_elements():
+                if not only_runnable_elements or cur_executor.has_runnable_tests():
                     return [cur_executor.base_instance]
             cur_executor = cur_executor.parent_executor
 
@@ -221,32 +233,34 @@ class BasicExecutor(ABC):
                         summary[cur_key] = cur_child_dict[cur_key]
         return summary
 
-    def execute(self):
+    def execute(self, show_discarded=False):
         """
         Executes the whole branch
         """
         start_time = time.perf_counter()
-        self._prepare_execution()
+        self._prepare_execution(show_discarded=show_discarded)
 
         try:
             try:
-                self.fixture_manager.enter(self)
-                self.construct_result.set_result(ResultState.SUCCESS)
+                if self.has_runnable_tests():
+                    self.fixture_manager.enter(self)
+                    self.construct_result.set_result(ResultState.SUCCESS)
 
-                self._body_execution()
+                self._body_execution(show_discarded=show_discarded)
             except Exception as exc:
                 # this has to be a construction fixture error
                 traceback.print_exception(*sys.exc_info())
                 self.construct_result.set_result(ResultState.ERROR, exc)
             finally:
-                if self.fixture_manager.is_allowed_to_leave(self):
-                    self.fixture_manager.leave(self)
-                    self.teardown_result.set_result(ResultState.SUCCESS)
+                if self.has_runnable_tests():
+                    if self.fixture_manager.is_allowed_to_leave(self):
+                        self.fixture_manager.leave(self)
+                        self.teardown_result.set_result(ResultState.SUCCESS)
         except Exception as exc:
             # this has to be a teardown fixture error
             traceback.print_exception(*sys.exc_info())
             self.teardown_result.set_result(ResultState.ERROR, exc)
 
-        self._cleanup_execution()
+        self._cleanup_execution(show_discarded=show_discarded)
 
         self.execution_time_sec = time.perf_counter() - start_time

_balder/executor/executor_tree.py

@@ -18,6 +18,7 @@ class ExecutorTree(BasicExecutor):
     """
     This class is the root object of the executor tree structure
     """
+    LINE_LENGTH = 120
 
     def __init__(self, fixture_manager: FixtureManager):
         super().__init__()
@@ -35,18 +36,13 @@ class ExecutorTree(BasicExecutor):
 
     @property
     def all_child_executors(self) -> List[BasicExecutor]:
-        return self.setup_executors
+        return self._setup_executors
 
     @property
     def base_instance(self) -> object:
         """returns None because this element is a ExecutorTree"""
         return None
 
-    @property
-    def setup_executors(self) -> List[SetupExecutor]:
-        """returns all setup executors of this tree"""
-        return self._setup_executors
-
     @property
     def fixture_manager(self) -> FixtureManager:
         """returns the fixture manager of this tree"""
@@ -58,13 +54,13 @@ class ExecutorTree(BasicExecutor):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         pass
 
-    def _body_execution(self):
-        for cur_setup_executor in self.setup_executors:
-            if cur_setup_executor.has_runnable_elements():
-                cur_setup_executor.execute()
+    def _body_execution(self, show_discarded):
+        for cur_setup_executor in self.get_setup_executors():
+            if cur_setup_executor.has_runnable_tests(consider_discarded_too=show_discarded):
+                cur_setup_executor.execute(show_discarded=show_discarded)
             elif cur_setup_executor.prev_mark == PreviousExecutorMark.SKIP:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.SKIP)
             elif cur_setup_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
@@ -72,27 +68,31 @@ class ExecutorTree(BasicExecutor):
             else:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
         pass
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def get_setup_executors(self) -> List[SetupExecutor]:
+        """returns all setup executors of this tree"""
+        return self._setup_executors
+
     def get_all_scenario_executors(self) -> List[ScenarioExecutor]:
         """
         returns a list with all scenario executors
         """
         all_scenario_executor = []
-        for cur_setup_executor in self.setup_executors:
-            all_scenario_executor += cur_setup_executor.scenario_executors
+        for cur_setup_executor in self.get_setup_executors():
+            all_scenario_executor += cur_setup_executor.get_scenario_executors()
         return all_scenario_executor
 
-    def get_all_variation_executors(self) -> List[VariationExecutor]:
+    def get_all_variation_executors(self, return_discarded=False) -> List[VariationExecutor]:
         """
         returns a list with all variation executors
         """
         all_variation_executor = []
         for cur_scenario_executor in self.get_all_scenario_executors():
-            all_variation_executor += cur_scenario_executor.variation_executors
+            all_variation_executor += cur_scenario_executor.get_variation_executors(return_discarded=return_discarded)
         return all_variation_executor
 
     def get_all_testcase_executors(self) -> List[TestcaseExecutor]:
@@ -101,8 +101,8 @@ class ExecutorTree(BasicExecutor):
         """
         all_testcase_executor = []
         for cur_scenario_executor in self.get_all_scenario_executors():
-            for cur_variation_executor in cur_scenario_executor.variation_executors:
-                all_testcase_executor += cur_variation_executor.testcase_executors
+            for cur_variation_executor in cur_scenario_executor.get_variation_executors():
+                all_testcase_executor += cur_variation_executor.get_testcase_executors()
         return all_testcase_executor
 
     def add_setup_executor(self, setup_executor: SetupExecutor):
@@ -131,33 +131,33 @@ class ExecutorTree(BasicExecutor):
 
     def cleanup_empty_executor_branches(self):
         to_remove_executor = []
-        for cur_setup_executor in self.setup_executors:
+        for cur_setup_executor in self.get_setup_executors():
             cur_setup_executor.cleanup_empty_executor_branches()
-            if len(cur_setup_executor.scenario_executors) == 0:
+            if len(cur_setup_executor.get_scenario_executors()) == 0:
                 # remove this whole executor because it has no children anymore
                 to_remove_executor.append(cur_setup_executor)
         for cur_setup_executor in to_remove_executor:
             self._setup_executors.remove(cur_setup_executor)
 
-    def execute(self) -> None:
+    def execute(self, show_discarded=False) -> None:
         """
         This method executes this branch of the tree
         """
         start_text = "START TESTSESSION"
         end_text = "FINISH TESTSESSION"
-        line_length = 120
 
         def print_line(text):
-            full_text = int((line_length - (len(start_text) + 2)) / 2) * "=" + " " + text + " "
-            full_text += "=" * (line_length - len(full_text))
+            full_text = int((self.LINE_LENGTH - (len(start_text) + 2)) / 2) * "=" + " " + text + " "
+            full_text += "=" * (self.LINE_LENGTH - len(full_text))
             print(full_text)
 
         print_line(start_text)
         # check if there exists runnable elements
-        runnables = [cur_exec.has_runnable_elements() for cur_exec in self.setup_executors]
+        runnables = [cur_exec.has_runnable_tests(consider_discarded_too=show_discarded)
+                     for cur_exec in self.get_setup_executors()]
         one_or_more_runnable_setups = None if len(runnables) == 0 else max(runnables)
         if one_or_more_runnable_setups:
-            super().execute()
+            super().execute(show_discarded=show_discarded)
         else:
             print("NO EXECUTABLE SETUPS/SCENARIOS FOUND")
         print_line(end_text)
@@ -171,19 +171,31 @@ class ExecutorTree(BasicExecutor):
             print(f"TOTAL {cur_key.value}: {cur_val}", end="")
         print("")
 
-    def print_tree(self) -> None:
+    def print_tree(self, show_discarded=False) -> None:
         """this method is an auxiliary method which outputs the entire tree"""
         print("RESOLVING OVERVIEW", end="\n\n")
-        for cur_setup_executor in self.setup_executors:
-            for cur_scenario_executor in cur_setup_executor.scenario_executors:
-                for cur_variation_executor in cur_scenario_executor.variation_executors:
-                    print(f"Scenario `{cur_scenario_executor.base_scenario_class.__class__.__qualname__}` <-> "
+        for cur_setup_executor in self.get_setup_executors():
+            for cur_scenario_executor in cur_setup_executor.get_scenario_executors():
+                for cur_variation_executor in cur_scenario_executor.get_variation_executors(
+                        return_discarded=show_discarded):
+                    applicable = cur_variation_executor.prev_mark != PreviousExecutorMark.DISCARDED
+                    start_char = '+' if applicable else 'X'
+                    print(start_char * self.LINE_LENGTH)
+                    applicability_str = "[APPLICABLE]" if applicable else "[DISCARDED] "
+                    print(f"{start_char} {applicability_str} Scenario "
+                          f"`{cur_scenario_executor.base_scenario_class.__class__.__qualname__}` <-> "
                           f"Setup `{cur_setup_executor.base_setup_class.__class__.__qualname__}`")
                     mapping_printings = {}
                     for cur_scenario_device, cur_setup_device in cur_variation_executor.base_device_mapping.items():
                         mapping_printings[f"   {cur_scenario_device.__qualname__}"] = str(cur_setup_device.__qualname__)
                     max_len = max(len(cur_elem) for cur_elem in mapping_printings.keys())
                     for cur_key, cur_val in mapping_printings.items():
-                        print(("{:<" + str(max_len) + "} = {}").format(cur_key, cur_val))
-                    for cur_testcase_excutor in cur_variation_executor.testcase_executors:
-                        print(f"   -> Testcase<{cur_testcase_excutor.base_testcase_callable.__qualname__}>")
+                        print(("{} {:<" + str(max_len) + "} = {}").format(start_char, cur_key, cur_val))
+                    for cur_testcase_excutor in cur_variation_executor.get_testcase_executors():
+                        print(f"{start_char}    -> Testcase<{cur_testcase_excutor.base_testcase_callable.__qualname__}>")
+                    if cur_variation_executor.prev_mark == PreviousExecutorMark.DISCARDED:
+                        print(f"{start_char}")
+                        print(f"{start_char}    DISCARDED BECAUSE "
+                              f"`{cur_variation_executor.not_applicable_variation_exc.args[0]}`")
+                    print(('+' if applicable else 'X') * self.LINE_LENGTH)
+                    print('')

_balder/executor/scenario_executor.py

@@ -46,7 +46,7 @@ class ScenarioExecutor(BasicExecutor):
 
     @property
     def all_child_executors(self) -> List[VariationExecutor]:
-        return self.variation_executors
+        return self._variation_executors
 
     @property
     def parent_executor(self) -> SetupExecutor:
@@ -64,11 +64,6 @@ class ScenarioExecutor(BasicExecutor):
         """returns the :class:`Scenario` class that belongs to this executor"""
         return self._base_scenario_class
 
-    @property
-    def variation_executors(self) -> List[VariationExecutor]:
-        """returns all variation executors that are child executor of this scenario executor"""
-        return self._variation_executors
-
     @property
     def fixture_manager(self) -> FixtureManager:
         """returns the current active fixture manager that belongs to this scenario executor"""
@@ -91,13 +86,13 @@ class ScenarioExecutor(BasicExecutor):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         print(f"  SCENARIO {self.base_scenario_class.__class__.__name__}")
 
-    def _body_execution(self):
-        for cur_variation_executor in self.variation_executors:
-            if cur_variation_executor.has_runnable_elements():
-                cur_variation_executor.execute()
+    def _body_execution(self, show_discarded):
+        for cur_variation_executor in self.get_variation_executors(return_discarded=show_discarded):
+            if cur_variation_executor.has_runnable_tests(show_discarded):
+                cur_variation_executor.execute(show_discarded=show_discarded)
             elif cur_variation_executor.prev_mark == PreviousExecutorMark.SKIP:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.SKIP)
             elif cur_variation_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
@@ -105,18 +100,29 @@ class ScenarioExecutor(BasicExecutor):
             else:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
         pass
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def get_variation_executors(self, return_discarded=False) -> List[VariationExecutor]:
+        """
+        :param return_discarded: True if the method should return discarded variations too
+
+        :return: returns all variation executors that are child executor of this scenario executor
+        """
+        if not return_discarded:
+            return [cur_executor for cur_executor in self._variation_executors
+                    if cur_executor.prev_mark != PreviousExecutorMark.DISCARDED]
+        return self._variation_executors
+
     def cleanup_empty_executor_branches(self):
         """
         This method removes all sub executors that are empty and not relevant anymore.
         """
         to_remove_executor = []
-        for cur_variation_executor in self.variation_executors:
-            if len(cur_variation_executor.testcase_executors) == 0:
+        for cur_variation_executor in self.get_variation_executors():
+            if len(cur_variation_executor.get_testcase_executors()) == 0:
                 # remove this whole executor because it has no children anymore
                 to_remove_executor.append(cur_variation_executor)
         for cur_variation_executor in to_remove_executor:

_balder/executor/setup_executor.py

@@ -42,7 +42,7 @@ class SetupExecutor(BasicExecutor):
 
     @property
     def all_child_executors(self) -> List[ScenarioExecutor]:
-        return self.scenario_executors
+        return self._scenario_executors
 
     @property
     def parent_executor(self) -> ExecutorTree:
@@ -58,11 +58,6 @@ class SetupExecutor(BasicExecutor):
         """returns the base :class:`Setup` that belongs to this executor"""
         return self._base_setup_class
 
-    @property
-    def scenario_executors(self) -> List[ScenarioExecutor]:
-        """returns a list with all scenario executors that belongs to this setup executor"""
-        return self._scenario_executors
-
     @property
     def fixture_manager(self) -> FixtureManager:
         """returns the current active fixture manager for this executor"""
@@ -70,13 +65,13 @@ class SetupExecutor(BasicExecutor):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         print(f"SETUP {self.base_setup_class.__class__.__name__}")
 
-    def _body_execution(self):
-        for cur_scenario_executor in self.scenario_executors:
-            if cur_scenario_executor.has_runnable_elements():
-                cur_scenario_executor.execute()
+    def _body_execution(self, show_discarded):
+        for cur_scenario_executor in self.get_scenario_executors():
+            if cur_scenario_executor.has_runnable_tests(consider_discarded_too=show_discarded):
+                cur_scenario_executor.execute(show_discarded=show_discarded)
             elif cur_scenario_executor.prev_mark == PreviousExecutorMark.SKIP:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.SKIP)
             elif cur_scenario_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
@@ -84,16 +79,20 @@ class SetupExecutor(BasicExecutor):
             else:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
         pass
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def get_scenario_executors(self) -> List[ScenarioExecutor]:
+        """returns a list with all scenario executors that belongs to this setup executor"""
+        return self._scenario_executors
+
     def cleanup_empty_executor_branches(self):
         to_remove_executor = []
-        for cur_scenario_executor in self.scenario_executors:
+        for cur_scenario_executor in self.get_scenario_executors():
             cur_scenario_executor.cleanup_empty_executor_branches()
-            if len(cur_scenario_executor.variation_executors) == 0:
+            if len(cur_scenario_executor.get_variation_executors()) == 0:
                 # remove this whole executor because it has no children anymore
                 to_remove_executor.append(cur_scenario_executor)
         for cur_scenario_executor in to_remove_executor:

_balder/executor/testcase_executor.py

@@ -76,7 +76,7 @@ class TestcaseExecutor(BasicExecutor):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         print(f"      TEST {self.base_testcase_callable.__qualname__} ", end='')
         if self.should_be_skipped():
             self.body_result.set_result(ResultState.SKIP)
@@ -84,7 +84,7 @@ class TestcaseExecutor(BasicExecutor):
             print("[S]")
             return
 
-    def _body_execution(self):
+    def _body_execution(self, show_discarded):
         start_time = time.perf_counter()
         try:
             _, func_type = inspect_method(self.base_testcase_callable)
@@ -109,14 +109,11 @@ class TestcaseExecutor(BasicExecutor):
             self.body_result.set_result(ResultState.FAILURE, exc)
         self.test_execution_time_sec = time.perf_counter() - start_time
 
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
         print(f"[{self.body_result.get_result_as_char()}]")
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def has_runnable_elements(self) -> bool:
-        return self.prev_mark == PreviousExecutorMark.RUNNABLE
-
     def should_run(self):
         """returns true if the testcase should be executed (defined in scenario)"""
         if self.base_testcase_callable in self.parent_executor.parent_executor.all_run_tests: