baldertest 0.1.0__py3-none-any.whl

_balder/testresult.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING, List, Union
+
+from enum import Enum
+
+if TYPE_CHECKING:
+    from _balder.executor.basic_executor import BasicExecutor
+
+
+class ResultState(Enum):
+    """
+    enumeration that describes the possible results of a testcase-/fixture-executor
+    """
+    # this state will be assigned if the executor doesn't run yet
+    NOT_RUN = 'not_run'
+    # this state will be assigned if the test fails (only assignable to :class:`TestcaseExecutor`)
+    FAILURE = 'failure'
+    # this state will be assigned if the executor can not be executed because the fixture fails (only possible in
+    # construction part of fixtures, if the error occurs in teardown the next higher executer get this state) - will be
+    # assigned to the executor which has the fixture that fails
+    ERROR = 'error'
+    # this state will be assigned if the executor was executed successfully (session fixture and teardown fixture; for
+    # :class:`TestcaseExecutor` also the testcase itself)
+    SUCCESS = 'success'
+    # this state will be assigned if the executor was skipped
+    SKIP = 'skip'
+    # this state will be assigned if the executor is covered by another executor and wasn't executed (only assignable
+    # to :class:`ScenarioExecutor` and :class:`TestcaseExecutor`)
+    COVERED_BY = 'covered_by'
+
+    @staticmethod
+    def priority_order() -> List[ResultState]:
+        """
+        returns an order of states that returns the highest priority as first item and the lowest as last one
+        """
+        return [ResultState.ERROR, ResultState.FAILURE, ResultState.SUCCESS, ResultState.COVERED_BY, ResultState.SKIP,
+                ResultState.NOT_RUN]
+
+
+class _Result:
+
+    def __init__(self, executor: BasicExecutor):
+        self._result = ResultState.NOT_RUN
+
+        self._related_executor = executor
+        #: contains the exception that was thrown and returned into this result
+        self.exception = None
+
+        self.char_mapping = {
+            ResultState.NOT_RUN: " ",
+            ResultState.FAILURE: "X",
+            ResultState.ERROR: "E",
+            ResultState.SUCCESS: ".",
+            ResultState.SKIP: "S",
+            ResultState.COVERED_BY: "C"
+        }
+
+    def __str__(self):
+        return self.result.name
+
+    @property
+    def result(self) -> ResultState:
+        """returns the result"""
+        return self._result
+
+    def get_result_as_char(self):
+        """
+        returns a single char that represents the result state
+        """
+
+        return self.char_mapping[self.result]
+
+
+class _SettableResult(_Result):
+    ALLOWED_STATES = [ResultState.NOT_RUN, ResultState.FAILURE, ResultState.ERROR, ResultState.SUCCESS,
+                      ResultState.SKIP, ResultState.COVERED_BY]
+
+    def set_result(self, result: ResultState, exception: Union[Exception, None] = None) -> None:
+        """this method allows to set the result - if the value is SKIP or COVERED_BY this method automatically sets this
+        values also for all components of the branch in related executor"""
+
+        if result not in self.ALLOWED_STATES:
+            raise ValueError(
+                f"it is not allowed to set the given result `{result.name}` in a ´{self.__class__.__name__}´")
+        self._result = result
+        self.exception = exception
+
+
+class BranchBodyResult(_Result):
+    """
+    This result is used in every branch body. So it isn't set directly, it is always determined depending on the
+    :class:`FixturePartResult` and :class:`TestcaseResult` of the executors children.
+    """
+
+    def __init__(self, executor: BasicExecutor):
+        from _balder.executor.testcase_executor import TestcaseExecutor  # pylint: disable=import-outside-toplevel
+
+        if isinstance(executor, TestcaseExecutor):
+            raise TypeError("testcase executors are not allowed to use in `BranchBodyResult`")
+        super().__init__(executor=executor)
+
+    @property
+    def result(self):
+        """returns the determined result for the inner branch of the related executor"""
+        relative_result = ResultState.NOT_RUN
+        priority_order = ResultState.priority_order()
+        if self._related_executor.all_child_executors:
+            for cur_child in self._related_executor.all_child_executors:
+                if priority_order.index(cur_child.executor_result) < priority_order.index(relative_result):
+                    relative_result = cur_child.executor_result
+        self._result = relative_result
+        return self._result
+
+
+class FixturePartResult(_SettableResult):
+    """
+    This result is used for fixture construct or teardown code. It describes if there was an error in the construct
+    or teardown part of the fixture code for an executor.
+    """
+    #: contains the possible values that can be set for this Result type
+    ALLOWED_STATES = [ResultState.NOT_RUN, ResultState.ERROR, ResultState.SUCCESS]
+
+
+class TestcaseResult(_SettableResult):
+    """
+    This result is used for real executed testcase methods. These elements can only be assigned to real testcase methods
+    which are only available in :class:`TestcaseExecutor`.
+    """
+    #: contains the possible values that can be set for this Result type
+    ALLOWED_STATES = [ResultState.NOT_RUN, ResultState.FAILURE, ResultState.SUCCESS, ResultState.SKIP,
+                      ResultState.COVERED_BY]
+
+@dataclass
+class ResultSummary:
+    """
+    object that holds the test results for multiple tests like on branch or global level
+    """
+    # this state will be assigned if the executor doesn't run yet
+    not_run: int = 0
+    # this state will be assigned if the test fails (only assignable to :class:`TestcaseExecutor`)
+    failure: int = 0
+    # this state will be assigned if the executor can not be executed because the fixture fails (only possible in
+    # construction part of fixtures, if the error occurs in teardown the next higher executer get this state) - will be
+    # assigned to the executor which has the fixture that fails
+    error: int = 0
+    # this state will be assigned if the executor was executed successfully (session fixture and teardown fixture; for
+    # :class:`TestcaseExecutor` also the testcase itself)
+    success: int = 0
+    # this state will be assigned if the executor was skipped
+    skip: int = 0
+    # this state will be assigned if the executor is covered by another executor and wasn't executed (only assignable
+    # to :class:`ScenarioExecutor` and :class:`TestcaseExecutor`)
+    covered_by: int = 0
+
+    def __add__(self, other) -> ResultSummary:
+        new_summary = ResultSummary()
+        for cur_field in fields(self.__class__):
+            self_val = getattr(self, cur_field.name)
+            other_val = getattr(other, cur_field.name)
+            setattr(new_summary, cur_field.name, self_val + other_val)
+        return new_summary

