baldertest 0.1.0b12__py3-none-any.whl → 0.1.0b14__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:
         """

_balder/executor/variation_executor.py

@@ -171,7 +171,7 @@ class VariationExecutor(BasicExecutableExecutor):
             self.exchange_unmapped_vdevice_references()
             self.update_vdevice_referenced_feature_instances()
             self.set_conn_dependent_methods()
-            self.resolve_possible_parametrization()
+            self.resolve_and_exchange_unresolved_parametrization()
 
     def _body_execution(self, show_discarded):
         if show_discarded and not self.can_be_applied():
@@ -179,13 +179,10 @@ class VariationExecutor(BasicExecutableExecutor):
             return
 
         for cur_testcase_executor in self.get_testcase_executors():
-            if cur_testcase_executor.has_runnable_tests():
-
+            if (cur_testcase_executor.has_runnable_tests()
+                    or cur_testcase_executor.has_skipped_tests()
+                    or cur_testcase_executor.has_covered_by_tests()):
                 cur_testcase_executor.execute()
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.SKIP:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_testcase_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
-                cur_testcase_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_testcase_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
@@ -335,16 +332,9 @@ class VariationExecutor(BasicExecutableExecutor):
             return super().testsummary()
         return ResultSummary()
 
-    def get_testcase_executors(self) -> List[TestcaseExecutor]:
+    def get_testcase_executors(self) -> List[TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor]:
         """returns all sub testcase executors that belongs to this variation-executor"""
-        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
+        return self._testcase_executors.copy()
 
     def add_testcase_executor(self, testcase_executor: TestcaseExecutor | UnresolvedParametrizedTestcaseExecutor):
         """
@@ -388,12 +378,9 @@ class VariationExecutor(BasicExecutableExecutor):
             setup_dev: FeatureVDeviceMapping() 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()
 
