baldertest 0.1.0b11__py3-none-any.whl → 0.1.0b13__py3-none-any.whl

_balder/executor/scenario_executor.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
-from typing import Type, Union, List, Dict, TYPE_CHECKING
+from typing import Type, Union, List, TYPE_CHECKING
 
 from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult
-from _balder.utils import get_class_that_defines_method
 from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.executor.variation_executor import VariationExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
@@ -78,19 +77,19 @@ class ScenarioExecutor(BasicExecutableExecutor):
         return self._fixture_manager
 
     @property
-    def all_run_tests(self):
+    def all_run_tests(self) -> List[callable]:
         """returns a list of all test methods that are declared to `RUN` in their base :class:`Scenario` class"""
-        return self._base_scenario_class.RUN
+        return self.base_scenario_controller.get_run_test_methods()
 
     @property
-    def all_skip_tests(self):
+    def all_skip_tests(self) -> List[callable]:
         """returns a list of all test methods that are declared to `SKIP` in their base :class:`Scenario` class"""
-        return self._base_scenario_class.SKIP
+        return self.base_scenario_controller.get_skip_test_methods()
 
     @property
-    def all_ignore_tests(self):
+    def all_ignore_tests(self) -> List[callable]:
         """returns a list of all test methods that are declared to `IGNORE` in their base :class:`Scenario` class"""
-        return self._base_scenario_class.IGNORE
+        return self.base_scenario_controller.get_ignore_test_methods()
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
@@ -99,11 +98,12 @@ class ScenarioExecutor(BasicExecutableExecutor):
 
     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):
+            prev_mark = cur_variation_executor.prev_mark
+            if cur_variation_executor.has_runnable_tests() or cur_variation_executor.has_skipped_tests():
                 cur_variation_executor.execute(show_discarded=show_discarded)
-            elif cur_variation_executor.prev_mark == PreviousExecutorMark.SKIP:
+            elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_variation_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
+            elif prev_mark == PreviousExecutorMark.COVERED_BY:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_variation_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
@@ -136,71 +136,12 @@ class ScenarioExecutor(BasicExecutableExecutor):
         for cur_variation_executor in to_remove_executor:
             self._variation_executors.remove(cur_variation_executor)
 
-    def get_covered_by_dict(self) -> Dict[Union[Type[Scenario], callable], List[Union[Type[Scenario], callable]]]:
-        """
-        This method returns the complete resolved ``@covered_by`` dictionary for this scenario. It automatically
-        cleans up every inheritance of the covered_by decorators for every parent class of our scenario.
-        """
-        def determine_most_inherited_class(class_list):
-            for cur_candidate in class_list:
-                candidate_is_valid = True
-                for cur_other_candidate in class_list:
-                    if cur_candidate == cur_other_candidate:
-                        pass
-                    if not issubclass(cur_candidate, cur_other_candidate):
-                        candidate_is_valid = False
-                        break
-                if candidate_is_valid:
-                    return cur_candidate
-            return None
-
-        # all data will be inherited while ``@covered_by`` overwrites elements only if there is a new decorator at the
-        # overwritten method
-        #  -> we have to filter the dictionary and only return the value given for highest overwritten method
-        relative_covered_by_dict = {}
-        if hasattr(self.base_scenario_class, '_covered_by'):
-            function_name_mapping = {}
-            classes = []
-            for cur_key in self.base_scenario_class._covered_by.keys():
-                if issubclass(cur_key, Scenario):
-                    # this is a covered_by definition for the whole class
-                    classes.append(cur_key)
-                else:
-                    # this is a covered_by definition for one test method
-                    if cur_key.__name__ in function_name_mapping.keys():
-                        function_name_mapping[cur_key.__name__] = [cur_key]
-                    else:
-                        function_name_mapping[cur_key.__name__].append(cur_key)
-
-            # determine the highest definition for class statement (only if necessary)
-            if len(classes) > 0:
-                most_inherited_class = determine_most_inherited_class(classes)
-                # this is the most inherited child -> add this definition
-                relative_covered_by_dict[most_inherited_class] = \
-                    self.base_scenario_class._covered_by[most_inherited_class]
-
-            # determine the highest definition for every test method
-            for cur_function_name, cur_possible_candidates in function_name_mapping.items():
-                classes = [get_class_that_defines_method(meth) for meth in cur_possible_candidates]
-                most_inherited_class = determine_most_inherited_class(classes)
-                most_inherited_test_method = cur_possible_candidates[classes.index(most_inherited_class)]
-                # this is the most inherited test method -> add the definition of this one and replace the method with
-                # this Scenario's one
-                relative_covered_by_dict[getattr(self.base_scenario_class, cur_function_name)] = \
-                    self.base_scenario_class._covered_by[most_inherited_test_method]
-        else:
-            pass
-        return relative_covered_by_dict
-
     def get_covered_by_element(self) -> List[Union[Scenario, callable]]:
         """
         This method returns a list of elements where the whole scenario is covered from. This means, that the whole
         test methods in this scenario are already be covered from one of the elements in the list.
         """