_balder/unmapped_vdevice.py

@@ -0,0 +1,13 @@
+from _balder.vdevice import VDevice
+from _balder.exceptions import AccessToUnmappedVDeviceException
+
+
+class UnmappedVDevice(VDevice):
+    """
+    This special vdevice class will be assigned to all existing VDevice's that are not mapped during the execution of
+    a variation.
+    """
+
+    def __getattr__(self, item):
+        raise AccessToUnmappedVDeviceException('it is not allowed to access the attributes of an unmapped VDevice - '
+                                               'did you forget to map it?')

_balder/utils/functions.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from typing import List, Type, Union, TYPE_CHECKING
+
+import inspect
+from _balder.scenario import Scenario
+from _balder.exceptions import InheritanceError
+
+if TYPE_CHECKING:
+    from _balder.connection import Connection
+    from _balder.cnnrelations.base_connection_relation import BaseConnectionRelationT
+    from _balder.utils.typings import MethodLiteralType
+
+
+def get_scenario_inheritance_list_of(scenario: Type[Scenario]) -> List[Type[Scenario]]:
+    """
+    This method returns a list, beginning with the given `scenario`, of all parent classes that are from type
+    :class:´Scenario`. The last element of the list is always the original :class:`Scenario` class.
+
+    :param scenario: the scenario the method should look for in the inheritance list
+
+    :returns: a list with all classes that are from type scenario
+    """
+    if scenario == Scenario:
+        return [Scenario]
+    base_class_of_interest = None
+    for cur_parent in scenario.__bases__:
+        if issubclass(cur_parent, Scenario):
+            if base_class_of_interest is not None:
+                raise InheritanceError("it is not allowed to have multiple parent class that inherit from the "
+                                       "class `Scenario`")
+            base_class_of_interest = cur_parent
+
+    return [scenario] + get_scenario_inheritance_list_of(base_class_of_interest)
+
+
+def get_class_that_defines_method(meth):
+    """credits to https://stackoverflow.com/a/25959545"""
+    if inspect.ismethod(meth):
+        for cls in inspect.getmro(meth.__self__.__class__):
+            if meth.__name__ in cls.__dict__:
+                return cls
+        meth = meth.__func__  # fallback to __qualname__ parsing
+    if inspect.isfunction(meth):
+        cls = getattr(inspect.getmodule(meth), meth.__qualname__.split('.<locals>', 1)[0].rsplit('.', 1)[0], None)
+        if isinstance(cls, type):
+            return cls
+    return None  # not required since None would have been implicitly returned anyway
+
+
+def cnn_type_check_and_convert(elem: Union[Connection, Type[Connection], BaseConnectionRelationT]) \
+        -> Union[Connection, BaseConnectionRelationT]:
+    """
+    converts possible type object to instance and checks if the element is a connection type
+
+    :param elem: the connection object to be converted/checked
+    """
+
+    from ..connection import Connection  # pylint: disable=import-outside-toplevel
+    from ..cnnrelations.and_connection_relation import AndConnectionRelation  # pylint: disable=import-outside-toplevel
+    from ..cnnrelations.or_connection_relation import OrConnectionRelation  # pylint: disable=import-outside-toplevel
+
+    if isinstance(elem, type):
+        if issubclass(elem, Connection):
+            return elem()
+    elif isinstance(elem, (Connection, AndConnectionRelation, OrConnectionRelation)):
+        # okay
+        return elem
+    raise TypeError(f'object needs to be a `Connection`, a connection relation or a `Type[Connection]` - no '
+                    f'`{elem}`')
+
+
+def get_method_type(func_class, func) -> MethodLiteralType:
+    """
+    This helper function returns the type of the method (`staticmethod`, `classmethod` or `instancemethod`). It never
+    returns `function` because this type does not have a class.
+    """
+    expected_class_qualname = func.__qualname__.rpartition('.')[0]
+
+    def get_for(the_class):
+        if func.__name__ in the_class.__dict__.keys() and the_class.__qualname__ == expected_class_qualname:
+            fn_type = the_class.__dict__.get(func.__name__)
+
+            if isinstance(fn_type, classmethod):
+                return 'classmethod'
+
+            if isinstance(fn_type, staticmethod):
+                return 'staticmethod'
+
+            if fn_type is not None and fn_type.__class__.__name__ == 'function':
+                return 'instancemethod'
+            raise TypeError(f'unknown element type `{func}`')
+
+        for cur_base in the_class.__bases__:
+            result = get_for(cur_base)
+            if result:
+                return result
+        return None
+
+    meth_type = get_for(func_class)
+    if meth_type is None:
+        raise KeyError(f'the provided function `{func.__qualname__}` does not match with the provided class '
+                       f'`{func_class.__qualname__}`')
+    return meth_type

