baldertest 0.1.0__py3-none-any.whl

_balder/exit_code.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class ExitCode(Enum):
+    """
+    This enum describes the balder exit codes.
+    """
+    #: tests were collected and all tests and fixtures terminates with success
+    SUCCESS = 0
+    #: tests were collected but some tests failed
+    TESTS_FAILED = 1
+    #: test was interrupted by user
+    USER_INTERRUPT = 2
+    #: an internal unexpected error occurs
+    UNEXPECTED_ERROR = 3
+    #: Balder usage error
+    BALDER_USAGE_ERROR = 4
+    #: no tests were collected
+    NO_TESTS_COLLECTED = 5

_balder/feature.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from typing import Type, Dict, Tuple, Union
+
+from _balder.device import Device
+from _balder.vdevice import VDevice
+from _balder.utils.inner_device_managing_metaclass import InnerDeviceManagingMetaclass
+
+
+class Feature(metaclass=InnerDeviceManagingMetaclass):
+    """
+    This is the basic feature class. It represents an abstract class that should not be used directly. It is the base
+    class for all feature elements.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        :param kwargs: contains a dictionary that references all vDevices of the feature and a real
+                        scenario :meth:`Device` as value
+        """
+        from _balder.controllers import FeatureController  # pylint: disable=import-outside-toplevel
+
+        #: this property contains the active mapping for the devices
+        self.active_vdevices: Dict[VDevice, Union[Device, str]] = {}
+        all_vdevices = FeatureController.get_for(self.__class__).get_abs_inner_vdevice_classes()
+        not_processed_kwargs = {}
+        for cur_kwargs_key, cur_kwargs_val in kwargs.items():
+            if cur_kwargs_key in [cur_vdevice.__name__ for cur_vdevice in all_vdevices]:
+                cur_vdevice = [cur_vdevice for cur_vdevice in all_vdevices if cur_vdevice.__name__ == cur_kwargs_key][0]
+                if isinstance(cur_kwargs_val, str) or issubclass(cur_kwargs_val, Device):
+                    if not isinstance(cur_kwargs_val, str) and issubclass(cur_kwargs_val, VDevice):
+                        raise TypeError(f"the given value of vDevice mapping for vDevice `{cur_kwargs_key}` has to be "
+                                        f"of the type `Device` - it is a subclass of `VDevice` - this is not allowed "
+                                        f"here")
+                    if self.active_vdevices:
+                        raise AttributeError(
+                            "the constructor expects exactly none or one vDevice mapping - found more than one here")
+
+                    self.active_vdevices = {cur_vdevice: cur_kwargs_val}
+                else:
+                    raise TypeError(f"the given value of vDevice mapping for vDevice `{cur_kwargs_key}` has to be of "
+                                    f"the type `Device` or has to be a string with the name of the device class")
+            else:
+                not_processed_kwargs[cur_kwargs_key] = cur_kwargs_val
+        if len(not_processed_kwargs) != 0:
+            raise TypeError(
+                f"can not resolve the given attributes `{str(not_processed_kwargs)}` in feature "
+                f"`{self.__class__.__name__}`")
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- CLASS METHODS ----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    def active_vdevice_device_mapping(self) -> Tuple[Union[None, Type[VDevice]], Union[None, Type[Device]]]:
+        """This property returns the mapped device that is active here"""
+        if len(self.active_vdevices) == 0:
+            return None, None
+        return list(self.active_vdevices.keys())[0], list(self.active_vdevices.values())[0]
+
+    @property
+    def active_vdevice(self) -> Union[None, Type[VDevice]]:
+        """This property returns the active VDevice that is active here"""
+        return self.active_vdevice_device_mapping[0]
+
+    @property
+    def active_mapped_device(self) -> Union[None, Type[VDevice]]:
+        """This property returns the active mapped Device"""
+        return self.active_vdevice_device_mapping[1]
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------

_balder/feature_replacement_mapping.py

