baldertest 0.1.0b5__py3-none-any.whl → 0.1.0b7__py3-none-any.whl

_balder/executor/variation_executor.py

@@ -12,7 +12,7 @@ from _balder.previous_executor_mark import PreviousExecutorMark
 from _balder.routing_path import RoutingPath
 from _balder.unmapped_vdevice import UnmappedVDevice
 from _balder.controllers import DeviceController, VDeviceController, FeatureController, NormalScenarioSetupController
-from _balder.exceptions import NotApplicableVariationError, UnclearAssignableFeatureConnectionError
+from _balder.exceptions import NotApplicableVariationException, UnclearAssignableFeatureConnectionError
 
 if TYPE_CHECKING:
     from _balder.setup import Setup
@@ -62,6 +62,12 @@ class VariationExecutor(BasicExecutor):
         self._original_active_vdevice_mappings: \
             Dict[Type[Device], Dict[Feature, Dict[Type[VDevice], Type[Device]]]] = {}
 
+        # is True if the applicability check was done
+        self._applicability_check_done = False
+        #: this property holds the exception of type :class:`NotApplicableVariationException` if the variation can not
+        #:  be applied, otherwise this property is None
+        self._not_applicable_variation_exc = None
+
         # contains the result object for the BODY part of this branch
         self.body_result = BranchBodyResult(self)
 
@@ -90,7 +96,7 @@ class VariationExecutor(BasicExecutor):
     @property
     def cur_setup_class(self) -> Setup:
         """property returns the current :class:`Setup` for this variation"""
-        return self._parent_executor._parent_executor.base_setup_class
+        return self._parent_executor.parent_executor.base_setup_class
 
     @property
     def base_device_mapping(self) -> Dict[Type[Device], Type[Device]]:
@@ -102,11 +108,6 @@ class VariationExecutor(BasicExecutor):
 
     @property
     def all_child_executors(self) -> List[TestcaseExecutor]:
-        return self.testcase_executors
-
-    @property
-    def testcase_executors(self) -> List[TestcaseExecutor]:
-        """returns all sub testcase executors that belongs to this variation-executor"""
         return self._testcase_executors
 
     @property