_balder/utils/inner_device_managing_metaclass.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+import inspect
+from _balder.device import Device
+
+
+class InnerDeviceManagingMetaclass(type):
+    """metaclass for all classes that holds :class:`Device` objects - sets the reference to the outer class for them"""
+    def __new__(mcs, name, parents, dct):
+        cls = super(InnerDeviceManagingMetaclass, mcs).__new__(mcs, name, parents, dct)
+        for inner_item in dct.values():
+            if inspect.isclass(inner_item) and issubclass(inner_item, Device):
+                inner_item._outer_balder_class = cls
+
+        return cls

_balder/utils/mixin_can_be_covered_by_executor.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from _balder.scenario import Scenario
+    from _balder.executor.scenario_executor import ScenarioExecutor
+
+
+class MixinCanBeCoveredByExecutor(ABC):
+    """mixin class for executor that can hold covered-by items"""
+
+    @property
+    @abstractmethod
+    def scenario_executor(self) -> ScenarioExecutor:
+        """
+        returns the current active scenario executor
+        """
+
+    @abstractmethod
+    def get_covered_by_element(self) -> list[Scenario | callable]:
+        """
+        This method returns a list of elements where the elements of the executor are covered from.
+        """

_balder/utils/typings.py

@@ -0,0 +1,4 @@
+from typing import Literal
+
+
+MethodLiteralType = Literal["function", "classmethod", "staticmethod", "instancemethod"]

