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

_balder/executor/variation_executor.py

@@ -1,13 +1,18 @@
 from __future__ import annotations
+
+import itertools
 from typing import Type, Union, List, Dict, Tuple, TYPE_CHECKING
 
 import inspect
 import logging
+from _balder.cnnrelations import OrConnectionRelation
 from _balder.device import Device
 from _balder.connection import Connection
+from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
-from _balder.executor.basic_executor import BasicExecutor
+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
@@ -19,6 +24,8 @@ if TYPE_CHECKING:
     from _balder.feature import Feature
     from _balder.scenario import Scenario
     from _balder.vdevice import VDevice
+    from _balder.controllers.scenario_controller import ScenarioController
+    from _balder.controllers.setup_controller import SetupController
     from _balder.executor.scenario_executor import ScenarioExecutor
     from _balder.fixture_manager import FixtureManager
 
@@ -26,10 +33,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__()
@@ -93,11 +101,25 @@ class VariationExecutor(BasicExecutor):
         """property returns the current :class:`Scenario` for this variation"""
         return self._parent_executor.base_scenario_class
 
+    @property
+    def cur_scenario_controller(self) -> ScenarioController:
+        """
+        returns the current :class:`ScenarioController` for this variation
+        """
+        return self._parent_executor.base_scenario_controller
+
     @property
     def cur_setup_class(self) -> Setup:
         """property returns the current :class:`Setup` for this variation"""
         return self._parent_executor.parent_executor.base_setup_class
 
+    @property
+    def cur_setup_controller(self) -> SetupController:
+        """
+        returns the current :class:`SetupController` for this variation
+        """
+        return self._parent_executor.parent_executor.base_setup_controller
+
     @property
     def base_device_mapping(self) -> Dict[Type[Device], Type[Device]]:
         """
@@ -107,7 +129,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
@@ -153,6 +175,7 @@ class VariationExecutor(BasicExecutor):
             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():
@@ -280,6 +303,39 @@ class VariationExecutor(BasicExecutor):
                     f'can not find a valid routing on setup level for the connection `{scenario_cnn.get_tree_str()}` '
                     f'between scenario devices `{scenario_cnn.from_device}` and `{scenario_cnn.to_device}`')
 
+    def _get_matching_setup_features_for(
+            self,
+            scenario_feature_obj: Feature,
+            in_setup_device: Type[Device]
+    ) -> List[Feature]:
+        """
+        Helper method that returns all matching setup features for the provided scenario feature in the provided setup
+        device.
+        """
+        cur_setup_features = DeviceController.get_for(in_setup_device).get_all_instantiated_feature_objects()
+
+        replacing_feature_candidates = [
+            cur_setup_feature for cur_setup_feature in cur_setup_features.values()
+            if isinstance(cur_setup_feature, scenario_feature_obj.__class__)
+        ]
+        active_scenario_vdev, mapped_scenario_dev = scenario_feature_obj.active_vdevice_device_mapping
+
+        replacing_features = replacing_feature_candidates.copy()
+        if mapped_scenario_dev is not None:
+            # get the related setup device for the mapped scenario device (on scenario level)
+            setup_dev_of_mapped_scenario_dev = self.get_setup_device_for(mapped_scenario_dev)
+
+            # now check if there is a mapping on setup level too
+            for cur_replacing_feature in replacing_feature_candidates:
+                mapped_setup_vdev, mapped_setup_dev = cur_replacing_feature.active_vdevice_device_mapping
+                if mapped_setup_vdev is not None and not issubclass(mapped_setup_vdev, active_scenario_vdev):
+                    # drop this feature matching, because we have different vdevice mapped
+                    replacing_features.remove(cur_replacing_feature)
+                elif mapped_setup_dev is not None and mapped_setup_dev != setup_dev_of_mapped_scenario_dev:
+                    # drop this feature matching, because it is not applicable here
+                    replacing_features.remove(cur_replacing_feature)
+        return replacing_features
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def testsummary(self) -> ResultSummary:
@@ -289,14 +345,22 @@ class VariationExecutor(BasicExecutor):
 
     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)
@@ -324,75 +388,53 @@ class VariationExecutor(BasicExecutor):
         :raises NotApplicableVariationError: will be thrown if this variation cannot be applied, because the setup-/
                                              scenario-device-features can not be resolved
         """
