baldertest 0.1.0b11__py3-none-any.whl → 0.1.0b13__py3-none-any.whl

_balder/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0b11'
+__version__ = version = '0.1.0b13'
 __version_tuple__ = version_tuple = (0, 1, 0)

_balder/cnnrelations/and_connection_relation.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Type
 
 import itertools
 
@@ -19,6 +19,33 @@ class AndConnectionRelation(BaseConnectionRelation):
         based_on_strings = [cur_elem.get_tree_str() for cur_elem in self._connections]
         return f"({' | '.join(based_on_strings)})"
 
+    def get_possibilities_for_direct_parent_cnn(self, for_cnn_class: Type[Connection]) -> list[AndConnectionRelation]:
+        """
+        Helper method that returns a list of possible :class:`AndConnectionRelation` elements that hold the next parent
+        in the connection-tree that can be there instead of the origin connection.
+        The method returns a list, because there can exist different possibilities for this AND connection.
+        """
+        direct_ancestors_relations = ()
+        for cur_and_elem in self.connections:
+            # `cur_and_elem` needs to be a connection, because we are using simplified which has only
+            # `OR[AND[Cnn, ...], Cnn, ..]`
+            if cur_and_elem.__class__ in for_cnn_class.get_parents():
+                # element already is a direct ancestor
+                direct_ancestors_relations += (cur_and_elem,)
+            else:
+                all_pos_possibilities = []
+                # add all possible direct parents to the possibilities list
+                for cur_direct_parent in for_cnn_class.get_parents():
+                    if cur_direct_parent.is_parent_of(cur_and_elem.__class__):
+                        all_pos_possibilities.append(cur_direct_parent.based_on(cur_and_elem))
+                direct_ancestors_relations += (all_pos_possibilities,)
+        # resolve the opportunities and create multiple possible AND relations where all elements are
+        # direct parents
+        return [
+            AndConnectionRelation(*cur_possibility).get_resolved()
+            for cur_possibility in itertools.product(*direct_ancestors_relations)
+        ]
+
     def get_simplified_relation(self) -> OrConnectionRelation:
         from ..connection import Connection  # pylint: disable=import-outside-toplevel
         from .or_connection_relation import OrConnectionRelation  # pylint: disable=import-outside-toplevel

_balder/cnnrelations/base_connection_relation.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import List, Union, Type, Dict, TypeVar, TYPE_CHECKING
 from abc import ABC, abstractmethod
-from ..utils import cnn_type_check_and_convert
+from _balder.utils.functions import cnn_type_check_and_convert
 
 if TYPE_CHECKING:
     from ..connection import Connection

_balder/collector.py

@@ -10,7 +10,7 @@ import inspect
 import pathlib
 import functools
 import importlib.util
-from _balder.utils import get_class_that_defines_method, inspect_method
+from _balder.utils.functions import get_class_that_defines_method, get_method_type
 from _balder.setup import Setup
 from _balder.device import Device
 from _balder.feature import Feature
@@ -23,7 +23,8 @@ from _balder.fixture_execution_level import FixtureExecutionLevel
 from _balder.controllers import ScenarioController, SetupController, DeviceController, VDeviceController, \
     FeatureController, NormalScenarioSetupController
 from _balder.exceptions import DuplicateForVDeviceError, UnknownVDeviceException
-from _balder.utils import get_scenario_inheritance_list_of
+from _balder.utils.functions import get_scenario_inheritance_list_of
+from _balder.utils.typings import MethodLiteralType
 
 if TYPE_CHECKING:
     from _balder.plugin_manager import PluginManager
@@ -62,8 +63,13 @@ class Collector:
         sys.path.insert(0, str(self.working_dir.parent.absolute()))
 
         self._all_py_files: Union[List[pathlib.Path], None] = None
+
+        self._all_collected_scenarios: Union[List[Type[Scenario]], None] = None
+        self._all_collected_setups: Union[List[Type[Setup]], None] = None
+
         self._all_scenarios: Union[List[Type[Scenario]], None] = None
         self._all_setups: Union[List[Type[Setup]], None] = None
