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

_balder/fixture_manager.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
-from typing import List, Tuple, Generator, Dict, Union, Type, Callable, TYPE_CHECKING
+from typing import List, Tuple, Generator, Dict, Union, Type, Callable, Iterable, TYPE_CHECKING
 
 import inspect
 from graphlib import TopologicalSorter
 from _balder.executor.testcase_executor import TestcaseExecutor
 from _balder.scenario import Scenario
 from _balder.setup import Setup
+from _balder.fixture_definition_scope import FixtureDefinitionScope
+from _balder.fixture_execution_level import FixtureExecutionLevel
+from _balder.fixture_metadata import FixtureMetadata
 from _balder.executor.basic_executor import BasicExecutor
 from _balder.executor.setup_executor import SetupExecutor
 from _balder.executor.scenario_executor import ScenarioExecutor
@@ -22,22 +25,22 @@ class FixtureManager:
     """
     This class is the global fixture manager. It provides various methods to manage fixtures in the balder system.
     """
-    #: the ordering for the execution levels
-    EXECUTION_LEVEL_ORDER = ['session', 'setup', 'scenario', 'variation', 'testcase']
 
-    def __init__(self, fixtures: Dict[str, Dict[Union[type, None], List[Tuple[MethodLiteralType, Callable]]]]):
+    def __init__(
+            self,
+            fixtures: Dict[FixtureExecutionLevel,
+                           Dict[Union[None, Type[Scenario], Type[Setup]], List[Tuple[MethodLiteralType, Callable]]]]):
 
-        # The first key is the fixture level, the second key is the namespace in which the fixture is defined (for
-        # example the scenario class), which describes the definition-scope. As value a list with tuples is returned.
-        #  The first element is the type of the method/function and the second is the callable itself.
-        self.fixtures: Dict[str, Dict[Union[type, None], List[Tuple[MethodLiteralType, Callable]]]] = fixtures
+        # The first key is the fixture level, the second key is the namespace in which the fixture is defined. As value
+        # a list with tuples is returned. The first element is the type of the method/function and the second is the
+        # callable itself.
+        self.fixtures: Dict[FixtureExecutionLevel,
+                            Dict[Union[None, Type[Scenario], Type[Setup]], List[Tuple[MethodLiteralType, Callable]]]] \
+            = fixtures
 
-        # contains all active fixtures with their namespace, their func_type, their callable, the generator object
-        # (otherwise an empty generator, if the fixture is not a generator) and the result according to the fixture's
-        # construction code (will be cleaned after it leaves a level)
-        self.current_tree_fixtures: \
-            Dict[str, List[
-                Tuple[Union[Type[ExecutorTree], Type[Setup], Type[Scenario]], str, Callable, Generator, object]]] = {}
+        # contains all active fixtures with their namespace, their func_type, their callable, the generator object and
+        # the result according to the fixture's construction code (will be cleaned after it leaves a level)
+        self.current_tree_fixtures: Dict[FixtureExecutionLevel, List[FixtureMetadata]] = {}
 
     # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
 
@@ -45,128 +48,23 @@ class FixtureManager:
 
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
-    @property
-    def resolve_type_level(self):
-        """
-        returns a dictionary that holds the executor class as key and the fixture definition that belongs to this
-        executor class as key
-        """
-        from _balder.executor.executor_tree import ExecutorTree
-
-        return {
-            ExecutorTree: 'session',
-            SetupExecutor: 'setup',
-            ScenarioExecutor: 'scenario',
-            VariationExecutor: 'variation',
-            TestcaseExecutor: 'testcase'
-        }
-
-    @property
-    def definition_scope_order(self):
-        """
-        returns a list with the definition scope objects in the priority order (ExecutorTree stands for global fixtures)
-        """
-        from _balder.executor.executor_tree import ExecutorTree
-        return [ExecutorTree, Setup, Scenario]
-
     @property
     def all_already_run_fixtures(self) -> List[Callable]:
         """
         returns a list of all fixtures that have already been run
         """
         complete_list_in_order = []