@@ -0,0 +1,107 @@
+from typing import Union, Type
+import dataclasses
+from .device import Device
+from .feature import Feature
+from .controllers import DeviceController
+
+
+class FeatureReplacementMapping:
+    """
+    helper object that stores mappings between scenario and setup features - is used in :class:`VariationExecutor`
+    """
+
+    @dataclasses.dataclass
+    class FeatureMapping:
+        """
+        stores a single mapping
+        """
+        #: the feature attribute name in scenario device
+        attr_name: str
+        #: the scenario feature instance or None if the current variation does not use this setup feature in scenario
+        scenario_feature: Union[Feature, None]
+        #: the setup feature that is used for the scenario feature
+        setup_feature: Feature
+
+    def __init__(self):
+        self._mappings: list[FeatureReplacementMapping.FeatureMapping] = []
+
+    @property
+    def mappings(self) -> list[FeatureMapping]:
+        """
+        returns all existing mappings
+        """
+        return list(self._mappings)
+
+    @property
+    def attr_names(self) -> list[str]:
+        """
+        returns all used attribute names
+        """
+        return [mapping.attr_name for mapping in self._mappings]
+
+    @property
+    def all_scenario_features(self) -> list[Feature]:
+        """
+        returns all scenario features
+        """
+        return [mapping.scenario_feature for mapping in self._mappings]
+
+    @property
+    def all_setup_features(self) -> list[Feature]:
+        """
+        returns all setup features
+        """
+        return [mapping.setup_feature for mapping in self._mappings]
+
+    def add(self, attr_name: str, scenario_feature: Union[Feature, None], setup_feature: Feature):
+        """
+        adds a new mapping
+
+        :param attr_name: the feature attribute name in scenario device
+        :param scenario_feature: the scenario feature instance or None if the current variation does not use this setup
+                                 feature in scenario
+        :param setup_feature: the setup feature that is used for the scenario feature
+        """
+        if attr_name in self.attr_names:
+            raise KeyError(f'entry for property name `{attr_name}` already exist - can not define it multiple times')
+        self._mappings.append(FeatureReplacementMapping.FeatureMapping(attr_name, scenario_feature, setup_feature))
+
+    def get_features_for_attr_name(self, attr_name: str) -> tuple[Feature, Feature]:
+        """
+        returns the scenario and its mapped setup feature for a specific attribute name used in the scenario device
+        """
+        for mapping in self._mappings:
+            if mapping.attr_name == attr_name:
+                return mapping.scenario_feature, mapping.setup_feature
+        raise KeyError(f'entry for property name `{attr_name}` does not exist')
+
+    def get_replaced_scenario_feature_for(self, setup_feature: Feature) -> Union[Feature, None]:
+        """
+        returns the mapped scenario feature for a given setup feature
+        """
+        for mapping in self._mappings:
+            if mapping.setup_feature == setup_feature:
+                return mapping.scenario_feature
+        raise KeyError(f'cannot find setup feature for {setup_feature}')
+
+    def add_remaining_setup_features_as_autonomous(self, cur_setup_device: Type[Device]):
+        """
+        Adds all features that were not added as autonomous features.
+        """
+        cur_setup_features = DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+
+        # also add all setup features that are not assigned as autonomous features
+        for cur_setup_feature in cur_setup_features.values():
+            if cur_setup_feature not in self.all_setup_features:
+                # determine free name
+                idx = 0
+                autonomous_name = None
+                while (autonomous_name is None
+                       or autonomous_name in self.attr_names):
+                    autonomous_name = f"_autonomous_feat_{idx}"
+                    idx += 1
+                self.add(
+                    attr_name=autonomous_name,
+                    scenario_feature=None,
+                    setup_feature=cur_setup_feature
+                )

