baldertest 0.1.0__py3-none-any.whl

_balder/exceptions.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+
+class BalderException(Exception):
+    """basic balder exception"""
+
+
+class BalderWarning(Warning):
+    """basic balder warning"""
+
+
+class FixtureScopeError(BalderException):
+    """is thrown for fixtures that were defined in an illegal scope"""
+
+
+class FixtureReferenceError(BalderException):
+    """
+    is thrown when an error is detected in the reference between fixtures
+    """
+
+
+class UnclearSetupScopedFixtureReference(BalderException):
+    """
+    is thrown for the special UNCLEAR SETUP SCOPED FIXTURE REFERENCE error
+    """
+
+
+class UnclearUniqueClassReference(BalderException):
+    """
+    is thrown after balder can not clearly determine the related instance reference for a :class:`Scenario` or
+    :class:`Setup` class
+    """
+
+
+class LostInExecutorTreeException(BalderException):
+    """
+    is thrown if you make a wrong call when entering and leaving the fixture manager, and you got lost
+    """
+
+
+class DeviceResolvingException(BalderException):
+    """
+    is thrown if an error occurs while resolving a device string
+    """
+
+
+class NodeNotExistsError(BalderException):
+    """
+    is thrown if no connection node exists for a device
+    """
+
+
+class DuplicateForVDeviceError(BalderException):
+    """
+    is thrown if some illegal `@for_vdevice` decorator exists for a feature
+    """
+
+
+class DuplicateBalderSettingError(BalderException):
+    """
+    is thrown if balder can not determine the BalderSettings object clearly.
+    """
+
+
+class VDeviceOverwritingError(BalderException):
+    """
+    is thrown if the device is not overwritten correctly
+    """
+
+
+class AccessToUnmappedVDeviceException(BalderException):
+    """
+    is thrown if an unmapped vdevice is accessed
+    """
+
+
+class DeviceOverwritingError(BalderException):
+    """
+    is thrown if the device is not overwritten correctly
+    """
+
+
+class FeatureOverwritingError(BalderException):
+    """
+    is thrown if an inner instantiated feature is not overwritten correctly
+    """
+
+
+class UnknownVDeviceException(BalderException):
+    """
+    is thrown if some not allowed vDevices are given in a :meth:`Feature`
+    """
+
+
+class RoutingBrokenChainError(BalderException):
+    """
+    is thrown if the routing determines a broken pipe
+    """
+
+
+class IllegalConnectionTypeError(BalderException):
+    """
+    is thrown if the connection is illegal
+    """
+
+
+class ConnectionMetadataConflictError(BalderException):
+    """
+    is thrown if here is an illegal conflict between some metadata
+    """
+
+
+class DeviceScopeError(BalderException):
+    """
+    is thrown if the device class is placed on an illegal scope
+    """
+
+
+class ConnectionIntersectionError(BalderException):
+    """
+    is thrown if the intersection connection between two devices is reduced in a way that no intersection exists anymore
+    """
+
+
+class UnclearAssignableFeatureConnectionError(BalderException):
+    """
+    is thrown if two devices have parallel connections and a used feature could use both or more at the same time
+    """
+
+
+class InheritanceError(BalderException):
+    """
+    is thrown if a class inheritance is not allowed for the mentioned class
+    """
+
+
+class MultiInheritanceError(BalderException):
+    """
+    is thrown if multi inheritance was used where it is not allowed
+    """
+
+
+class InnerFeatureResolvingError(BalderException):
+    """
+    is thrown if an inner feature reference can not be resolved with the instantiated features of the device
+    """
+
+
+class VDeviceResolvingError(BalderException):
+    """
+    is thrown if there is an error while resolving VDevice's.
+    """
+
+
+class IllegalVDeviceMappingError(BalderException):
+    """
+    is thrown if there is an error while resolving vDevice mappings.
+    """
+
+
+class MissingFeaturesOfVDeviceError(BalderException):
+    """
+    is thrown if the related device does not implement all features specified in its mapped VDevice.
+    """
+
+
+class NotApplicableVariationException(BalderException):
+    """
+    is thrown internally after the current variation is not applicable
+    """
+
+
+class UnclearMethodVariationError(BalderException):
+    """
+    is thrown if there are more than one possible method variations possible
+    """
+
+
+class UnexpectedPluginMethodReturnValue(BalderException):
+    """
+    is thrown if a user plugin doesn't return something or returns wrong values in its plugin method
+    """