_balder/vdevice.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from _balder.device import Device
+
+
+class VDevice(Device):
+    """
+    This is the main class for vDevices that will be used as inner classes in :class:`Feature` classes.
+    """

balder/__init__.py

@@ -0,0 +1,56 @@
+from _balder import __version__, __version_tuple__
+from _balder.setup import Setup
+from _balder.device import Device
+from _balder.vdevice import VDevice
+from _balder.feature import Feature
+from _balder.scenario import Scenario
+from _balder.connection import Connection
+from _balder.balder_plugin import BalderPlugin
+from _balder.balder_settings import BalderSettings
+from _balder.unmapped_vdevice import UnmappedVDevice
+from _balder.decorator_fixture import fixture
+from _balder.decorator_connect import connect
+from _balder.decorator_covered_by import covered_by
+from _balder.decorator_for_vdevice import for_vdevice
+from _balder.decorator_insert_into_tree import insert_into_tree
+from _balder.decorator_parametrize import parametrize
+from _balder.decorator_parametrize_by_feature import parametrize_by_feature
+
+
+__all__ = [
+    '__version__',
+
+    '__version_tuple__',
+
+    'connect',
+
+    'fixture',
+
+    'for_vdevice',
+
+    'insert_into_tree',
+
+    'covered_by',
+
+    'parametrize',
+
+    'parametrize_by_feature',
+
+    'Setup',
+
+    'Device',
+
+    'VDevice',
+
+    'Feature',
+
+    'Scenario',
+
+    'Connection',
+
+    'BalderPlugin',
+
+    'BalderSettings',
+
+    'UnmappedVDevice'
+]

balder/connections.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from _balder.objects.connections.osi_1_physical import BluetoothConnection, CanBusConnection, CoaxialCableConnection, \
+    DslConnection, RS232Connection, RS422Connection, RS485Connection, IsdnConnection, I2CConnection, I2SConnection, \
+    OneWireConnection, OpticalFiberConnection, SpiConnection, TwistedPairCableConnection, UsbConnection, WifiConnection
+from _balder.objects.connections.osi_2_datalink import EthernetConnection, WirelessLanConnection, LLDPConnection, \
+    ProfibusConnection
+from _balder.objects.connections.osi_3_network import IpSecConnection, IPv4Connection, IPv6Connection, \
+    ICMPv4Connection, ICMPv6Connection, IPConnection, ICMPConnection
+from _balder.objects.connections.osi_4_transport import TcpIPv4Connection, UdpIPv4Connection, TcpIPv6Connection, \
+    UdpIPv6Connection, TcpConnection, UdpConnection
+from _balder.objects.connections.osi_5_session import PptpConnection
+from _balder.objects.connections.osi_6_presentation import TelnetConnection
+from _balder.objects.connections.osi_7_application import HttpConnection, ImapConnection, LdapConnection, \
+    NtpConnection, RpcConnection, SmtpConnection, SntpConnection, SshConnection, DnsConnection
+
+__all__ = [
+    # OSI: Physical Layer
+    "BluetoothConnection", "CanBusConnection", "CoaxialCableConnection", "DslConnection", "RS232Connection",
+    "RS422Connection", "RS485Connection", "IsdnConnection", "I2CConnection", "I2SConnection", "OneWireConnection",
+    "OpticalFiberConnection", "SpiConnection", "TwistedPairCableConnection", "UsbConnection", "WifiConnection",
+
+    # OSI: Data Link Layer
+    "EthernetConnection", "WirelessLanConnection", "LLDPConnection", "ProfibusConnection",
+
+    # OSI: Network Layer
+    "IpSecConnection", "IPv4Connection", "IPv6Connection", "ICMPv4Connection", "ICMPv6Connection",
+    "IPConnection", "ICMPConnection",
+
+    # OSI: Transport Layer
+    "TcpIPv4Connection", "UdpIPv4Connection", "TcpIPv6Connection", "UdpIPv6Connection", "TcpConnection",
+    "UdpConnection",
+
+    # OSI: Session Layer
+    "PptpConnection",
+
+    # OSI Presentation Layer
+    "TelnetConnection",
+
+    # OSI Application Layer
+    "HttpConnection", "ImapConnection", "LdapConnection", "NtpConnection", "RpcConnection",
+    "SmtpConnection", "SntpConnection", "SshConnection", "DnsConnection"
+]