-        feature_replacement = {}
-        abs_setup_vdevice_mappings = {}
+        feature_replacement = {scenario_dev: {} for scenario_dev in self.base_device_mapping.keys()}
+        abs_setup_vdevice_mappings = {setup_dev: {} for setup_dev in self.base_device_mapping.values()}
         for cur_scenario_device, cur_setup_device in self.base_device_mapping.items():
             cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
 
-            if cur_scenario_device not in feature_replacement.keys():
-                feature_replacement[cur_scenario_device] = {}
-
-            if cur_setup_device not in abs_setup_vdevice_mappings.keys():
-                abs_setup_vdevice_mappings[cur_setup_device] = {}
-
             all_assigned_setup_features = []
             cur_scenario_device_orig_features = \
                 DeviceController.get_for(cur_scenario_device).get_original_instanced_feature_objects()
-            for cur_attr_name, cur_abstract_scenario_feature_obj in cur_scenario_device_orig_features.items():
-                replacing_features = [cur_setup_feature for _, cur_setup_feature in cur_setup_features.items()
-                                      if isinstance(cur_setup_feature, cur_abstract_scenario_feature_obj.__class__)]
-                used_scenario_vdevice, mapped_scenario_device = \
-                    cur_abstract_scenario_feature_obj.active_vdevice_device_mapping
-                # check if there is a mapped device in scenario level
-                cleanup_replacing_features = replacing_features.copy()
-                if mapped_scenario_device is not None:
-                    # get the related setup device for the mapped scenario device (on scenario level)
-                    to_scenarios_vdevice_mapped_setup_device = self.get_setup_device_for(mapped_scenario_device)
-
-                    # now check if there is a mapping on setup level too
-                    for cur_replacing_feature in replacing_features:
-                        mapped_setup_vdevice, mapped_setup_device = cur_replacing_feature.active_vdevice_device_mapping
-                        if mapped_setup_vdevice is not None and \
-                                not issubclass(mapped_setup_vdevice, used_scenario_vdevice):
-                            # drop this feature matching, because we have different vdevice mapped
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-                        elif mapped_setup_device is not None and \
-                                mapped_setup_device != to_scenarios_vdevice_mapped_setup_device:
-                            # drop this feature matching, because it is not applicable here
-                            cleanup_replacing_features.remove(cur_replacing_feature)
-
-                if len(cleanup_replacing_features) != 1:
+            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_orig_features.items():
+                active_scenario_vdevice, mapped_scenario_device = cur_scenario_feature_obj.active_vdevice_device_mapping
+
+                cur_setup_feature_objs = self._get_matching_setup_features_for(
+                    scenario_feature_obj=cur_scenario_feature_obj, in_setup_device=cur_setup_device
+                )
+
+                if len(cur_setup_feature_objs) != 1:
                     raise NotApplicableVariationException(
                         f'this variation can not be applicable because there was no setup feature implementation of '
-                        f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                        f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
+                cur_setup_feature_obj = cur_setup_feature_objs[0]
 
                 if mapped_scenario_device is None:
                     # we have exactly one matching candidate, but also no vDevice mapping
                     # check if the matching candidate has a vDevice mapping
-                    _, mapped_setup_device = cleanup_replacing_features[0].active_vdevice_device_mapping
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_replacing_features[0].__class__)
+                    _, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
                     if mapped_setup_device is None \
                             and len(cleanup_feature_controller.get_abs_inner_vdevice_classes()) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
                             f"missing vDevice mapping for feature "
