baldertest 0.1.0__py3-none-any.whl

_balder/executor/executor_tree.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+from typing import Union, List, Type, TYPE_CHECKING
+
+from dataclasses import fields
+from _balder.executor.setup_executor import SetupExecutor
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
+from _balder.fixture_execution_level import FixtureExecutionLevel
+from _balder.testresult import ResultState, BranchBodyResult, ResultSummary
+from _balder.previous_executor_mark import PreviousExecutorMark
+
+if TYPE_CHECKING:
+    from _balder.setup import Setup
+    from _balder.fixture_manager import FixtureManager
+    from _balder.executor.scenario_executor import ScenarioExecutor
+    from _balder.executor.variation_executor import VariationExecutor
+    from _balder.executor.testcase_executor import TestcaseExecutor
+
+
+class ExecutorTree(BasicExecutableExecutor):
+    """
+    This class is the root object of the executor tree structure
+    """
+    fixture_execution_level = FixtureExecutionLevel.SESSION
+    LINE_LENGTH = 120
+
+    def __init__(self, fixture_manager: FixtureManager):
+        super().__init__()
+        self._setup_executors: List[SetupExecutor] = []
+        self._fixture_manager = fixture_manager
+
+        # contains the result object for the BODY part of this branch (will be overwritten in :class:`TestcaseExecutor`)
+        self.body_result = BranchBodyResult(self)
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    def all_child_executors(self) -> List[BasicExecutableExecutor] | None:
+        return self._setup_executors
+
+    @property
+    def base_instance(self) -> object:
+        """returns None because this element is a ExecutorTree"""
+        return None
+
+    @property
+    def fixture_manager(self) -> FixtureManager:
+        """returns the fixture manager of this tree"""
+        return self._fixture_manager
+
+    @property
+    def parent_executor(self) -> None:
+        return None
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    def _prepare_execution(self, show_discarded):
+        if not show_discarded:
+            self.update_inner_feature_reference_in_all_setups()
+
+    def _body_execution(self, show_discarded):
+        for cur_setup_executor in self.get_setup_executors():
+            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 prev_mark == PreviousExecutorMark.SKIP:
+                cur_setup_executor.set_result_for_whole_branch(ResultState.SKIP)
+            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)
+
+    def _cleanup_execution(self, show_discarded):
+        pass
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def get_setup_executors(self) -> List[SetupExecutor]:
+        """returns all setup executors of this tree"""
+        return self._setup_executors
+
+    def get_all_scenario_executors(self) -> List[ScenarioExecutor]:
+        """
+        returns a list with all scenario executors
+        """
+        all_scenario_executor = []
+        for cur_setup_executor in self.get_setup_executors():
+            all_scenario_executor += cur_setup_executor.get_scenario_executors()
+        return all_scenario_executor
+
+    def get_all_variation_executors(self, return_discarded=False) -> List[VariationExecutor]:
+        """
+        returns a list with all variation executors
+        """
+        all_variation_executor = []
+        for cur_scenario_executor in self.get_all_scenario_executors():
+            all_variation_executor += cur_scenario_executor.get_variation_executors(return_discarded=return_discarded)
+        return all_variation_executor
+
+    def get_all_testcase_executors(self) -> List[TestcaseExecutor]:
+        """
+        returns a list with all testcase executors
+        """
+        all_testcase_executor = []
+        for cur_scenario_executor in self.get_all_scenario_executors():
+            for cur_variation_executor in cur_scenario_executor.get_variation_executors():
+                all_testcase_executor += cur_variation_executor.get_testcase_executors()
+        return all_testcase_executor
+
+    def add_setup_executor(self, setup_executor: SetupExecutor):
+        """
+        This method adds a new :class:`SetupExecutor` to the child element's list of this tree object
+        """
+        if not isinstance(setup_executor, SetupExecutor):
+            raise TypeError("the given object `setup_executor` must be of type `SetupExecutor`")
+        if setup_executor in self._setup_executors:
+            raise ValueError("the given object `setup_executor` already exists in child list")
+        self._setup_executors.append(setup_executor)
+
+    def get_executor_for_setup(self, setup: Type[Setup]) -> Union[SetupExecutor, None]:
+        """
+        This method searches for a SetupExecutor in the internal list for the given :class:`Setup` type
+
+        :param setup: the setup class for which the executor is being searched for
+
+        :return: returns the associated SetupExecutor or None if there are no matches for the given type
+        """
+        for cur_setup_executor in self._setup_executors:
+            if cur_setup_executor.base_setup_class.__class__ == setup:
+                return cur_setup_executor
+        # can not find some
+        return None
+
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
+        to_remove_executor = []
+        for cur_setup_executor in self.get_setup_executors():
+            cur_setup_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
+            if len(cur_setup_executor.get_scenario_executors()) == 0:
+                # remove this whole executor because it has no children anymore
+                to_remove_executor.append(cur_setup_executor)
+        for cur_setup_executor in to_remove_executor:
+            self._setup_executors.remove(cur_setup_executor)
+
+    def update_inner_feature_reference_in_all_setups(self):
+        """
+        This method iterates over all setups and triggers the method that updates the inner feature references.
+
+        This needs to be done on ExecutorTree level, because this reference should also be accessible within session
+        fixtures (in case they have setup scope).
+        """
+        for cur_setup_executor in self.get_setup_executors():
+            cur_setup_executor.update_inner_referenced_feature_instances()
+
+    def execute(self, show_discarded=False) -> None:
+        """
+        This method executes this branch of the tree
+        """
+        start_text = "START TESTSESSION"
+        end_text = "FINISH TESTSESSION"
+
+        def print_line(text):
+            full_text = int((self.LINE_LENGTH - (len(start_text) + 2)) / 2) * "=" + " " + text + " "
+            full_text += "=" * (self.LINE_LENGTH - len(full_text))
+            print(full_text)
+
+        print_line(start_text)
+        # check if there exists runnable elements
+        runnables = [cur_exec.has_runnable_tests(consider_discarded_too=show_discarded)
+                     for cur_exec in self.get_setup_executors()]
+        one_or_more_runnable_setups = None if len(runnables) == 0 else max(runnables)
+        if one_or_more_runnable_setups:
+            super().execute(show_discarded=show_discarded)
+        else:
+            print("NO EXECUTABLE SETUPS/SCENARIOS FOUND")
+        print_line(end_text)
+        summary = self.testsummary()
+        is_first = True
+        for cur_field in fields(ResultSummary):
+            if is_first:
+                is_first = False
+            else:
+                print(" | ", end="")
+            print(f"TOTAL {cur_field.name.upper()}: {getattr(summary, cur_field.name)}", end="")
+        print("")
+
+    def print_tree(self, show_discarded=False) -> None:
+        """this method is an auxiliary method which outputs the entire tree"""
+        print("RESOLVING OVERVIEW", end="\n\n")
+        for cur_setup_executor in self.get_setup_executors():
+            for cur_scenario_executor in cur_setup_executor.get_scenario_executors():
+                for cur_variation_executor in cur_scenario_executor.get_variation_executors(
+                        return_discarded=show_discarded):
+                    applicable = cur_variation_executor.prev_mark != PreviousExecutorMark.DISCARDED
+                    start_char = '+' if applicable else 'X'
+                    print(start_char * self.LINE_LENGTH)
+                    applicability_str = "[APPLICABLE]" if applicable else "[DISCARDED] "
+                    print(f"{start_char} {applicability_str} Scenario "
+                          f"`{cur_scenario_executor.base_scenario_class.__class__.__qualname__}` <-> "
+                          f"Setup `{cur_setup_executor.base_setup_class.__class__.__qualname__}`")
+                    mapping_printings = {}
+                    for cur_scenario_device, cur_setup_device in cur_variation_executor.base_device_mapping.items():
+                        mapping_printings[f"   {cur_scenario_device.__qualname__}"] = str(cur_setup_device.__qualname__)
+                    max_len = max(len(cur_elem) for cur_elem in mapping_printings.keys())
+                    for cur_key, cur_val in mapping_printings.items():
+                        print(("{} {:<" + str(max_len) + "} = {}").format(start_char, cur_key, cur_val))
+                    for cur_testcase_excutor in cur_variation_executor.get_testcase_executors():
+                        print(f"{start_char}    -> Testcase<"
+                              f"{cur_testcase_excutor.base_testcase_callable.__qualname__}>")
+                    if cur_variation_executor.prev_mark == PreviousExecutorMark.DISCARDED:
+                        print(f"{start_char}")
+                        print(f"{start_char}    DISCARDED BECAUSE "
+                              f"`{cur_variation_executor.not_applicable_variation_exc.args[0]}`")
+                    print(('+' if applicable else 'X') * self.LINE_LENGTH)
+                    print('')