-        for cur_level in self.EXECUTION_LEVEL_ORDER:
+        for cur_level in FixtureExecutionLevel:
             if cur_level in self.current_tree_fixtures.keys():
                 complete_list_in_order += [
-                    cur_fixture for _, _, cur_fixture, _, _ in self.current_tree_fixtures[cur_level]]
+                    cur_fixture_metadata.callable for cur_fixture_metadata in self.current_tree_fixtures[cur_level]]
         return complete_list_in_order
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def get_all_attribute_values(
-            self, branch: Union[ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor, TestcaseExecutor],
-            callable_func_namespace: Union[Type[ExecutorTree], Type[Scenario], Type[Setup]], callable_func: Callable,
-            func_type: str) -> Dict[str, object]:
-        """
-        This method tries to fill the unresolved function/method arguments of the given fixture callable. For this it
-        searches the return values of all already executed fixtures and supplies the argument values of the
-        given ``fixture`` callable in a dictionary.
-
-        It automatically manages `self` / `cls` references for func_type `instancemethod` or `classmethod`. It
-        only returns the fixture references and ignores `self` / `cls`
-
-        First the method tries to find the arguments in all fixtures that are in the same namespace. If it does not find
-        any references, it will look in the next higher scope. It only uses fixture that has run before!
-
-        :param branch: the current active branch
-
-        :param callable_func_namespace: the namespace of the current fixture
-
-        :param callable_func: the callable with the arguments
-
-        :param func_type: returns the func_type of the fixture - depending on this value the first argument will be
-                          ignored, because it has to be `cls` for `classmethod` and `self` for `instancemethod`
-
-        :return: the method returns a dictionary with the attribute name as key and the return value as value
-        """
-        from _balder.executor.executor_tree import ExecutorTree
-
-        arguments = inspect.getfullargspec(callable_func).args
-        result_dict = {}
-
-        if func_type in ["classmethod", "instancemethod"]:
-            arguments = arguments[1:]
-
-        self._validate_for_unclear_setup_scoped_fixture_reference(
-            callable_func_namespace, callable_func, arguments,
-            cur_execution_level=self.resolve_type_level[branch.__class__])
-        all_possible_namespaces = [ExecutorTree]
-        # determine namespaces (in the correct order)
-        setup_type = None
-        scenario_type = None
-        if isinstance(branch, SetupExecutor):
-            setup_type = branch.base_setup_class.__class__
-            # normally the scenario is None - only if the current namespace is a scenario we can use it
-            if issubclass(callable_func_namespace, Scenario):
-                scenario_type = callable_func_namespace
-            else:
-                scenario_type = None
-        elif isinstance(branch, ScenarioExecutor):
-            setup_type = branch.parent_executor.base_setup_class.__class__
-            scenario_type = branch.base_scenario_class.__class__
-        elif isinstance(branch, VariationExecutor):
-            setup_type = branch.cur_setup_class.__class__
-            scenario_type = branch.cur_scenario_class.__class__
-        elif isinstance(branch, TestcaseExecutor):
-            setup_type = branch.parent_executor.cur_setup_class.__class__
-            scenario_type = branch.parent_executor.cur_scenario_class.__class__
-
-        # add to possible namespaces only if the namespace of the current fixture allows this
-        if (issubclass(callable_func_namespace, Setup) or issubclass(callable_func_namespace, Scenario)) \
-                and setup_type is not None:
-            all_possible_namespaces.append(setup_type)
-        if issubclass(callable_func_namespace, Scenario) and scenario_type is not None:
-            all_possible_namespaces.append(scenario_type)
-
-        for cur_arg in arguments:
-            # go to the most specific fixture, because more specific ones overwrite the more global ones
-            for cur_possible_namespace in all_possible_namespaces:
-                for cur_level in self.EXECUTION_LEVEL_ORDER:
-                    if cur_level in self.current_tree_fixtures.keys():
-                        # filter only these fixtures that have the same namespace
-                        for cur_fixt_namespace, _, cur_fixt, _, cur_fixt_retval in \
-                                self.current_tree_fixtures[cur_level]:
-                            if cur_fixt_namespace == cur_possible_namespace:
-                                if cur_fixt.__name__ == cur_arg:
-                                    result_dict[cur_arg] = cur_fixt_retval
-            if cur_arg not in result_dict.keys():
-                raise FixtureReferenceError(
-                        f"the argument `{cur_arg}` in fixture `{callable_func.__qualname__}` could not be resolved")
-        return result_dict
-
     def _validate_for_unclear_setup_scoped_fixture_reference(
-            self, fixture_callable_namespace: Union[Type[ExecutorTree], Type[Scenario], Type[Setup]],
-            fixture_callable: Callable, arguments: List[str], cur_execution_level: str):
+            self, fixture_callable_namespace: Union[None, Type[Scenario], Type[Setup]],
+            fixture_callable: Callable, arguments: List[str], cur_execution_level: FixtureExecutionLevel):
         """
         This helper method validates a given fixture reference for the unclear setup scoped fixture reference.
 
@@ -184,7 +82,7 @@ class FixtureManager:
             The error will be thrown if a scenario scoped fixture with the execution level SESSION references a fixture
             name that exists in one or more setup scoped fixtures with the execution level SESSION.
 
-        :param fixture_callable_namespace: the namespace of the current fixture
+        :param fixture_callable_namespace: the namespace of the current fixture or None if it is a `balderglob.py` file
 
         :param fixture_callable: the callable with the arguments
 
@@ -194,10 +92,11 @@ class FixtureManager:
         """
         # this method is only interested in fixtures with execution level SESSION!
 