@@ -131,24 +132,35 @@ class VariationExecutor(BasicExecutor):
         `determine_feature_replacement_and_vdevice_mappings()`"""
         return self._abs_setup_feature_vdevice_mappings
 
+    @property
+    def not_applicable_variation_exc(self) -> Union[NotApplicableVariationException, None]:
+        return self._not_applicable_variation_exc
+
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
-    def _prepare_execution(self):
+    def _prepare_execution(self, show_discarded):
         print("    VARIATION ", end='')
         device_map_str = [f"{scenario_device.__qualname__}:{setup_device.__qualname__}"
                           for scenario_device, setup_device in self._base_device_mapping.items()]
         print(' | '.join(device_map_str))
-        self.determine_abs_variation_connections()
-        self.update_scenario_device_feature_instances()
-        self.update_active_vdevice_device_mappings_in_all_features()
-        self.update_inner_referenced_feature_instances()
-        self.exchange_unmapped_vdevice_references()
-        self.update_vdevice_referenced_feature_instances()
-        self.set_conn_dependent_methods()
-
-    def _body_execution(self):
-        for cur_testcase_executor in self.testcase_executors:
-            if cur_testcase_executor.has_runnable_elements():
+        if show_discarded and not self.can_be_applied():
+            print(f"      DISCARDED BECAUSE `{self.not_applicable_variation_exc.args[0]}`")
+        else:
+            self.determine_abs_variation_connections()
+            self.update_scenario_device_feature_instances()
+            self.update_active_vdevice_device_mappings_in_all_features()
+            self.update_inner_referenced_feature_instances()
+            self.exchange_unmapped_vdevice_references()
+            self.update_vdevice_referenced_feature_instances()
+            self.set_conn_dependent_methods()
+
+    def _body_execution(self, show_discarded):
+        if show_discarded and not self.can_be_applied():
+            # do nothing if this variation can not be applied (is discarded)
+            return
+
+        for cur_testcase_executor in self.get_testcase_executors():
+            if cur_testcase_executor.has_runnable_tests():
 
                 cur_testcase_executor.execute()
             elif cur_testcase_executor.prev_mark == PreviousExecutorMark.SKIP:
@@ -158,13 +170,134 @@ class VariationExecutor(BasicExecutor):
             else:
                 cur_testcase_executor.set_result_for_whole_branch(ResultState.NOT_RUN)
 
-    def _cleanup_execution(self):
+    def _cleanup_execution(self, show_discarded):
+        if show_discarded and not self.can_be_applied():
+            # do nothing if this variation can not be applied (is discarded)
+            return
+
         self.restore_original_vdevice_references()
         self.revert_active_vdevice_device_mappings_in_all_features()
         self.revert_scenario_device_feature_instances()
 
+    def _verify_applicability_trough_feature_implementation_matching(self):
+        """
+        This method validates, that the features in this variation are valid. For this the setup devices must
+        implement all the required features of the scenario device. In other words, a feature child class must be
+        implemented in the setup device for each feature in the scenario device.
+        """
+        for scenario_device, setup_device in self._base_device_mapping.items():
+            scenario_device_orig_features = \
+                DeviceController.get_for(scenario_device).get_original_instanced_feature_objects()
+            for cur_scenario_feature_attr_name, cur_scenario_feature in scenario_device_orig_features.items():
+                found_setup_feature_for_scenario_feature = False
+                setup_device_instantiated_features = \
+                    DeviceController.get_for(setup_device).get_all_instantiated_feature_objects()
+                for _, cur_setup_feature in setup_device_instantiated_features.items():
+                    if isinstance(cur_setup_feature, cur_scenario_feature.__class__):
+                        found_setup_feature_for_scenario_feature = True
+                if not found_setup_feature_for_scenario_feature:
+                    raise NotApplicableVariationException(
+                        f'no matching setup-level feature found for scenario-level feature '
+                        f'`{cur_scenario_feature_attr_name} = {cur_scenario_feature.__class__.__name__}()` of device '
+                        f'`{scenario_device.__qualname__}`')
+
+    def _verify_applicability_trough_vdevice_feature_impl_matching(self) -> None:
+        """
+        This method checks for all vDevices that are in the setups/scenario features of this VariationExecutor, if their
+        vDevices-Mappings (so the mapped setup-devices) implements all features that are defined in the vDevices
+        """
+
+        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
+            cur_setup_device = self.get_setup_device_for(scenario_device=cur_scenario_device)
+            all_inner_setup_features = \
+                DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
+
+            # describes the mapping from the new setup feature (key) to the instantiated scenario feature (value)
+            #  note that this dictionary only contains the required one
+            setup_to_scenario_feature_mapping: Dict[Type[Feature], Feature] = {
+                cur_replacement_tuple[1]: cur_replacement_tuple[0]
+                for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items()
+                if cur_replacement_tuple[0] is not None}
+
+            # now secure that all features are available in the corresponding setup device, that are defined in the
+            #  mapped vDevice
+            for _, cur_setup_feature_obj in all_inner_setup_features.items():
+                # only check if there is a requirement of this feature (the feature is required by the Scenario)
+                if cur_setup_feature_obj.__class__ not in setup_to_scenario_feature_mapping.keys():
+                    # ignore this, because no requirement for this feature
+                    continue
+                related_scenario_feature_obj = setup_to_scenario_feature_mapping[cur_setup_feature_obj.__class__]
+                # get vDevice and device mapping
+                partner_scenario_vdevice, partner_scenario_device = \
+                    related_scenario_feature_obj.active_vdevice_device_mapping
+
+                if partner_scenario_device is None:
+                    # ignore because no mapping exist here
+                    continue
+
+                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_vdevice)
+                # get the related vDevice on setup view that is currently active
+                mapped_setup_vdevices = [
+                    cur_vdevice for cur_vdevice
+                    in FeatureController.get_for(
+                        cur_setup_feature_obj.__class__).get_abs_inner_vdevice_classes()
+                    if issubclass(cur_vdevice, partner_scenario_vdevice)]
+                if len(mapped_setup_vdevices) != 1:
+                    # find no mapping for the vDevice -> not possible
+                    # todo optimize this exception message
+                    raise NotApplicableVariationException(
+                        f'can not find a valid setup-level vDevice in setup feature '
+                        f'`{cur_setup_feature_obj.__class__}`')
+                # now check that the setup partner device has all features implemented that are required
+                # features from the VDevice
+                partner_setup_device_features = \
+                    DeviceController.get_for(partner_setup_device).get_all_instantiated_feature_objects()
+                mapped_setup_vdevices_instantiated_features = \
+                    VDeviceController.get_for(mapped_setup_vdevices[0]).get_all_instantiated_feature_objects()
+                for _, cur_vdevice_feature in mapped_setup_vdevices_instantiated_features.items():
+                    # check that there exists a child feature in the setup device for every used feature in the
+                    # vDevice class
+                    if len([cur_device_feature for _, cur_device_feature in partner_setup_device_features.items()
+                            if isinstance(cur_device_feature, cur_vdevice_feature.__class__)]) == 0:
+                        raise NotApplicableVariationException(
+                            f'can not find a child feature in mapped setup device `{partner_setup_device.__qualname__}`'
+                            f' for required feature `{cur_vdevice_feature.__class__}` of vDevice '
+                            f'`{mapped_setup_vdevices[0].__qualname__}`')
+
+    def _verify_applicability_trough_all_valid_routings(self) -> None:
+        """
+        This method ensures that valid routings exist for every defined connection.
+
+        The check is passed, if the method finds one or more valid routings for EVERY scenario-level
+        :class:`Connection`.
+        """
+        if not self._routings:
+            self.determine_absolute_scenario_device_connections()
+            self.create_all_valid_routings()
+        for scenario_cnn, cur_routings in self._routings.items():
+            if len(cur_routings) == 0:
+                raise NotApplicableVariationException(
+                    f'can not find a valid routing on setup level for the connection `{scenario_cnn.get_tree_str()}` '
+                    f'between scenario devices `{scenario_cnn.from_device}` and `{scenario_cnn.to_device}`')
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
+    def testsummary(self):
+        if self.can_be_applied():
+            return super().testsummary()
+        return {
+            ResultState.NOT_RUN: 0,
+            ResultState.FAILURE: 0,
+            ResultState.ERROR: 0,
+            ResultState.SUCCESS: 0,
+            ResultState.SKIP: 0,
+            ResultState.COVERED_BY: 0
+        }
+
+    def get_testcase_executors(self) -> List[TestcaseExecutor]:
+        """returns all sub testcase executors that belongs to this variation-executor"""
+        return self._testcase_executors
+
     def add_testcase_executor(self, testcase_executor: TestcaseExecutor):
         """
         This method adds a new TestcaseExecutor to the child element list of this object branch
