robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/libraries/XML.py

@@ -34,8 +34,7 @@ else:
 from robot.api import logger
 from robot.api.deco import keyword
 from robot.libraries.BuiltIn import BuiltIn
-from robot.utils import (asserts, ET, ETSource, is_bytes, is_falsy, is_string,
-                         is_truthy, plural_or_not as s)
+from robot.utils import asserts, ET, ETSource, plural_or_not as s
 from robot.version import get_version
 
 
@@ -53,7 +52,7 @@ class XML:
     The library has the following main usages:
 
     - Parsing an XML file, or a string containing XML, into an XML element
-      structure and finding certain elements from it for for further analysis
+      structure and finding certain elements from it for further analysis
       (e.g. `Parse XML` and `Get Element` keywords).
     - Getting text or attributes of elements
       (e.g. `Get Element Text` and `Get Element Attribute`).
@@ -75,10 +74,10 @@ class XML:
     children and their children. Possible comments and processing instructions
     in the source XML are removed.
 
-    XML is not validated during parsing even if has a schema defined. How
+    XML is not validated during parsing even if it has a schema defined. How
     possible doctype elements are handled otherwise depends on the used XML
     module and on the platform. The standard ElementTree strips doctypes
-    altogether but when `using lxml` they are preserved when XML is saved.
+    altogether, but when `using lxml` they are preserved when XML is saved.
 
     The element structure returned by `Parse XML`, as well as elements
     returned by keywords such as `Get Element`, can be used as the ``source``
@@ -95,8 +94,6 @@ class XML:
     escaped by doubling it (``\\\\``). Using the built-in variable ``${/}``
     naturally works too.
 
-    Note: Support for XML as bytes is new in Robot Framework 3.2.
-
     = Using lxml =
 
     By default, this library uses Python's standard
