baldertest 0.1.0b12__py3-none-any.whl → 0.1.0b13__py3-none-any.whl

_balder/controllers/normal_scenario_setup_controller.py

@@ -72,8 +72,7 @@ class NormalScenarioSetupController(Controller, ABC):
             if not issubclass(cur_class, Device):
                 # filter all classes and make sure that only the child classes of :meth:`Device` remain
                 continue
-            outer_class_name, _ = cur_class.__qualname__.split('.')
-            if outer_class_name != self.related_cls.__name__:
+            if DeviceController.get_for(cur_class).get_outer_class() != self.related_cls:
                 # filter all classes that do not match the setup name in __qualname__
                 continue
             # otherwise, add this candidate

_balder/controllers/scenario_controller.py

@@ -14,6 +14,7 @@ from _balder.controllers.normal_scenario_setup_controller import NormalScenarioS
 from _balder.parametrization import FeatureAccessSelector, Parameter
 from _balder.exceptions import UnclearAssignableFeatureConnectionError, ConnectionIntersectionError, \
     MultiInheritanceError
+from _balder.utils.functions import get_scenario_inheritance_list_of
 
 logger = logging.getLogger(__file__)
 
@@ -36,6 +37,9 @@ class ScenarioController(NormalScenarioSetupController):
         # describes if the current controller is for setups or for scenarios (has to be set in child controller)
         self._related_type = Scenario
 
