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

_balder/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0b8'
+__version__ = version = '0.1.0b10'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/balder_session.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     from _balder.scenario import Scenario
     from _balder.connection import Connection
 
-# pylint: disable-next=too-many-instance-attributes
+
 class BalderSession:
     """
     This is the main balder executable object. It contains all information about the current session and executes the
@@ -289,8 +289,10 @@ class BalderSession:
         """
         This method resolves all classes and executes different checks, that can be done before the test session starts.
         """
-        self.solver = Solver(setups=self.all_collected_setups, scenarios=self.all_collected_scenarios,
-                             connections=self.all_collected_connections, raw_fixtures=self.collector.raw_fixtures)
+        self.solver = Solver(setups=self.all_collected_setups,
+                             scenarios=self.all_collected_scenarios,
+                             connections=self.all_collected_connections,
+                             fixture_manager=self.collector.get_fixture_manager())
         self.solver.resolve(plugin_manager=self.plugin_manager)
 
     def create_executor_tree(self):

_balder/collector.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Type, Union, Dict, Callable, Tuple, TYPE_CHECKING, Any
+from typing import List, Type, Union, Dict, Callable, Tuple, Iterable, Any, TYPE_CHECKING
 
 import os
 import sys
@@ -10,13 +10,16 @@ import inspect
 import pathlib
 import functools
 import importlib.util
-from _balder.utils import get_class_that_defines_method
+from _balder.utils import get_class_that_defines_method, inspect_method
 from _balder.setup import Setup
 from _balder.device import Device
 from _balder.feature import Feature
 from _balder.vdevice import VDevice
 from _balder.scenario import Scenario
 from _balder.connection import Connection
+from _balder.parametrization import FeatureAccessSelector, Parameter
+from _balder.fixture_manager import FixtureManager
+from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.controllers import ScenarioController, SetupController, DeviceController, VDeviceController, \
     FeatureController, NormalScenarioSetupController
 from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
@@ -24,6 +27,7 @@ from _balder.utils import get_scenario_inheritance_list_of
 
 if TYPE_CHECKING:
     from _balder.plugin_manager import PluginManager
+    ConnectionType = Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]
 
 logger = logging.getLogger(__file__)
 
@@ -34,16 +38,23 @@ class Collector:
     but secures that all relevant data is being collected.
     """
     # metadata object that contains all raw fixtures (classes that were not be resolved yet)
-    raw_fixtures = {}
+    _raw_fixtures = {}
 
     # this static attribute will be managed by the decorator `@for_vdevice(..)`. It holds all functions/methods that
     # were decorated with `@for_vdevice(..)` (without checking their correctness). The collector will check them later
     # with the method `rework_method_variation_decorators()`
     _possible_method_variations: Dict[
         Callable,
-        List[Tuple[Union[Type[VDevice], str],
-                   Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]],
-                         List[Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]]]]]] = {}
+        List[Tuple[Union[Type[VDevice], str], Union[ConnectionType, List[ConnectionType]]]]
+    ] = {}
+
+    # this static attribute will be managed by the decorator `@parametrize(..)`. It holds all functions/methods that
+    # were decorated with `@parametrize(..)` (without checking their correctness). The collector will check it later
+    # with the method `rework_static_parametrization_decorators()`
+    _possible_parametrization: Dict[
+        Callable,
+        Dict[str, Union[Iterable[Any], FeatureAccessSelector]]
+    ] = {}
 
     def __init__(self, working_dir: pathlib.Path):
         self.working_dir = pathlib.Path(working_dir)
@@ -58,6 +69,54 @@ class Collector:
 
         self.balderglob_was_loaded = False
 