-        if isinstance(fixture_callable_namespace, Scenario) and cur_execution_level == "session":
+        if (fixture_callable_namespace is not None and isinstance(fixture_callable_namespace, Scenario)
+                and cur_execution_level == FixtureExecutionLevel.SESSION):
             all_setup_scoped_fixtures = []
 
-            for cur_namespace_type, fixtures in self.fixtures.get('session', {}).items():
+            for cur_namespace_type, fixtures in self.fixtures.get(FixtureExecutionLevel.SESSION, {}).items():
                 if cur_namespace_type is not None and issubclass(cur_namespace_type, Setup):
                     all_setup_scoped_fixtures += [cur_fixt.__name__ for _, cur_fixt in fixtures]
             for cur_arg in arguments:
@@ -208,9 +107,9 @@ class FixtureManager:
                         f"fixtures with the definition scope that have the same name - please rename them!")
 
     def _sort_fixture_list_of_same_definition_scope(
-            self, fixture_namespace_dict: Dict[Tuple[str, Union[Type[ExecutorTree], Type[Scenario], Type[Setup]]],
-                                               List[object]], outer_scope_fixtures: List[object]) \
-            -> List[Tuple[Union[Type[ExecutorTree], Type[Scenario], Type[Setup]], str, Callable]]:
+            self, fixture_namespace_dict: Dict[Union[None, Type[Scenario], Type[Setup]], List[object]],
+            outer_scope_fixtures: List[object]) \
+            -> List[Tuple[Union[None, Type[Scenario], Type[Setup]], str, Callable]]:
         """
         This is a helper method that allows to sort the fixtures given in `fixture_namespace_dict`, depending on their
         arguments.
@@ -233,7 +132,7 @@ class FixtureManager:
 
         # returns the func_type for the given fixture
         fixture_func_types = {}
-        for cur_namespace_type, cur_fixture_list in fixture_namespace_dict.items():
+        for _, cur_fixture_list in fixture_namespace_dict.items():
             for cur_func_type, cur_fixture in cur_fixture_list:
                 fixture_func_types[cur_fixture] = cur_func_type
 
@@ -279,6 +178,39 @@ class FixtureManager:
         return [(cur_definition_scope, fixture_func_types[cur_func], cur_func)
                 for cur_definition_scope, cur_func in sorter.static_order()]
 
+    def _determine_setup_and_scenario_type(
+            self,
+            from_branch: Union[ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor, TestcaseExecutor],
+            callable_func_namespace: Union[None, Type[Scenario], Type[Setup]]) \
+            -> Tuple[Union[None, Type[Setup]], Union[None, Type[Scenario]]]:
+        """
+        determines the setup and scenario type for a specific fixture based on the branch the system is in
+
+        :param from_branch: the branch for which the types should be determined
+        :param callable_func_namespace: the namespace of the current fixture or `None` if it is defined in balderglob
+                                        file
+        """
+        # determine namespaces (in the correct order)
+        setup_type = None
+        scenario_type = None
+        if isinstance(from_branch, SetupExecutor):
+            setup_type = from_branch.base_setup_class.__class__
+            # normally the scenario is None - only if the current namespace is a scenario we can use it
+            if callable_func_namespace is not None and issubclass(callable_func_namespace, Scenario):
+                scenario_type = callable_func_namespace
+            else:
+                scenario_type = None
+        elif isinstance(from_branch, ScenarioExecutor):
+            setup_type = from_branch.parent_executor.base_setup_class.__class__
+            scenario_type = from_branch.base_scenario_class.__class__
+        elif isinstance(from_branch, VariationExecutor):
+            setup_type = from_branch.cur_setup_class.__class__
+            scenario_type = from_branch.cur_scenario_class.__class__
+        elif isinstance(from_branch, TestcaseExecutor):
+            setup_type = from_branch.parent_executor.cur_setup_class.__class__
+            scenario_type = from_branch.parent_executor.cur_scenario_class.__class__
+        return setup_type, scenario_type
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def is_allowed_to_enter(
@@ -287,8 +219,7 @@ class FixtureManager:
         """
         This method return true if the given branch can be entered, otherwise false
         """
-        execution_level = self.resolve_type_level[branch.__class__]
-        return execution_level not in self.current_tree_fixtures.keys()
+        return branch.fixture_execution_level not in self.current_tree_fixtures.keys()
 
     def is_allowed_to_leave(
             self, branch: Union[BasicExecutor, ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor,
@@ -298,8 +229,7 @@ class FixtureManager:
         This method returns true if the given branch can be left now (there exist entries from earlier run enter()
         for this branch), otherwise false
         """