_balder/executor/parametrized_testcase_executor.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
+
+from collections import OrderedDict
+from _balder.utils.functions import get_method_type
+from .testcase_executor import TestcaseExecutor
+
+if TYPE_CHECKING:
+    from _balder.executor.unresolved_parametrized_testcase_executor import UnresolvedParametrizedTestcaseExecutor
+    from _balder.executor.variation_executor import VariationExecutor
+
+
+class ParametrizedTestcaseExecutor(TestcaseExecutor):
+    """
+    special testcase executor for parametrized testcases
+    """
+    def __init__(
+            self,
+            testcase: callable,
+            parent: VariationExecutor,
+            parametrization: OrderedDict[str, Any] = None,
+            unresolved_group_obj: UnresolvedParametrizedTestcaseExecutor = None
+    ) -> None:
+        super().__init__(testcase=testcase, parent=parent)
+        self._parametrization = parametrization
+        # holds a reference to the parent unresolved object (if it has dynamic parametrized components
+        self._unresolved_group_obj: UnresolvedParametrizedTestcaseExecutor | None = unresolved_group_obj
+
+    @property
+    def full_test_name_str(self) -> str:
+        """
+        returns the name of the test method, that should be used in output
+        """
+        # try to get string name for parametrization
+        if self._parametrization:
+            # todo what if it is not convertable to string?
+            parametrization_name = ';'.join([str(e) for e in self._parametrization.values()])
+            return f"{super().full_test_name_str}[{parametrization_name}]"
+        return super().full_test_name_str
+
+    def get_all_test_method_args(self):
+        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__,
+            self.base_testcase_callable,
+            func_type,
+            ignore_attributes=self._parametrization.keys()
+        )
+        if self._parametrization:
+            all_kwargs.update(self._parametrization)
+        return all_kwargs