@@ -168,7 +165,7 @@ class XML:
 
     If lxml support is enabled when `importing` the library, the whole
     [http://www.w3.org/TR/xpath/|xpath 1.0 standard] is supported.
-    That includes everything listed below but also lot of other useful
+    That includes everything listed below but also a lot of other useful
     constructs.
 
     == Tag names ==
@@ -304,7 +301,7 @@ class XML:
     = Handling XML namespaces =
 
     ElementTree and lxml handle possible namespaces in XML documents by adding
-    the namespace URI to tag names in so called Clark Notation. That is
+    the namespace URI to tag names in so-called Clark Notation. That is
     inconvenient especially with xpaths, and by default this library strips
     those namespaces away and moves them to ``xmlns`` attribute instead. That
     can be avoided by passing ``keep_clark_notation`` argument to `Parse XML`
@@ -433,8 +430,6 @@ class XML:
     | `Parse XML` | ${XML} | keep_clark_notation=${EMPTY} | # Empty string is false.       |
     | `Parse XML` | ${XML} | keep_clark_notation=${FALSE} | # Python ``False`` is false.   |
 
-    Considering ``OFF`` and ``0`` false is new in Robot Framework 3.1.
-
     == Pattern matching ==
 
     Some keywords, for example `Elements Should Match`, support so called
@@ -450,9 +445,6 @@ class XML:
     Unlike with glob patterns normally, path separator characters ``/`` and
     ``\\`` and the newline character ``\\n`` are matches by the above
     wildcards.
-
-    Support for brackets like ``[abc]`` and ``[!a-z]`` is new in
-    Robot Framework 3.1
     """
     ROBOT_LIBRARY_SCOPE = 'GLOBAL'
     ROBOT_LIBRARY_VERSION = get_version()
@@ -470,7 +462,6 @@ class XML:
         If lxml mode is enabled but the module is not installed, this library
         emits a warning and reverts back to using the standard ElementTree.
         """
-        use_lxml = is_truthy(use_lxml)
         if use_lxml and lxml_etree:
             self.etree = lxml_etree
             self.modern_etree = True
@@ -523,8 +514,8 @@ class XML:
             strip = (lxml_etree.Comment, lxml_etree.ProcessingInstruction)
             lxml_etree.strip_elements(tree, *strip, **dict(with_tail=False))
         root = tree.getroot()
-        if not is_truthy(keep_clark_notation):
-            self._ns_stripper.strip(root, preserve=is_falsy(strip_namespaces))
+        if not keep_clark_notation:
+            self._ns_stripper.strip(root, preserve=not strip_namespaces)
         return root
 
     def get_element(self, source, xpath='.'):
@@ -565,10 +556,10 @@ class XML:
 
     def _wrong_number_of_matches(self, count, xpath):
         if not count:
-            return "No element matching '%s' found." % xpath
+            return f"No element matching '{xpath}' found."
         if count == 1:
-            return "One element matching '%s' found." % xpath
-        return "Multiple elements (%d) matching '%s' found." % (count, xpath)
+            return f"One element matching '{xpath}' found."
+        return f"Multiple elements ({count}) matching '{xpath}' found."
 
     def get_elements(self, source, xpath):
         """Returns a list of elements in the ``source`` matching the ``xpath``.
@@ -619,7 +610,7 @@ class XML:
         See also `Element Should Exist` and `Element Should Not Exist`.
         """
         count = len(self.get_elements(source, xpath))
-        logger.info("%d element%s matched '%s'." % (count, s(count), xpath))
+        logger.info(f"{count} element{s(count)} matched '{xpath}'.")
         return count
 
     def element_should_exist(self, source, xpath='.', message=None):
@@ -685,7 +676,7 @@ class XML:
         """
         element = self.get_element(source, xpath)
         text = ''.join(self._yield_texts(element))
-        if is_truthy(normalize_whitespace):
+        if normalize_whitespace:
             text = self._normalize_whitespace(text)
         return text
 
@@ -854,7 +845,7 @@ class XML:
         """
         attr = self.get_element_attribute(source, name, xpath)
         if attr is None:
-            raise AssertionError("Attribute '%s' does not exist." % name)
+            raise AssertionError(f"Attribute '{name}' does not exist.")
         should_match(attr, pattern, message, values=False)
 
     def element_should_not_have_attribute(self, source, name, xpath='.', message=None):
@@ -876,11 +867,11 @@ class XML:
         """
         attr = self.get_element_attribute(source, name, xpath)
         if attr is not None:
-            raise AssertionError(message or "Attribute '%s' exists and "
-                                            "has value '%s'." % (name, attr))
+            raise AssertionError(message or
+                                 f"Attribute '{name}' exists and has value '{attr}'.")
 
     def elements_should_be_equal(self, source, expected, exclude_children=False,
-                                 normalize_whitespace=False):
+                                 normalize_whitespace=False, sort_children=False):
         """Verifies that the given ``source`` element is equal to ``expected``.
 
         Both ``source`` and ``expected`` can be given as a path to an XML file,
@@ -890,12 +881,14 @@ class XML:
 
         The keyword passes if the ``source`` element and ``expected`` element
         are equal. This includes testing the tag names, texts, and attributes
-        of the elements. By default also child elements are verified the same
+        of the elements. By default, also child elements are verified the same
         way, but this can be disabled by setting ``exclude_children`` to a
-        true value (see `Boolean arguments`).
+        true value (see `Boolean arguments`). Child elements are expected to
+        be in the same order, but that can be changed by giving ``sort_children``
+        a true value. Notice that elements are sorted solely based on tag names.
 
         All texts inside the given elements are verified, but possible text
-        outside them is not. By default texts must match exactly, but setting
+        outside them is not. By default, texts must match exactly, but setting
         ``normalize_whitespace`` to a true value makes text verification
         independent on newlines, tabs, and the amount of spaces. For more
         details about handling text see `Get Element Text` keyword and
@@ -915,12 +908,14 @@ class XML:
         the ``.`` at the end that is the `tail` text of the ``<i>`` element.
 
         See also `Elements Should Match`.
+
+        ``sort_children`` is new in Robot Framework 7.0.
         """
-        self._compare_elements(source, expected, should_be_equal,
-                               exclude_children, normalize_whitespace)
+        self._compare_elements(source, expected, should_be_equal, exclude_children,
+                               sort_children, normalize_whitespace)
 
     def elements_should_match(self, source, expected, exclude_children=False,
-                              normalize_whitespace=False):
+                              normalize_whitespace=False, sort_children=False):
         """Verifies that the given ``source`` element matches ``expected``.
 
         This keyword works exactly like `Elements Should Be Equal` except that
@@ -937,16 +932,22 @@ class XML:
 
         See `Elements Should Be Equal` for more examples.
         """
-        self._compare_elements(source, expected, should_match,
-                               exclude_children, normalize_whitespace)
+        self._compare_elements(source, expected, should_match, exclude_children,
+                               sort_children, normalize_whitespace)
 
     def _compare_elements(self, source, expected, comparator, exclude_children,
-                          normalize_whitespace):
-        normalizer = self._normalize_whitespace \
-            if is_truthy(normalize_whitespace) else None
-        comparator = ElementComparator(comparator, normalizer, exclude_children)
+                          sort_children, normalize_whitespace):
+        normalizer = self._normalize_whitespace if normalize_whitespace else None
+        sorter = self._sort_children if sort_children else None
+        comparator = ElementComparator(comparator, normalizer, sorter, exclude_children)
         comparator.compare(self.get_element(source), self.get_element(expected))
 
+    def _sort_children(self, element):
+        tails = [child.tail for child in element]
+        element[:] = sorted(element, key=lambda child: child.tag)
+        for child, tail in zip(element, tails):
+            child.tail = tail
+
     def set_element_tag(self, source, tag, xpath='.'):
         """Sets the tag of the specified element.
 
@@ -1219,7 +1220,7 @@ class XML:
 
     def _remove_element(self, root, element, remove_tail=False):
         parent = self._find_parent(root, element)
-        if not is_truthy(remove_tail):
+        if not remove_tail:
             self._preserve_tail(element, parent)
         parent.remove(element)
 
@@ -1269,7 +1270,7 @@ class XML:
         element = self.get_element(source, xpath)
         tail = element.tail
         element.clear()
-        if not is_truthy(clear_tail):
+        if not clear_tail:
             element.tail = tail
         return source
 
@@ -1279,7 +1280,7 @@ class XML:
         The element to copy is specified using ``source`` and ``xpath``. They
         have exactly the same semantics as with `Get Element` keyword.
 
-        If the copy or the original element is modified afterwards, the changes
+        If the copy or the original element is modified afterward, the changes
         have no effect on the other.
 
         Examples using ``${XML}`` structure from `Example`:
@@ -1308,6 +1309,8 @@ class XML:
         See also `Log Element` and `Save XML`.
         """
         source = self.get_element(source, xpath)
+        if self.lxml_etree:
+            source = self._ns_stripper.unstrip(source)
         string = self.etree.tostring(source, encoding='UTF-8').decode('UTF-8')
         string = re.sub(r'^<\?xml .*\?>', '', string).strip()
         if encoding:
@@ -1365,8 +1368,7 @@ class XML:
                 output.write(self.etree.tostring(tree, **config))
             else:
                 tree.write(output, **config)
-        logger.info('XML saved to <a href="file://%s">%s</a>.' % (path, path),
-                    html=True)
+        logger.info(f'XML saved to <a href="file://{path}">{path}</a>.', html=True)
 
     def evaluate_xpath(self, source, expression, context='.'):
         """Evaluates the given xpath expression and returns results.
@@ -1420,7 +1422,7 @@ class NameSpaceStripper:
             elem = copy.deepcopy(elem)
         ns = elem.attrib.pop('xmlns', current_ns)
         if ns:
-            elem.tag = '{%s}%s' % (ns, elem.tag)
+            elem.tag = f'{{{ns}}}{elem.tag}'
         for child in elem:
             self.unstrip(child, ns, copied=True)
         return elem
@@ -1460,10 +1462,12 @@ class ElementFinder:
 
 class ElementComparator:
 
-    def __init__(self, comparator, normalizer=None, exclude_children=False):
-        self._comparator = comparator
-        self._normalizer = normalizer or (lambda text: text)
-        self._exclude_children = is_truthy(exclude_children)
+    def __init__(self, comparator, normalizer=None, child_sorter=None,
+                 exclude_children=False):
+        self.comparator = comparator
+        self.normalizer = normalizer or (lambda text: text)
+        self.child_sorter = child_sorter
+        self.exclude_children = exclude_children
 
     def compare(self, actual, expected, location=None):
         if not location:
@@ -1473,7 +1477,7 @@ class ElementComparator:
         self._compare_texts(actual, expected, location)
         if location.is_not_root:
             self._compare_tails(actual, expected, location)
-        if not self._exclude_children:
+        if not self.exclude_children:
             self._compare_children(actual, expected, location)
 
     def _compare_tags(self, actual, expected, location):
@@ -1482,9 +1486,9 @@ class ElementComparator:
 
     def _compare(self, actual, expected, message, location, comparator=None):
         if location.is_not_root:
-            message = "%s at '%s'" % (message, location.path)
+            message = f"{message} at '{location.path}'"
         if not comparator:
-            comparator = self._comparator
+            comparator = self.comparator
         comparator(actual, expected, message)
 
     def _compare_attributes(self, actual, expected, location):
@@ -1492,14 +1496,14 @@ class ElementComparator:
                       'Different attribute names', location, should_be_equal)
         for key in actual.attrib:
             self._compare(actual.attrib[key], expected.attrib[key],
-                          "Different value for attribute '%s'" % key, location)
+                          f"Different value for attribute '{key}'", location)
 
     def _compare_texts(self, actual, expected, location):
         self._compare(self._text(actual.text), self._text(expected.text),
                       'Different text', location)
 
     def _text(self, text):