-        execution_level = self.resolve_type_level[branch.__class__]
-        return execution_level in self.current_tree_fixtures.keys()
+        return branch.fixture_execution_level in self.current_tree_fixtures.keys()
 
     def enter(self, branch: Union[BasicExecutor, ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor,
                                   TestcaseExecutor]):
@@ -311,7 +241,6 @@ class FixtureManager:
 
         :raise BalderFixtureException: is thrown if an error occurs while executing a user fixture
         """
-        execution_level = self.resolve_type_level[branch.__class__]
 
         if not self.is_allowed_to_enter(branch):
             raise LostInExecutorTreeException(
@@ -321,7 +250,7 @@ class FixtureManager:
             yield None
         # now iterate over all fixtures that should be executed in this enter() call
         #  -> collect them with all different DEFINITION-SCOPES
-        for cur_definition_scope in self.definition_scope_order:
+        for cur_definition_scope in FixtureDefinitionScope:
             cur_fixture_list = self.get_all_fixtures_for_current_level(branch=branch).get(cur_definition_scope)
             for cur_scope_namespace_type, cur_fixture_func_type, cur_fixture in cur_fixture_list:
                 try:
@@ -354,10 +283,11 @@ class FixtureManager:
                         cur_generator = empty()
                         next(cur_generator)
                     # add the executed fixtures to global reference
-                    if execution_level not in self.current_tree_fixtures.keys():
-                        self.current_tree_fixtures[execution_level] = []
-                    self.current_tree_fixtures[execution_level].append(
-                        (cur_scope_namespace_type, cur_fixture_func_type, cur_fixture, cur_generator, cur_retvalue))
+                    if branch.fixture_execution_level not in self.current_tree_fixtures.keys():
+                        self.current_tree_fixtures[branch.fixture_execution_level] = []
+                    self.current_tree_fixtures[branch.fixture_execution_level].append(
+                        FixtureMetadata(namespace=cur_scope_namespace_type, function_type=cur_fixture_func_type,
+                                        callable=cur_fixture, generator=cur_generator, retval=cur_retvalue))
                 except StopIteration:
                     pass
                 # every other exception that is thrown, will be recognized and rethrown
@@ -371,36 +301,96 @@ class FixtureManager:
         :param branch: specifies the element of the ExecutorTree that should be left (note that the current position
                        is very important here)
         """
