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

_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

_balder/executor/variation_executor.py

@@ -5,9 +5,11 @@ import inspect
 import logging
 from _balder.device import Device
 from _balder.connection import Connection
-from _balder.testresult import ResultState, BranchBodyResult
-from _balder.executor.basic_executor import BasicExecutor
+from _balder.fixture_execution_level import FixtureExecutionLevel
+from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
 from _balder.executor.testcase_executor import TestcaseExecutor
+from _balder.executor.unresolved_parametrized_testcase_executor import UnresolvedParametrizedTestcaseExecutor
 from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.routing_path import RoutingPath
 from _balder.unmapped_vdevice import UnmappedVDevice
@@ -26,10 +28,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__file__)
 
 
-class VariationExecutor(BasicExecutor):
+class VariationExecutor(BasicExecutableExecutor):
     """
     A VariationExecutor only contains :meth:`TestcaseExecutor` children.
     """
+    fixture_execution_level = FixtureExecutionLevel.VARIATION
 
     def __init__(self, device_mapping: Dict[Type[Device], Type[Device]], parent: ScenarioExecutor):
         super().__init__()
@@ -107,7 +110,7 @@ class VariationExecutor(BasicExecutor):
         return self._base_device_mapping
 
     @property
-    def all_child_executors(self) -> List[TestcaseExecutor]:
+    def all_child_executors(self) -> List[TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
         return self._testcase_executors
 
     @property
@@ -150,10 +153,10 @@ class VariationExecutor(BasicExecutor):
             self.determine_abs_variation_connections()
             self.update_scenario_device_feature_instances()
             self.update_active_vdevice_device_mappings_in_all_features()
-            self.update_inner_referenced_feature_instances()
             self.exchange_unmapped_vdevice_references()
             self.update_vdevice_referenced_feature_instances()
             self.set_conn_dependent_methods()
+            self.resolve_possible_parametrization()
 
     def _body_execution(self, show_discarded):
         if show_discarded and not self.can_be_applied():
@@ -283,28 +286,29 @@ class VariationExecutor(BasicExecutor):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
-    def testsummary(self):
+    def testsummary(self) -> ResultSummary:
         if self.can_be_applied():
             return super().testsummary()
-        return {
-            ResultState.NOT_RUN: 0,
-            ResultState.FAILURE: 0,
-            ResultState.ERROR: 0,
-            ResultState.SUCCESS: 0,
-            ResultState.SKIP: 0,
-            ResultState.COVERED_BY: 0
-        }
+        return ResultSummary()
 
     def get_testcase_executors(self) -> List[TestcaseExecutor]:
         """returns all sub testcase executors that belongs to this variation-executor"""
-        return self._testcase_executors
+        result = []
+        for cur_executor in self._testcase_executors:
+            if (isinstance(cur_executor, UnresolvedParametrizedTestcaseExecutor) and
+                    cur_executor.parametrization_has_been_resolved):
+                result += cur_executor.get_testcase_executors()
+            else:
+                result.append(cur_executor)
+        return result
 
-    def add_testcase_executor(self, testcase_executor: TestcaseExecutor):
+    def add_testcase_executor(self, testcase_executor: TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor):
         """
         This method adds a new TestcaseExecutor to the child element list of this object branch
         """
-        if not isinstance(testcase_executor, TestcaseExecutor):
-            raise TypeError("the given object `testcase_executor` must be of type type `TestcaseExecutor`")
+        if not isinstance(testcase_executor, (TestcaseExecutor, UnresolvedParametrizedTestcaseExecutor)):
+            raise TypeError("the given object `testcase_executor` must be of type type `TestcaseExecutor` or "
+                            "`UnresolvedParametrizedTestcaseExecutor`")
         if testcase_executor in self._testcase_executors:
             raise ValueError("the given object `testcase_executor` already exists in child list")
         self._testcase_executors.append(testcase_executor)
@@ -469,7 +473,7 @@ class VariationExecutor(BasicExecutor):
             raise KeyError("the requested setup device exists more than one time in `base_device_mapping`")
         return [cur_key for cur_key, cur_value in self.base_device_mapping.items() if cur_value == setup_device][0]
 
-    def get_executor_for_testcase(self, testcase: callable) -> Union[TestcaseExecutor, None]:
+    def get_executor_for_testcase(self, testcase: callable) -> TestcaseExecutor | None:
         """
         This method searches for a TestcaseExecutor in the internal list for which the given testcase method is
         contained in
@@ -570,34 +574,6 @@ class VariationExecutor(BasicExecutor):
             for cur_feature, cur_original_mapping in cur_feature_mapping_dict.items():
                 cur_feature.active_vdevices = cur_original_mapping
 
-    def update_inner_referenced_feature_instances(self):
-        """
-        This method ensures that all inner referenced feature instances of the used feature object, will be replaced
-        with the related feature instances of the device object itself.
-
-        .. note::
-            Note that this method expects that the true defined scenario features are already replaced with the real
-            setup features. So the method requires that the method `update_scenario_device_feature_instances()` was
-            called before.
-        """
-        for scenario_device, _ in self._base_device_mapping.items():
-            # these features are subclasses of the real defined one (because they are already the replaced ones)
-            all_device_features = DeviceController.get_for(scenario_device).get_all_instantiated_feature_objects()
-            all_instantiated_feature_objs = [cur_feature for _, cur_feature in all_device_features.items()]
-            for _, cur_feature in all_device_features.items():
-                cur_feature_controller = FeatureController.get_for(cur_feature.__class__)
-                # now check the inner referenced features of this feature and check if that exists in the device
-                for cur_ref_feature_name, cur_ref_feature in \
-                        cur_feature_controller.get_inner_referenced_features().items():
-                    potential_candidates = [candidate_feature for candidate_feature in all_instantiated_feature_objs
-                                            if isinstance(candidate_feature, cur_ref_feature.__class__)]
-                    if len(potential_candidates) != 1:
-                        raise RuntimeError("found none or more than one potential replacing candidates")
-                    replacing_candidate = potential_candidates[0]
-                    # because `cur_feature` is only the object instance, the value will be overwritten only for this
-                    # object
-                    setattr(cur_feature, cur_ref_feature_name, replacing_candidate)
-
     def exchange_unmapped_vdevice_references(self):
         """
         This method exchanges all :class:`VDevice` references to an instance of :class:`UnmappedVDevice` if the
@@ -722,10 +698,7 @@ class VariationExecutor(BasicExecutor):
                     if cur_scenario_device not in abs_var_scenario_device_cnns.keys():
                         abs_var_scenario_device_cnns[cur_scenario_device] = {}
 
-                    if cur_cnn.from_device == cur_scenario_device:
-                        cur_to_device = cur_cnn.to_device
-                    else:
-                        cur_to_device = cur_cnn.from_device
+                    cur_to_device, _ = cur_cnn.get_conn_partner_of(cur_scenario_device)
 
                     if cur_to_device not in abs_var_scenario_device_cnns[cur_scenario_device].keys():
                         abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device] = []