+        # holds covered-by configuration
+        self._covered_by = {}
+
         # this helps to make this constructor only possible inside the controller object
         if _priv_instantiate_key != ScenarioController.__priv_instantiate_key:
             raise RuntimeError('it is not allowed to instantiate a controller manually -> use the static method '
@@ -126,6 +130,73 @@ class ScenarioController(NormalScenarioSetupController):
             ordered_dict[cur_arg] = params[cur_arg]
         return ordered_dict
 
+    def register_covered_by_for(self, meth: Union[str, None], covered_by: Union[Scenario, Callable, None]) -> None:
+        """
+        This method registers a covered-by statement for this Scenario. If `meth` is provided, the statement is for the
+        specific test method of the scenario, otherwise it is for the whole setup. The item provided in `covered_by`
+        describes the test object that covers this scenario (method).
+
+        :param meth: if provided this attribute describes the test method that should be registered, otherwise the whole
+                     scenario will be registered
+        :param covered_by: describes the test object that covers this scenario (method)
+        """
+        if not (meth is None or isinstance(meth, str)):
+            raise TypeError('meth needs to be None or a string')
+        if meth is not None:
+            if not meth.startswith('test_'):
+                raise TypeError(
+                    f"the use of the `@covered_by` decorator is only allowed for `Scenario` objects and test methods "
+                    f"of `Scenario` objects - the method `{self.related_cls.__name__}.{meth}` does not start with "
+                    f"`test_` and is not a valid test method")
+            if not hasattr(self.related_cls, meth):
+                raise ValueError(
+                    f"the provided test method `{meth}` does not exist in scenario `{self.related_cls.__name__}`"
+                )
+
+        if meth not in self._covered_by.keys():
+            self._covered_by[meth] = []
+        if covered_by is None:
+            # reset it
+            # todo what if there are more than one decorator in one class
+            del self._covered_by[meth]
+        else:
+            self._covered_by[meth].append(covered_by)
+
+    def get_raw_covered_by_dict(self) -> Dict[Union[str, None], List[Union[Scenario, Callable]]]:
+        """
+        :return: returns the internal covered-by dictionary
+        """
+        return self._covered_by.copy()
+
+    def get_abs_covered_by_dict(self) -> Dict[Union[str, None], List[Union[Scenario, Callable]]]:
+        """
+        This method resolves the covered-by statements over all inheritance levels. It automatically
+        cleans up every inheritance of the covered_by decorators for every parent class of this scenario.
+        """
+        parent_classes = [p for p in self.related_cls.__bases__ if issubclass(p, Scenario) and p != Scenario]
+        if len(parent_classes) > 1:
+            raise MultiInheritanceError(
+                f'can not resolve classes for `{self.related_cls}` because there are more than one Scenario based '
+                f'parent classes'
+            )
+        # no more parent classes -> raw is absolute
+        if len(parent_classes) == 0:
+            return self.get_raw_covered_by_dict()
+        parent_controller = self.__class__.get_for(parent_classes[0])
+        self_raw_covered_by_dict = self.get_raw_covered_by_dict()
+
+        #: first fill result with data from parent controller
+        result = {
+            k if k is None else getattr(self.related_cls, k.__name__): v
+            for k, v in parent_controller.get_abs_covered_by_dict().items()
+        }
+        for cur_callable, cur_coveredby in self_raw_covered_by_dict.items():
+            if cur_callable in result.keys():
+                result[cur_callable].extend(cur_coveredby)
+            else:
+                result[cur_callable] = cur_coveredby
+        return result
+
     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
@@ -196,6 +267,56 @@ class ScenarioController(NormalScenarioSetupController):
 
         return all_relevant_func
 
+    def get_ignore_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that have the IGNORE marker. It automatically resolves marker that
+        were provided on parent class scenarios.
+        """
+        result = []
+        next_parent_class = get_scenario_inheritance_list_of(self.related_cls)[1]
+        if next_parent_class != Scenario:
+            next_parent_class_controller = ScenarioController.get_for(next_parent_class)
+            next_parent_ignore_meths = next_parent_class_controller.get_ignore_test_methods()
+            result.extend(next_parent_ignore_meths)
+        for cur_ignore_meth_as_str in self.related_cls.IGNORE:
+            cur_ignore_meth = getattr(self.related_cls, cur_ignore_meth_as_str)
+            result.append(cur_ignore_meth)
+        return list(set(result))
+
+    def get_skip_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that have the SKIP marker. It automatically resolves marker that were
+        provided on parent class scenarios.
+        """
+        result = []
+        next_parent_class = get_scenario_inheritance_list_of(self.related_cls)[1]
+        next_parent_ignore_meths = []
+
+        if next_parent_class != Scenario:
+            next_parent_class_controller = ScenarioController.get_for(next_parent_class)
+            next_parent_ignore_meths = next_parent_class_controller.get_ignore_test_methods()
+            next_parent_skip_meths = next_parent_class_controller.get_skip_test_methods()
+            result.extend(next_parent_skip_meths)
+
+        for cur_skip_meth_as_str in self.related_cls.SKIP:
+            cur_skip_meth = getattr(self.related_cls, cur_skip_meth_as_str)
+            if cur_skip_meth in next_parent_ignore_meths:
+                raise ValueError(f'found skip method `{cur_skip_meth}` defined in `{self.related_cls}.SKIP`, but was '
+                                 f'already added to IGNORE in parent class')
+            result.append(cur_skip_meth)
+
+        return list(set(result))
+
+    def get_run_test_methods(self) -> List[callable]:
+        """
+        This method returns a list of all methods that should run in this scenario. It automatically resolves
+        SKIP/IGNORE marker that were provided on parent class scenarios.
+        """
+        result = (set(self.get_all_test_methods())
+                  - set(self.get_skip_test_methods())
+                  - set(self.get_ignore_test_methods()))
+        return list(result)
+
     def validate_feature_clearance_for_parallel_connections(self):
         """
         This method validates for every active class-based feature (only the ones that have an active VDevice<->Device

_balder/controllers/vdevice_controller.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 from typing import Type, Dict, Union
 
 import logging
-import inspect
 from _balder.vdevice import VDevice
 from _balder.feature import Feature
 from _balder.controllers.base_device_controller import BaseDeviceController
-from _balder.exceptions import DeviceScopeError, VDeviceResolvingError
+from _balder.exceptions import VDeviceResolvingError
 
 logger = logging.getLogger(__file__)
 
@@ -69,27 +68,7 @@ class VDeviceController(BaseDeviceController):
         """
         This method delivers the outer class of this device. In Balder, this has to be a :class:`Feature`.
         """
-
-        if self.related_cls.__qualname__.count('.') == 0:
-            raise DeviceScopeError("the current device class is no inner class")
-        all_splits = self.related_cls.__qualname__.split('.')
-
-        outer_class = [cur_class for cur_name, cur_class in inspect.getmembers(
-            inspect.getmodule(self.related_cls), inspect.isclass) if cur_name == all_splits[0]][0]
-        # only get the next outer class (not higher)
-        for cur_class_name in all_splits[1:-1]:
-            outer_class = getattr(outer_class, cur_class_name)
-        # instantiate it to get the real type (not the decorator class of `@for_vdevice`)
-        #  we can instantiate it, because we do nothing in it
-        outer_class = outer_class().__class__
-
-        all_inner_classes = [cur_inner_class for _, cur_inner_class in inspect.getmembers(outer_class, inspect.isclass)]
-        if self.related_cls in all_inner_classes:
-            if not issubclass(outer_class, Feature):
-                raise TypeError(f"the found outer class is of type `{outer_class.__name__}` - this is a type which is "
-                                f"not allowed (outer class has to be a `Feature` class)")
-            return outer_class
-        raise RuntimeError(f"can not find the outer class of this vDevice `{self.related_cls.__qualname__}`")
+        return getattr(self.related_cls, '_outer_balder_class', None)
 
     def get_next_parent_vdevice(self) -> Union[Type[VDevice], None]:
         """

_balder/decorator_connect.py

@@ -69,10 +69,10 @@ def connect(
             nonlocal self_node_name
             nonlocal dest_node_name
 
-            this_outer_class_name, _ = decorated_cls.__qualname__.split('.')
+            this_outer_ref = decorated_cls.__qualname__.split('.')[:-1]
             if not isinstance(with_device, str):
-                other_outer_class_name, _ = with_device.__qualname__.split('.')
-                if this_outer_class_name != other_outer_class_name:
+                other_outer_ref = with_device.__qualname__.split('.')[:-1]
+                if this_outer_ref != other_outer_ref:
                     raise ValueError(
                         f"the given device is not mentioned in this setup/scenario - please create a new "
                         f"direct inner device class, it can be inherited from `{with_device.__qualname__}`")

_balder/decorator_covered_by.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 from typing import Type, Union
 
 import inspect
+
+from _balder.controllers import ScenarioController
 from _balder.scenario import Scenario
-from _balder.utils import get_class_that_defines_method
 
 
-def covered_by(item: Union[Type[Scenario], callable, None]):
+def covered_by(item: Union[Type[Scenario], str, callable, None]):
     """
     This decorator defines that there exists another Scenario class or test method item that has a similar
     implementation like the decorated :class:`Scenario` class or the decorated test method.
@@ -16,14 +17,15 @@ def covered_by(item: Union[Type[Scenario], callable, None]):
 
     if item is None:
         pass
-    elif callable(item) and inspect.isfunction(item) and item.__name__.startswith("test_") and \
-            issubclass(get_class_that_defines_method(item), Scenario):
+    elif isinstance(item, str) and item.startswith("test_"):
         pass
-    elif isinstance(item, type) and issubclass(item, Scenario):
+    elif callable(item) and inspect.isfunction(item) and item.__name__.startswith("test_"):
         pass
+    elif isinstance(item, type) and issubclass(item, Scenario):
+        raise NotImplementedError('The covered-by other scenario classes is not supported yet')
     else:
-        raise TypeError("the given element for `item` must be a `Scenario` (or a subclass thereof) or a test method of "
-                        "a scenario class (has to start with `test_`)")
+        raise TypeError("the given element for `item` must be a test method of a scenario class (has to start with "
+                        "`test_`)")
 
     class CoveredByDecorator:
         """decorator class for `@covered_by` decorator"""
@@ -36,46 +38,36 @@ def covered_by(item: Union[Type[Scenario], callable, None]):
                     raise TypeError(f"The decorator `@covered_by` may only be used for `Scenario` objects or for test "
                                     f"methods of one `Scenario` object. This is not possible for the applied class "
                                     f"`{func.__name__}`.")
-                if not hasattr(func, '_covered_by'):
-                    func._covered_by = {}
-                if func not in func._covered_by.keys():
-                    func._covered_by[func] = []
-                if item is None:
-                    # reset it
-                    func._covered_by[func] = []
-                elif item not in func._covered_by[func]:
-                    func._covered_by[func].append(item)
-            elif inspect.isfunction(func):
+                raise NotImplementedError('The covered-by decoration of other scenario classes is not supported yet')
+                # scenario_controller = ScenarioController.get_for(func)
+                # register for the whole class
+                # scenario_controller.register_covered_by_for(meth=None, covered_by=item)
+            if inspect.isfunction(func):
                 # work will done in `__set_name__`
                 pass
             else:
                 raise TypeError(f"The use of the `@covered_by` decorator is not allowed for the `{str(func)}` element. "
-                                f"You should only use this decorator for `Scenario` elements or test method elements "
-                                f"of a `Scenario` object")
+                                f"You should only use this decorator for test method elements of a `Scenario` object")
 
         def __set_name__(self, owner, name):
             if issubclass(owner, Scenario):
                 if not inspect.isfunction(self.func):
-                    raise TypeError("the use of the `@covered_by` decorator is only allowed for `Scenario` objects and "
-                                    "test methods of `Scenario` objects")
+                    raise TypeError("the use of the `@covered_by` decorator is only allowed for test methods of "
+                                    "`Scenario` objects")
                 if not name.startswith('test_'):
-                    raise TypeError(f"the use of the `@covered_by` decorator is only allowed for `Scenario` objects "
-                                    f"and test methods of `Scenario` objects - the method `{owner.__name__}.{name}` "
-                                    f"does not start with `test_` and is not a valid test method")
-
-                if not hasattr(owner, '_covered_by'):
-                    owner._covered_by = {}
-                if self.func not in owner._covered_by.keys():
-                    owner._covered_by[self.func] = []
-                if item is None:
-                    # reset it
-                    owner._covered_by[self.func] = []
-                elif item not in owner._covered_by[self.func]:
-                    owner._covered_by[self.func].append(item)
+                    raise TypeError(f"the use of the `@covered_by` decorator is only allowed for test methods of "
+                                    f"`Scenario` objects - the method `{owner.__name__}.{name}` does not start with "
+                                    f"`test_` and is not a valid test method")
+                # if item is a string - resolve method
+                cleared_item = item
+                if isinstance(item, str):
+                    cleared_item = getattr(owner, item)
+                scenario_controller = ScenarioController.get_for(owner)
+                scenario_controller.register_covered_by_for(meth=name, covered_by=cleared_item)
             else:
                 raise TypeError(f"The use of the `@covered_by` decorator is not allowed for methods of a "
-                                f"`{owner.__name__}`. You should only use this decorator for `Scenario` objects or "
-                                f"valid test methods of a `Scenario` object")
+                                f"`{owner.__name__}`. You should only use this decorator for valid test methods of a "
+                                f"`Scenario` object")
 
             setattr(owner, name, self.func)
 

_balder/executor/basic_executable_executor.py

@@ -9,7 +9,7 @@ import traceback
 from abc import ABC, abstractmethod
 
 from _balder.executor.basic_executor import BasicExecutor
-from _balder.testresult import ResultState, TestcaseResult
+from _balder.testresult import ResultState
 
 if TYPE_CHECKING:
     from _balder.fixture_execution_level import FixtureExecutionLevel
@@ -73,9 +73,11 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
         """
         if value not in (ResultState.SKIP, ResultState.COVERED_BY, ResultState.NOT_RUN):
             raise ValueError("can not set a state that is not NOT_RUN, SKIP or COVERED_BY for a whole branch")
-        for cur_child_executor in self.all_child_executors:
-            if isinstance(cur_child_executor.body_result, TestcaseResult):
-                cur_child_executor.body_result.set_result(result=value, exception=None)
+        if self.all_child_executors is None:
+            self.body_result.set_result(result=value, exception=None)
+        else:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.set_result_for_whole_branch(value)
 
     @abstractmethod
     def cleanup_empty_executor_branches(self, consider_discarded=False):
@@ -90,8 +92,9 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
         """
         This method calls all user defined filters that are to be applied to the executor tree.
         """
-        for cur_child_executor in self.all_child_executors:
-            cur_child_executor.filter_tree_for_user_filters()
+        if self.all_child_executors:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.filter_tree_for_user_filters()
 
     def execute(self, show_discarded=False):
         """
@@ -105,6 +108,8 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
                 if self.has_runnable_tests():
                     self.fixture_manager.enter(self)
                     self.construct_result.set_result(ResultState.SUCCESS)
+                else:
+                    self.construct_result.set_result(ResultState.NOT_RUN)
 
                 self._body_execution(show_discarded=show_discarded)
             except Exception as exc:  # pylint: disable=broad-exception-caught
@@ -116,6 +121,8 @@ class BasicExecutableExecutor(BasicExecutor, ABC):
                     if self.fixture_manager.is_allowed_to_leave(self):
                         self.fixture_manager.leave(self)
                         self.teardown_result.set_result(ResultState.SUCCESS)
+                else:
+                    self.teardown_result.set_result(ResultState.NOT_RUN)
         except Exception as exc:  # pylint: disable=broad-exception-caught
             # this has to be a teardown fixture error
             traceback.print_exception(*sys.exc_info())

_balder/executor/basic_executor.py

@@ -38,7 +38,7 @@ class BasicExecutor(ABC):
 
     @property
     @abstractmethod
-    def all_child_executors(self) -> List[BasicExecutor]:
+    def all_child_executors(self) -> list[BasicExecutor] | None:
         """
         returns all child executors of this object or None if no child executors can exist (this element is a leaf)
         """
@@ -115,6 +115,32 @@ class BasicExecutor(ABC):
             return False
         return True
 
+    def has_skipped_tests(self) -> bool:
+        """
+        This method returns true if this executor element has at least one test that is marked to be skipped. The method
+        returns true if minimum one of its children has `prev_mark=SKIP`.
+        """
+        if self.all_child_executors is not None:
+            # the executor has child executors -> check them
+            for cur_child in self.all_child_executors:
+                if cur_child.has_skipped_tests():
+                    return True
+            return False
+        return False
+
+    def has_covered_by_tests(self) -> bool:
+        """
+        This method returns true if this executor element has at least one test that is marked as covered-by. The method
+        returns true if minimum one of its children has `prev_mark=COVERED_BY`.
+        """
+        if self.all_child_executors is not None:
+            # the executor has child executors -> check them
+            for cur_child in self.all_child_executors:
+                if cur_child.has_covered_by_tests():
+                    return True
+            return False
+        return False
+
     def get_all_base_instances_of_this_branch(
             self, with_type: Union[Type[Setup], Type[Scenario], Type[types.FunctionType]],
             only_runnable_elements: bool = True) -> List[Union[Setup, Scenario, object]]:
@@ -159,8 +185,9 @@ class BasicExecutor(ABC):
         """
         This method calls all user defined filters that are to be applied to the executor tree.
         """
-        for cur_child_executor in self.all_child_executors:
-            cur_child_executor.filter_tree_for_user_filters()
+        if self.all_child_executors:
+            for cur_child_executor in self.all_child_executors:
+                cur_child_executor.filter_tree_for_user_filters()
 
     def testsummary(self) -> ResultSummary:
         """
@@ -172,7 +199,7 @@ class BasicExecutor(ABC):
 
         if isinstance(self.body_result, TestcaseResult):
             setattr(summary, self.executor_result.value, 1)
-        else:
+        elif self.all_child_executors:
             for cur_child_exec in self.all_child_executors:
                 summary += cur_child_exec.testsummary()
         return summary

_balder/executor/executor_tree.py

@@ -38,7 +38,7 @@ class ExecutorTree(BasicExecutableExecutor):
     # ---------------------------------- PROPERTIES --------------------------------------------------------------------
 
     @property
-    def all_child_executors(self) -> List[BasicExecutableExecutor]:
+    def all_child_executors(self) -> List[BasicExecutableExecutor] | None:
         return self._setup_executors
 
     @property
@@ -63,11 +63,12 @@ class ExecutorTree(BasicExecutableExecutor):
 
     def _body_execution(self, show_discarded):
         for cur_setup_executor in self.get_setup_executors():
-            if cur_setup_executor.has_runnable_tests(consider_discarded_too=show_discarded):
+            prev_mark = cur_setup_executor.prev_mark
+            if cur_setup_executor.has_runnable_tests(show_discarded) or cur_setup_executor.has_skipped_tests():
                 cur_setup_executor.execute(show_discarded=show_discarded)
-            elif cur_setup_executor.prev_mark == PreviousExecutorMark.SKIP:
+            elif prev_mark == PreviousExecutorMark.SKIP:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.SKIP)
-            elif cur_setup_executor.prev_mark == PreviousExecutorMark.COVERED_BY:
+            elif prev_mark == PreviousExecutorMark.COVERED_BY:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.COVERED_BY)
             else:
                 cur_setup_executor.set_result_for_whole_branch(ResultState.NOT_RUN)

_balder/executor/parametrized_testcase_executor.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 
 from collections import OrderedDict
-from _balder.utils import inspect_method
+from _balder.utils.functions import get_method_type
 from .testcase_executor import TestcaseExecutor
 
 if TYPE_CHECKING:
@@ -39,7 +39,7 @@ class ParametrizedTestcaseExecutor(TestcaseExecutor):
         return super().full_test_name_str
 
     def get_all_test_method_args(self):
-        _, func_type = inspect_method(self.base_testcase_callable)
+        func_type = get_method_type(self.base_testcase_obj.__class__, self.base_testcase_callable)
         all_kwargs = self.fixture_manager.get_all_attribute_values(
             self,
             self.base_testcase_obj.__class__,

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