balder/devices.py

@@ -0,0 +1,9 @@
+"""contains all balder device objects"""
+from __future__ import annotations
+
+# from _balder.objects.devices.this_device import ThisDevice
+
+__all__ = [
+
+    # "ThisDevice"
+]

balder/exceptions.py

@@ -0,0 +1,44 @@
+from _balder.exceptions import BalderException, BalderWarning
+from _balder.exceptions import (FixtureScopeError, FixtureReferenceError, UnclearSetupScopedFixtureReference, \
+    UnclearUniqueClassReference, LostInExecutorTreeException, DeviceResolvingException, NodeNotExistsError, \
+    DuplicateForVDeviceError, DuplicateBalderSettingError, DeviceOverwritingError, VDeviceOverwritingError, \
+    AccessToUnmappedVDeviceException, FeatureOverwritingError, UnknownVDeviceException, RoutingBrokenChainError, \
+    IllegalConnectionTypeError, ConnectionMetadataConflictError, DeviceScopeError, ConnectionIntersectionError, \
+    UnclearAssignableFeatureConnectionError, InheritanceError, MultiInheritanceError, InnerFeatureResolvingError, \
+    VDeviceResolvingError, IllegalVDeviceMappingError, MissingFeaturesOfVDeviceError, NotApplicableVariationException, \
+    UnclearMethodVariationError, UnexpectedPluginMethodReturnValue)
+
+__all__ = [
+
+    "BalderException",
+    "BalderWarning",
+    "FixtureScopeError",
+    "FixtureReferenceError",
+    "UnclearSetupScopedFixtureReference",
+    "UnclearUniqueClassReference",
+    "LostInExecutorTreeException",
+    "DeviceResolvingException",
+    "NodeNotExistsError",
+    "DuplicateForVDeviceError",
+    "DuplicateBalderSettingError",
+    "DeviceOverwritingError",
+    "VDeviceOverwritingError",
+    "AccessToUnmappedVDeviceException",
+    "FeatureOverwritingError",
+    "UnknownVDeviceException",
+    "RoutingBrokenChainError",
+    "IllegalConnectionTypeError",
+    "ConnectionMetadataConflictError",
+    "DeviceScopeError",
+    "ConnectionIntersectionError",
+    "UnclearAssignableFeatureConnectionError",
+    "InheritanceError",
+    "MultiInheritanceError",
+    "InnerFeatureResolvingError",
+    "VDeviceResolvingError",
+    "IllegalVDeviceMappingError",
+    "MissingFeaturesOfVDeviceError",
+    "NotApplicableVariationException",
+    "UnclearMethodVariationError",
+    "UnexpectedPluginMethodReturnValue",
+]

balder/parametrization.py

@@ -0,0 +1,8 @@
+from _balder.parametrization import FeatureAccessSelector, Parameter, Value
+
+
+__all__ = [
+    'FeatureAccessSelector',
+    'Parameter',
+    'Value'
+]