+    @staticmethod
+    def register_raw_fixture(fixture: Callable, level: str):
+        """
+        allows to register a new fixture - used by decorator `@balder.fixture()`
+
+        :param level: the fixture level
+        :param fixture: the fixture callable itself
+        """
+        if level not in Collector._raw_fixtures.keys():
+            Collector._raw_fixtures[level] = []
+        Collector._raw_fixtures[level].append(fixture)
+
+    @staticmethod
+    def register_possible_method_variation(
+            meth: Callable,
+            vdevice: Union[Type[VDevice], str],
+            with_connections: Union[ConnectionType, List[ConnectionType]]):
+        """
+        allows to register a new method variation - used by decorator `@balder.for_vdevice()`
+
+        :param meth: the method that should be registered
+        :param vdevice: the vdevice the method is for
+        :param with_connections: the connections the method is for
+        """
+        if meth not in Collector._possible_method_variations.keys():
+            Collector._possible_method_variations[meth] = []
+        Collector._possible_method_variations[meth].append((vdevice, with_connections))
+
+    @staticmethod
+    def register_possible_parametrization(
+            meth: Callable,
+            field_name: str,
+            values: Union[Iterable[Any], FeatureAccessSelector]
+    ):
+        """
+        allows to register a possible parametrization - used by decorator `@balder.parametrize()` or
+        `@balder.parametrize_by_feature()`
+
+        :param meth: the method that should be registered
+        :param field_name: the name of the method argument, the parametrized value should be added
+        :param values: an Iterable of all values that should be parametrized or the FeatureAccessSelector object
+        """
+        if meth not in Collector._possible_parametrization.keys():
+            Collector._possible_parametrization[meth] = {}
+        if field_name in Collector._possible_parametrization[meth].keys():
+            raise ValueError(f'field `{field_name}` already registered for method `{meth.__qualname__}`')
+        Collector._possible_parametrization[meth][field_name] = values
+
     @property
     def all_pyfiles(self) -> List[pathlib.Path]:
         """returns a list of all python files that were be found by the collector"""
@@ -96,6 +155,23 @@ class Collector:
             raise AttributeError("please call the `collect()` method before omitting this value")
         return self._all_connections
 
+    def get_fixture_manager(self) -> FixtureManager:
+        """
+        Resolves all fixtures and returns the fixture manager for this session
+        :return: the fixture manager that is valid for this session
+        """
+        resolved_dict = {}
+        for cur_level_as_str, cur_module_fixture_dict in self._raw_fixtures.items():
+            cur_level = FixtureExecutionLevel(cur_level_as_str)
+            resolved_dict[cur_level] = {}
+            for cur_fn in cur_module_fixture_dict:
+                cls, func_type = inspect_method(cur_fn)
+                # mechanism also works for balderglob fixtures (`func_type` is 'function' and `cls` is None)
+                if cls not in resolved_dict[cur_level].keys():
+                    resolved_dict[cur_level][cls] = []
+                resolved_dict[cur_level][cls].append((func_type, cur_fn))
+        return FixtureManager(resolved_dict)
+
     def load_balderglob_py_file(self) -> Union[types.ModuleType, None]:
         """
         This method loads the global balderglob.py file and returns the module or None if the file does not exist.
@@ -475,6 +551,38 @@ class Collector:
             setattr(owner, name, new_callback)
             owner_feature_controller.set_method_based_for_vdevice(owner_for_vdevice)
 
+    @staticmethod
+    def rework_parametrization_decorators():
+        """
+        This method iterates over the static attribute `Collector._possible_static_parametrization` and checks if these
+        decorated functions are valid (if they are test methods and part of a :meth:`Scenario` class).
+        """
+
+        for cur_fn, cur_decorator_data_dict in Collector._possible_parametrization.items():
+            owner = get_class_that_defines_method(cur_fn)
+            if not issubclass(owner, Scenario):
+                raise TypeError(f'the related class of `{cur_fn.__qualname__}` is not a `Scenario` class')
+            owner_scenario_controller = ScenarioController.get_for(owner)
+            if cur_fn not in owner_scenario_controller.get_all_test_methods():
+                raise TypeError(f'the method {cur_fn.__qualname__} is not a test method')
+            args_of_cur_fn = inspect.getfullargspec(cur_fn).args
+
+            for cur_field_name, cur_value_list in cur_decorator_data_dict.items():
+                if isinstance(cur_value_list, FeatureAccessSelector):
+                    # make sure that all parameters exist in test method parametrization
+                    for cur_value_parameter in cur_value_list.parameters.values():
+                        if isinstance(cur_value_parameter, Parameter):
+                            if cur_value_parameter.name not in cur_decorator_data_dict.keys():
+                                raise AttributeError(f'can not find attribute `{cur_value_parameter.name}` that is '
+                                                     f'used in parametrization for attribute `{cur_field_name}` in '
+                                                     f'test method `{cur_fn.__qualname__}`')
+                if cur_field_name not in args_of_cur_fn:
+                    raise ValueError(f'the argument `{cur_field_name}` does not exist in test method '
+                                     f'`{cur_fn.__qualname__}`')
+                owner_scenario_controller.register_parametrization(cur_fn, cur_field_name, cur_value_list)
+
+            owner_scenario_controller.check_for_parameter_loop_in_dynamic_parametrization(cur_fn)
+
     def get_all_scenario_feature_classes(self) -> List[Type[Feature]]:
         """
         This method returns a list with all :class:`Feature` classes that are being instantiated in one or more