-        execution_level = self.resolve_type_level[branch.__class__]
-        if execution_level not in self.current_tree_fixtures.keys():
+        if branch.fixture_execution_level not in self.current_tree_fixtures.keys():
             raise LostInExecutorTreeException("can not leave the current branch, because it was not entered before")
 
-        current_tree_fixtures_reversed = self.current_tree_fixtures[execution_level]
+        current_tree_fixtures_reversed = self.current_tree_fixtures[branch.fixture_execution_level]
         current_tree_fixtures_reversed.reverse()
         exception = None
-        for _, _, _, cur_generator, _ in current_tree_fixtures_reversed:
+        for cur_fixture_metadata in current_tree_fixtures_reversed:
             try:
-                next(cur_generator)
+                next(cur_fixture_metadata.generator)
             except StopIteration:
                 pass
-            except Exception as exc:
+            except Exception as exc:  # pylint: disable=broad-exception-caught
                 if not exception:
                     # only save the first exception
                     exception = exc
 
         # reset the left location
-        del self.current_tree_fixtures[execution_level]
+        del self.current_tree_fixtures[branch.fixture_execution_level]
 
         if exception:
             raise exception
 
-    def get_fixture_for_class(
-            self,
-            execution_level: Union[Type[ExecutorTree], Type[SetupExecutor], Type[ScenarioExecutor],
-                                   Type[VariationExecutor], Type[TestcaseExecutor]],
-            setup_or_scenario_class: Union[None, Type[Setup], Type[Scenario]],
-            parent_classes: bool = True
-    ) -> List[Tuple[MethodLiteralType, Callable]]:
+    def get_all_attribute_values(
+            self, branch: Union[ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor, TestcaseExecutor],
+            callable_func_namespace: Union[None, Type[Scenario], Type[Setup]], callable_func: Callable,
+            func_type: str, ignore_attributes: Iterable[str] = None) -> Dict[str, object]:
+        """
+        This method tries to fill the unresolved function/method arguments of the given fixture callable. For this it
+        searches the return values of all already executed fixtures and supplies the argument values of the
+        given ``fixture`` callable in a dictionary.
+
+        It automatically manages `self` / `cls` references for func_type `instancemethod` or `classmethod`. It
+        only returns the fixture references and ignores `self` / `cls`
+
+        First the method tries to find the arguments in all fixtures that are in the same namespace. If it does not find
+        any references, it will look in the next higher scope. It only uses fixture that has run before!
+
+        :param branch: the current active branch
+        :param callable_func_namespace: the namespace of the current fixture or `None` if it is defined in balderglob
+                                        file
+        :param callable_func: the callable with the arguments
+        :param func_type: returns the func_type of the fixture - depending on this value the first argument will be
+                          ignored, because it has to be `cls` for `classmethod` and `self` for `instancemethod`
+        :param ignore_attributes: holds a list of attributes in the test method that should be ignored
+        :return: the method returns a dictionary with the attribute name as key and the return value as value
+
+        """
+        arguments = inspect.getfullargspec(callable_func).args
+        result_dict = {}
+
+        if func_type in ["classmethod", "instancemethod"]:
+            arguments = arguments[1:]
+        if ignore_attributes is None:
+            ignore_attributes = []
+
+        self._validate_for_unclear_setup_scoped_fixture_reference(
+            callable_func_namespace, callable_func, arguments, cur_execution_level=branch.fixture_execution_level)
+        all_possible_namespaces = [None]
+        setup_type, scenario_type = self._determine_setup_and_scenario_type(
+            from_branch=branch, callable_func_namespace=callable_func_namespace)
+
+        # add to possible namespaces only if the namespace of the current fixture allows this
+        if callable_func_namespace is not None:
+            if (issubclass(callable_func_namespace, Setup) or issubclass(callable_func_namespace, Scenario)) \
+                    and setup_type is not None:
+                all_possible_namespaces.append(setup_type)
+            if issubclass(callable_func_namespace, Scenario) and scenario_type is not None:
+                all_possible_namespaces.append(scenario_type)
+
+        for cur_arg in arguments:
+            if cur_arg in ignore_attributes:
+                continue
+            # go to the most specific fixture, because more specific ones overwrite the more global ones
+            for cur_possible_namespace in all_possible_namespaces:
+                for cur_level in FixtureExecutionLevel:
+                    if cur_level not in self.current_tree_fixtures.keys():
+                        continue
+                    # filter only these fixtures that have the same namespace
+                    for cur_fixture_metadata in self.current_tree_fixtures[cur_level]:
+                        if (cur_fixture_metadata.namespace == cur_possible_namespace
+                                and cur_fixture_metadata.callable.__name__ == cur_arg):
+                            result_dict[cur_arg] = cur_fixture_metadata.retval
+            if cur_arg not in result_dict.keys():
+                raise FixtureReferenceError(
+                        f"the argument `{cur_arg}` in fixture `{callable_func.__qualname__}` could not be resolved")
+        return result_dict
+
+    def get_fixture_for_class(self, execution_level: FixtureExecutionLevel,
+                              setup_or_scenario_class: Union[None, Type[Setup], Type[Scenario]],
+                              parent_classes: bool = True) -> List[Tuple[MethodLiteralType, Callable]]:
         """
         This method returns all classes of a specific Setup/Scenario class for a specific execution-level.
 
@@ -409,10 +399,9 @@ class FixtureManager:
         :param parent_classes: true if the method should look for fixtures in parent classes too
         :return: list with all fixtures that are matching search criteria
         """