@@ -915,3 +888,9 @@ class VariationExecutor(BasicExecutor):
                         (mapped_vdevice, absolute_feature_method_var_cnn, cur_method_variation)
 
                 cur_setup_feature_controller.set_active_method_variation(method_selection=method_var_selection)
+
+    def resolve_possible_parametrization(self):
+        """resolves the parametrization if there are any :class:`UnresolvedParametrizedTestcaseExecutor` in the tree"""
+        for cur_child in self._testcase_executors:
+            if isinstance(cur_child, UnresolvedParametrizedTestcaseExecutor):
+                cur_child.resolve_dynamic_parametrization()

_balder/fixture_definition_scope.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import List
+from enum import Enum
+
+
+class FixtureDefinitionScope(Enum):
+    """
+    This enum describes the definition scope of a fixture. A definition scope is the position the fixture was defined.
+    If the fixture was defined within the balderglob.py file, it has the definition-scope `GLOB`. If it is defined
+    within a scenario or setup it has the equivalent SCENARIO or SETUP scope.
+    """
+    GLOB = 'glob'
+    SETUP = 'setup'
+    SCENARIO = 'scenario'
+
+    @classmethod
+    def get_order(cls) -> List[FixtureDefinitionScope]:
+        """returns the priority order of the fixture definition scope"""
+        return [cls.GLOB, cls.SETUP, cls.SCENARIO]

_balder/fixture_execution_level.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from typing import List
+from enum import Enum
+
+
+class FixtureExecutionLevel(Enum):
+    """
+    This enum describes the fixture-execution-level of a fixture. It describes when the fixture should be executed. This
+    level will be set in the fixture decorator.
+    """
+    SESSION = 'session'
+    SETUP = 'setup'
+    SCENARIO = 'scenario'
+    VARIATION = 'variation'
+    TESTCASE = 'testcase'
+
+    @classmethod
+    def get_order(cls) -> List[FixtureExecutionLevel]:
+        """
+        returns the execution order of fixtures
+        """
+        return [cls.SESSION, cls.SETUP, cls.SCENARIO, cls.VARIATION, cls.TESTCASE]