_balder/executor/basic_executable_executor.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+import sys
+
+import traceback
+from abc import ABC, abstractmethod
+
+from _balder.executor.basic_executor import BasicExecutor
+from _balder.testresult import ResultState
+
+if TYPE_CHECKING:
+    from _balder.fixture_execution_level import FixtureExecutionLevel
+    from _balder.fixture_manager import FixtureManager
+
+
+class BasicExecutableExecutor(BasicExecutor, ABC):
+    """
+    The BasicExecutor class is an abstract class that represents the parent class of all executors. Together with other
+    executor classes, an executor forms a tree structure in which individual tests, which later on are executed, are
+    assigned to individual scenarios
+    """
+    fixture_execution_level: FixtureExecutionLevel = None
+
+    def __init__(self):
+        super().__init__()
+
+        # holds the execution time of this branch (with branch fixtures)
+        self.execution_time_sec = None
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    @abstractmethod
+    def fixture_manager(self) -> FixtureManager:
+        """returns the active fixture manager instance"""
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    @abstractmethod
+    def _prepare_execution(self, show_discarded):
+        """
+        This method runs before the branch will be executed and before the fixture construction code of this branch
+        runs.
+        """
+
+    @abstractmethod
+    def _body_execution(self, show_discarded):
+        """
+        This method runs between the fixture construction and teardown code. It should trigger the execution of the
+        child branches.
+        """
+
+    @abstractmethod
+    def _cleanup_execution(self, show_discarded):
+        """
+        This method runs after the branch was executed (also after the fixture teardown code ran)
+        """
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def set_result_for_whole_branch(self, value: ResultState):
+        """
+        This method sets the executor result for all sub executors.
+
+        :param value: the new value that should be set for this branch
+        """
+        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")
+        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):
+        """
+        This method searches the whole tree and removes branches where an executor item has no own children. It can
+        remove these branches, because they have no valid matchings.
+
+        :param consider_discarded: true if this method should consider discarded branches, otherwise False
+        """
+
+    def filter_tree_for_user_filters(self):
+        """
+        This method calls all user defined filters that are to be applied to the executor tree.
+        """
+        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):
+        """
+        Executes the whole branch
+        """
+        start_time = time.perf_counter()
+        self._prepare_execution(show_discarded=show_discarded)
+
+        try:
+            try:
+                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
+                # this has to be a construction fixture error
+                traceback.print_exception(*sys.exc_info())
+                self.construct_result.set_result(ResultState.ERROR, exc)
+            finally:
+                if self.has_runnable_tests():
+                    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())
+            self.teardown_result.set_result(ResultState.ERROR, exc)
+
+        self._cleanup_execution(show_discarded=show_discarded)
+
+        self.execution_time_sec = time.perf_counter() - start_time

