baldertest 0.1.0__py3-none-any.whl

_balder/objects/connections/osi_1_physical.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+
+@insert_into_tree(parents=[])
+class BluetoothConnection(Connection):
+    """
+    Balder Bluetooth connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class CanBusConnection(Connection):
+    """
+    Balder CAN-Bus connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class CoaxialCableConnection(Connection):
+    """
+    Balder Coaxial-Cable connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class DslConnection(Connection):
+    """
+    Balder DSL connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class RS232Connection(Connection):
+    """
+    Balder RS232 connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class RS422Connection(Connection):
+    """
+    Balder RS422 connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class RS485Connection(Connection):
+    """
+    Balder RS485 connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class IsdnConnection(Connection):
+    """
+    Balder ISDN connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class I2CConnection(Connection):
+    """
+    Balder I2C connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class I2SConnection(Connection):
+    """
+    Balder I2S connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class OneWireConnection(Connection):
+    """
+    Balder One-Wire connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class OpticalFiberConnection(Connection):
+    """
+    Balder Optical-Fiber connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class SpiConnection(Connection):
+    """
+    Balder SPI connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class TwistedPairCableConnection(Connection):
+    """
+    Balder Twisted-Pair Cable connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class UsbConnection(Connection):
+    """
+    Balder USB connection (OSI LAYER 1)
+    """
+
+
+@insert_into_tree(parents=[])
+class WifiConnection(Connection):
+    """
+    Balder Wi-Fi connection (OSI LAYER 1)
+    """

_balder/objects/connections/osi_2_datalink.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_1_physical
+
+
+@insert_into_tree(parents=[osi_1_physical.OpticalFiberConnection, osi_1_physical.DslConnection,
+                           osi_1_physical.IsdnConnection])
+class EthernetConnection(Connection):
+    """
+    Balder Ethernet connection (OSI LAYER 2)
+    """
+
+
+@insert_into_tree(parents=[osi_1_physical.WifiConnection])
+class WirelessLanConnection(Connection):
+    """
+    Balder Wireless LAN connection (OSI LAYER 2)
+    """
+
+
+@insert_into_tree(parents=[])
+class LLDPConnection(Connection):
+    """
+    Balder LLDP connection (OSI LAYER 2)
+    """
+
+
+@insert_into_tree(parents=[])
+class ProfibusConnection(Connection):
+    """
+    Balder Profibus connection (OSI LAYER 2)
+    """

_balder/objects/connections/osi_3_network.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_2_datalink
+
+
+@insert_into_tree(parents=[osi_2_datalink.EthernetConnection, osi_2_datalink.WirelessLanConnection])
+class IPv4Connection(Connection):
+    """
+    Balder IPv4 connection (OSI LAYER 3)
+    """
+
+
+@insert_into_tree(parents=[osi_2_datalink.EthernetConnection, osi_2_datalink.WirelessLanConnection])
+class IPv6Connection(Connection):
+    """
+    Balder IPv6 connection (OSI LAYER 3)
+    """
+
+
+IPConnection = Connection.based_on(IPv4Connection | IPv6Connection)
+
+
+@insert_into_tree(parents=[IPv4Connection, IPv6Connection])
+class IpSecConnection(Connection):
+    """
+    Balder IPSec connection (OSI LAYER 3)
+    """
+
+
+@insert_into_tree(parents=[IPv4Connection])
+class ICMPv4Connection(Connection):
+    """
+    Balder ICMP IPv4 connection (OSI LAYER 3)
+    """
+
+
+@insert_into_tree(parents=[IPv6Connection])
+class ICMPv6Connection(Connection):
+    """
+    Balder ICMP IPv6 connection (OSI LAYER 3)
+    """
+
+
+ICMPConnection = Connection.based_on(ICMPv4Connection | ICMPv6Connection)

_balder/objects/connections/osi_4_transport.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_3_network
+
+
+@insert_into_tree(parents=[osi_3_network.IPv4Connection])
+class TcpIPv4Connection(Connection):
+    """
+    Balder TCP IPv4 connection (OSI LAYER 4)
+    """
+
+
+@insert_into_tree(parents=[osi_3_network.IPv6Connection])
+class TcpIPv6Connection(Connection):
+    """
+    Balder TCP IPv6 connection (OSI LAYER 4)
+    """
+
+
+TcpConnection = Connection.based_on(TcpIPv4Connection | TcpIPv6Connection)
+
+
+@insert_into_tree(parents=[osi_3_network.IPv4Connection])
+class UdpIPv4Connection(Connection):
+    """
+    Balder UDP IPv4 connection (OSI LAYER 4)
+    """
+
+
+@insert_into_tree(parents=[osi_3_network.IPv6Connection])
+class UdpIPv6Connection(Connection):
+    """
+    Balder UDP IPv6 connection (OSI LAYER 4)
+    """
+
+
+UdpConnection = Connection.based_on(UdpIPv4Connection | UdpIPv6Connection)