-        return self._normalizer(text or '')
+        return self.normalizer(text or '')
 
     def _compare_tails(self, actual, expected, location):
         self._compare(self._text(actual.tail), self._text(expected.tail),
@@ -1508,6 +1512,9 @@ class ElementComparator:
     def _compare_children(self, actual, expected, location):
         self._compare(len(actual), len(expected), 'Different number of child elements',
                       location, should_be_equal)
+        if self.child_sorter:
+            self.child_sorter(actual)
+            self.child_sorter(expected)
         for act, exp in zip(actual, expected):
             self.compare(act, exp, location.child(act.tag))
 
@@ -1517,12 +1524,12 @@ class Location:
     def __init__(self, path, is_root=True):
         self.path = path
         self.is_not_root = not is_root
-        self._children = {}
+        self.children = {}
 
     def child(self, tag):
-        if tag not in self._children:
-            self._children[tag] = 1
+        if tag not in self.children:
+            self.children[tag] = 1
         else:
-            self._children[tag] += 1
-            tag += '[%d]' % self._children[tag]
-        return Location('%s/%s' % (self.path, tag), is_root=False)
+            self.children[tag] += 1
+            tag += f'[{self.children[tag]}]'
+        return Location(f'{self.path}/{tag}', is_root=False)

{robotframework-6.1.1 → robotframework-7.0}/src/robot/libraries/__init__.py

@@ -27,5 +27,5 @@ the http://robotframework.org web site.
 """
 
 STDLIBS = frozenset(('BuiltIn', 'Collections', 'DateTime', 'Dialogs', 'Easter',
-                     'OperatingSystem', 'Process', 'Remote', 'Reserved',
-                     'Screenshot', 'String', 'Telnet', 'XML'))
+                     'OperatingSystem', 'Process', 'Remote', 'Screenshot',
+                     'String', 'Telnet', 'XML'))

{robotframework-6.1.1 → robotframework-7.0}/src/robot/model/__init__.py

@@ -25,16 +25,16 @@ elsewhere.
 This package is considered stable.
 """
 
-from .body import BaseBody, Body, BodyItem, BaseBranches
+from .body import BaseBody, Body, BodyItem, BaseBranches, BaseIterations
 from .configurer import SuiteConfigurer
-from .control import Break, Continue, Error, For, If, IfBranch, Return, Try, TryBranch, While
+from .control import (Break, Continue, Error, For, ForIteration, If, IfBranch,
+                      Return, Try, TryBranch, Var, While, WhileIteration)
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
-from .message import Message, Messages
+from .keyword import Arguments, Keyword
+from .message import Message, MessageLevel, Messages
 from .modelobject import DataDict, ModelObject
 from .modifier import ModelModifier
-from .namepatterns import SuiteNamePatterns, TestNamePatterns
 from .statistics import Statistics
 from .tags import Tags, TagPattern, TagPatterns
 from .testcase import TestCase, TestCases

{robotframework-6.1.1 → robotframework-7.0}/src/robot/model/body.py

@@ -23,10 +23,9 @@ from .itemlist import ItemList
 from .modelobject import DataDict, full_name, ModelObject
 
 if TYPE_CHECKING:
-    from robot.result.model import ForIteration, WhileIteration
-    from robot.running.model import UserKeyword, ResourceFile
-    from .control import (Break, Continue, Error, For, If, IfBranch, Return,
-                          Try, TryBranch, While)
+    from robot.running.model import ResourceFile, UserKeyword
+    from .control import (Break, Continue, Error, For, ForIteration, If, IfBranch,
+                          Return, Try, TryBranch, Var, While, WhileIteration)
     from .keyword import Keyword
     from .message import Message
     from .testcase import TestCase
@@ -35,19 +34,21 @@ if TYPE_CHECKING:
 
 BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'ForIteration',
                        'If', 'IfBranch', 'Try', 'TryBranch', 'While', 'WhileIteration',
-                       'Keyword', 'Return', 'Continue', 'Break', 'Error', None]
+                       'Keyword', 'Var', 'Return', 'Continue', 'Break', 'Error', None]
 BI = TypeVar('BI', bound='BodyItem')
 KW = TypeVar('KW', bound='Keyword')
 F = TypeVar('F', bound='For')
 W = TypeVar('W', bound='While')
 I = TypeVar('I', bound='If')
 T = TypeVar('T', bound='Try')