-                            f"`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used in scenario device "
+                            f"`{cur_scenario_feature_obj.__class__.__name__}` (used in scenario device "
                             f"`{cur_scenario_device.__name__}` and in setup device `{cur_setup_device.__name__}`) - "
                             f"VARIATION CAN NOT BE APPLIED")
                         raise NotApplicableVariationException(
-                            f'this variation can not be applicable because there was no vDevice mapping given on '
+                            f'this variation can not be applied because there was no vDevice mapping given on '
                             f'scenario or on setup level for the feature '
-                            f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
+                            f'`{cur_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                             f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
 
-                all_assigned_setup_features.append(cleanup_replacing_features[0])
+                all_assigned_setup_features.append(cur_setup_feature_obj)
                 if cur_attr_name not in feature_replacement[cur_scenario_device].keys():
-                    cleanup_feature = cleanup_replacing_features[0]
-                    cleanup_feature_controller = FeatureController.get_for(cleanup_feature.__class__)
+                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
 
-                    used_setup_vdevice, mapped_setup_device = cleanup_feature.active_vdevice_device_mapping
+                    used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
 
                     # if there is a vDevice mapping on scenario level, but not on setup level, so update the
                     # VDevice-Device-Mapping there
@@ -401,21 +443,21 @@ class VariationExecutor(BasicExecutor):
                         # because check was already done in collector-stage)
                         setup_vdevices = [cur_vdevice for cur_vdevice
                                           in cleanup_feature_controller.get_abs_inner_vdevice_classes()
-                                          if cur_vdevice.__name__ == used_scenario_vdevice.__name__]
+                                          if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
-                        abs_setup_vdevice_mappings[cur_setup_device][cleanup_feature] = {
+                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
                             used_setup_vdevice: self.get_setup_device_for(mapped_scenario_device)}
                     # if there is a vDevice mapping on setup level, but not on scenario level, so directly update the
                     # VDevice-Device-Mapping there
                     elif mapped_scenario_device is None and mapped_setup_device is not None:
-                        abs_setup_vdevice_mappings[cur_setup_device][cleanup_feature] = {
+                        abs_setup_vdevice_mappings[cur_setup_device][cur_setup_feature_obj] = {
                             used_setup_vdevice: mapped_setup_device}
 
                     feature_replacement[cur_scenario_device][cur_attr_name] = \
-                        (cur_abstract_scenario_feature_obj, cleanup_feature)
+                        (cur_scenario_feature_obj, cur_setup_feature_obj)
             # also add all setup features that are not assigned as autonomous features
-            for _, cur_setup_feature in cur_setup_features.items():
+            for cur_setup_feature in cur_setup_features.values():
                 if cur_setup_feature not in all_assigned_setup_features:
                     # determine free name
                     idx = 0
@@ -461,7 +503,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
@@ -667,31 +709,16 @@ class VariationExecutor(BasicExecutor):
 
     def determine_absolute_scenario_device_connections(self):
         """
-        This method determines the variation absolute connections for this variation and sets them to the internal
-        properties `_abs_variation_*_device_connections`. This will be used to determine the real connection-subtree
+        This method determines the absolute connections for this variation and sets the internal properties
+        `_abs_variation_*_device_connections` with them. This will be used to determine the real connection-subtree
         (that can be used for this variation) by the method `create_all_valid_routings()`.
 
         The method re-executes the algorithm to determine the absolute connections for a scenario/setup (see the method
         :meth:`Collector.determine_absolute_device_connections_for`), but it considers the real applied vDevice and
         their feature restrictions too.
         """
-        abs_var_scenario_device_cnns = {}
-
         # first determine all relevant absolute connection depending on the current scenario
-        for cur_scenario_device, _ in self.base_device_mapping.items():
-            cur_scenario_device_abs_cnns = \
-                DeviceController.get_for(cur_scenario_device).get_all_absolute_connections()
-            for _, cur_cnn_list in cur_scenario_device_abs_cnns.items():
-                for cur_cnn in cur_cnn_list:
-                    if cur_scenario_device not in abs_var_scenario_device_cnns.keys():
-                        abs_var_scenario_device_cnns[cur_scenario_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] = []
-
-                    abs_var_scenario_device_cnns[cur_scenario_device][cur_to_device].append(cur_cnn)
+        abs_var_scenario_device_cnns = self.cur_scenario_controller.get_all_abs_connections()
 
         # now iterate over every feature, that is used by the scenario and determine the class-based feature connections
         # of the mapped scenario feature (and its vDevice)
@@ -714,31 +741,34 @@ class VariationExecutor(BasicExecutor):
 
                 # get relevant class based connections for the current feature on setup level (this is really be used
                 # here)
-                feature_cnns = \
+                feature_cnn = \
                     FeatureController.get_for(
                         cur_setup_feature.__class__).get_abs_class_based_for_vdevice()[cur_setup_feature_vdevice]
                 # connection that are relevant for this feature
-                relevant_cnns = abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device]
+                relevant_cnns = [
+                    cnn for cnn in abs_var_scenario_device_cnns
+                    if cnn.has_connection_from_to(cur_scenario_device, end_device=cur_mapped_scenario_device)
+                ]
 
                 relevant_device_cnn = None
 
                 if len(relevant_cnns) > 1:
                     # we have parallel possibilities -> determine the selected one (only one is allowed to fit)
                     for cur_relevant_cnn in relevant_cnns:
-                        for cur_relevant_single_cnn in cur_relevant_cnn.get_singles():
-                            for cur_feature_cnn in feature_cnns:
-                                for cur_feature_single_cnn in cur_feature_cnn.get_singles():
-                                    if cur_feature_single_cnn.contained_in(cur_relevant_single_cnn):
-                                        if relevant_device_cnn is not None:
-                                            raise UnclearAssignableFeatureConnectionError(
-                                                f"the devices {cur_scenario_device.__name__} and "
-                                                f"{cur_mapped_scenario_device.__name__} have multiple parallel "
-                                                f"connections - the device `{cur_scenario_device.__name__}` uses a "
-                                                f"feature `{cur_scenario_feature.__class__.__name__}` that matches "
-                                                f"with the device `{cur_mapped_scenario_device.__name__}`, but it is "
-                                                f"not clear which of the parallel connection could be used"
-                                            )
-                                        relevant_device_cnn = cur_relevant_cnn
+                        for cur_relevant_single_cnn, cur_feature_single_cnn in (
+                                itertools.product(cur_relevant_cnn.get_singles(), feature_cnn.get_singles())):
+                            if not cur_feature_single_cnn.contained_in(cur_relevant_single_cnn, ignore_metadata=True):
+                                continue
+                            if relevant_device_cnn is not None:
+                                raise UnclearAssignableFeatureConnectionError(
+                                    f"the devices {cur_scenario_device.__name__} and "
+                                    f"{cur_mapped_scenario_device.__name__} have multiple parallel connections - the "
+                                    f"device `{cur_scenario_device.__name__}` uses a feature "
+                                    f"`{cur_scenario_feature.__class__.__name__}` that matches with the device "
+                                    f"`{cur_mapped_scenario_device.__name__}`, but it is not clear which of the "
+                                    f"parallel connection could be used"
+                                )
+                            relevant_device_cnn = cur_relevant_cnn
                 elif len(relevant_cnns) == 1:
                     relevant_device_cnn = relevant_cnns[0]
                 if relevant_device_cnn is None:
@@ -747,36 +777,19 @@ class VariationExecutor(BasicExecutor):
 
                 # now cleanup the scenario-device connection `relevant_device_cnn` according to the class-based feature
                 # connection
-                new_cleaned_singles = []
-                for cur_old_cnn_single in relevant_device_cnn.get_singles():
-                    for cur_feature_cnn in feature_cnns:
-                        if cur_feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True):
-                            new_cleaned_singles.append(cur_old_cnn_single)
-
-                new_cnn_to_replace = Connection.based_on(*new_cleaned_singles)
-                new_cnn_to_replace.set_metadata_for_all_subitems(new_cleaned_singles[0].metadata)
-
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].remove(
-                    relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_scenario_device][cur_mapped_scenario_device].append(new_cnn_to_replace)
-
-                # also search the connection in the other direction
-                other_dir_relevant_device_cnn = None
-                for cur_cnn in abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device]:
-                    if cur_cnn.equal_with(relevant_device_cnn):
-                        other_dir_relevant_device_cnn = cur_cnn
-                        break
-                # and also replace it
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].remove(
-                    other_dir_relevant_device_cnn)
-                abs_var_scenario_device_cnns[cur_mapped_scenario_device][cur_scenario_device].append(new_cnn_to_replace)
+                new_cnn_to_replace = Connection.based_on(OrConnectionRelation(*[
+                    cur_old_cnn_single for cur_old_cnn_single in relevant_device_cnn.get_singles()
+                    if feature_cnn.contained_in(cur_old_cnn_single, ignore_metadata=True)
+                ]))
+                new_cnn_to_replace.set_metadata_for_all_subitems(relevant_device_cnn.metadata)
+
+                abs_var_scenario_device_cnns.remove(relevant_device_cnn)
+                abs_var_scenario_device_cnns.append(new_cnn_to_replace)
+
+                # we do not need to check other direction because `has_connection_from_to()` returns both possibilities
 
         # set the determined values in variation object
