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

_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,28 @@ 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
+        return True
 
     def get_all_base_instances_of_this_branch(
             self, with_type: Union[Type[Setup], Type[Scenario], Type[types.FunctionType]],
@@ -165,7 +176,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
 
@@ -181,10 +192,12 @@ class BasicExecutor(ABC):
         return list(set(result))
 
     @abstractmethod
-    def cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         """
         This method searches the whole tree and removes branches where an executor item has no own children. It can
         remove these branches, because they have no valid matchings.
+
+        :param consider_discarded: true if this method should consider discarded branches, otherwise False
         """
 
     def filter_tree_for_user_filters(self):
@@ -221,32 +234,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):
@@ -129,35 +129,35 @@ class ExecutorTree(BasicExecutor):
         # can not find some
         return None
 
-    def cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         to_remove_executor = []
-        for cur_setup_executor in self.setup_executors:
-            cur_setup_executor.cleanup_empty_executor_branches()
-            if len(cur_setup_executor.scenario_executors) == 0:
+        for cur_setup_executor in self.get_setup_executors():
+            cur_setup_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
+            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,32 @@ 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<"
+                              f"{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 cleanup_empty_executor_branches(self):
+    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, consider_discarded=False):
         """
         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(return_discarded=consider_discarded):
+            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 cleanup_empty_executor_branches(self):
+    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, consider_discarded=False):
         to_remove_executor = []
-        for cur_scenario_executor in self.scenario_executors:
-            cur_scenario_executor.cleanup_empty_executor_branches()
-            if len(cur_scenario_executor.variation_executors) == 0:
+        for cur_scenario_executor in self.get_scenario_executors():
+            cur_scenario_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
+            if len(cur_scenario_executor.get_variation_executors(return_discarded=consider_discarded)) == 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

@@ -7,7 +7,6 @@ import traceback
 from _balder.utils import inspect_method
 from _balder.testresult import ResultState, TestcaseResult
 from _balder.executor.basic_executor import BasicExecutor
-from _balder.previous_executor_mark import PreviousExecutorMark
 
 if TYPE_CHECKING:
     from _balder.executor.variation_executor import VariationExecutor
@@ -76,7 +75,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 +83,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 +108,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:
@@ -135,7 +131,7 @@ class TestcaseExecutor(BasicExecutor):
             return True
         return False
 
-    def cleanup_empty_executor_branches(self):
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
         """
         This method searches the whole tree and removes branches where an executor item has no own children. It can
         remove these branches, because they have no valid matchings.