_balder/feature_vdevice_mapping.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from typing import Type
+import dataclasses
+
+from .controllers.feature_controller import FeatureController
+from .device import Device
+from .feature import Feature
+from .vdevice import VDevice
+
+
+class FeatureVDeviceMapping:
+    """
+    helper object that stores mappings between :class:`VDevice` and :class:`Device`
+    """
+
+    @dataclasses.dataclass
+    class VDeviceDeviceMapping:
+        """describes the mapping of one VDevice to one Device"""
+        #: the vdevice class
+        vdevice: Type[VDevice]
+        #: the mapped device to this VDevice
+        device: Type[Device]
+
+    @dataclasses.dataclass
+    class VDevicesMapping:
+        """
+        stores a single mapping
+        """
+        #: the feature object, this mapping belongs to
+        feature: Feature
+        #: the available mapping for this feature (at the moment, we only support one)
+        mappings: list[FeatureVDeviceMapping.VDeviceDeviceMapping]
+
+    def __init__(self):
+        self._mappings: list[FeatureVDeviceMapping.VDevicesMapping] = []
+
+    @property
+    def mappings(self) -> list[VDevicesMapping]:
+        """
+        returns all existing mappings
+        """
+        return list(self._mappings)
+
+    @property
+    def features(self) -> list[Feature]:
+        """
+        returns all used attribute names
+        """
+        return [mapping.feature for mapping in self._mappings]
+
+    def items(self) -> list[tuple[Feature, list[VDeviceDeviceMapping]]]:
+        """
+        :return: a list of Feature/vdevice mapping tuples
+        """
+        return [(mapping.feature, mapping.mappings) for mapping in self._mappings]
+
+    def add(self, feature: Feature, mappings: dict[Type[VDevice], Type[Device]]):
+        """
+        adds a new mapping
+
+        :param feature: the :class:`Feature` class this mapping belongs to
+        :param mappings: a dictionary that describes the mapping between the :class:`VDevice` and :class:`Device`. The
+                         :class:`VDevice` needs to be part of the :class:`Feature`
+        """
+        if feature in self.features:
+            raise KeyError(f'entry for feature `{feature}` already exist - can not define it multiple times')
+        feature_controller = FeatureController.get_for(feature.__class__)
+        vdevice_device_mappings = []
+        for cur_vdev, cur_dev in mappings.items():
+            if not (isinstance(cur_vdev, type) and issubclass(cur_vdev, VDevice)):
+                raise TypeError(f'the provided key objects in mappings needs to be a subclass of `{VDevice.__name__}`')
+            if not (isinstance(cur_dev, type) and issubclass(cur_dev, Device)):
+                raise TypeError(f'the provided value objects in mappings needs to be a subclass of `{Device.__name__}`')
+            if cur_vdev not in feature_controller.get_abs_inner_vdevice_classes():
+                raise ValueError(f'the provided VDevice `{cur_vdev}` is not part of the provided feature `{feature}`')
+            vdevice_device_mappings.append(self.VDeviceDeviceMapping(cur_vdev, cur_dev))
+        new_mapping = self.VDevicesMapping(feature=feature, mappings=vdevice_device_mappings)
+
+        self._mappings.append(new_mapping)
+
+    def get_mappings_for_feature(self, feature: Feature) -> list[VDeviceDeviceMapping]:
+        """
+        returns the list with all mappings for the provided feature
+        """
+        for cur_item in self._mappings:
+            if cur_item.feature == feature:
+                return cur_item.mappings
+        raise KeyError(f'entry for feature `{feature}` does not exist')

_balder/fixture_definition_scope.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import List
+from enum import Enum
+
+
+class FixtureDefinitionScope(Enum):
+    """
+    This enum describes the definition scope of a fixture. A definition scope is the position the fixture was defined.
+    If the fixture was defined within the balderglob.py file, it has the definition-scope `GLOB`. If it is defined
+    within a scenario or setup it has the equivalent SCENARIO or SETUP scope.
+    """
+    GLOB = 'glob'
+    SETUP = 'setup'
+    SCENARIO = 'scenario'
+
+    @classmethod
+    def get_order(cls) -> List[FixtureDefinitionScope]:
+        """returns the priority order of the fixture definition scope"""
+        return [cls.GLOB, cls.SETUP, cls.SCENARIO]

_balder/fixture_execution_level.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from typing import List
+from enum import Enum
+
+
+class FixtureExecutionLevel(Enum):
+    """
+    This enum describes the fixture-execution-level of a fixture. It describes when the fixture should be executed. This
+    level will be set in the fixture decorator.
+    """
+    SESSION = 'session'
+    SETUP = 'setup'
+    SCENARIO = 'scenario'
+    VARIATION = 'variation'
+    TESTCASE = 'testcase'
+
+    @classmethod
+    def get_order(cls) -> List[FixtureExecutionLevel]:
+        """
+        returns the execution order of fixtures
+        """
+        return [cls.SESSION, cls.SETUP, cls.SCENARIO, cls.VARIATION, cls.TESTCASE]