@@ -678,7 +786,8 @@ class Collector:
         for cur_setup in self.all_setups:
             SetupController.get_for(cur_setup).validate_feature_possibility()
 
-    def _filter_paths_after_allowed_paths(self, paths: List[pathlib.Path], filter_patterns: List[str]) -> List[pathlib.Path]:
+    def _filter_paths_after_allowed_paths(self, paths: List[pathlib.Path], filter_patterns: List[str]) \
+            -> List[pathlib.Path]:
         """
         This method filters the given list of filepaths for the given filter_patterns. It returns a list with all
         remaining paths that are mathing the filter statements in `filter_paths`.
@@ -696,7 +805,6 @@ class Collector:
                           if fnmatch.fnmatch(str(cur_abs_path.relative_to(self.working_dir)), cur_pattern)]
         return list(set(remaining))
 
-
     def collect(self, plugin_manager: PluginManager, scenario_filter_patterns: Union[List[str], None],
                 setup_filter_patterns: Union[List[str], None]):
         """
@@ -738,6 +846,7 @@ class Collector:
         self._all_setups = Collector.filter_parent_classes_of(items=self._all_setups)
 
         Collector.rework_method_variation_decorators()
+        Collector.rework_parametrization_decorators()
 
         # do some further stuff after everything was read
         self._set_original_vdevice_in_features()

_balder/console/balder.py