-        covered_by_dict_resolved = self.get_covered_by_dict()
-        if self in covered_by_dict_resolved.keys():
-            return covered_by_dict_resolved[self]
-        return []
+        return self.base_scenario_controller.get_abs_covered_by_dict().get(None, [])
 
     def add_variation_executor(self, variation_executor: VariationExecutor):
         """

_balder/executor/setup_executor.py

@@ -80,11 +80,12 @@ class SetupExecutor(BasicExecutableExecutor):
 
     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):
+            prev_mark = cur_scenario_executor.prev_mark
+            if cur_scenario_executor.has_runnable_tests(show_discarded) or cur_scenario_executor.has_skipped_tests():
                 cur_scenario_executor.execute(show_discarded=show_discarded)
-            elif cur_scenario_executor.prev_mark == PreviousExecutorMark.SKIP:
+            elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_scenario_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
+            elif prev_mark == PreviousExecutorMark.COVERED_BY:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_scenario_executor.set_result_for_whole_branch(ResultState.NOT_RUN)

_balder/executor/testcase_executor.py

@@ -9,15 +9,17 @@ from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.testresult import ResultState, TestcaseResult
-from _balder.utils import inspect_method
+from _balder.utils.functions import get_method_type
+from _balder.utils.mixin_can_be_covered_by_executor import MixinCanBeCoveredByExecutor
 
 if TYPE_CHECKING:
+    from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.fixture_manager import FixtureManager
     from _balder.scenario import Scenario
 
 
-class TestcaseExecutor(BasicExecutableExecutor):
+class TestcaseExecutor(BasicExecutableExecutor, MixinCanBeCoveredByExecutor):
     """
     A TestcaseExecutor class represents an actual single test that can be executed. It therefore references exactly to a
     test method of a scenario that can be executed on the specific setup this executor belongs to.
@@ -65,6 +67,10 @@ class TestcaseExecutor(BasicExecutableExecutor):
     def parent_executor(self) -> VariationExecutor:
         return self._parent_executor
 
+    @property
+    def scenario_executor(self) -> ScenarioExecutor:
+        return self.parent_executor.parent_executor
+
     @property
     def base_instance(self) -> object:
         """
@@ -99,15 +105,23 @@ class TestcaseExecutor(BasicExecutableExecutor):
 
     def _prepare_execution(self, show_discarded):
         print(f"      TEST {self.full_test_name_str} ", end='')
+
+    def _body_execution(self, show_discarded):
+        self.test_execution_time_sec = 0
+
         if self.should_be_skipped():
             self.body_result.set_result(ResultState.SKIP)
-            self.execution_time_sec = 0
-            print("[S]")
+            return
+        if self.should_be_ignored():
+            self.body_result.set_result(ResultState.NOT_RUN)
+            return
+        if self.is_covered_by():
+            self.body_result.set_result(ResultState.COVERED_BY)
+            return
 
-    def _body_execution(self, show_discarded):
         start_time = time.perf_counter()
         try:
-            _, func_type = inspect_method(self.base_testcase_callable)
+            func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
             all_args = self.get_all_test_method_args()
             if func_type == "staticmethod":
                 # testcase is a staticmethod - no special first attribute
@@ -151,6 +165,16 @@ class TestcaseExecutor(BasicExecutableExecutor):
             return True
         return False
 
+    def is_covered_by(self):
+        """returns true if the testcase is covered-by"""
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
+
+    def has_skipped_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.SKIP
+
+    def has_covered_by_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
+
     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
@@ -160,25 +184,17 @@ class TestcaseExecutor(BasicExecutableExecutor):
         """
 
     def get_covered_by_element(self) -> List[Union[Scenario, callable]]:
-        """
-        This method returns a list of elements where the whole scenario is covered from. This means, that the whole
-        test methods in this scenario are already be covered from every single element in the list.
-        """
-        all_covered_by_data = []
-        scenario_executor = self.parent_executor.parent_executor
-        scenario_class = scenario_executor.base_scenario_class
-        covered_by_dict_resolved = scenario_executor.get_covered_by_dict()
-        if self.base_testcase_callable in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[self.base_testcase_callable]
-        if scenario_class in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[scenario_class]
+        covered_by_dict = self.scenario_executor.base_scenario_controller.get_abs_covered_by_dict()
+        all_covered_by_data = covered_by_dict.get(self.base_testcase_callable.__name__, [])
+        # also add all scenario specified covered-by elements
+        all_covered_by_data.extend(covered_by_dict.get(None, []))
         return all_covered_by_data
 
     def get_all_test_method_args(self):
         """
         returns all kwargs values for the test method
         """