@@ -226,7 +359,8 @@ class VariationExecutor(BasicExecutor):
                     # now check if there is a mapping on setup level too
                     for cur_replacing_feature in replacing_features:
                         mapped_setup_vdevice, mapped_setup_device = cur_replacing_feature.active_vdevice_device_mapping
-                        if mapped_setup_vdevice is not None and not issubclass(mapped_setup_vdevice, used_scenario_vdevice):
+                        if mapped_setup_vdevice is not None and \
+                                not issubclass(mapped_setup_vdevice, used_scenario_vdevice):
                             # drop this feature matching, because we have different vdevice mapped
                             cleanup_replacing_features.remove(cur_replacing_feature)
                         elif mapped_setup_device is not None and \
@@ -235,7 +369,7 @@ class VariationExecutor(BasicExecutor):
                             cleanup_replacing_features.remove(cur_replacing_feature)
 
                 if len(cleanup_replacing_features) != 1:
-                    raise NotApplicableVariationError(
+                    raise NotApplicableVariationException(
                         f'this variation can not be applicable because there was no setup feature implementation of '
                         f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
                         f'`{cur_scenario_device.__name__}`) in setup device `{cur_setup_device.__name__}`')
@@ -254,7 +388,7 @@ class VariationExecutor(BasicExecutor):
                             f"`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used in scenario device "
                             f"`{cur_scenario_device.__name__}` and in setup device `{cur_setup_device.__name__}`) - "
                             f"VARIATION CAN NOT BE APPLIED")