_balder/objects/connections/osi_5_session.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_4_transport
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class PptpConnection(Connection):
+    """
+    Balder PPTP connection (OSI LAYER 5)
+    """

_balder/objects/connections/osi_6_presentation.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_4_transport
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class TelnetConnection(Connection):
+    """
+    Balder TELNET connection (OSI LAYER 6)
+    """

_balder/objects/connections/osi_7_application.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from _balder.connection import Connection
+from _balder.decorator_insert_into_tree import insert_into_tree
+
+from _balder.objects.connections import osi_3_network, osi_4_transport
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class HttpConnection(Connection):
+    """
+    Balder HTTP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class ImapConnection(Connection):
+    """
+    Balder IMAP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(
+    parents=[
+        (osi_4_transport.TcpIPv4Connection, osi_4_transport.UdpIPv4Connection),
+        (osi_4_transport.TcpIPv6Connection, osi_4_transport.UdpIPv6Connection),
+        osi_3_network.IPv4Connection,
+        osi_3_network.IPv6Connection
+    ])
+class LdapConnection(Connection):
+    """
+    Balder LDAP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(parents=[osi_4_transport.UdpIPv4Connection, osi_4_transport.UdpIPv6Connection])
+class NtpConnection(Connection):
+    """
+    Balder NTP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(
+    parents=[
+        (osi_4_transport.UdpIPv4Connection, osi_4_transport.TcpIPv4Connection),
+        (osi_4_transport.UdpIPv6Connection, osi_4_transport.TcpIPv6Connection)
+    ])
+class RpcConnection(Connection):
+    """
+    Balder RPC connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class SmtpConnection(Connection):
+    """
+    Balder SMTP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(parents=[osi_4_transport.UdpIPv4Connection, osi_4_transport.UdpIPv6Connection])
+class SntpConnection(Connection):
+    """
+    Balder SNTP connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(parents=[osi_4_transport.TcpIPv4Connection, osi_4_transport.TcpIPv6Connection])
+class SshConnection(Connection):
+    """
+    Balder SSH connection (OSI LAYER 7)
+    """
+
+
+@insert_into_tree(
+    parents=[
+        (osi_4_transport.UdpIPv4Connection, osi_4_transport.TcpIPv4Connection),
+        (osi_4_transport.UdpIPv6Connection, osi_4_transport.TcpIPv6Connection)
+    ])
+class DnsConnection(Connection):
+    """
+    Balder DNS connection (OSI LAYER 7)
+    """

_balder/objects/devices/this_device.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from _balder.device import Device
+
+
+class ThisDevice(Device):
+    """
+    This class describes the test computer on which this code is currently being executed. It represents an abstract
+    class that must not be used directly. Rather, it serves as the large superclass over all Balder objects.
+
+    Note that this is the parent class for the :class:`Setup` inner class :class:`Setup.DeviceThis`.
+    """

_balder/parametrization.py

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

_balder/plugin_manager.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, List, Type, Tuple, Union
+
+import argparse
+import pathlib
+from _balder.balder_plugin import BalderPlugin
+from _balder.exceptions import UnexpectedPluginMethodReturnValue
+
+if TYPE_CHECKING:
+    from _balder.balder_session import BalderSession
+    from _balder.executor.executor_tree import ExecutorTree
+    from _balder.scenario import Scenario
+    from _balder.setup import Setup
+
+
+class PluginManager:
+    """
+    This class is a helper class that manages all existing plugins.
+    """
+
+    def __init__(self):
+        self.all_plugins: List[BalderPlugin] = []
+
+    def register(self, plugin_class: Type[BalderPlugin], session: BalderSession):
+        """
+        This method registers a new plugin class.
+
+        :param plugin_class: the new class that should be registered
+
+        :param session: the balder session, the new plugin belongs to
+        """
+        if plugin_class in [cur_plugin_instance.__class__ for cur_plugin_instance in self.all_plugins]:
+            raise ValueError(f"the given plugin class `{plugin_class.__name__}` can not be added twice")
+        plugin_instance = plugin_class(session)
+        self.all_plugins.append(plugin_instance)
+
+    def execute_addoption(self, argument_parser: argparse.ArgumentParser) -> None:
+        """
+        This method executes all plugin callbacks :ref:`BalderPlugin.addoption`.
+
+        The callback will be executed while the `ArgumentParser` is being created.
+
+        :param argument_parser: the argument parser object
+        """
+        for cur_plugin in self.all_plugins:
+            cur_plugin.addoption(argument_parser)
+
+    def execute_modify_collected_pyfiles(self, pyfiles: List[pathlib.Path]) -> List[pathlib.Path]:
+        """
+        This method executes all plugin callbacks :ref:`BalderPlugin.cb_filter_executor_tree`.
+
+        The callback will be executed to filter the collected pyfiles, that will be analysed later. From these files,
+        balder tries to determine and then import relevant :class:`Scenario` and :class:`Setup` classes later.
+
+        :param pyfiles: a list with all collected pyfiles
+
+        :return: the new list that should be used for the pyfiles
+        """
+        cur_pyfiles = pyfiles
+        for cur_plugin in self.all_plugins:
+            if cur_plugin.__class__.modify_collected_pyfiles == BalderPlugin.modify_collected_pyfiles:
+                # there is no specific implementation
+                break
+            ret = cur_plugin.modify_collected_pyfiles(pyfiles=cur_pyfiles)
+            if ret is None:
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `modify_collected_pyfiles` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned something - a list of filepaths was expected")
+            if not isinstance(ret, list):
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `modify_collected_pyfiles` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned a list (return type is `{type(ret)}`)")
+            cur_pyfiles = ret
+        return cur_pyfiles
+
+    def execute_collected_classes(self, scenarios: List[Type[Scenario]], setups: List[Type[Setup]]) \
+            -> Tuple[List[Type[Scenario]], List[Type[Setup]]]:
+        """
+        This method executes all plugin callbacks :ref:`BalderPlugin.cb_filter_executor_tree`.
+
+        The callback will be executed to filter the collected :class:`Scenario` and :class:`Setup` classes.
+
+        :param scenarios: a list with all collected :class:`Scenario` classes before the plugin can filter it
+
+        :param setups: a list with all collected :class:`Setup` classes before the plugin can filter it
+
+        :return: a tuple where the first element is the new :class:`Scenario` list and the second is the new
+                 :class:`Setup` class list
+        """
+        cur_scenarios = scenarios
+        cur_setups = setups
+        for cur_plugin in self.all_plugins:
+            if cur_plugin.__class__.modify_collected_classes == BalderPlugin.modify_collected_classes:
+                # there is no specific implementation
+                break
+            ret = cur_plugin.modify_collected_classes(scenarios=cur_scenarios, setups=cur_setups)
+            if ret is None:
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `execute_collected_classes` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned something - a tuple with two lists for Scenarios and Setups was expected")
+            if not isinstance(ret, tuple):
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `execute_collected_classes` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned a tuple (return type is `{type(ret)}`)")
+            if not len(ret) == 2:
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `execute_collected_classes` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned a tuple of length 2")
+            if not isinstance(ret[0], list) or not isinstance(ret[1], list):
+                raise UnexpectedPluginMethodReturnValue(
+                    f"the method `execute_collected_classes` of balder plugin `{cur_plugin.__class__.__name__}` has not"
+                    f"returned a tuple with two lists as values")
+            cur_scenarios, cur_setups = ret
+        return cur_scenarios, cur_setups
+
+    def execute_filter_executor_tree(self, executor_tree: ExecutorTree) -> None:
+        """
+        This method executes all plugin methods :ref:`BalderPlugin.filter_executor_tree`.
+
+        The callback will be executed to filter the created :class:`ExecutorTree` for this balder session. For this the
+        :class:`ExecutorTree` reference (given by ``executor_tree``) can be manipulated.
+
+        :param executor_tree: the reference to the main :class:`ExecutorTree` object that balder uses for this session
+        """
+        for cur_plugin in self.all_plugins:
+            cur_plugin.filter_executor_tree(executor_tree=executor_tree)
+
+    def execute_session_finished(self, executor_tree: Union[ExecutorTree, None]) -> None:
+        """
+        This method executes all plugin methods :ref:`BalderPlugin.session_finished`.
+
+        This callback will be executed at the end of every session. The callback will run in a `collect-only` and
+        `resolve-only` session too. Note, that the `executor_tree` argument is None in a `collect-only` session.
+
+        :param executor_tree: the reference to the main :class:`ExecutorTree` object that balder uses for this session
+        """
+        for cur_plugin in self.all_plugins:
+            cur_plugin.session_finished(executor_tree=executor_tree)

_balder/previous_executor_mark.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class PreviousExecutorMark(Enum):
+    """
+    This enum defines the previous state of an executor object. It allows to set a pre-state to an executor, that
+    describes if it is executable before the executor-tree will be called
+    """
+    #: this is the normal state, where all sub elements are allowed to be executed
+    RUNNABLE = 1
+
+    #: this marks the element and all of its sub elements as skip-able
+    SKIP = 2
+
+    #: this marks the element and all of its sub elements as NOT RUNNABLE, because this element is covered_by another
+    COVERED_BY = 3
+
+    #: this marks that the element should be ignored from the executor mechanism
+    IGNORE = -1
+
+    #: this marks that the element was already discarded because its variation is not applicable
+    DISCARDED = -2