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

_balder/executor/basic_executor.py

@@ -1,20 +1,15 @@
 from __future__ import annotations
 
-import time
 from typing import List, Union, Type, TYPE_CHECKING
 
-import sys
 import types
-import traceback
 from abc import ABC, abstractmethod
-from _balder.testresult import FixturePartResult, ResultState, ResultSummary
 from _balder.previous_executor_mark import PreviousExecutorMark
-from _balder.testresult import TestcaseResult
+from _balder.testresult import FixturePartResult, ResultState, ResultSummary, TestcaseResult
 
 if TYPE_CHECKING:
     from _balder.setup import Setup
     from _balder.scenario import Scenario
-    from _balder.fixture_manager import FixtureManager
 
 
 class BasicExecutor(ABC):
@@ -35,9 +30,6 @@ class BasicExecutor(ABC):
         # contains the result object for the TEARDOWN FIXTURE part of this branch
         self.teardown_result = FixturePartResult(self)
 
-        # holds the execution time of this branch (with branch fixtures)
-        self.execution_time_sec = None
-
     # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
 
     # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
@@ -62,11 +54,6 @@ class BasicExecutor(ABC):
         """returns the base class instance to which this executor instance belongs or None if this element is a
         ExecutorTree"""
 
-    @property
-    @abstractmethod
-    def fixture_manager(self) -> FixtureManager:
-        """returns the active fixture manager instance"""
-
     @property
     def executor_result(self) -> ResultState:
         """
@@ -86,26 +73,6 @@ class BasicExecutor(ABC):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    @abstractmethod
-    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, 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, show_discarded):
-        """
-        This method runs after the branch was executed (also after the fixture teardown code ran)
-        """
-
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def get_all_recognized_exception(self) -> List[Exception]:
@@ -125,18 +92,6 @@ class BasicExecutor(ABC):
             all_own.remove(None)
         return all_own
 
-    def set_result_for_whole_branch(self, value: ResultState):
-        """
-        This method sets the executor result for all sub executors.
-
-        :param value: the new value that should be set for this branch
-        """
-        if value not in (ResultState.SKIP, ResultState.COVERED_BY, ResultState.NOT_RUN):
-            raise ValueError("can not set a state that is not NOT_RUN, SKIP or COVERED_BY for a whole branch")
-        for cur_child_executor in self.all_child_executors:
-            if isinstance(cur_child_executor.body_result, TestcaseResult):
-                cur_child_executor.body_result.set_result(result=value, exception=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
@@ -221,35 +176,3 @@ class BasicExecutor(ABC):
             for cur_child_exec in self.all_child_executors:
                 summary += cur_child_exec.testsummary()
         return summary
-
-    def execute(self, show_discarded=False):
-        """
-        Executes the whole branch
-        """
-        start_time = time.perf_counter()
-        self._prepare_execution(show_discarded=show_discarded)
-
-        try:
-            try:
-                if self.has_runnable_tests():
-                    self.fixture_manager.enter(self)
-                    self.construct_result.set_result(ResultState.SUCCESS)
-
-                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.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(show_discarded=show_discarded)
-
-        self.execution_time_sec = time.perf_counter() - start_time

_balder/executor/executor_tree.py

@@ -3,22 +3,24 @@ from typing import Union, List, Type, TYPE_CHECKING
 
 from dataclasses import fields
 from _balder.executor.setup_executor import SetupExecutor
-from _balder.executor.basic_executor import BasicExecutor
-from _balder.fixture_manager import FixtureManager
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
+from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
 from _balder.previous_executor_mark import PreviousExecutorMark
 
 if TYPE_CHECKING:
     from _balder.setup import Setup
+    from _balder.fixture_manager import FixtureManager
     from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.executor.variation_executor import VariationExecutor
     from _balder.executor.testcase_executor import TestcaseExecutor
 
 
-class ExecutorTree(BasicExecutor):
+class ExecutorTree(BasicExecutableExecutor):
     """
     This class is the root object of the executor tree structure
     """
+    fixture_execution_level = FixtureExecutionLevel.SESSION
     LINE_LENGTH = 120
 
     def __init__(self, fixture_manager: FixtureManager):
@@ -36,7 +38,7 @@ class ExecutorTree(BasicExecutor):
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
-    def all_child_executors(self) -> List[BasicExecutor]:
+    def all_child_executors(self) -> List[BasicExecutableExecutor]:
         return self._setup_executors
 
     @property
@@ -180,7 +182,7 @@ class ExecutorTree(BasicExecutor):
                 is_first = False
             else:
                 print(" | ", end="")
-            print(f"TOTAL {cur_field.name}: {getattr(summary, cur_field.name)}", end="")
+            print(f"TOTAL {cur_field.name.upper()}: {getattr(summary, cur_field.name)}", end="")
         print("")
 
     def print_tree(self, show_discarded=False) -> None:

_balder/executor/parametrized_testcase_executor.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
+
+from collections import OrderedDict
+from _balder.utils import inspect_method
+from .testcase_executor import TestcaseExecutor
+
+if TYPE_CHECKING:
+    from _balder.executor.unresolved_parametrized_testcase_executor import UnresolvedParametrizedTestcaseExecutor
+    from _balder.executor.variation_executor import VariationExecutor
+
+
+class ParametrizedTestcaseExecutor(TestcaseExecutor):
+    """
+    special testcase executor for parametrized testcases
+    """
+    def __init__(
+            self,
+            testcase: callable,
+            parent: VariationExecutor,
+            parametrization: OrderedDict[str, Any] = None,
+            unresolved_group_obj: UnresolvedParametrizedTestcaseExecutor = None
+    ) -> None:
+        super().__init__(testcase=testcase, parent=parent)
+        self._parametrization = parametrization
+        # holds a reference to the parent unresolved object (if it has dynamic parametrized components
+        self._unresolved_group_obj: UnresolvedParametrizedTestcaseExecutor | None = unresolved_group_obj
+
+    @property
+    def full_test_name_str(self) -> str:
+        """
+        returns the name of the test method, that should be used in output
+        """
+        # try to get string name for parametrization
+        if self._parametrization:
+            # todo what if it is not convertable to string?
+            parametrization_name = ';'.join([str(e) for e in self._parametrization.values()])
+            return f"{super().full_test_name_str}[{parametrization_name}]"
+        return super().full_test_name_str
+
+    def get_all_test_method_args(self):
+        _, func_type = inspect_method(self.base_testcase_callable)
+        all_kwargs = self.fixture_manager.get_all_attribute_values(
+            self,
+            self.base_testcase_obj.__class__,
+            self.base_testcase_callable,
+            func_type,
+            ignore_attributes=self._parametrization.keys()
+        )
+        if self._parametrization:
+            all_kwargs.update(self._parametrization)
+        return all_kwargs

_balder/executor/scenario_executor.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 from typing import Type, Union, List, Dict, 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_executor import BasicExecutor
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.executor.variation_executor import VariationExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.controllers.scenario_controller import ScenarioController
@@ -14,10 +15,11 @@ if TYPE_CHECKING:
     from _balder.fixture_manager import FixtureManager
 
 
-class ScenarioExecutor(BasicExecutor):
+class ScenarioExecutor(BasicExecutableExecutor):
     """
     A ScenarioExecutor can contain :meth:`VariationExecutor` as children.
     """
+    fixture_execution_level = FixtureExecutionLevel.SCENARIO
 
     def __init__(self, scenario: Type[Scenario], parent: SetupExecutor):
         super().__init__()
@@ -67,6 +69,7 @@ class ScenarioExecutor(BasicExecutor):
 
     @property
     def base_scenario_controller(self) -> ScenarioController:
+        """returns the :class:`ScenarioController` for the setup object of this executor"""
         return ScenarioController.get_for(self.base_scenario_class.__class__)
 
     @property

_balder/executor/setup_executor.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 from typing import Type, Union, List, TYPE_CHECKING
 
+from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult
-from _balder.executor.basic_executor import BasicExecutor
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.executor.scenario_executor import ScenarioExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.controllers.setup_controller import SetupController
@@ -16,11 +17,12 @@ if TYPE_CHECKING:
     from _balder.executor.executor_tree import ExecutorTree
 
 
-class SetupExecutor(BasicExecutor):
+class SetupExecutor(BasicExecutableExecutor):
     """
     A SetupExecutor is the highest branch object of an :class:`ExecutorTree`. It contains all scenarios and the
     underlying device mappings and their test cases that exist with this setup.
     """
+    fixture_execution_level = FixtureExecutionLevel.SETUP
 
     def __init__(self, setup: Type[Setup], parent: ExecutorTree):
         super().__init__()
@@ -63,6 +65,7 @@ class SetupExecutor(BasicExecutor):
 
     @property
     def base_setup_controller(self) -> SetupController:
+        """returns the :class:`SetupController` for the setup object of this executor"""
         return SetupController.get_for(self.base_setup_class.__class__)
 
     @property

_balder/executor/testcase_executor.py

@@ -4,9 +4,12 @@ from typing import List, Union, TYPE_CHECKING
 import sys
 import time
 import traceback
-from _balder.utils import inspect_method
+
+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.executor.basic_executor import BasicExecutor
+from _balder.utils import inspect_method
 
 if TYPE_CHECKING:
     from _balder.executor.variation_executor import VariationExecutor
@@ -14,13 +17,18 @@ if TYPE_CHECKING:
     from _balder.scenario import Scenario
 
 
-class TestcaseExecutor(BasicExecutor):
+class TestcaseExecutor(BasicExecutableExecutor):
     """
     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.
     """
+    fixture_execution_level = FixtureExecutionLevel.TESTCASE
 
-    def __init__(self, testcase: callable, parent: VariationExecutor):
+    def __init__(
+            self,
+            testcase: callable,
+            parent: VariationExecutor,
+    ) -> None:
         super().__init__()
 
         self._base_testcase_callable = testcase
@@ -36,6 +44,13 @@ class TestcaseExecutor(BasicExecutor):
         # holds the raw test execution time in seconds
         self.test_execution_time_sec = 0
 
+        # determine prev_mark IGNORE/SKIP for the testcase
+        if self.should_be_skipped():
+            self.prev_mark = PreviousExecutorMark.SKIP
+        # always overwrite if it should be ignored
+        if self.should_be_ignored():
+            self.prev_mark = PreviousExecutorMark.IGNORE
+
     # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
 
     # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
@@ -73,22 +88,27 @@ class TestcaseExecutor(BasicExecutor):
         """returns the current active fixture manager"""
         return self._fixture_manager
 
+    @property
+    def full_test_name_str(self) -> str:
+        """
+        returns the name of the test method, that should be used in output
+        """
+        return self._base_testcase_callable.__qualname__
+
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
     def _prepare_execution(self, show_discarded):
-        print(f"      TEST {self.base_testcase_callable.__qualname__} ", end='')
+        print(f"      TEST {self.full_test_name_str} ", end='')
         if self.should_be_skipped():
             self.body_result.set_result(ResultState.SKIP)
             self.execution_time_sec = 0
             print("[S]")
-            return
 
     def _body_execution(self, show_discarded):
         start_time = time.perf_counter()
         try:
             _, func_type = inspect_method(self.base_testcase_callable)
-            all_args = self.fixture_manager.get_all_attribute_values(
-                self, self.base_testcase_obj.__class__, self.base_testcase_callable, func_type)
+            all_args = self.get_all_test_method_args()
             if func_type == "staticmethod":
                 # testcase is a staticmethod - no special first attribute
                 self.base_testcase_callable(**all_args)
@@ -102,7 +122,7 @@ class TestcaseExecutor(BasicExecutor):
                                  f"`{self.base_testcase_callable.__name__}`")
 
             self.body_result.set_result(ResultState.SUCCESS)
-        except Exception as exc:
+        except Exception as exc:  # pylint: disable=broad-exception-caught
             # this has to be a test error
             traceback.print_exception(*sys.exc_info())
             self.body_result.set_result(ResultState.FAILURE, exc)
@@ -153,3 +173,15 @@ class TestcaseExecutor(BasicExecutor):
         if scenario_class in covered_by_dict_resolved.keys():
             all_covered_by_data += covered_by_dict_resolved[scenario_class]
         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)
+        return self.fixture_manager.get_all_attribute_values(
+            self,
+            self.base_testcase_obj.__class__,
+            self.base_testcase_callable,
+            func_type
+        )

_balder/executor/unresolved_parametrized_testcase_executor.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import inspect
+from typing import List, Type, Any, Dict, Iterable, TYPE_CHECKING
+import types
+from graphlib import TopologicalSorter
+from collections import OrderedDict
+
+from _balder.executor.basic_executor import BasicExecutor
+from _balder.executor.parametrized_testcase_executor import ParametrizedTestcaseExecutor
+from _balder.parametrization import Parameter
+from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.testresult import BranchBodyResult
+
+if TYPE_CHECKING:
+    from _balder.executor.variation_executor import VariationExecutor
+    from _balder.scenario import Scenario
+    from _balder.setup import Setup
+
+
+class UnresolvedParametrizedTestcaseExecutor(BasicExecutor):
+    """
+    This executor class represents a group of dynamically parametrized tests.
+    """
+
+    def __init__(
+            self,
+            testcase: callable,
+            parent: VariationExecutor,
+            static_parameters: Dict[str, Any] = None,
+    ) -> None:
+        super().__init__()
+
+        self._base_testcase_callable = testcase
+        self._parent_executor = parent
+
+        # 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)
+
+    @property
+    def parent_executor(self) -> VariationExecutor:
+        return self._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()
+
+    @property
+    def base_testcase_obj(self) -> Scenario:
+        """
+        return the testcase Scenario this testcase is defined in
+        """
+        return self.parent_executor.cur_scenario_class
+
+    @property
+    def base_instance(self) -> object:
+        """
+        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)
+
+        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 get_all_base_instances_of_this_branch(
+            self, with_type: Type[Setup] | Type[Scenario] | Type[types.FunctionType],
+            only_runnable_elements: bool = True) -> List[Setup | Scenario | object]:
+        """
+        returns itself if the type matches, otherwise an empty list
+        """
+        # todo
+        if isinstance(self.base_instance, with_type):
+            return [self.base_instance]
+        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]
+        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):
+        """
+        resolves the dynamic parametrization - should be called when setup features are active in the scenario
+        """
+        self._testcase_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
+                    )
+                )
+
+    def get_parametrization(self) -> List[OrderedDict[str, Any]] | None:
+        """
+        returns all parametrization elements that belongs to this group executor
+        """
+        scenario_controller = self.parent_executor.parent_executor.base_scenario_controller
+        dynamic_parametrization = scenario_controller.get_parametrization_for(self._base_testcase_callable,
+                                                                              static=False)
+        if not dynamic_parametrization:
+            raise ValueError('can not determine dynamic parametrization, because there are no dynamic parameters')
+
+        # sort attributes according their Parameter - using TopologicalSorter
+        graph = {attr: [param.name for param in config.get_parameters(of_type=Parameter).values()]
+                 for attr, config in dynamic_parametrization.items()}
+        # also add all elements from static parameters
+        graph.update({param: [] for param in self._static_parameters})
+
+        ts = TopologicalSorter(graph)
+        resolvable_order_of_attribues = ts.static_order()
+        resolvable_dynamic_attribues = [attr for attr in resolvable_order_of_attribues
+                                        if attr in dynamic_parametrization.keys()]
+
+        def get_variations_for(
+                resolved_parameters: Dict[str, Any],
+                remaining_attributes: Iterable[str]
+        ) -> List[Dict[str, Any]]:
+            result = []
+            remaining_attributes = list(remaining_attributes).copy()
+            attr = remaining_attributes.pop(0)
+            feature_access_selector = dynamic_parametrization[attr]
+            # get value for this attribute
+            attr_value_list = feature_access_selector.get_value(resolved_parameters)
+            if not isinstance(attr_value_list, Iterable):
+                raise TypeError(
+                    f'feature parametrizing not possible, because `{feature_access_selector.device.__qualname__}'
+                    f'.{feature_access_selector.device_property_name}.{feature_access_selector.feature_property_name}` '
+                    f'does not return Iterable')
+
+            for cur_value in attr_value_list:
+                parameters_with_cur_attr_value = resolved_parameters.copy()
+                parameters_with_cur_attr_value[attr] = cur_value
+                if len(remaining_attributes) > 0:
+                    result.extend(get_variations_for(parameters_with_cur_attr_value, remaining_attributes))
+                else:
+                    result.append(parameters_with_cur_attr_value)
+
+            return result
+
+        resolved_parameters = self._static_parameters.copy()
+
+        all_full_parametrization = get_variations_for(resolved_parameters, resolvable_dynamic_attribues)
+
+        # get combined parametrization
+        result = []
+        for cur_full_parametrization in all_full_parametrization:
+            cur_parameter_set = OrderedDict()
+            for cur_arg in inspect.getfullargspec(self._base_testcase_callable).args:
+                # only if this is a parametrization value
+                if cur_arg in cur_full_parametrization:
+                    cur_parameter_set[cur_arg] = cur_full_parametrization[cur_arg]
+            result.append(cur_parameter_set)
+        return result
+
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
+        pass