@@ -50,7 +50,7 @@ def _console_balder_debug(cmd_args: Optional[List[str]] = None, working_dir: Uni
             cb_balder_exc(exc)
         traceback.print_exception(*sys.exc_info())
         sys.exit(ExitCode.BALDER_USAGE_ERROR.value)
-    except Exception as exc:
+    except Exception as exc:  # pylint: disable=broad-exception-caught
         # a unexpected error occurs
         if cb_unexpected_exc:
             cb_unexpected_exc(exc)

_balder/controllers/device_controller.py

@@ -122,7 +122,7 @@ class DeviceController(BaseDeviceController, ABC):
             if issubclass(cur_base, Device):
                 if next_base_class is not None:
                     raise MultiInheritanceError(
-                        f"found more than one Devuce parent classes for `{self.related_cls.__name__}` "
+                        f"found more than one Device parent classes for `{self.related_cls.__name__}` "
                         f"- multi inheritance is not allowed for Device classes")
                 next_base_class = cur_base
         if next_base_class == Device:

_balder/controllers/feature_controller.py

@@ -129,6 +129,39 @@ class FeatureController(Controller):
             return [Connection()]
         return intersection
 
+    def _determine_all_theoretically_unordered_method_variations(
+            self, of_method_name: str, for_vdevice: Type[VDevice],
+            with_connection: Union[Connection, Tuple[Connection]]) -> Dict[Callable, Connection]:
+        """
+        This method returns all theoretically matching method variations. It returns more than one, if there are
+        multiple method variation for the given VDevice in this feature, where the given connection is part of the
+        connection described by the method variation.
+
+        :param of_method_name: the name of the method that should be returned
+        :param for_vdevice: the VDevice that is mapped
+        :param with_connection: the connection that is used between the device that uses the related feature and the
+                                VDevice
+        :return: a dictionary that holds all available method variation that matches here
+        """
+        all_possible_method_variations = {}
+        for cur_impl_method, cur_method_impl_dict in self.get_method_based_for_vdevice()[of_method_name].items():
+            if for_vdevice in cur_method_impl_dict.keys():
+                cur_impl_method_cnns = []
+                for cur_cnn in cur_method_impl_dict[for_vdevice]:
+                    cur_impl_method_cnns += cur_cnn.get_singles()
+                for cur_single_impl_method_cnn in cur_impl_method_cnns:
+                    if cur_single_impl_method_cnn.contained_in(with_connection, ignore_metadata=True):
+                        # this variation is possible
+                        # ADD IT if it is not available yet
+                        if cur_impl_method not in all_possible_method_variations.keys():
+                            all_possible_method_variations[cur_impl_method] = cur_single_impl_method_cnn
+                        # COMBINE IT if it is already available
+                        else:
+                            all_possible_method_variations[cur_impl_method] = Connection.based_on(
+                                all_possible_method_variations[cur_impl_method], cur_single_impl_method_cnn)
+        return all_possible_method_variations
+
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def get_class_based_for_vdevice(self) -> Union[Dict[Type[VDevice], List[Connection]], None]:
@@ -321,24 +354,10 @@ class FeatureController(Controller):
             raise ValueError(f"can not find the method `{of_method_name}` in method variation data dictionary")
 
         # first determine all possible method-variations
-        all_possible_method_variations = {}
-        for cur_impl_method, cur_method_impl_dict in self.get_method_based_for_vdevice()[of_method_name].items():
-            if for_vdevice in cur_method_impl_dict.keys():
-                cur_impl_method_cnns = []
-                for cur_cnn in cur_method_impl_dict[for_vdevice]:
-                    cur_impl_method_cnns += cur_cnn.get_singles()
-                for cur_single_impl_method_cnn in cur_impl_method_cnns:
-                    if cur_single_impl_method_cnn.contained_in(with_connection, ignore_metadata=True):
-                        # this variation is possible
-                        # ADD IT if it is not available yet
-                        if cur_impl_method not in all_possible_method_variations.keys():
-                            all_possible_method_variations[cur_impl_method] = cur_single_impl_method_cnn
-                        # COMBINE IT if it is already available
-                        else:
-                            all_possible_method_variations[cur_impl_method] = Connection.based_on(
-                                all_possible_method_variations[cur_impl_method], cur_single_impl_method_cnn)
+        all_possible_method_variations = self._determine_all_theoretically_unordered_method_variations(
+            of_method_name=of_method_name, for_vdevice=for_vdevice, with_connection=with_connection)
 
-        # if there are more than one possible method variation, try to sort them hierarchical
+        # there are no method variations in this feature directly -> check parent classes
         if len(all_possible_method_variations) == 0:
             # try to execute this method in parent classes
             for cur_base in self.related_cls.__bases__:
@@ -355,9 +374,11 @@ class FeatureController(Controller):
                     f"and usable connection `{with_connection.get_tree_str()}´")
             return None
 
+        # we only have one -> selection is clear
         if len(all_possible_method_variations) == 1:
             return list(all_possible_method_variations.keys())[0]
 
+        # if there are more than one possible method variation, try to sort them hierarchical
         # we have to determine the outer one
         length_before = None
         while length_before is None or length_before != len(all_possible_method_variations):

_balder/controllers/normal_scenario_setup_controller.py

@@ -10,7 +10,7 @@ from _balder.scenario import Scenario
 from _balder.controllers.controller import Controller
 from _balder.controllers.device_controller import DeviceController
 from _balder.controllers.vdevice_controller import VDeviceController
-from _balder.exceptions import MultiInheritanceError, DeviceOverwritingError
+from _balder.exceptions import MultiInheritanceError, DeviceOverwritingError, MissingFeaturesOfVDeviceError
 
 if TYPE_CHECKING:
     from _balder.connection import Connection
@@ -188,7 +188,7 @@ class NormalScenarioSetupController(Controller, ABC):
 
         devices = self.get_all_inner_device_classes()
         abs_parent_devices = parent_scenario_or_setup_controller.get_all_abs_inner_device_classes()
-        abs_parent_devices_as_names = [cur_parent.__name__ for cur_parent in abs_parent_devices]
+        abs_parent_devices_by_name = {cur_parent.__name__: cur_parent for cur_parent in abs_parent_devices}
 
         if len(devices) == 0:
             # ignore it because cur item has no own device definitions