_balder/executor/basic_executor.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from typing import List, Union, Type, TYPE_CHECKING
+
+import types
+from abc import ABC, abstractmethod
+from _balder.previous_executor_mark import PreviousExecutorMark
+from _balder.testresult import FixturePartResult, ResultState, ResultSummary, TestcaseResult
+
+if TYPE_CHECKING:
+    from _balder.setup import Setup
+    from _balder.scenario import Scenario
+
+
+class BasicExecutor(ABC):
+    """
+    The BasicExecutor class is an abstract class that represents the parent class of all executors. Together with other
+    executor classes, an executor forms a tree structure in which individual tests, which later on are executed, are
+    assigned to individual scenarios
+    """
+    # this property describes the runnable state of the executor branch before the executor is really used
+    #  with this you can declare a whole branch as inactive, while the collecting process is active
+    prev_mark = PreviousExecutorMark.RUNNABLE
+
+    def __init__(self):
+        # contains the result object for the CONSTRUCT FIXTURE part of this branch
+        self.construct_result = FixturePartResult(self)
+        # contains the result object for the BODY part of this branch (will be defined in subclasses)
+        self.body_result = None
+        # contains the result object for the TEARDOWN FIXTURE part of this branch
+        self.teardown_result = FixturePartResult(self)
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    @abstractmethod
+    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)
+        """
+
+    @property
+    @abstractmethod
+    def parent_executor(self) -> BasicExecutor:
+        """returns the parent executor of this element"""
+
+    @property
+    @abstractmethod
+    def base_instance(self) -> object:
+        """returns the base class instance to which this executor instance belongs or None if this element is a
+        ExecutorTree"""
+
+    @property
+    def executor_result(self) -> ResultState:
+        """
+        This property returns the combined state of this executor object. This is determined by its properties
+        ``construct_result``, ``body_result`` and ``teardown_result``.
+        """
+        relative_result = ResultState.NOT_RUN
+        priority_order = ResultState.priority_order()
+
+        if priority_order.index(self.construct_result.result) < priority_order.index(relative_result):
+            relative_result = self.construct_result.result
+        if priority_order.index(self.body_result.result) < priority_order.index(relative_result):
+            relative_result = self.body_result.result
+        if priority_order.index(self.teardown_result.result) < priority_order.index(relative_result):
+            relative_result = self.teardown_result.result
+        return relative_result
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def get_all_recognized_exception(self) -> List[Exception]:
+        """
+        This method returns all occurred Exception of this branch.
+
+        :return: a list with all occurred and recorded exceptions
+        """
+        all_own = [self.construct_result.exception, self.body_result.exception, self.teardown_result.exception]
+        if self.all_child_executors:
+            for cur_child_executor in self.all_child_executors:
+                all_own += cur_child_executor.get_all_recognized_exception()
+
+        # filter all duplicated entries
+        all_own = list(set(all_own))
+        if None in all_own:
+            all_own.remove(None)
+        return all_own
+
+    def has_runnable_tests(self, consider_discarded_too=False) -> bool:
+        """
+        This method returns true if this executor element is runnable. The method returns true if this element has
+        `prev_mark=RUNNABLE` and minimum one of its children has `prev_mark=RUNNABLE` too.
+
+        :param consider_discarded_too: True if the method allows DISCARDED elements too
+        """
+        allowed_prev_marks = [PreviousExecutorMark.RUNNABLE]
+
+        if consider_discarded_too:
+            allowed_prev_marks.append(PreviousExecutorMark.DISCARDED)
+
+        if self.prev_mark not in allowed_prev_marks:
+            return False
+
+        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_runnable_tests(consider_discarded_too):
+                    return True
+            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]]:
+        """
+        This method returns a list of all base instance elements that are from given type `with_type`. If `with_type`
+        is a base type of this branch element, the method always returns a list with one element. If the base instance
+        element is a child of the current branch, it could be a list with zero to infinite elements.
+
+        .. note::
+            The method only returns unique objects.
+        """
+        # search all higher classes and this one (if there is a match, return value is a list with exactly one element)
+        cur_executor = self
+        # only go through cur_executor == ExecutorTree (do not iterate with this object)
+        while cur_executor.parent_executor is not None:
+            if isinstance(cur_executor.base_instance, with_type):
+                if not only_runnable_elements or cur_executor.has_runnable_tests():
+                    return [cur_executor.base_instance]
+            cur_executor = cur_executor.parent_executor
+
+        # go in the branch and search in all children (recursively)
+        result = []
+        # if there are no child executors -> we do not need to search in children because there are no children
+        if self.all_child_executors is not None:
+            for cur_child_executor in self.all_child_executors:
+                child_result = cur_child_executor.get_all_base_instances_of_this_branch(
+                    with_type=with_type, only_runnable_elements=only_runnable_elements)
+                result += child_result
+        # remove duplicate items
+        return list(set(result))
+
+    @abstractmethod
+    def cleanup_empty_executor_branches(self, consider_discarded=False):
+        """
+        This method searches the whole tree and removes branches where an executor item has no own children. It can
+        remove these branches, because they have no valid matchings.
+
+        :param consider_discarded: true if this method should consider discarded branches, otherwise False
+        """
+
+    def filter_tree_for_user_filters(self):
+        """
+        This method calls all user defined filters that are to be applied to the executor tree.
+        """
+        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:
+        """
+        returns a dictionary with all possible :class:`ResultState` as keys and the number of times they have occurred
+        in this branch as values
+        """
+
+        summary = ResultSummary()
+
+        if isinstance(self.body_result, TestcaseResult):
+            setattr(summary, self.executor_result.value, 1)
+        elif self.all_child_executors:
+            for cur_child_exec in self.all_child_executors:
+                summary += cur_child_exec.testsummary()
+        return summary