-        # current relevant EXECUTION LEVEL - all other levels are not relevant for this call
-        cur_execution_level = self.resolve_type_level[execution_level]
-        # get all fixtures of the current relevant level
-        fixtures_of_exec_level = self.fixtures.get(cur_execution_level, {})
+        # get all fixtures of the current relevant level (only `execution_level` is relevant - all other levels are
+        # not relevant for this call)
+        fixtures_of_exec_level = self.fixtures.get(execution_level, {})
         if setup_or_scenario_class is not None and parent_classes:
             all_fixtures = []
             for cur_parent_class in inspect.getmro(setup_or_scenario_class):
@@ -426,13 +415,11 @@ class FixtureManager:
                     _added_fixtures.append(cur_fixture_tuple[1].__name__)
                     remaining_fixtures.append(cur_fixture_tuple)
             return remaining_fixtures
-        else:
-            return fixtures_of_exec_level.get(setup_or_scenario_class, [])
+        return fixtures_of_exec_level.get(setup_or_scenario_class, [])
 
     def get_all_fixtures_for_current_level(
             self, branch: Union[ExecutorTree, SetupExecutor, ScenarioExecutor, VariationExecutor, TestcaseExecutor]) \
-            -> Dict[Union[Type[ExecutorTree], Type[Scenario], Type[Setup]],
-                    List[Tuple[Union[Type[ExecutorTree], Type[Scenario], Type[Setup]], str, object]]]:
+            -> Dict[FixtureDefinitionScope, List[Tuple[Union[None, Type[Scenario], Type[Setup]], str, object]]]:
         """
         This method delivers all fixtures which should be executed for the given branch of the executor tree.
 
@@ -450,46 +437,46 @@ class FixtureManager:
                  or :class:`Setup`) as first argument, the fixture func_type as second and the fixture callable as third
                  argument (this list is ordered after the call hierarchy)
         """
-        from _balder.executor.executor_tree import ExecutorTree
-
         all_fixtures = {}
         # get all relevant fixtures of `balderglob.py` (None is key for balderglob fixtures)