-        _, func_type = inspect_method(self.base_testcase_callable)
+        func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
         return self.fixture_manager.get_all_attribute_values(
             self,
             self.base_testcase_obj.__class__,

_balder/executor/unresolved_parametrized_testcase_executor.py

@@ -11,14 +11,16 @@ from _balder.executor.parametrized_testcase_executor import ParametrizedTestcase
 from _balder.parametrization import Parameter
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.testresult import BranchBodyResult
+from _balder.utils.mixin_can_be_covered_by_executor import MixinCanBeCoveredByExecutor
 
 if TYPE_CHECKING:
+    from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.scenario import Scenario
     from _balder.setup import Setup
 
 
-class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
+class UnresolvedParametrizedTestcaseExecutor(BasicExecutor, MixinCanBeCoveredByExecutor):
     """
     This executor class represents a group of dynamically parametrized tests.
     """
@@ -37,9 +39,6 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         # holds the specific static parameters for this unresolved group
         self._static_parameters = static_parameters if static_parameters is not None else {}
 
-        # holds the dynamically created testcase executors as soon as this executor is entered
-        self._testcase_executors = None
-
         # contains the result object for the BODY part of this branch
         self.body_result = BranchBodyResult(self)
 
@@ -47,14 +46,18 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
     def parent_executor(self) -> VariationExecutor:
         return self._parent_executor
 
+    @property
+    def scenario_executor(self) -> ScenarioExecutor:
+        return self.parent_executor.parent_executor
+
     @property
     def base_testcase_callable(self) -> callable:
         """returns the testcase function"""
         return self._base_testcase_callable
 
     @property
-    def all_child_executors(self) -> List[ParametrizedTestcaseExecutor]:
-        return self.get_testcase_executors()
+    def all_child_executors(self) -> None:
+        return None
 
     @property
     def base_testcase_obj(self) -> Scenario:
@@ -69,29 +72,11 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         returns the base class instance to which this executor instance belongs"""
         return self._base_testcase_callable
 
-    @property
-    def parametrization_has_been_resolved(self) -> bool:
-        """returns true if the parametrization has been resolved"""
-        return self._testcase_executors is not None
-
-    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.parametrization_has_been_resolved:
-            return super().has_runnable_tests(consider_discarded_too=consider_discarded_too)
+    def has_skipped_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.SKIP
 
-        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
-        return True
+    def has_covered_by_tests(self) -> bool:
+        return self.prev_mark == PreviousExecutorMark.COVERED_BY
 
     def get_all_base_instances_of_this_branch(
             self, with_type: Type[Setup] | Type[Scenario] | Type[types.FunctionType],
@@ -105,43 +90,33 @@ class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
         return []
 
     def get_covered_by_element(self) -> List[Scenario | callable]:
-        """
-        This method returns a list of elements where the whole scenario is covered from. This means, that the whole
-        test methods in this scenario are already be covered from every single element in the list.
-        """
-        all_covered_by_data = []
-        scenario_executor = self.parent_executor.parent_executor
-        scenario_class = scenario_executor.base_scenario_class
-        covered_by_dict_resolved = scenario_executor.get_covered_by_dict()
-        if self.base_testcase_callable in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[self.base_testcase_callable]
-        if scenario_class in covered_by_dict_resolved.keys():
-            all_covered_by_data += covered_by_dict_resolved[scenario_class]
+        covered_by_dict = self.scenario_executor.base_scenario_controller.get_abs_covered_by_dict()
+        all_covered_by_data = covered_by_dict.get(self.base_testcase_callable.__name__, [])
+        # also add all scenario specified covered-by elements
+        all_covered_by_data.extend(covered_by_dict.get(None, []))
         return all_covered_by_data
 
-    def get_testcase_executors(self) -> List[ParametrizedTestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
-        """returns all sub testcase executors that belongs to this variation-executor"""
-        if self._testcase_executors is None:
-            return [self]
-        return self._testcase_executors
-
-    def resolve_dynamic_parametrization(self):
+    def get_resolved_parametrized_testcase_executors(self):
         """
         resolves the dynamic parametrization - should be called when setup features are active in the scenario
         """
-        self._testcase_executors = []
+        executors = []
 
         parametrization = self.get_parametrization()
-        if parametrization:
-            for cur_parametrization in parametrization:
-                self._testcase_executors.append(
-                    ParametrizedTestcaseExecutor(
-                        self._base_testcase_callable,
-                        parent=self.parent_executor,
-                        parametrization=cur_parametrization,
-                        unresolved_group_obj=self
-                    )
+
+        if not parametrization:
+            return []
+
+        for cur_parametrization in parametrization:
+            executors.append(
+                ParametrizedTestcaseExecutor(
+                    self._base_testcase_callable,
+                    parent=self.parent_executor,
+                    parametrization=cur_parametrization,
+                    unresolved_group_obj=self
                 )
+            )
+        return executors
 
     def get_parametrization(self) -> List[OrderedDict[str, Any]] | None:
         """