+V = TypeVar('V', bound='Var')
 R = TypeVar('R', bound='Return')
 C = TypeVar('C', bound='Continue')
 B = TypeVar('B', bound='Break')
 M = TypeVar('M', bound='Message')
 E = TypeVar('E', bound='Error')
 IT = TypeVar('IT', bound='IfBranch|TryBranch')
+FW = TypeVar('FW', bound='ForIteration|WhileIteration')
 
 
 class BodyItem(ModelObject):
@@ -65,11 +66,13 @@ class BodyItem(ModelObject):
     EXCEPT = 'EXCEPT'
     FINALLY = 'FINALLY'
     WHILE = 'WHILE'
+    VAR = 'VAR'
     RETURN = 'RETURN'
     CONTINUE = 'CONTINUE'
     BREAK = 'BREAK'
     ERROR = 'ERROR'
     MESSAGE = 'MESSAGE'
+    KEYWORD_TYPES = (KEYWORD, SETUP, TEARDOWN)
     type = None
     __slots__ = ['parent']
 
@@ -111,7 +114,7 @@ class BodyItem(ModelObject):
         raise NotImplementedError
 
 
-class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
+class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
     """Base class for Body and Branches objects."""
     __slots__ = []
     # Set using 'BaseBody.register' when these classes are created.