-            all_assigned_setup_features = []
-            cur_scenario_device_features = \
-                DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects()
-            for cur_attr_name, cur_scenario_feature_obj in cur_scenario_device_features.items():
+            for cur_attr_name, cur_scenario_feature_obj in \
+                    DeviceController.get_for(cur_scenario_device).get_all_instantiated_feature_objects().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(
@@ -407,13 +394,14 @@ class VariationExecutor(BasicExecutableExecutor):
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
                 cur_setup_feature_obj = cur_setup_feature_objs[0]
 
+                all_abs_inner_vdevs_of_setup = \
+                    FeatureController.get_for(cur_setup_feature_obj.__class__).get_abs_inner_vdevice_classes()
+                used_setup_vdevice, mapped_setup_device = cur_setup_feature_obj.active_vdevice_device_mapping
+
                 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 = 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:
+                    if mapped_setup_device is None and len(all_abs_inner_vdevs_of_setup) > 0:
                         # there is no vDevice mapping on scenario and no vDevice mapping on setup level, but the
                         # feature defined vDevices -> NOT APPLICABLE
                         logger.warning(
@@ -427,19 +415,14 @@ class VariationExecutor(BasicExecutableExecutor):
                             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(cur_setup_feature_obj)
                 if cur_attr_name not in feature_replacement[cur_scenario_device].attr_names:
-                    cleanup_feature_controller = FeatureController.get_for(cur_setup_feature_obj.__class__)
-
-                    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
                     if mapped_scenario_device is not None and mapped_setup_device is None:
                         # search the equivalent vDevice on setup level and use this one (we had not to check it,
                         # because check was already done in collector-stage)
-                        setup_vdevices = [cur_vdevice for cur_vdevice
-                                          in cleanup_feature_controller.get_abs_inner_vdevice_classes()
+                        setup_vdevices = [cur_vdevice for cur_vdevice in all_abs_inner_vdevs_of_setup
                                           if cur_vdevice.__name__ == active_scenario_vdevice.__name__]
                         used_setup_vdevice = setup_vdevices[0]
                         # set the mapping
@@ -463,21 +446,7 @@ class VariationExecutor(BasicExecutableExecutor):
                                                                  scenario_feature=cur_scenario_feature_obj,
                                                                  setup_feature=cur_setup_feature_obj)
 
-            # also add all setup features that are not assigned as autonomous features
-            for cur_setup_feature in cur_setup_features.values():
-                if cur_setup_feature not in all_assigned_setup_features:
-                    # determine free name
-                    idx = 0
-                    autonomous_name = None
-                    while (autonomous_name is None
-                           or autonomous_name in feature_replacement[cur_scenario_device].attr_names):
-                        autonomous_name = f"_autonomous_feat_{idx}"
-                        idx += 1
-                    feature_replacement[cur_scenario_device].add(
-                        attr_name=autonomous_name,
-                        scenario_feature=None,
-                        setup_feature=cur_setup_feature
-                    )
+            feature_replacement[cur_scenario_device].add_remaining_setup_features_as_autonomous(cur_setup_device)
 
         # set the result to internal properties
         self._feature_replacement = feature_replacement
@@ -902,8 +871,12 @@ class VariationExecutor(BasicExecutableExecutor):
 
                 cur_setup_feature_controller.set_active_method_variation(method_selection=method_var_selection)
 
-    def resolve_possible_parametrization(self):
+    def resolve_and_exchange_unresolved_parametrization(self):
         """resolves the parametrization if there are any :class:`UnresolvedParametrizedTestcaseExecutor` in the tree"""
+        replaced_executors = []
         for cur_child in self._testcase_executors:
             if isinstance(cur_child, UnresolvedParametrizedTestcaseExecutor):
-                cur_child.resolve_dynamic_parametrization()
+                replaced_executors.extend(cur_child.get_resolved_parametrized_testcase_executors())
+            else:
+                replaced_executors.append(cur_child)
+        self._testcase_executors = replaced_executors

_balder/feature.py

@@ -3,9 +3,10 @@ from typing import Type, Dict, Tuple, Union
 
 from _balder.device import Device
 from _balder.vdevice import VDevice
+from _balder.utils.inner_device_managing_metaclass import InnerDeviceManagingMetaclass
 
 
-class Feature:
+class Feature(metaclass=InnerDeviceManagingMetaclass):
     """
     This is the basic feature class. It represents an abstract class that should not be used directly. It is the base
     class for all feature elements.

_balder/feature_replacement_mapping.py

@@ -1,6 +1,8 @@
-from typing import Union
+from typing import Union, Type
 import dataclasses
+from .device import Device
 from .feature import Feature
+from .controllers import DeviceController
 
 
 class FeatureReplacementMapping:
@@ -37,6 +39,20 @@ class FeatureReplacementMapping:
         """
         return [mapping.attr_name for mapping in self._mappings]
 
+    @property
+    def all_scenario_features(self) -> list[Feature]:
+        """
+        returns all scenario features
+        """
+        return [mapping.scenario_feature for mapping in self._mappings]
+
+    @property
+    def all_setup_features(self) -> list[Feature]:
+        """
+        returns all setup features
+        """
+        return [mapping.setup_feature for mapping in self._mappings]
+
     def add(self, attr_name: str, scenario_feature: Union[Feature, None], setup_feature: Feature):
         """
         adds a new mapping
@@ -67,3 +83,25 @@ class FeatureReplacementMapping:
             if mapping.setup_feature == setup_feature:
                 return mapping.scenario_feature
         raise KeyError(f'cannot find setup feature for {setup_feature}')
+
+    def add_remaining_setup_features_as_autonomous(self, cur_setup_device: Type[Device]):
+        """
+        Adds all features that were not added as autonomous features.
+        """
+        cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+
+        # also add all setup features that are not assigned as autonomous features
+        for cur_setup_feature in cur_setup_features.values():
+            if cur_setup_feature not in self.all_setup_features:
+                # determine free name
+                idx = 0
+                autonomous_name = None
+                while (autonomous_name is None
+                       or autonomous_name in self.attr_names):
+                    autonomous_name = f"_autonomous_feat_{idx}"
+                    idx += 1
+                self.add(
+                    attr_name=autonomous_name,
+                    scenario_feature=None,
+                    setup_feature=cur_setup_feature
+                )

_balder/fixture_manager.py

@@ -19,7 +19,7 @@ from _balder.exceptions import LostInExecutorTreeException, FixtureReferenceErro
     UnclearUniqueClassReference
 
 if TYPE_CHECKING:
-    from _balder.utils import MethodLiteralType
+    from _balder.utils.functions import MethodLiteralType
     from _balder.executor.executor_tree import ExecutorTree
 
 

_balder/fixture_metadata.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Union, Type, Callable, Generator, TYPE_CHECKING
 import dataclasses
 
-from .utils import MethodLiteralType
+from .utils.typings import MethodLiteralType
 
 if TYPE_CHECKING:
     from _balder.scenario import Scenario