-                        raise NotApplicableVariationError(
+                        raise NotApplicableVariationException(
                             f'this variation can not be applicable because there was no vDevice mapping given on '
                             f'scenario or on setup level for the feature '
                             f'`{cur_abstract_scenario_feature_obj.__class__.__name__}` (used by scenario device '
@@ -349,26 +483,6 @@ class VariationExecutor(BasicExecutor):
         # can not find some
         return None
 
-    def has_feature_implementation_matching(self):
-        """
-        This method returns True if the features in this variation are valid. For this the setup devices must
-        implement all the required features of the scenario device. In other words, a feature child class must be
-        implemented in the setup device for each feature in the scenario device.
-        """
-        for scenario_device, setup_device in self._base_device_mapping.items():
-            scenario_device_orig_features = \
-                DeviceController.get_for(scenario_device).get_original_instanced_feature_objects()
-            for _, cur_scenario_feature in scenario_device_orig_features.items():
-                found_setup_feature_for_scenario_feature = False
-                setup_device_instantiated_features = \
-                    DeviceController.get_for(setup_device).get_all_instantiated_feature_objects()
-                for _, cur_setup_feature in setup_device_instantiated_features.items():
-                    if isinstance(cur_setup_feature, cur_scenario_feature.__class__):
-                        found_setup_feature_for_scenario_feature = True
-                if not found_setup_feature_for_scenario_feature:
-                    return False
-        return True
-
     def cleanup_empty_executor_branches(self):
         """
         This method searches the whole tree and removes branches where an executor item has no own children. It can
@@ -377,82 +491,6 @@ class VariationExecutor(BasicExecutor):
         This method implementation of the :class:`VariationExecutor` does nothing.
         """
 
-    def has_vdevice_feature_implementation_matching(self) -> bool:
-        """
-        This method checks for all vDevices that are in the setups/scenario features of this VariationExecutor, if their
-        vDevices-Mappings (so the mapped setup-devices) implements all features that are defined in the vDevices
-
-        This method returns false, if there is missing some :class:`Feature` classes.
-        """
-
-        for cur_scenario_device, cur_replacement_dict in self.feature_replacement.items():
-            cur_setup_device = self.get_setup_device_for(scenario_device=cur_scenario_device)
-            all_inner_setup_features = \
-                DeviceController.get_for(cur_setup_device).get_all_instantiated_feature_objects()
-
-            # describes the mapping from the new setup feature (key) to the instantiated scenario feature (value)
-            #  note that this dictionary only contains the required one
-            new_to_old_feature_mapping: Dict[Type[Feature], Feature] = {
-                cur_replacement_tuple[1]: cur_replacement_tuple[0]
-                for cur_attr_name, cur_replacement_tuple in cur_replacement_dict.items()
-                if cur_replacement_tuple[0] is not None}
-
-            # now secure that all features are available in the corresponding setup device, that are defined in the
-            #  mapped vDevice
-            for _, cur_setup_feature_obj in all_inner_setup_features.items():
-                # only check if there is a requirement of this feature (the feature is required by the Scenario)
-                if cur_setup_feature_obj.__class__ not in new_to_old_feature_mapping.keys():
-                    # ignore this, because no requirement for this feature
-                    continue
-                related_scenario_feature_obj = new_to_old_feature_mapping[cur_setup_feature_obj.__class__]
-                # get vDevice and device mapping
-                partner_scenario_vdevice, partner_scenario_device = \
-                    related_scenario_feature_obj.active_vdevice_device_mapping
-
-                if partner_scenario_device is None:
-                    # ignore because no mapping exist here
-                    continue
-
-                partner_setup_device = self.get_setup_device_for(scenario_device=partner_scenario_vdevice)
-                # get the related vDevice on setup view that is currently active
-                mapped_setup_vdevices = [
-                    cur_vdevice for cur_vdevice
-                    in FeatureController.get_for(
-                        cur_setup_feature_obj.__class__).get_abs_inner_vdevice_classes()
-                    if issubclass(cur_vdevice, partner_scenario_vdevice)]
-                if len(mapped_setup_vdevices) != 1:
-                    # find no mapping for the vDevice -> not possible
-                    return False
-                # now check that the setup partner device has all features implemented that are required
-                # features from the VDevice
-                partner_setup_device_features = \
-                    DeviceController.get_for(partner_setup_device).get_all_instantiated_feature_objects()
-                mapped_setup_vdevices_instantiated_features = \
-                    VDeviceController.get_for(mapped_setup_vdevices[0]).get_all_instantiated_feature_objects()
-                for _, cur_vdevice_feature in mapped_setup_vdevices_instantiated_features.items():
-                    # check that there exists a child feature in the setup device for every used feature in the
-                    # vDevice class
-                    if len([cur_device_feature for _, cur_device_feature in partner_setup_device_features.items()
-                            if isinstance(cur_device_feature, cur_vdevice_feature.__class__)]) == 0:
-                        return False
-        return True
-
-    def has_all_valid_routings(self) -> bool:
-        """
-        This method returns true if there exist valid routings for every defined connection. Otherwise, it returns
-        false.
-
-        :return: returns true if the method finds one or more valid routings for EVERY :class:`Connection`. Otherwise,
-                 it returns false
-        """
-        if not self._routings:
-            self.determine_absolute_scenario_device_connections()
-            self.create_all_valid_routings()
-        for _, cur_routings in self._routings.items():
-            if len(cur_routings) == 0:
-                return False
-        return True
-
     def update_scenario_device_feature_instances(self):
         """
         This method ensures that the (mostly abstract) feature instances of a scenario are exchanged with the
@@ -632,26 +670,35 @@ class VariationExecutor(BasicExecutor):
                         # object
                         setattr(cur_vdevice, cur_vdevice_attr_name, replacing_candidate)
 
-    def can_be_applied(self) -> bool:
+    def verify_applicability(self) -> None:
         """
-        This method returns True if this Variation is executable. First the method checks if all defined
+        This method verifies if this variation is executable. First the method checks if all defined
         :class:`Feature` instances are available and fully implemented in the mapped setup :class:`Device`.
         Furthermore, it checks if their exists a valid routing which also matches the defined class `@for_vdevice`
         definition of the used :class:`Feature` classes.
         """
+        self._applicability_check_done = True
         try:
             self.determine_feature_replacement_and_vdevice_mappings()
-        except NotApplicableVariationError:
+
+            self._verify_applicability_trough_feature_implementation_matching()
+
+            self._verify_applicability_trough_vdevice_feature_impl_matching()
+
+            self._verify_applicability_trough_all_valid_routings()
+        except NotApplicableVariationException as not_applicable_variation_exc:
             # this variation can not be used, because the features can not be resolved correctly!
-            return False
+            self._not_applicable_variation_exc = not_applicable_variation_exc
+            self.prev_mark = PreviousExecutorMark.DISCARDED
+
+    def can_be_applied(self) -> bool:
+        """
+        :return: returns True if the previous verify_applicability check was successfully
+        """
+        if self._applicability_check_done is not True:
+            raise RuntimeError('this method can not be used before no check was executed')
 
-        if not self.has_feature_implementation_matching():
-            return False
-        if not self.has_vdevice_feature_implementation_matching():
-            return False
-        if not self.has_all_valid_routings():
-            return False
-        return True
+        return self._not_applicable_variation_exc is None
 
     def determine_absolute_scenario_device_connections(self):
         """
@@ -695,6 +742,12 @@ class VariationExecutor(BasicExecutor):
                 cur_scenario_feature: Feature = feature_replacement[cur_setup_feature]
                 cur_setup_feature_vdevice = list(mapping_dict.keys())[0]
                 cur_mapped_setup_device = list(mapping_dict.values())[0]
+
+                if cur_mapped_setup_device not in self.base_device_mapping.values():
+                    raise NotApplicableVariationException(
+                        f'the mapped setup device `{cur_mapped_setup_device.__qualname__}` which is mapped to the '
+                        f'VDevice `{cur_setup_feature_vdevice.__qualname__}` is no part of this variation')
+
                 cur_mapped_scenario_device = self.get_scenario_device_for(cur_mapped_setup_device)
 
                 # get relevant class based connections for the current feature on setup level (this is really be used

_balder/previous_executor_mark.py

@@ -18,3 +18,6 @@ class PreviousExecutorMark(Enum):
 
     #: 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

_balder/routing_path.py

@@ -301,7 +301,7 @@ class RoutingPath:
                     raise RoutingBrokenChainError(
                         f"can not append gateway, because the device of the gateway (`{elem.device}`) doesn't "
                         f"match with the latest end-device (`{self.end_device}`) of this route")
-                elif self.end_node_name not in [elem.from_node_name, elem.to_node_name]:
+                if self.end_node_name not in [elem.from_node_name, elem.to_node_name]:
                     raise RoutingBrokenChainError(
                         f"can not append gateway, because neither the from-node "
                         f"(`{elem.from_node_name}`) nor the to-node (`{elem.to_node_name}`) of the gateway match with "

_balder/solver.py

@@ -198,21 +198,19 @@ class Solver:
             if variation_executor is None:
                 # variation is not available -> create new VariationExecutor
                 variation_executor = VariationExecutor(device_mapping=cur_device_mapping, parent=scenario_executor)
-
-                # only add if the features for this device mapping matches
-                if variation_executor.can_be_applied():
-                    scenario_executor.add_variation_executor(variation_executor)
-
-                    for cur_testcase in ScenarioController.get_for(cur_scenario).get_all_test_methods():
-                        cur_testcase_executor = TestcaseExecutor(cur_testcase, parent=variation_executor)
-                        variation_executor.add_testcase_executor(cur_testcase_executor)
-
-                        # determine prev_mark IGNORE/SKIP for the testcase
-                        if cur_testcase_executor.should_be_skipped():
-                            variation_executor.prev_mark = PreviousExecutorMark.SKIP
-                        # always overwrite if it should be ignored
-                        if cur_testcase_executor.should_be_ignored():
-                            variation_executor.prev_mark = PreviousExecutorMark.IGNORE
+                variation_executor.verify_applicability()
+
+                scenario_executor.add_variation_executor(variation_executor)
+                for cur_testcase in ScenarioController.get_for(cur_scenario).get_all_test_methods():
+                    cur_testcase_executor = TestcaseExecutor(cur_testcase, parent=variation_executor)
+                    variation_executor.add_testcase_executor(cur_testcase_executor)
+
+                    # determine prev_mark IGNORE/SKIP for the testcase
+                    if cur_testcase_executor.should_be_skipped():
+                        cur_testcase_executor.prev_mark = PreviousExecutorMark.SKIP
+                    # always overwrite if it should be ignored
+                    if cur_testcase_executor.should_be_ignored():
+                        cur_testcase_executor.prev_mark = PreviousExecutorMark.IGNORE
 
         # now filter all elements that have no child elements
         #   -> these are items that have no valid matching, because no variation can be applied for it (there are no

balder/exceptions.py

@@ -5,7 +5,7 @@ from _balder.exceptions import FixtureScopeError, FixtureReferenceError, Unclear
     AccessToUnmappedVDeviceException, FeatureOverwritingError, UnknownVDeviceException, RoutingBrokenChainError, \
     IllegalConnectionTypeError, ConnectionMetadataConflictError, DeviceScopeError, ConnectionIntersectionError, \
     UnclearAssignableFeatureConnectionError, InheritanceError, MultiInheritanceError, InnerFeatureResolvingError, \
-    VDeviceResolvingError, IllegalVDeviceMappingError, NotApplicableVariationError, UnclearMethodVariationError, \
+    VDeviceResolvingError, IllegalVDeviceMappingError, NotApplicableVariationException, UnclearMethodVariationError, \
     UnexpectedPluginMethodReturnValue
 
 __all__ = [
@@ -37,7 +37,7 @@ __all__ = [
     "InnerFeatureResolvingError",
     "VDeviceResolvingError",
     "IllegalVDeviceMappingError",
-    "NotApplicableVariationError",
+    "NotApplicableVariationException",
     "UnclearMethodVariationError",
     "UnexpectedPluginMethodReturnValue",
 ]