_balder/executor/scenario_executor.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+from typing import Type, Union, List, TYPE_CHECKING
+
+from _balder.fixture_execution_level import FixtureExecutionLevel
+from _balder.testresult import ResultState, BranchBodyResult
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
+from _balder.executor.variation_executor import VariationExecutor
+from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.controllers.scenario_controller import ScenarioController
+
+if TYPE_CHECKING:
+    from _balder.scenario import Scenario
+    from _balder.executor.setup_executor import SetupExecutor
+    from _balder.fixture_manager import FixtureManager
+
+
+class ScenarioExecutor(BasicExecutableExecutor):
+    """
+    A ScenarioExecutor can contain :meth:`VariationExecutor` as children.
+    """
+    fixture_execution_level = FixtureExecutionLevel.SCENARIO
+
+    def __init__(self, scenario: Type[Scenario], parent: SetupExecutor):
+        super().__init__()
+        self._variation_executors: List[VariationExecutor] = []
+        # check if instance already exists
+        if hasattr(scenario, "_instance") and scenario._instance is not None and \
+                isinstance(scenario._instance, scenario):
+            self._base_scenario_class = scenario._instance
+        else:
+            self._base_scenario_class = scenario()
+            scenario._instance = self._base_scenario_class
+        self._parent_executor = parent
+        self._fixture_manager = parent.fixture_manager
+
+        # contains the result object for the BODY part of this branch
+        self.body_result = BranchBodyResult(self)
+
+        # if the related scenario class of this executor is decorated with ``@covered_by``, this property contains a
+        # list with the :class:`ScenarioExecutor` or/and :class:`TestcaseExecutor` that covers this one
+        self.covered_by_executors = None
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    def all_child_executors(self) -> List[VariationExecutor]:
+        return self._variation_executors
+
+    @property
+    def parent_executor(self) -> SetupExecutor:
+        return self._parent_executor
+
+    @property
+    def base_instance(self) -> object:
+        """
+        returns the base class instance to which this executor instance belongs
+        """
+        return self.base_scenario_class
+
+    @property
+    def base_scenario_class(self) -> Scenario:
+        """returns the :class:`Scenario` class that belongs to this executor"""
+        return self._base_scenario_class
+
+    @property
+    def base_scenario_controller(self) -> ScenarioController:
+        """returns the :class:`ScenarioController` for the setup object of this executor"""
+        return ScenarioController.get_for(self.base_scenario_class.__class__)
+
+    @property
+    def fixture_manager(self) -> FixtureManager:
+        """returns the current active fixture manager that belongs to this scenario executor"""
+        return self._fixture_manager
+
+    @property
+    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_controller.get_run_test_methods()
+
+    @property
+    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_controller.get_skip_test_methods()
+
+    @property
+    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_controller.get_ignore_test_methods()
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    def _prepare_execution(self, show_discarded):
+        print(f"  SCENARIO {self.base_scenario_class.__class__.__name__}")
+
+    def _body_execution(self, show_discarded):
+        for cur_variation_executor in self.get_variation_executors(return_discarded=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 prev_mark == PreviousExecutorMark.SKIP:
+                cur_variation_executor.set_result_for_whole_branch(ResultState.SKIP)
+            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)
+
+    def _cleanup_execution(self, show_discarded):
+        pass
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def get_variation_executors(self, return_discarded=False) -> List[VariationExecutor]:
+        """
+        :param return_discarded: True if the method should return discarded variations too
+
+        :return: returns all variation executors that are child executor of this scenario executor
+        """
+        if not return_discarded:
+            return [cur_executor for cur_executor in self._variation_executors
+                    if cur_executor.prev_mark != PreviousExecutorMark.DISCARDED]
+        return self._variation_executors
+
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
+        """
+        This method removes all sub executors that are empty and not relevant anymore.
+        """
+        to_remove_executor = []
+        for cur_variation_executor in self.get_variation_executors(return_discarded=consider_discarded):
+            if len(cur_variation_executor.get_testcase_executors()) == 0:
+                # remove this whole executor because it has no children anymore
+                to_remove_executor.append(cur_variation_executor)
+        for cur_variation_executor in to_remove_executor:
+            self._variation_executors.remove(cur_variation_executor)
+
+    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.
+        """
+        return self.base_scenario_controller.get_abs_covered_by_dict().get(None, [])
+
+    def add_variation_executor(self, variation_executor: VariationExecutor):
+        """
+        This method adds a new VariationExecutor to the child element list of the tree
+        """
+        if not isinstance(variation_executor, VariationExecutor):
+            raise TypeError("the given object `variation_executor` must be of type `VariationExecutor`")
+        if variation_executor in self._variation_executors:
+            raise ValueError("the given object `variation_executor` already exists in child list")
+        self._variation_executors.append(variation_executor)
+
+    def get_executor_for_device_mapping(self, device_mapping: dict) -> Union[VariationExecutor, None]:
+        """
+        This method searches for a VariationExecutor in the internal list for which the given device mapping is
+        contained in
+
+        :param device_mapping: the device_mapping dictionary for which the executor should be searched for
+
+        :return: returns the associated VariationExecutor or None if no matching could be found
+        """
+        for cur_variation_executor in self._variation_executors:
+            if cur_variation_executor.base_device_mapping == device_mapping:
+                return cur_variation_executor
+        # can not find some
+        return None

_balder/executor/setup_executor.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from typing import Type, Union, List, TYPE_CHECKING
+
+from _balder.fixture_execution_level import FixtureExecutionLevel
+from _balder.testresult import ResultState, BranchBodyResult
+from _balder.executor.basic_executable_executor import BasicExecutableExecutor
+from _balder.executor.scenario_executor import ScenarioExecutor
+from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.controllers.setup_controller import SetupController
+from _balder.controllers.device_controller import DeviceController
+from _balder.controllers.feature_controller import FeatureController
+
+if TYPE_CHECKING:
+    from _balder.setup import Setup
+    from _balder.scenario import Scenario
+    from _balder.fixture_manager import FixtureManager
+    from _balder.executor.executor_tree import ExecutorTree
+
+
+class SetupExecutor(BasicExecutableExecutor):
+    """
+    A SetupExecutor is the highest branch object of an :class:`ExecutorTree`. It contains all scenarios and the
+    underlying device mappings and their test cases that exist with this setup.
+    """
+    fixture_execution_level = FixtureExecutionLevel.SETUP
+
+    def __init__(self, setup: Type[Setup], parent: ExecutorTree):
+        super().__init__()
+        self._scenario_executors: List[ScenarioExecutor] = []
+        # check if instance already exists
+        if hasattr(setup, "_instance") and setup._instance is not None and isinstance(setup._instance, setup):
+            self._base_setup_class = setup._instance
+        else:
+            self._base_setup_class = setup()
+            setup._instance = self._base_setup_class
+        self._parent_executor = parent
+        self._fixture_manager = parent.fixture_manager
+
+        # contains the result object for the BODY part of this branch
+        self.body_result = BranchBodyResult(self)
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    def all_child_executors(self) -> List[ScenarioExecutor]:
+        return self._scenario_executors
+
+    @property
+    def parent_executor(self) -> ExecutorTree:
+        return self._parent_executor
+
+    @property
+    def base_instance(self) -> object:
+        """returns the base class instance to which this executor instance belongs"""
+        return self.base_setup_class
+
+    @property
+    def base_setup_class(self) -> Setup:
+        """returns the base :class:`Setup` that belongs to this executor"""
+        return self._base_setup_class
+
+    @property
+    def base_setup_controller(self) -> SetupController:
+        """returns the :class:`SetupController` for the setup object of this executor"""
+        return SetupController.get_for(self.base_setup_class.__class__)
+
+    @property
+    def fixture_manager(self) -> FixtureManager:
+        """returns the current active fixture manager for this executor"""
+        return self._fixture_manager
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    def _prepare_execution(self, show_discarded):
+        print(f"SETUP {self.base_setup_class.__class__.__name__}")
+
+    def _body_execution(self, show_discarded):
+        for cur_scenario_executor in self.get_scenario_executors():
+            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 prev_mark == PreviousExecutorMark.SKIP:
+                cur_scenario_executor.set_result_for_whole_branch(ResultState.SKIP)
+            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)
+
+    def _cleanup_execution(self, show_discarded):
+        pass
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def update_inner_referenced_feature_instances(self):
+        """
+        This method ensures that all inner referenced feature instances of all devices that are used in this setup are
+        set to the correct feature instance. For every existing device, this method goes trough all assigned features
+        and checks for a inner-referenced feature. It makes sure, that every inner-referenced feature variable has the
+        final assigned setup feature that belongs to it.
+
+        # TODO check where we validate that inner references feature exists in setup
+        """
+        for cur_setup_device in self.base_setup_controller.get_all_abs_inner_device_classes():
+            # these features are subclasses of the real defined one (because they are already the replaced ones)
+            all_device_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+            all_instantiated_feature_objs_of_this_dev = [cur_feature for _, cur_feature in all_device_features.items()]
+            for _, cur_feature in all_device_features.items():
+                cur_feature_controller = FeatureController.get_for(cur_feature.__class__)
+                # now check the inner referenced features of this feature and check if that exists in the device
+                for cur_ref_feature_name, cur_ref_feature in \
+                        cur_feature_controller.get_inner_referenced_features().items():
+                    potential_candidates = [
+                        candidate_feature for candidate_feature in all_instantiated_feature_objs_of_this_dev
+                        if isinstance(candidate_feature, cur_ref_feature.__class__)]
+                    if len(potential_candidates) != 1:
+                        raise RuntimeError("found none or more than one potential replacing candidates")
+                    replacing_candidate = potential_candidates[0]
+                    # because `cur_feature` is only the object instance, the value will be overwritten only for this
+                    # object
+                    setattr(cur_feature, cur_ref_feature_name, replacing_candidate)
+
+    def get_scenario_executors(self) -> List[ScenarioExecutor]:
+        """returns a list with all scenario executors that belongs to this setup executor"""
+        return self._scenario_executors
+
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
+        to_remove_executor = []
+        for cur_scenario_executor in self.get_scenario_executors():
+            cur_scenario_executor.cleanup_empty_executor_branches(consider_discarded=consider_discarded)
+            if len(cur_scenario_executor.get_variation_executors(return_discarded=consider_discarded)) == 0:
+                # remove this whole executor because it has no children anymore
+                to_remove_executor.append(cur_scenario_executor)
+        for cur_scenario_executor in to_remove_executor:
+            self._scenario_executors.remove(cur_scenario_executor)
+
+    def add_scenario_executor(self, scenario_executor: ScenarioExecutor):
+        """
+        This method adds a new ScenarioExecutor to the child element list of the tree
+        """
+        if not isinstance(scenario_executor, ScenarioExecutor):
+            raise TypeError("the given object `scenario_executor` must be of type type `ScenarioExecutor`")
+        if scenario_executor in self._scenario_executors:
+            raise ValueError("the given object `scenario_executor` already exists in child list")
+        self._scenario_executors.append(scenario_executor)
+
+    def get_executor_for_scenario(self, scenario: Type[Scenario]) -> Union[ScenarioExecutor, None]:
+        """
+        This method searches for a ScenarioExecutor in the internal list for which the given scenario is
+        contained in
+
+        :param scenario: the scenario class for which the executor should be searched for
+
+        :return: returns the associated ScenarioExecutor or None if no matching could be found
+        """
+        for cur_scenario_executor in self._scenario_executors:
+            if cur_scenario_executor.base_scenario_class.__class__ == scenario:
+                return cur_scenario_executor
+        # can not find some
+        return None