-        glob_fixtures = self.get_fixture_for_class(branch.__class__, None)
-        all_fixtures[ExecutorTree] = {}
-        all_fixtures[ExecutorTree][ExecutorTree] = glob_fixtures
+        glob_fixtures = self.get_fixture_for_class(branch.fixture_execution_level, None)
+        all_fixtures[FixtureDefinitionScope.GLOB] = {}
+        all_fixtures[FixtureDefinitionScope.GLOB][None] = glob_fixtures
         # get all relevant fixtures with definition scope "setup"
-        all_fixtures[Setup] = {}
+        all_fixtures[FixtureDefinitionScope.SETUP] = {}
         for cur_setup in branch.get_all_base_instances_of_this_branch(Setup, only_runnable_elements=True):
             # check if there exists fixtures for the current setup
-            cur_setup_fixtures = self.get_fixture_for_class(branch.__class__, cur_setup.__class__)
+            cur_setup_fixtures = self.get_fixture_for_class(branch.fixture_execution_level, cur_setup.__class__)
             if cur_setup_fixtures:
-                all_fixtures[Setup][cur_setup.__class__] = cur_setup_fixtures
+                all_fixtures[FixtureDefinitionScope.SETUP][cur_setup.__class__] = cur_setup_fixtures
 
         # get all relevant fixtures with definition scope "scenario"
-        all_fixtures[Scenario] = {}
+        all_fixtures[FixtureDefinitionScope.SCENARIO] = {}
         for cur_scenario in branch.get_all_base_instances_of_this_branch(Scenario, only_runnable_elements=True):
-            cur_scenario_fixtures = self.get_fixture_for_class(branch.__class__, cur_scenario.__class__)
+            cur_scenario_fixtures = self.get_fixture_for_class(branch.fixture_execution_level, cur_scenario.__class__)
             if cur_scenario_fixtures:
-                all_fixtures[Scenario][cur_scenario.__class__] = cur_scenario_fixtures
+                all_fixtures[FixtureDefinitionScope.SCENARIO][cur_scenario.__class__] = cur_scenario_fixtures
 
         ordered_fixtures = {}
         # Now the basic order is: [All of ExecutorTree] -> [All of Setup] -> [All of Scenario]
         #  but the order within these DEFINITION SCOPES has to be determined now!
         outer_scope_fixtures = self.all_already_run_fixtures
-        ordered_fixtures[ExecutorTree] = self._sort_fixture_list_of_same_definition_scope(
-            fixture_namespace_dict=all_fixtures[ExecutorTree], outer_scope_fixtures=outer_scope_fixtures)
+        ordered_fixtures[FixtureDefinitionScope.GLOB] = self._sort_fixture_list_of_same_definition_scope(
+            fixture_namespace_dict=all_fixtures[FixtureDefinitionScope.GLOB], outer_scope_fixtures=outer_scope_fixtures)
 
         outer_scope_fixtures = \
             self.all_already_run_fixtures + \
-            [cur_fixture for _, _, cur_fixture in ordered_fixtures[ExecutorTree]]
-        ordered_fixtures[Setup] = self._sort_fixture_list_of_same_definition_scope(
-            fixture_namespace_dict=all_fixtures[Setup], outer_scope_fixtures=outer_scope_fixtures)
+            [cur_fixture for _, _, cur_fixture in ordered_fixtures[FixtureDefinitionScope.GLOB]]
+        ordered_fixtures[FixtureDefinitionScope.SETUP] = self._sort_fixture_list_of_same_definition_scope(
+            fixture_namespace_dict=all_fixtures[FixtureDefinitionScope.SETUP],
+            outer_scope_fixtures=outer_scope_fixtures)
 
         outer_scope_fixtures = \
             self.all_already_run_fixtures + \