@@ -197,10 +197,7 @@ class NormalScenarioSetupController(Controller, ABC):
         # check that a device is newly defined or has the same name as the parent device
         for cur_item_device in devices:
             # check if name exists in parent
-            relevant_parent_according_naming = None
-            if cur_item_device.__name__ in abs_parent_devices_as_names:
-                relevant_parent_according_naming = \
-                    abs_parent_devices[abs_parent_devices_as_names.index(cur_item_device.__name__)]
+            relevant_parent_according_naming = abs_parent_devices_by_name.get(cur_item_device.__name__, None)
 
             # check if device is inherited from a parent
             relevant_parent_device_according_inheritance = None
@@ -236,11 +233,7 @@ class NormalScenarioSetupController(Controller, ABC):
 
         # secure that all parent devices are implemented here too
         for cur_parent in abs_parent_devices:
-            found_parent = False
-            for cur_item_device in devices:
-                if issubclass(cur_item_device, cur_parent):
-                    found_parent = True
-                    break
+            found_parent = len([dev for dev in devices if issubclass(dev, cur_parent)]) > 0
             if not found_parent:
                 raise DeviceOverwritingError(
                     f"found a device `{cur_parent.__qualname__}` which is part of a parent class, but it is "
@@ -285,7 +278,7 @@ class NormalScenarioSetupController(Controller, ABC):
                             found_it = True
                             break
                     if not found_it:
-                        raise Exception(
+                        raise MissingFeaturesOfVDeviceError(
                             f"the device `{related_device.__name__}` which is mapped to the VDevice "
                             f"`{active_vdevice.__name__}` doesn't have an implementation for the feature "
                             f"`{cur_vdevice_feature.__class__.__name__}` required by the VDevice class "

_balder/controllers/scenario_controller.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
-from typing import Type, Dict, List, Tuple, Union
+from typing import Type, Dict, List, Tuple, Union, Callable, Iterable, Any
 
 import logging
 import inspect
+from collections import OrderedDict
 from _balder.device import Device
 from _balder.scenario import Scenario
 from _balder.connection import Connection
 from _balder.controllers.feature_controller import FeatureController
 from _balder.controllers.device_controller import DeviceController
 from _balder.controllers.normal_scenario_setup_controller import NormalScenarioSetupController
+from _balder.parametrization import FeatureAccessSelector, Parameter
 from _balder.exceptions import UnclearAssignableFeatureConnectionError, ConnectionIntersectionError, \
     MultiInheritanceError
 
@@ -26,6 +28,8 @@ class ScenarioController(NormalScenarioSetupController):
     #: contains all existing scenarios and its corresponding controller object
     _items: Dict[Type[Scenario], ScenarioController] = {}
 
+    _parametrization: Dict[Callable, Dict[str, Union[Iterable[Any], FeatureAccessSelector]]] = {}
+
     def __init__(self, related_cls, _priv_instantiate_key):
 
         # describes if the current controller is for setups or for scenarios (has to be set in child controller)
@@ -72,6 +76,92 @@ class ScenarioController(NormalScenarioSetupController):
 
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def register_parametrization(
+            self,
+            test_method: Callable,
+            field_name: str,
+            values: Iterable[Any] | FeatureAccessSelector
+    ) -> None:
+        """
+        This method registers a custom parametrization for a test method of this Scenario
+        """
+        if test_method not in self.get_all_test_methods():
+            raise ValueError(f'got test method `{test_method.__qualname__}` which is no part of the '
+                             f'scenario `{self.related_cls}`')
+        if test_method not in self._parametrization.keys():
+            self._parametrization[test_method] = {}
+        if field_name in self._parametrization[test_method].keys():
+            raise ValueError(f'field name `{field_name}` for test method `{test_method.__qualname__}` already '
+                             f'registered')
+        self._parametrization[test_method][field_name] = values
+
+    def get_parametrization_for(
+            self,
+            test_method: Callable,
+            static: bool = True,
+            dynamic: bool = True,
+    ) -> OrderedDict[str, Iterable[Any] | FeatureAccessSelector] | None:
+        """
+        This method returns the parametrization for a test method of this Scenario. It returns the parameter
+        configuration for every parameter in an OrderedDict.
+
+        :param test_method: the test method of the Scenario
+        :param static: if False, all static parameters will not be included into the dict.
+        :param dynamic: if False, all dynamic parameters will not be included into the dict.
+        """
+        if test_method not in self._parametrization.keys():
+            return None
+        params = self._parametrization[test_method]
+
+        # get arguments in defined order
+        arguments = [name for name in inspect.getfullargspec(test_method).args if name in params.keys()]
+        ordered_dict = OrderedDict()
+        for cur_arg in arguments:
+            cur_value = params[cur_arg]
+            if isinstance(cur_value, FeatureAccessSelector) and dynamic is False:
+                continue
+            if not isinstance(cur_value, FeatureAccessSelector) and static is False:
+                continue
+            ordered_dict[cur_arg] = params[cur_arg]
+        return ordered_dict
+
+    def check_for_parameter_loop_in_dynamic_parametrization(self, cur_fn: Callable):
+        """
+        This method checks for a parameter loop in all dynamic parametrization for a specific test method. If it detects
+        a loop an AttributeError is thrown
+        """
+        # only dynamic parametrization can have Parameter
+        parametrization = self.get_parametrization_for(cur_fn, static=False, dynamic=True)
+
+        def get_dependent_parameters_of_attribute(attribute: str) -> List[str] | None:
+            cur_feature_access_selector = parametrization.get(attribute)
+            if cur_feature_access_selector is None:
+                return None
+            # relevant are parameters only if they are from :class:`Parameter` and contained in the dynamic
+            # parametrization
+            return [param.name for param in cur_feature_access_selector.parameters.values()
+                    if isinstance(param, Parameter) and param.name in parametrization.keys()]
+
+        def recursive_parameter_loop_check(for_attribute, with_attribute: str):
+            dependent_attr = get_dependent_parameters_of_attribute(with_attribute)
+            if dependent_attr is None:
+                # no problematic dependencies because attribute is no dynamic attribute
+                return
+            if len(dependent_attr) == 0:
+                # no problematic dependencies
+                return
+
+            if for_attribute in dependent_attr:
+                # loop detected
+                raise AttributeError('detect a loop in Parameter() object - can not apply parametrization')
+            # go deeper and resolve all dependent
+            for cur_dependent_attr in dependent_attr:
+                recursive_parameter_loop_check(for_attribute, cur_dependent_attr)
+            return
+
+        for cur_attr in parametrization.keys():
+            recursive_parameter_loop_check(cur_attr, cur_attr)
+
     def get_next_parent_class(self) -> Union[Type[Scenario], None]:
         """
         This method returns the next parent class which is a subclass of the :class:`Scenario` itself.

_balder/decorator_fixture.py

@@ -3,7 +3,7 @@ from typing import Literal
 
 import functools
 from _balder.collector import Collector
-from _balder.fixture_manager import FixtureManager
+from _balder.fixture_execution_level import FixtureExecutionLevel
 
 
 def fixture(level: Literal['session', 'setup', 'scenario', 'variation', 'testcase']):
@@ -12,17 +12,14 @@ def fixture(level: Literal['session', 'setup', 'scenario', 'variation', 'testcas
 
     :param level: the execution level the fixture should have
     """
-    allowed_levels = FixtureManager.EXECUTION_LEVEL_ORDER
+    allowed_levels = [level.value for level in FixtureExecutionLevel]
 
     if level not in allowed_levels:
         raise ValueError(f"the value of `level` must be a `str` with one of the values `{'`, `'.join(allowed_levels)}`")
 
     def decorator_fixture(func):
-        # always add the fixture to FixtureManager.raw_fixtures - class determination will be done later by
-        # :meth:`Collector`
-        if level not in Collector.raw_fixtures.keys():
-            Collector.raw_fixtures[level] = []
-        Collector.raw_fixtures[level].append(func)
+        # always register the raw fixture in Collector - class determination will be done later by :meth:`Collector`
+        Collector.register_raw_fixture(func, level)
 
         @functools.wraps(func)
         def wrapper_fixture(*args, **kwargs):

_balder/decorator_for_vdevice.py

@@ -4,7 +4,6 @@ from typing import List, Union, Type, Tuple
 import inspect
 from _balder.collector import Collector
 from _balder.feature import Feature
-from _balder.device import Device
 from _balder.vdevice import VDevice
 from _balder.connection import Connection
 from _balder.controllers import FeatureController
@@ -12,7 +11,7 @@ from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
 
 
 def for_vdevice(
-        vdevice: Union[str, Device],
+        vdevice: Union[str, Type[VDevice]],
         with_connections: Union[
             Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]],
             List[Union[Type[Connection], Connection, Tuple[Union[Type[Connection], Connection]]]]] = Connection(),
@@ -58,9 +57,10 @@ def for_vdevice(
                              f"a element of it")
 
         idx += 1
+
     # note: if `args` is an empty list - no special sub-connection-tree bindings
 
-    if not isinstance(vdevice, str) and not isinstance(vdevice, VDevice):
+    if not (isinstance(vdevice, str) or (isinstance(vdevice, type) and issubclass(vdevice, VDevice))):
         raise ValueError('the given element for `vdevice` has to be a `str` or has to be a subclass of'
                          '`VDevice`')
 
@@ -74,9 +74,7 @@ def for_vdevice(
             self.func = func
 
             # we detect a decorated non-class object -> save it and check it later in collector
-            if func not in Collector._possible_method_variations.keys():
-                Collector._possible_method_variations[func] = []
-            Collector._possible_method_variations[func].append((vdevice, with_connections))
+            Collector.register_possible_method_variation(func, vdevice, with_connections)
 
         def __new__(cls, *args, **kwargs):  # pylint: disable=unused-argument
             nonlocal vdevice

_balder/decorator_parametrize.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import Iterable, Any
+
+import inspect
+from _balder.collector import Collector
+
+
+def parametrize(
+        field_name: str,
+        values: Iterable[Any],
+):
+    """
+    Allows to parametrize a test function. This decorator will be used to statically parametrize a test function.
+
+    :param field_name: the field name of the test function
+
+    :param values: an iterable of values, that should be used to parametrize the test function
+    """
+    if not isinstance(field_name, str):
+        raise ValueError('the given field name must be a string')
+
+    def decorator(func):
+        nonlocal field_name
+        nonlocal values
+
+        if not inspect.isfunction(func):
+            raise TypeError('the decorated object needs to be a test method')
+
+        Collector.register_possible_parametrization(func, field_name, values)
+        return func
+    return decorator

_balder/decorator_parametrize_by_feature.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Dict, Tuple, Type
+
+import inspect
+from _balder.collector import Collector
+from _balder.device import Device
+from _balder.parametrization import FeatureAccessSelector, Parameter, Value
+
+
+def parametrize_by_feature(
+        field_name: str,
+        feature_accessor: Tuple[Type[Device], str, str],
+        parameter: Dict[str, FeatureAccessSelector | Parameter | Value] = None
+):
+    """
+    Allows to parametrize a test function. This decorator will be used to dynamically parametrize a test function, by
+    the value a setup feature returns before entering the test.
+
+    :param field_name: the field name of the test function
+    :param feature_accessor: a tuple that provides information for accessing the feature
+    :param parameter: the parameter to parametrize the feature method (if necessary)
+    """
+    if not isinstance(field_name, str):
+        raise ValueError('the given field name must be a string')
+    if parameter is None:
+        parameter = {}
+
+    feature_accessor = FeatureAccessSelector(*feature_accessor, parameters=parameter)
+
+    def decorator(func):
+        if not inspect.isfunction(func):
+            raise TypeError('the decorated object needs to be a test method')
+
+        Collector.register_possible_parametrization(func, field_name, feature_accessor)
+        return func
+    return decorator

_balder/exceptions.py

@@ -158,6 +158,12 @@ class IllegalVDeviceMappingError(BalderException):
     """
 
 
+class MissingFeaturesOfVDeviceError(BalderException):
+    """
+    is thrown if the related device does not implement all features specified in its mapped VDevice.
+    """
+
+
 class NotApplicableVariationException(BalderException):
     """
     is thrown internally after the current variation is not applicable