@@ -120,6 +123,7 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
     while_class: Type[W] = KnownAtRuntime
     if_class: Type[I] = KnownAtRuntime
     try_class: Type[T] = KnownAtRuntime
+    var_class: Type[V] = KnownAtRuntime
     return_class: Type[R] = KnownAtRuntime
     continue_class: Type[C] = KnownAtRuntime
     break_class: Type[B] = KnownAtRuntime
@@ -132,7 +136,7 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
 
     def _item_from_dict(self, data: DataDict) -> BodyItem:
         item_type = data.get('type', None)
-        if not item_type:
+        if item_type is None:
             item_class = self.keyword_class
         elif item_type == BodyItem.IF_ELSE_ROOT:
             item_class = self.if_class
@@ -159,7 +163,7 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
             f"Use item specific methods like 'create_keyword' instead."
         )
 
-    def _create(self, cls: 'Type[BI]', name: str, args: 'tuple[Any]',
+    def _create(self, cls: 'Type[BI]', name: str, args: 'tuple[Any, ...]',
                 kwargs: 'dict[str, Any]') -> BI:
         if cls is KnownAtRuntime:
             raise TypeError(f"'{full_name(self)}' object does not support '{name}'.")
@@ -185,6 +189,10 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
     def create_while(self, *args, **kwargs) -> while_class:
         return self._create(self.while_class, 'create_while', args, kwargs)
 
+    @copy_signature(var_class)
+    def create_var(self, *args, **kwargs) -> var_class:
+        return self._create(self.var_class, 'create_var', args, kwargs)
+
     @copy_signature(return_class)
     def create_return(self, *args, **kwargs) -> return_class:
         return self._create(self.return_class, 'create_return', args, kwargs)
@@ -267,8 +275,8 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
         return steps
 
 
-class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                    'Break', 'Message', 'Error']):
+class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                    'Continue', 'Break', 'Message', 'Error']):
     """A list-like object representing a body of a test, keyword, etc.
 
     Body contains the keywords and other structures such as FOR loops.
@@ -276,19 +284,19 @@ class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue'
     pass
 
 
+# BaseBranches cannot extend Generic[IT] directly with BaseBody[...].
 class BranchType(Generic[IT]):
-    """Class that wrapps `Generic` as python doesn't allow multple generic inheritance"""
     pass
 
 