-        self._abs_variation_scenario_device_connections = []
-        for _, from_device_dict in abs_var_scenario_device_cnns.items():
-            for _, cur_cnn_list in from_device_dict.items():
-                for cur_cnn in cur_cnn_list:
-                    self._abs_variation_scenario_device_connections.append(cur_cnn)
+        self._abs_variation_scenario_device_connections = abs_var_scenario_device_cnns
 
     def create_all_valid_routings(self):
         """
@@ -816,16 +829,18 @@ class VariationExecutor(BasicExecutor):
                 if virtual_routing_cnns[cur_cnn] is None:
                     virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_cnn)
                 else:
-                    virtual_routing_cnns[cur_cnn] = Connection.based_on(virtual_routing_cnns[cur_cnn], virtual_cnn)
+                    virtual_routing_cnns[cur_cnn] = Connection.based_on(
+                        OrConnectionRelation(virtual_routing_cnns[cur_cnn], virtual_cnn))
                 virtual_routing_cnns[cur_cnn].set_metadata_for_all_subitems(virtual_cnn.metadata)
 
         self._abs_variation_connections = []
         for cur_cnn in self._abs_variation_scenario_device_connections:
             cur_virtual_cnn = virtual_routing_cnns[cur_cnn]
             new_intersection = cur_cnn.intersection_with(cur_virtual_cnn)
-            new_intersection.set_metadata_for_all_subitems(None)
-            # always set the metadata for setup devices
-            new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
+            if new_intersection:
+                new_intersection.set_metadata_for_all_subitems(None)
+                # always set the metadata for setup devices
+                new_intersection.set_metadata_for_all_subitems(cur_virtual_cnn.metadata)
             self._abs_variation_connections.append(new_intersection)
 
     def set_conn_dependent_methods(self):
@@ -861,11 +876,15 @@ class VariationExecutor(BasicExecutor):
                     relevant_abs_conn = []
                     for cur_cnn in self._abs_variation_connections:
                         if cur_cnn.has_connection_from_to(start_device=setup_device, end_device=mapped_setup_device):
-                            relevant_abs_conn.append(cur_cnn)
+                            # add the children
+                            relevant_abs_conn.extend(
+                                cur_cnn.based_on_elements.connections if cur_cnn.__class__ == Connection else [cur_cnn]
+                            )
+
                     if len(relevant_abs_conn) is None:
                         raise RuntimeError(f"detect empty absolute connection between device `{setup_device.__name__}` "
                                            f"and device `{mapped_setup_device.__name__}`")
-                    absolute_feature_method_var_cnn = Connection.based_on(*relevant_abs_conn)
+                    absolute_feature_method_var_cnn = Connection.based_on(OrConnectionRelation(*relevant_abs_conn))
                     cur_method_variation = cur_setup_feature_controller.get_method_variation(
                         of_method_name=cur_method_name, for_vdevice=mapped_vdevice,
                         with_connection=absolute_feature_method_var_cnn)
@@ -876,3 +895,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/feature.py

@@ -16,7 +16,7 @@ class Feature:
         :param kwargs: contains a dictionary that references all vDevices of the feature and a real
                         scenario :meth:`Device` as value
         """
-        from _balder.controllers import FeatureController
+        from _balder.controllers import FeatureController  # pylint: disable=import-outside-toplevel
 
         #: this property contains the active mapping for the devices
         self.active_vdevices: Dict[VDevice, Union[Device, str]] = {}

_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]