+
         self._all_connections: Union[List[Type[Connection]], None] = None
 
         self.balderglob_was_loaded = False
@@ -123,6 +129,20 @@ class Collector:
             raise AttributeError("please call the `collect()` method before omitting this value")
         return self._all_py_files
 
+    @property
+    def all_collected_scenarios(self) -> List[Type[Scenario]]:
+        """returns a list of all collected scenarios that were found by the collector"""
+        if self._all_collected_scenarios is None:
+            raise AttributeError("please call the `collect()` method before omitting this value")
+        return self._all_collected_scenarios
+
+    @property
+    def all_collected_setups(self) -> List[Type[Setup]]:
+        """returns a list of all collected setups that were found by the collector"""
+        if self._all_collected_setups is None:
+            raise AttributeError("please call the `collect()` method before omitting this value")
+        return self._all_collected_setups
+
     @property
     def all_scenarios(self) -> List[Type[Scenario]]:
         """returns a list of all scenarios that were found by the collector"""
@@ -154,6 +174,29 @@ class Collector:
             raise AttributeError("please call the `collect()` method before omitting this value")
         return self._all_connections
 
+    def get_class_and_method_type_for(self, func) -> Tuple[Union[type, None], MethodLiteralType]:
+        """
+        This helper function returns the related class and the type of the method (`staticmethod`, `classmethod`,
+        `instancemethod` or `function`) as tuple.
+        """
+
+        available_classes = self.all_collected_scenarios + self.all_collected_setups
+        available_classes_with_mro = []
+        for cur_class in available_classes:
+            available_classes_with_mro.extend([*inspect.getmro(cur_class)])
+        available_classes_with_mro = set(available_classes_with_mro)
+
+        qualname = func.__qualname__
+
+        if '.' not in qualname:
+            return None, 'function'
+
+        expected_class_name = qualname.rpartition('.')[0]
+        for cur_class in available_classes_with_mro:
+            if cur_class.__qualname__ == expected_class_name:
+                return cur_class, get_method_type(cur_class, func)
+        raise ValueError(f'function {func.__qualname__} is not part of any scenario or setup')
+
     def get_fixture_manager(self) -> FixtureManager:
         """
         Resolves all fixtures and returns the fixture manager for this session
@@ -164,7 +207,7 @@ class Collector:
             cur_level = FixtureExecutionLevel(cur_level_as_str)
             resolved_dict[cur_level] = {}
             for cur_fn in cur_module_fixture_dict:
-                cls, func_type = inspect_method(cur_fn)
+                cls, func_type = self.get_class_and_method_type_for(cur_fn)
                 # mechanism also works for balderglob fixtures (`func_type` is 'function' and `cls` is None)
                 if cls not in resolved_dict[cur_level].keys():
                     resolved_dict[cur_level][cls] = []
@@ -352,120 +395,62 @@ class Collector:
                 result.append(cur_class)
         return result
 
-    def set_run_skip_ignore_of_test_methods_in_scenarios(self):
-        """
-        This method secures that the scenario classes have a valid RUN, SKIP and IGNORE attribute.
-        """
+    def _validate_skip_ignore(self):
+        """
+        This method secures that the scenario classes have a valid SKIP and IGNORE attribute.
+        """
+        ignore_str = "IGNORE"
+        skip_str = "SKIP"
+
+        def validate(scenario_class, list_attr_name: str):
+            # IGNORE/SKIP is mentioned in this specific class
+            if not isinstance(getattr(scenario_class, list_attr_name), list):
+                raise TypeError(f"the class attribute `{cur_class.__name__}.{list_attr_name}` has to be from type list")
+            # check that all elements that are mentioned here exists as a valid test method
+            for method in getattr(scenario_class, list_attr_name):
+                if isinstance(method, str):
+                    if not hasattr(scenario_class, method):
+                        raise ValueError(f'can not find the mentioned attribute `{method}` from '
+                                         f'{list_attr_name} list for scenario `{scenario_class}`')
+                    if not method.startswith('test_'):
+                        raise ValueError(f'the attribute `{method}` mentioned in {list_attr_name} list of scenario '
+                                         f'`{scenario_class}` is no valid test method and can not be used here')
+                elif not inspect.ismethod(method) or not method.__name__.startswith('test_'):
+                    raise TypeError(f"the given element {method.__name__} for class attribute "
+                                    f"`{scenario_class.__name__}.{list_attr_name}` is no valid test method")
+            return True
+
         for cur_scenario in self._all_scenarios:
             # determines hierarchy of inherited classes
             base_classes = get_scenario_inheritance_list_of(cur_scenario)
             # removes the last scenario class
             base_classes = base_classes[:-1]
-            # now determine all RUN, SKIP and IGNORE values if they aren't already mentioned - if there exists a value
+            # now determine all SKIP and IGNORE values if they aren't already mentioned - if there exists a value
             #  for them, check if the value is valid
             base_classes.reverse()
+            # now go through all RUN/SKIP/IGNORE values and check if the values are correct here
             for cur_idx, cur_class in enumerate(base_classes):
                 next_parent = None if cur_idx == 0 else base_classes[cur_idx - 1]
-                if "IGNORE" in cur_class.__dict__.keys():
-                    # IGNORE is mentioned in this specific class
-                    if not isinstance(cur_class.IGNORE, list):
-                        raise TypeError(f"the class attribute `{cur_class.__name__}.IGNORE` has to be from type list")
-                    # check that all elements that are mentioned here exists in the parent's RUN, SKIP or IGNORE class
-                    # variable or are defined in this class
-                    for cur_ignore_method in cur_class.IGNORE:
-                        if not inspect.ismethod(cur_ignore_method) or \
-                                not cur_ignore_method.__name__.startswith('test_'):
-                            raise TypeError(f"the given element {cur_ignore_method.__name__} for class attribute "
-                                            f"`{cur_class.__name__}.IGNORE` is no valid test method")
-                        if cur_ignore_method not in cur_class.__dict__.values() and next_parent is None or \
-                                cur_ignore_method not in cur_class.__dict__.values() and next_parent is not None \
-                                and cur_ignore_method not in next_parent.RUN + next_parent.SKIP + next_parent.IGNORE:
-                            raise ValueError(f"the element `{cur_ignore_method.__name__}` given at class attribute "
-                                             f"`{cur_class.__name__}.IGNORE` is not a test method of this scenario")
-                else:
-                    # IGNORE is not mentioned in this specific class -> so add an empty list for further access
-                    cur_class.IGNORE = []
-                if "SKIP" in cur_class.__dict__.keys():
-                    # SKIP is mentioned in this specific class
-                    if not isinstance(cur_class.SKIP, list):
-                        raise TypeError(f"the class attribute `{cur_class.__name__}.SKIP` has to be from type list")
-                    # check that all elements that are mentioned here exist in the parent's RUN or SKIP class variable
-                    # or are defined in this class
-                    for cur_skip_method in cur_class.SKIP:
-                        if not inspect.ismethod(cur_skip_method) or \
-                                not cur_skip_method.__name__.startswith('test_'):
-                            raise TypeError(f"the given element {cur_skip_method.__name__} for class attribute "
-                                            f"`{cur_class.__name__}.IGNORE` is no valid test method")
-                        if cur_skip_method not in cur_class.__dict__.values():
-                            if next_parent is None:
-                                raise ValueError(f"the element `{cur_skip_method.__name__}` given at class attribute "
-                                                 f"`{cur_class.__name__}.SKIP` is not a test method of this scenario")
-
-                            if cur_skip_method in next_parent.IGNORE:
-                                raise ValueError(f"the element `{cur_skip_method.__name__}` given at class "
-                                                 f"attribute `{cur_class.__name__}.SKIP` was already added to "
-                                                 f"IGNORE in a higher parent class - not possible to add it now to "
-                                                 f"SKIP")
-
-                            if cur_skip_method not in next_parent.SKIP and cur_skip_method not in next_parent.IGNORE:
-                                raise ValueError(f"the element `{cur_skip_method.__name__}` given at class "
-                                                 f"attribute `{cur_class.__name__}.SKIP` is not a test method of "
-                                                 f"this scenario")
-                else:
-                    # SKIP is not mentioned in this specific class -> so add an empty list for further access
-                    cur_class.SKIP = []
-                if "RUN" in cur_class.__dict__.keys():
-                    # RUN is mentioned in this specific class
-                    if not isinstance(cur_class.RUN, list):
-                        raise TypeError(f"the class attribute `{cur_class.__name__}.RUN` has to be from type list")
-                    # check that all elements that are mentioned here exists in the parent's RUN class variable or are
-                    # defined in this class
-                    for cur_run_method in cur_class.RUN:
-                        if not inspect.ismethod(cur_run_method) or \
-                                not cur_run_method.__name__.startswith('test_'):
-                            raise TypeError(f"the given element {cur_run_method.__name__} for class attribute "
-                                            f"`{cur_class.__name__}.RUN` is no valid test method")
-                        if cur_run_method not in cur_class.__dict__.values():
-                            if next_parent is None:
-                                raise ValueError(
-                                    f"the element `{cur_run_method.__name__}` given at class attribute "
-                                    f"`{cur_class.__name__}.RUN` is not a test method of this scenario")
-
-                            if cur_run_method in next_parent.IGNORE:
-                                raise ValueError(
-                                    f"the element `{cur_run_method.__name__}` given at class attribute "
-                                    f"`{cur_class.__name__}.RUN` was already added to IGNORE in a higher parent "
-                                    f"class - not possible to add it now to RUN")
-                            if cur_run_method in next_parent.SKIP:
-                                raise ValueError(
-                                    f"the element `{cur_run_method.__name__}` given at class attribute "
-                                    f"`{cur_class.__name__}.RUN` was already added to SKIP in a higher parent "
-                                    f"class - not possible to add it now to RUN")
-                            if cur_run_method not in next_parent.RUN:
-                                raise ValueError(
-                                    f"the element `{cur_run_method.__name__}` given at class attribute "
-                                    f"`{cur_class.__name__}.RUN` is not a test method of this scenario")
-                else:
-                    # RUN is not mentioned in this specific class -> so add an empty list for further access
-                    cur_class.RUN = []
-
-                # also add all in this class defined test methods to this RUN list
-                for cur_item_name, cur_item in cur_class.__dict__.items():
-                    if cur_item_name.startswith("test_") and inspect.ismethod(cur_item):
-                        cur_class.RUN.append(cur_item)
-                # now add all items from parent classes to the lists that are not mentioned yet
-                if next_parent is not None:
-                    for cur_parent_run_method in next_parent.RUN:
-                        if cur_parent_run_method not in cur_class.RUN and cur_parent_run_method not in cur_class.SKIP \
-                                and cur_parent_run_method not in cur_class.IGNORE:
-                            cur_class.RUN.append(cur_parent_run_method)
-                    for cur_parent_skip_method in next_parent.SKIP:
-                        if cur_parent_skip_method not in cur_class.SKIP \
-                                and cur_parent_skip_method not in cur_class.IGNORE:
-                            cur_class.SKIP.append(cur_parent_skip_method)
-                    for cur_parent_ignore_method in next_parent.IGNORE:
-                        if cur_parent_ignore_method not in cur_class.IGNORE:
-                            cur_class.IGNORE.append(cur_parent_ignore_method)
+
+                validate(cur_class, 'IGNORE')
+                validate(cur_class, 'SKIP')
+
+                # make sure that the method is not mentioned in IGNORE and in SKIP
+                ignore_list = cur_class.__dict__.get(ignore_str, [])
+                skip_list = cur_class.__dict__.get(skip_str, [])
+                for cur_ignore_method_as_str in ignore_list:
+                    if cur_ignore_method_as_str in skip_list:
+                        raise ValueError(f'mentioned test method `{cur_ignore_method_as_str}` is in '
+                                         f'`{cur_class.__name__}.IGNORE` and `{cur_class.__name__}.SKIP`')
+                # make sure that the skip method was not defined in IGNORE in parent classes
+                if next_parent:
+                    for cur_skip_method_as_str in skip_list:
+                        cur_skip_method = getattr(cur_class, cur_skip_method_as_str)
+                        if cur_skip_method in ScenarioController.get_for(next_parent).get_ignore_test_methods():
+                            raise ValueError(f"the element `{cur_skip_method.__name__}` given at class "
+                                             f"attribute `{cur_class.__name__}.SKIP` was already added to "
+                                             f"IGNORE in a higher parent class - not possible to add it now to "
+                                             f"SKIP")
 
     @staticmethod
     def rework_method_variation_decorators():
@@ -829,12 +814,16 @@ class Collector:
         self._all_connections = self.get_all_connection_classes()
 
         # collect all `Scenario` classes
-        self._all_scenarios = self.get_all_scenario_classes(py_file_paths=all_scenario_filepaths, filter_abstracts=True)
+        self._all_collected_scenarios = self.get_all_scenario_classes(
+            py_file_paths=all_scenario_filepaths, filter_abstracts=True
+        )
         # collect all `Setup` classes
-        self._all_setups = self.get_all_setup_classes(py_file_paths=all_setup_filepaths, filter_abstracts=True)
+        self._all_collected_setups = self.get_all_setup_classes(
+            py_file_paths=all_setup_filepaths, filter_abstracts=True
+        )
 
         self._all_scenarios, self._all_setups = plugin_manager.execute_collected_classes(
-            scenarios=self._all_scenarios, setups=self._all_setups)
+            scenarios=self._all_collected_scenarios, setups=self._all_collected_setups)
 
         self._all_scenarios = Collector.filter_parent_classes_of(items=self._all_scenarios)
         self._all_setups = Collector.filter_parent_classes_of(items=self._all_setups)
@@ -847,8 +836,7 @@ class Collector:
         self._set_original_device_features()
         self._exchange_strings_with_objects()
 
-        # todo move this implementation in related controller
-        self.set_run_skip_ignore_of_test_methods_in_scenarios()
+        self._validate_skip_ignore()
 
         self._validate_scenario_and_setups()
 

_balder/connection.py

@@ -8,7 +8,7 @@ from _balder.connection_metadata import ConnectionMetadata
 from _balder.device import Device
 from _balder.exceptions import IllegalConnectionTypeError
 from _balder.cnnrelations import AndConnectionRelation, OrConnectionRelation
-from _balder.utils import cnn_type_check_and_convert
+from _balder.utils.functions import cnn_type_check_and_convert
 
 
 class ConnectionType(type):
@@ -100,7 +100,7 @@ class Connection(metaclass=ConnectionType):
 
         :param tree_name: the tree name the parents should be returned (default: use tree defined in `GlobalSetting`)
         """