-class BaseBranches(BaseBody[KW, F, W, I, T, R, C, B, M, E], BranchType[IT]):
+class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
     """A list-like object representing IF and TRY branches."""
     __slots__ = ['branch_class']
     branch_type: Type[IT] = KnownAtRuntime
 
     def __init__(self, branch_class: Type[IT],
                  parent: BodyItemParent = None,
-                 items: 'Iterable[BodyItem|DataDict]' = ()):
+                 items: 'Iterable[IT|DataDict]' = ()):
         self.branch_class = branch_class
         super().__init__(parent, items)
 
@@ -298,3 +306,26 @@ class BaseBranches(BaseBody[KW, F, W, I, T, R, C, B, M, E], BranchType[IT]):
     @copy_signature(branch_type)
     def create_branch(self, *args, **kwargs) -> IT:
         return self._create(self.branch_class, 'create_branch', args, kwargs)
+
+
+# BaseIterations cannot extend Generic[IT] directly with BaseBody[...].
+class IterationType(Generic[FW]):
+    pass
+
+
+class BaseIterations(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], IterationType[FW]):
+    __slots__ = ['iteration_class']
+    iteration_type: Type[FW] = KnownAtRuntime
+
+    def __init__(self, iteration_class: Type[FW],
+                 parent: BodyItemParent = None,
+                 items: 'Iterable[FW|DataDict]' = ()):
+        self.iteration_class = iteration_class
+        super().__init__(parent, items)
+
+    def _item_from_dict(self, data: DataDict) -> FW:
+        return self.iteration_class.from_dict(data)
+
+    @copy_signature(iteration_type)
+    def create_iteration(self, *args, **kwargs) -> FW:
+        return self._create(self.iteration_class, 'iteration_class', args, kwargs)

{robotframework-6.1.1 → robotframework-7.0}/src/robot/model/configurer.py

@@ -66,22 +66,26 @@ class SuiteConfigurer(SuiteVisitor):
         parts = [{False: 'tests', True: 'tasks', None: 'tests or tasks'}[rpa],
                  self._get_test_selector_msgs(),
                  self._get_suite_selector_msg()]
-        raise DataError("Suite '%s' contains no %s."
-                        % (name, ' '.join(p for p in parts if p)))
+        raise DataError(f"Suite '{name}' contains no "
+                        f"{' '.join(p for p in parts if p)}.")
 
     def _get_test_selector_msgs(self):
         parts = []
-        for explanation, selector in [('matching tags', self.include_tags),
-                                      ('not matching tags', self.exclude_tags),
-                                      ('matching name', self.include_tests)]:
-            if selector:
-                parts.append(self._format_selector_msg(explanation, selector))
-        return seq2str(parts, quote='')
+        for separator, explanation, selectors in [
+                (None, 'matching name', self.include_tests),
+                ('or', 'matching tags', self.include_tags),
+                ('and', 'not matching tags', self.exclude_tags)
+        ]:
+            if selectors:
+                if parts:
+                    parts.append(separator)
+                parts.append(self._format_selector_msg(explanation, selectors))
+        return ' '.join(parts)
 
-    def _format_selector_msg(self, explanation, selector):
-        if len(selector) == 1 and explanation[-1] == 's':
+    def _format_selector_msg(self, explanation, selectors):
+        if len(selectors) == 1 and explanation[-1] == 's':
             explanation = explanation[:-1]
-        return '%s %s' % (explanation, seq2str(selector, lastsep=' or '))
+        return f"{explanation} {seq2str(selectors, lastsep=' or ')}"
 
     def _get_suite_selector_msg(self):
         if not self.include_suites: