baldertest 0.1.0__py3-none-any.whl

_balder/__init__.py

@@ -0,0 +1,12 @@
+
+__all__ = [
+    "__version__",
+
+    "__version_tuple__"
+]
+
+try:
+    from ._version import __version__, __version_tuple__
+except ImportError:
+    __version__ = ""
+    __version_tuple__ = tuple()

_balder/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

_balder/balder_plugin.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type, Tuple, List, Union
+
+import pathlib
+
+if TYPE_CHECKING:
+    from _balder.executor.executor_tree import ExecutorTree
+    from _balder.balder_session import BalderSession
+    from _balder.setup import Setup
+    from _balder.scenario import Scenario
+    import argparse
+
+
+class BalderPlugin:
+    """
+    This is the balder plugin class. You can create your own plugin, by creating a subclass of it. With that you are
+    able to overwrite the methods you want to use in your plugin.
+    """
+
+    def __init__(self, session: BalderSession):
+        self.balder_session = session
+
+    def addoption(self, argument_parser: argparse.ArgumentParser):
+        """
+        The callback will be executed while the `ArgumentParser` is being created.
+
+        :param argument_parser: the argument parser object
+        """
+
+    def modify_collected_pyfiles(self, pyfiles: List[pathlib.Path]) -> List[pathlib.Path]:
+        """
+        This callback will be executed after the :class:`Collector` has collected all python files that are inside the
+        current working directory.
+
+        .. note::
+            Note that these files are not filtered yet. The list will contain every existing python file.
+
+        :param pyfiles: a list with all python filepaths
+
+        :return: the new list of all filepaths
+        """
+
+    def modify_collected_classes(self, scenarios: List[Type[Scenario]], setups: List[Type[Setup]]) \
+            -> Tuple[List[Type[Scenario]], List[Type[Setup]]]:
+        """
+        This callback will be executed after the :class:`Collector` has collected the :class:`Scenario` classes and the
+        :class:`Setup` classes.
+
+        :param scenarios: all collected :class:`Scenario` classes that are currently in the collected list
+
+        :param setups: all collected :class:`Setup` classes that are currently in the collected list
+
+        :return: a tuple of lists, where the first list is the new list with all :class:`Scenario` classes, the second
+                 element is a list with all :class:`Setup` classes
+        """
+
+    def filter_executor_tree(self, executor_tree: ExecutorTree) -> None:
+        """
+        This callback will be executed before the ExecutorTree runs. It contains the current representation
+        of the :class:`ExecutorTree`, that will be executed in the next step. With this callback it is possible to
+        manipulate the :class:`ExecutorTree`. You have not to return something, the given ``executor_tree`` is a
+        reference.
+
+        :param executor_tree: the reference to the main :class:`ExecutorTree` object balder uses for this session
+        """
+
+    def session_finished(self, executor_tree: Union[ExecutorTree, None]):
+        """
+        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
+        """

_balder/balder_session.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+from typing import Union, List, Tuple, Dict, Type, TYPE_CHECKING
+
+import os
+import sys
+import inspect
+import pathlib
+import argparse
+import balder
+from _balder.balder_plugin import BalderPlugin
+from _balder.plugin_manager import PluginManager
+from _balder.executor.executor_tree import ExecutorTree
+from _balder.collector import Collector
+from _balder.solver import Solver
+from _balder.exceptions import DuplicateBalderSettingError
+from _balder.balder_settings import BalderSettings
+
+if TYPE_CHECKING:
+    from _balder.setup import Setup
+    from _balder.device import Device
+    from _balder.scenario import Scenario
+    from _balder.connection import Connection
+
+
+class BalderSession:
+    """
+    This is the main balder executable object. It contains all information about the current session and executes the
+    different steps.
+
+    This object contains all command line arguments that can be used, while calling `balder ..`. All settings that
+    are given in `balderglob.py` will be imported in `self.baldersetting`
+    """
+    # this is the default value (will be overwritten in this constructor if necessary)
+    baldersettings: BalderSettings = BalderSettings()
+
+    def __init__(self, cmd_args: Union[List[str], None] = None, working_dir: Union[pathlib.Path, None] = None):
+        """
+
+        :param cmd_args: optional the command line list of strings that should be parsed instead of parsing the real
+                         command line arguments (used for testing)
+
+        :param working_dir: the working directory that should be used instead of the given value in `cmd_arg_str` or
+                            the current directory (determined by `os.getcwd()`)
+        """
+        #: contains the alternative command line arguments as a string list (has to be given, if the object should
+        #: not use the console params of this call)
+        self._alt_cmd_args = cmd_args
+        #: contains a reference to the ArgumentParser that parses the command line string
+        self.cmd_arg_parser = None
+        #: contains the parsed object
+        self.parsed_args: argparse.Namespace
+
+        ##
+        # all general settings that can be modified by command line arguments
+        ##
+
+        #: the working directory for this balder session (default: current directory from `os.getcwd()`)
+        self.working_dir: Union[pathlib.Path, None] = pathlib.Path(os.getcwd())
+        #: specifies that the tests should only be collected but not be resolved and executed
+        self.collect_only: Union[bool, None] = None
+        #: specifies that the tests should only be collected and resolved but not executed
+        self.resolve_only: Union[bool, None] = None
+        #: specifies that all discarded variations should be printed (with information why they were discarded)
+        self.show_discarded: Union[bool, None] = None
+        #: contains a number of :class:`Setup` class strings that should only be considered for the execution
+        self.only_with_setup: Union[List[str], None] = None
+        #: contains a number of :class:`Scenario` class strings that should only be considered for the execution
+        self.only_with_scenario: Union[List[str], None] = None
+        #: if this is true, the test run should include duplicated tests that are declared as covered_by another test
+        #: method
+        self.force_covered_by_duplicates: Union[bool, None] = None
+
+        self.preparse_args()
+
+        #: overwrite working directory if necessary
+        if working_dir:
+            self.working_dir = working_dir
+
+        # add the current working variable to sys.path
+        sys.path.insert(0, str(self.working_dir.absolute()))
+
+        ##
+        # instantiate and initialize all components to completely load the plugins (plugins could access the command
+        # line argument parser)
+        ##
+        #: contains the reference to the used PluginManager
+        self.plugin_manager = PluginManager()
+        #: contains the reference to the used :class:`Collector` class
+        self.collector = Collector(self.working_dir)
+
+        # determine the balder settings
+        BalderSession.baldersettings = self.get_baldersettings_from_balderglob()
+        BalderSession.baldersettings = BalderSession.baldersettings if BalderSession.baldersettings is not None else \
+            BalderSettings()
+
+        if BalderSession.baldersettings.force_covered_by_duplicates:
+            # overwrite console argument only if the value in BalderSettings is true (because cmd line can only
+            # overwrite the value False)
+            self.force_covered_by_duplicates = True
+
+        for cur_plugin_cls in self.get_balderplugins_from_balderglob():
+            self.plugin_manager.register(cur_plugin_cls, self)
+
+        ##
+        # instantiate all sub objects that are relevant for this test session
+        ##
+        self.parse_args()
+
+        #: overwrite working directory if necessary
+        if working_dir:
+            self.working_dir = working_dir
+
+        #: contains the reference to the used :class:`Solver´ class (or none, if there was no solving executed till
+        #: now)
+        self.solver: Union[Solver, None] = None
+        #: contains the reference to the used :class:`ExecutorTree` class (or none, if there was no solving executed
+        #: till now)
+        self.executor_tree: Union[ExecutorTree, None] = None
+
+    # ---------------------------------- STATIC METHODS ----------------------------------------------------------------
+
+    @staticmethod
+    def get_current_active_global_conntree_name():
+        """
+        This method returns the current active global connection tree name, depending on the current active setting in
+        :class:`BalderSettings`, that is active for the current run.
+        """
+        if BalderSession.baldersettings is None:
+            raise ValueError("no baldersettings loaded yet")
+
+        return BalderSession.baldersettings.used_global_connection_tree
+
+    # ---------------------------------- CLASS METHODS -----------------------------------------------------------------
+
+    # ---------------------------------- PROPERTIES --------------------------------------------------------------------
+
+    @property
+    def all_collected_pyfiles(self) -> List[pathlib.Path]:
+        """returns all collected pyfiles"""
+        try:
+            return self.collector.all_pyfiles
+        except AttributeError as exc:
+            raise RuntimeError("this property is only available after the collecting process was executed") from exc
+
+    @property
+    def all_collected_setups(self) -> List[Type[Setup]]:
+        """returns all collected :class:`Setup` classes"""
+        try:
+            return self.collector.all_setups
+        except AttributeError as exc:
+            raise RuntimeError("this property is only available after the collecting process was executed") from exc
+
+    @property
+    def all_collected_scenarios(self) -> List[Type[Scenario]]:
+        """returns all collected :class:`Scenario` classes"""
+        try:
+            return self.collector.all_scenarios
+        except AttributeError as exc:
+            raise RuntimeError("this property is only available after the collecting process was executed") from exc
+
+    @property
+    def all_collected_connections(self) -> List[Type[Connection]]:
+        """returns all collected :class:`Connection` classes"""
+        try:
+            return self.collector.all_connections
+        except AttributeError as exc:
+            raise RuntimeError("this property is only available after the collecting process was executed") from exc
+
+    @property
+    def all_resolved_mappings(self) -> List[Tuple[Type[Setup], Type[Scenario], Dict[Type[Device], Type[Device]]]]:
+        """returns all resolved mappings for the :class:`Device` mappings between :class:`Scenario` and
+        :class:`Setup`"""
+        try:
+            return self.solver.all_mappings
+        except AttributeError as exc:
+            raise RuntimeError("this property is only available after the resolving process was executed") from exc
+
+    # ---------------------------------- PROTECTED METHODS -------------------------------------------------------------
+
+    # ---------------------------------- METHODS -----------------------------------------------------------------------
+
+    def get_baldersettings_from_balderglob(self) -> Union[BalderSettings, None]:
+        """
+        Helper method that checks if there is a valid :class:`BalderSettings` class in the given module
+        """
+        module = self.collector.load_balderglob_py_file()
+        class_members = inspect.getmembers(module, inspect.isclass)
+        all_classes = []
+        for _, cur_class in class_members:
+            if issubclass(cur_class, BalderSettings):
+                all_classes.append(cur_class)
+        if len(all_classes) == 0:
+            return None
+        if len(all_classes) > 1:
+            raise DuplicateBalderSettingError(f"found more than one object that could be a BalderSettings object - "
+                                              f"found {','.join([cur_class.__name__ for cur_class in all_classes])}")
+        return all_classes[0]()
+
+    def get_balderplugins_from_balderglob(self) -> List[Type[BalderPlugin]]:
+        """
+        Helper method that loads all valid :class:`BalderPlugin` classes and returns them
+        """
+        module = self.collector.load_balderglob_py_file()
+        class_members = inspect.getmembers(module, inspect.isclass)
+        all_classes = []
+        for _, cur_class in class_members:
+            if issubclass(cur_class, BalderPlugin):
+                all_classes.append(cur_class)
+        return all_classes
+
+    def preparse_args(self):
+        """
+        This method pre-parses the console arguments and checks if one or more of the most important (for example
+        `--working-dir`) attributes are given as CLI argument. This will be automatically pre-set. With that balder
+        secures that it can read the correct `balderglob.py` file, to initialize the plugins correctly.
+        """
+        argv_working_dir_key = "--working-dir"
+        if argv_working_dir_key in sys.argv:
+            found_idx = sys.argv.index(argv_working_dir_key)
+            if found_idx != -1:
+                if len(sys.argv) <= found_idx + 1:
+                    raise AttributeError(f"no path given for `{argv_working_dir_key}`")
+
+                self.working_dir = pathlib.Path(sys.argv[found_idx + 1]).absolute()
+                if not self.working_dir.is_dir():
+                    raise NotADirectoryError(
+                        f'can not parse the given working directory `{self.working_dir}` correctly or the given '
+                        f'path is no directory..')
+
+    def parse_args(self):
+        """
+        This method can be used to parse the `arg` object and fill all data from that object into the properties of this
+        :class:`BalderSession` object.
+        """
+        self.cmd_arg_parser = argparse.ArgumentParser(
+            description='Balder is a simple scenario-based test system that allows you to run your tests on various '
+                        'devices without rewriting them')
+
+        self.cmd_arg_parser.add_argument(
+            '--working-dir', nargs="?", default=os.getcwd(),
+            help="a explicit working directory on which the testsystem is to be executed with")
+
+        self.cmd_arg_parser.add_argument(
+            '--collect-only', action='store_true',
+            help="specifies that the tests are only collected but not resolved and executed")
+
+        self.cmd_arg_parser.add_argument(
+            '--resolve-only', action='store_true',
+            help="specifies that the tests are only collected and resolved but not executed")
+
+        self.cmd_arg_parser.add_argument(
+            '--show-discarded', action='store_true',
+            help="specifies that all discarded variations should be printed (with information why they were discarded)")
+
+        self.cmd_arg_parser.add_argument(
+            '--only-with-setup', nargs="*",
+            help="defines a number of Setup classes which should only be considered for the execution")
+
+        self.cmd_arg_parser.add_argument(
+            '--only-with-scenario', nargs="*",
+            help="defines a number of Scenario classes which should only be considered for the execution")
+        self.cmd_arg_parser.add_argument(
+            '--force-covered-by-duplicates', action='store_true',
+            help="specifies that the test run should include duplicated tests that are declared as covered_by another "
+                 "test method (also true if it was already set in baldersetting object)")
+
+        self.plugin_manager.execute_addoption(self.cmd_arg_parser)
+
+        self.parsed_args = self.cmd_arg_parser.parse_args(self._alt_cmd_args)
+
+        self.working_dir = self.parsed_args.working_dir
+        self.collect_only = self.parsed_args.collect_only
+        self.resolve_only = self.parsed_args.resolve_only
+        self.show_discarded = self.parsed_args.show_discarded
+        self.only_with_setup = self.parsed_args.only_with_setup
+        self.only_with_scenario = self.parsed_args.only_with_scenario
+        self.force_covered_by_duplicates = self.parsed_args.force_covered_by_duplicates
+
+    def collect(self):
+        """
+        This method collects all data.
+        """
+        self.collector.collect(
+            plugin_manager=self.plugin_manager,
+            scenario_filter_patterns=self.only_with_scenario,
+            setup_filter_patterns=self.only_with_setup)
+
+    def solve(self):
+        """
+        This method resolves all classes and executes different checks, that can be done before the test session starts.
+        """
+        self.solver = Solver(setups=self.all_collected_setups,
+                             scenarios=self.all_collected_scenarios,
+                             connections=self.all_collected_connections,
+                             fixture_manager=self.collector.get_fixture_manager())
+        self.solver.resolve(plugin_manager=self.plugin_manager)
+
+    def create_executor_tree(self):
+        """
+        This method creates the executor tree object.
+
+        .. note::
+            Note that the method creates an :class:`ExecutorTree`, that hasn't to be completely resolved yet.
+        """
+        self.executor_tree = self.solver.get_executor_tree(plugin_manager=self.plugin_manager,
+                                                           add_discarded=self.show_discarded)
+        self.plugin_manager.execute_filter_executor_tree(executor_tree=self.executor_tree)
+
+    def run(self):
+        """
+        This method executes the whole session
+        """
+        line_length = 120
+
+        self.collect()
+
+        def print_rect_row(text):
+            line = "| " + text
+            line = line + " " * (line_length - len(line) - 1) + "|"
+            print(line)
+
+        print("+" + "-" * (line_length - 2) + "+")
+        print_rect_row("BALDER Testsystem")
+        sys_version = sys.version.replace('\n', '')
+        print_rect_row(f" python version {sys_version} | balder version {balder.__version__}")
+        print("+" + "-" * (line_length - 2) + "+")
+        print(f"Collect {len(self.all_collected_setups)} Setups and {len(self.all_collected_scenarios)} Scenarios")
+        if not self.collect_only:
+            self.solve()
+            self.create_executor_tree()
+            count_valid = len(self.executor_tree.get_all_variation_executors())
+            count_discarded = len(self.executor_tree.get_all_variation_executors(return_discarded=True)) - count_valid
+            addon_text = f" ({count_discarded} discarded)" if self.show_discarded else ""
+            print(f"  resolve them to {count_valid} valid variations{addon_text}")
+            print("")
+            if not self.resolve_only:
+                self.executor_tree.execute(show_discarded=self.show_discarded)
+            else:
+                self.executor_tree.print_tree(show_discarded=self.show_discarded)
+
+        self.plugin_manager.execute_session_finished(self.executor_tree)

_balder/balder_settings.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+
+class BalderSettings:
+    """
+    This class can be overwritten to manipulate the default settings for the balder test system. You can overwrite these
+    settings by defining a subclass in your `balderglob.py`.
+    """
+
+    #: specifies that the test run should include duplicated tests that are declared as ``@covered_by`` another test
+    #:   method
+    force_covered_by_duplicates = False
+
+    #: specifies the connection tree identifier that should be used as global identifier ("" is the default one)
+    used_global_connection_tree = ""

_balder/cnnrelations/__init__.py

@@ -0,0 +1,7 @@
+from .and_connection_relation import AndConnectionRelation
+from .or_connection_relation import OrConnectionRelation
+
+__all__ = [
+    'AndConnectionRelation',
+    'OrConnectionRelation'
+]

_balder/cnnrelations/and_connection_relation.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type
+
+import itertools
+
+from .base_connection_relation import BaseConnectionRelation, BaseConnectionRelationT
+
+if TYPE_CHECKING:
+    from ..connection import List, Union, Connection
+    from .or_connection_relation import OrConnectionRelation
+
+
+class AndConnectionRelation(BaseConnectionRelation):
+    """
+    describes an AND relation between connections
+    """
+
+    def get_tree_str(self) -> str:
+        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
+
+        # create template with all elements that are definitely contained in every new AND relation (only
+        # ``Connection`` objects here)
+        and_template = AndConnectionRelation()
+        # add all OR relations that needs to be further resolved to that list
+        self_simplified_or_relations = []
+
+        # first: go through all inner elements and convert all relations in simplified relations
+        for cur_elem in self.connections:
+            if isinstance(cur_elem, Connection):
+                # that is fine - add it to the template
+                and_template.append(cur_elem)
+            elif isinstance(cur_elem, (AndConnectionRelation, OrConnectionRelation)):
+                # simplify this AND/OR relation and add the items of it
+                # (the simplified version is always an OR relation!)
+                self_simplified_or_relations.append(cur_elem.get_simplified_relation().connections)
+            else:
+                raise TypeError(f'unexpected type for inner element `{cur_elem}`')
+        # now our `self_simplified_or_relations` can only consist of the following nesting: `List[OR[Conn, AND[Conn]]]`
+        #  we need to resolve this constellation into `OR[Conn, AND[Conn]]` now
+
+        # now generate all possibilities out of the OR relations and add them to the AND template
+        all_new_ands = []
+        for cur_variation_tuple in itertools.product(*self_simplified_or_relations):
+            for cur_item in cur_variation_tuple:
+                if isinstance(cur_item, Connection):
+                    # just add the single connection item to the AND template
+                    new_full_and_relation = and_template.clone()
+                    new_full_and_relation.append(cur_item)
+                    all_new_ands.append(new_full_and_relation)
+                elif isinstance(cur_item, AndConnectionRelation):
+                    new_full_and_relation = and_template.clone()
+                    new_full_and_relation.extend(cur_item.connections)
+                    all_new_ands.append(new_full_and_relation)
+                else:
+                    #: note: inner element can not be an OR here!
+                    raise TypeError(f'detect illegal type `{cur_item.__class__}` for inner element')
+        if not self_simplified_or_relations:
+            all_new_ands.append(and_template)
+        return OrConnectionRelation(*all_new_ands)
+
+    def is_single(self) -> bool:
+
+        if len(self._connections) == 0:
+            return True
+
+        return min(cnn.is_single() for cnn in self._connections)
+
+    def get_singles(self) -> List[Connection]:
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        singles_and_relations = ()
+        for cur_elem in self._connections:
+            # get all singles of this AND relation element
+            singles_and_relations += (cur_elem.get_singles(),)
+        # now get the variations and add them to our results
+        return [
+            Connection.based_on(AndConnectionRelation(*cur_tuple))
+            for cur_tuple in itertools.product(*singles_and_relations)
+        ]
+
+    def cut_into_all_possible_subtree_branches(self) -> List[AndConnectionRelation]:
+        if not self.is_single():
+            raise ValueError('can not execute method, because relation is not single')
+
+        tuple_with_all_possibilities = (
+            tuple(cur_tuple_item.cut_into_all_possible_subtree_branches() for cur_tuple_item in self._connections))
+
+        cloned_tuple_list = []
+        for cur_tuple in list(itertools.product(*tuple_with_all_possibilities)):
+            cloned_tuple = AndConnectionRelation(*[cur_tuple_item.clone() for cur_tuple_item in cur_tuple])
+            cloned_tuple_list.append(cloned_tuple)
+        return cloned_tuple_list
+
+    def contained_in(self, other_conn: Union[Connection, BaseConnectionRelationT], ignore_metadata=False) -> bool:
+        # This method checks if the AND relation is contained in the `other_conn`. To ensure that an AND relation is
+        # contained in a connection tree, there has to be another AND relation into the `other_conn`, that has the same
+        # length or is bigger. In addition, there has to exist an order combination where every element of the this AND
+        # relation is contained in the found AND relation of the `other_cnn`. In this case it doesn't matter where the
+        # AND relation is in `other_elem` (will be converted to single, and AND relation will be searched in all
+        # BASED_ON elements). If the AND relation of `other_conn` has fewer items than this AND relation, it will be
+        # ignored. The method only search for a valid existing item in the `other_conn` AND relation for every item of
+        # this AND relation.
+        from ..connection import Connection  # pylint: disable=import-outside-toplevel
+
+        if not self.is_resolved():
+            raise ValueError('can not execute method, because connection relation is not resolved')
+        if not other_conn.is_resolved():
+            raise ValueError('can not execute method, because other connection relation is not resolved')
+
+        if isinstance(other_conn, BaseConnectionRelation):
+            other_conn = Connection.based_on(other_conn)
+
+        self_singles = self.get_singles()
+        other_singles = other_conn.get_singles()
+
+        for cur_self_single, cur_other_single in itertools.product(self_singles, other_singles):
+            # check if we can find an AND relation in the other object -> go the single connection upwards and
+            # search for a `AndConnectionRelation`
+
+            # self is a container connection -> use raw inner AND list
+            cur_self_single_and_relation = cur_self_single.based_on_elements.connections[0]
+
+            cur_sub_other_single = cur_other_single
+            while cur_sub_other_single is not None:
+                if isinstance(cur_sub_other_single, AndConnectionRelation):
+                    # found an AND relation -> check if length does match
+                    if len(cur_sub_other_single) < len(cur_self_single_and_relation):
+                        # this complete element is not possible - skip this single!
+                        break
+                    # length is okay, no check if every single element is contained in one of this tuple
+                    for cur_inner_self_elem in cur_self_single_and_relation.connections:
+
+                        if not cur_inner_self_elem.contained_in(cur_sub_other_single,
+                                                                ignore_metadata=ignore_metadata):
+                            # at least one element is not contained in other AND relation - this complete element
+                            # is not possible - skip this single!
+                            break
+                    # all items are contained in the current other AND relation -> match
+                    return True
+                # go further up, if this element is no AND relation
+                cur_sub_other_single = cur_sub_other_single.based_on_elements[0] \
+                    if cur_sub_other_single.based_on_elements else None
+
+        return False