-        from _balder.balder_session import BalderSession
+        from _balder.balder_session import BalderSession  # pylint: disable=import-outside-toplevel
         if tree_name is None:
             tree_name = BalderSession.get_current_active_global_conntree_name()
         conn_dict = Connection.__parents.get(cls, {})
@@ -241,6 +241,62 @@ class Connection(metaclass=ConnectionType):
 
     # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
 
+    def _is_directly_contained_in(self, other_conn: Connection, ignore_metadata: bool) -> bool:
+        """
+        Helper method that returns true if this connection is directly contained in the `other_conn`.
+
+        .. note::
+            'Directly contained-in' means that the resolved versions of both connections are of the same connection
+            type, and the elements of that connection are directly embedded within one another from that point onward.
+            It does not check deeper into the other_conn.
+
+        :param other_conn: the other connection
+        :param ignore_metadata: True, if the metadata should be ignored
+        """
+
+        resolved_self = self.get_resolved()
+        resolved_other = other_conn.get_resolved()
+
+        if resolved_self.__class__ == Connection and len(resolved_self.based_on_elements) == 0 or \
+                resolved_other.__class__ == Connection and len(resolved_other.based_on_elements) == 0:
+            # one of the resolved object is a raw `Connection` object without based-on-elements -> always true
+            return True
+
+        if resolved_self.__class__ == Connection:
+            return resolved_self.based_on_elements.contained_in(resolved_other, ignore_metadata=ignore_metadata)
+
+        if resolved_self.__class__ == resolved_other.__class__:
+            # The element itself has already matched, now we still have to check whether at least one inner element
+            # of this type is contained in minimum one element of the other
+            singles_self = resolved_self.get_singles()
+            singles_other = other_conn.get_singles()
+
+            # check that for one single_self element all hierarchical based_on elements are in one of the single
+            # other element
+            for cur_single_self, cur_single_other in itertools.product(singles_self, singles_other):
+                # check if both consists of only one element
+                if len(cur_single_self.based_on_elements) == 0:
+                    # the cur self single is only one element -> this is contained in the other
+                    return True
+
+                if len(cur_single_other.based_on_elements) == 0:
+                    # the other element is only one element, but the self element not -> contained_in
+                    # for this single definitely false
+                    continue
+
+                # note: for both only one `based_on_elements` is possible, because they are singles
+                self_first_basedon = cur_single_self.based_on_elements[0]
+                other_first_basedon = cur_single_other.based_on_elements[0]
+
+                if isinstance(self_first_basedon, Connection) and \
+                        isinstance(other_first_basedon, AndConnectionRelation):
+                    continue
+
+                # find a complete valid match
+                if self_first_basedon.contained_in(other_first_basedon, ignore_metadata=ignore_metadata):
+                    return True
+        return False
+
     # ---------------------------------- METHODS -----------------------------------------------------------------------
 
     def get_intersection_with_other_single(
@@ -516,25 +572,8 @@ class Connection(metaclass=ConnectionType):
             for next_higher_parent in simplified_based_on:
                 if isinstance(next_higher_parent, AndConnectionRelation):
                     # determine all possibilities
-                    direct_ancestors_relations = ()
-                    for cur_and_elem in next_higher_parent:
-                        # `cur_and_elem` needs to be a connection, because we are using simplified which has only
-                        # `OR[AND[Cnn, ...], Cnn, ..]`
-                        if cur_and_elem.__class__ in self.__class__.get_parents():
-                            # element already is a direct ancestor
-                            direct_ancestors_relations += (cur_and_elem, )
-                        else:
-                            all_pos_possibilities = []
-                            # add all possible direct parents to the possibilities list
-                            for cur_direct_parent in self.__class__.get_parents():
-                                if cur_direct_parent.is_parent_of(cur_and_elem.__class__):
-                                    all_pos_possibilities.append(cur_direct_parent.based_on(cur_and_elem))
-                            direct_ancestors_relations += (all_pos_possibilities, )
-                    # resolve the opportunities and create multiple possible AND relations where all elements are
-                    # direct parents
-                    for cur_possibility in itertools.product(*direct_ancestors_relations):
-                        new_child_relation = AndConnectionRelation(*cur_possibility).get_resolved()
-                        copied_base.append_to_based_on(new_child_relation)
+                    for new_and_relation in next_higher_parent.get_possibilities_for_direct_parent_cnn(self.__class__):
+                        copied_base.append_to_based_on(new_and_relation)
                 else:
                     # `next_higher_parent` needs to be a connection, because we are using simplified which has only
                     # `OR[AND[Cnn, ...], Cnn, ..]`
@@ -673,9 +712,10 @@ class Connection(metaclass=ConnectionType):
             ignore_metadata=False
     ) -> bool:
         """
-        This method helps to find out whether this connection-tree fits within another connection tree. A connection
-        object is a certain part of the large connection tree that Balder has at its disposal. This method checks
-        whether a possibility of this connection tree fits in one possibility of the given connection tree.
+        This method determines if one connection tree can be embedded within another connection tree. A connection
+        object represents a specific segment of the extensive connection tree managed by Balder. The method evaluates
+        whether at least one SINGLE connection object of this connection tree fits within a possible SINGLE connection
+        of the provided connection `other_conn`.
 
         .. note::
             The method returns true if one single connection of this object fits in another single connection that is
@@ -698,70 +738,26 @@ class Connection(metaclass=ConnectionType):
         resolved_self = self.get_resolved()
         resolved_other = other_conn.get_resolved()
 
-        if resolved_self.__class__ == Connection and len(resolved_self.based_on_elements) == 0 or \
-                resolved_other.__class__ == Connection and len(resolved_other.based_on_elements) == 0:
-            # one of the resolved object is a raw `Connection` object without based-on-elements -> always true
+        if self._is_directly_contained_in(resolved_other, ignore_metadata=ignore_metadata):
             return True
 
-        if resolved_self.__class__ == Connection:
-            return resolved_self.based_on_elements.contained_in(resolved_other, ignore_metadata=ignore_metadata)
+        # the elements itself do not match -> go deeper within the other connection
 
-        if resolved_self.__class__ == resolved_other.__class__:
-            # The element itself has already matched, now we still have to check whether at least one inner element
-            # of this type is contained in the minimum one element of the other
-            singles_self = resolved_self.get_singles()
-            singles_other = resolved_other.get_singles()
+        resolved_other_relation = resolved_other.based_on_elements \
+            if isinstance(resolved_other, Connection) else resolved_other
 
-            # check that for one single_self element all hierarchical based_on elements are in one of the single
-            # other element
-            for cur_single_self, cur_single_other in itertools.product(singles_self, singles_other):
-                # check if both consists of only one element
-                if len(cur_single_self.based_on_elements) == 0:
-                    # the cur self single is only one element -> this is contained in the other
-                    return True
-
-                if len(cur_single_other.based_on_elements) == 0:
-                    # the other element is only one element, but the self element not -> contained_in
-                    # for this single definitely false
-                    continue
-
-                # note: for both only one `based_on_elements` is possible, because they are singles
-                self_first_based_on = cur_single_self.based_on_elements[0]
-                other_first_based_on = cur_single_other.based_on_elements[0]
-
-                self_is_and = isinstance(self_first_based_on, AndConnectionRelation)
-                self_is_cnn = isinstance(self_first_based_on, Connection)
-                other_is_and = isinstance(other_first_based_on, AndConnectionRelation)
-                other_is_cnn = isinstance(other_first_based_on, Connection)
-
-                if self_is_and and (other_is_and or other_is_cnn) or self_is_cnn and other_is_cnn:
-                    # find a complete valid match
-                    if self_first_based_on.contained_in(other_first_based_on, ignore_metadata=ignore_metadata):
-                        return True
-                # skip all others possibilities
-        else:
-            # the elements itself do not match -> go deeper within the other connection
-            if isinstance(resolved_other, AndConnectionRelation):
+        for cur_other_based_on in resolved_other_relation.connections:
+            # `cur_other_based_on` can only be a Connection or an AND (resolved can not ba a inner OR)
+            if isinstance(cur_other_based_on, AndConnectionRelation):
                 # check if the current connection fits in one of the AND relation items -> allowed too (f.e. a
                 # smaller AND contained in a bigger AND)
-                for cur_other_and_element in resolved_other.connections:
+                for cur_other_and_element in cur_other_based_on.connections:
                     if resolved_self.contained_in(cur_other_and_element, ignore_metadata=ignore_metadata):
                         return True
-
-            resolved_other_relation = resolved_other.based_on_elements \
-                if isinstance(resolved_other, Connection) else resolved_other
-
-            for cur_other_based_on in resolved_other_relation.connections:
-                if isinstance(cur_other_based_on, AndConnectionRelation):
-                    # check if the current connection fits in one of the AND relation items -> allowed too (f.e. a
-                    # smaller AND contained in a bigger AND)
-                    for cur_other_and_element in cur_other_based_on.connections:
-                        if resolved_self.contained_in(cur_other_and_element, ignore_metadata=ignore_metadata):
-                            return True
-                else:
-                    if resolved_self.contained_in(cur_other_based_on, ignore_metadata=ignore_metadata):
-                        # element was found in this branch
-                        return True
+            else:
+                if resolved_self.contained_in(cur_other_based_on, ignore_metadata=ignore_metadata):
+                    # element was found in this branch
+                    return True
         return False
 
     def intersection_with(