-            [cur_fixture for _, _, cur_fixture in ordered_fixtures[ExecutorTree]] + \
-            [cur_fixture for _, _, cur_fixture in ordered_fixtures[Setup]]
-        ordered_fixtures[Scenario] = self._sort_fixture_list_of_same_definition_scope(
-            fixture_namespace_dict=all_fixtures[Scenario], outer_scope_fixtures=outer_scope_fixtures)
+            [cur_fixture for _, _, cur_fixture in ordered_fixtures[FixtureDefinitionScope.GLOB]] + \
+            [cur_fixture for _, _, cur_fixture in ordered_fixtures[FixtureDefinitionScope.SETUP]]
+        ordered_fixtures[FixtureDefinitionScope.SCENARIO] = self._sort_fixture_list_of_same_definition_scope(
+            fixture_namespace_dict=all_fixtures[FixtureDefinitionScope.SCENARIO],
+            outer_scope_fixtures=outer_scope_fixtures)
 
         return ordered_fixtures

_balder/fixture_metadata.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Union, Type, Callable, Generator, TYPE_CHECKING
+import dataclasses
+
+from .utils import MethodLiteralType
+
+if TYPE_CHECKING:
+    from _balder.scenario import Scenario
+    from _balder.setup import Setup
+
+
+@dataclasses.dataclass
+class FixtureMetadata:
+    """
+    describes meta information for a fixture
+    """
+    #: the namespace where it is defined (None if it is in a balderglob file)
+    namespace: Union[None, Type[Scenario], Type[Setup]]
+    #: the type of the fixture function
+    function_type: MethodLiteralType
+    #: the fixture callable itself
+    callable: Callable
+    #: the generator object (if the fixture is not a generator, it holds an empty generator)
+    generator: Generator
+    #: result according to the fixture's construction code (will be cleaned after it leaves a level)
+    retval: object

_balder/parametrization.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+from typing import Type, Dict, Any, TypeVar, List
+import dataclasses
+
+from _balder.device import Device
+
+ValueTypeT = TypeVar("ValueTypeT")
+
+
+@dataclasses.dataclass
+class FeatureAccessSelector:
+    """helper object for dynamic parametrizing by feature method/property"""
+    device: Type[Device]
+    device_property_name: str
+    feature_property_name: str
+    parameters: Dict[str, FeatureAccessSelector | Value] = dataclasses.field(default_factory=dict)
+
+    def get_value(self, available_parameters: Dict[str, Any]) -> List[Any]:
+        """accesses the configured method/property"""
+        resolved_parameters = {}
+        for cur_key, cur_value in self.parameters.items():
+            if isinstance(cur_value, FeatureAccessSelector):
+                resolved_parameters[cur_key] = cur_value.get_value(available_parameters)
+            elif isinstance(cur_value, Parameter):
+                resolved_parameters[cur_key] = available_parameters[cur_value.name]
+            elif isinstance(cur_value, Value):
+                resolved_parameters[cur_key] = cur_value.value
+            else:
+                raise TypeError(f'go unexpected parameter type {type(cur_value)} in FeatureAccessSelector')
+
+        feature = getattr(self.device, self.device_property_name)
+
+        if isinstance(getattr(feature.__class__, self.feature_property_name), property):
+            return getattr(feature, self.feature_property_name)
+
+        return getattr(feature, self.feature_property_name)(**resolved_parameters)
+
+    def get_parameters(
+            self,
+            of_type: Type[FeatureAccessSelector | Parameter | Value] | None = None
+    ) -> Dict[str, FeatureAccessSelector | Parameter | Value]:
+        """
+        Returns the parameters of this access selector
+
+        :param of_type: allows to filter the parameters by the value's type
+        """
+        result = {}
+        for cur_attr, cur_value in self.parameters.items():
+            if of_type is None or isinstance(cur_value, of_type):
+                result[cur_attr] = cur_value
+        return result
+
+
+class Parameter:
+    """allows to parametrize a parametrization by another parametrization value"""
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    @property
+    def name(self) -> str:
+        """returns the name of the parameter"""
+        return self._name
+
+
+class Value:
+    """allows to parametrize a parametrization by a fix value"""
+
+    def __init__(self, value: ValueTypeT) -> None:
+        self._value = value
+
+    @property
+    def value(self) -> ValueTypeT:
+        """returns the value of the parametrization"""
+        return self._value