robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/modifier.py

@@ -35,7 +35,7 @@ class ModelModifier(SuiteVisitor):
                 message, details = get_error_details()
                 self._log_error(f"Executing model modifier '{type_name(visitor)}' "
                                 f"failed: {message}\n{details}")
-        if not (suite.test_count or self._empty_suite_ok):
+        if not (suite.has_tests or self._empty_suite_ok):
             raise DataError(f"Suite '{suite.name}' contains no tests after "
                             f"model modifiers.")
 

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/namepatterns.py

@@ -23,15 +23,9 @@ class NamePatterns(Iterable[str]):
     def __init__(self, patterns: Sequence[str] = (), ignore: Sequence[str] = '_'):
         self.matcher = MultiMatcher(patterns, ignore)
 
-    def match(self, name: str, longname: 'str|None' = None) -> bool:
-        return bool(self._match(name) or
-                    longname and self._match_longname(longname))
-
-    def _match(self, name: str) -> bool:
-        return self.matcher.match(name)
-
-    def _match_longname(self, name: str) -> bool:
-        raise NotImplementedError
+    def match(self, name: str, full_name: 'str|None' = None) -> bool:
+        match = self.matcher.match
+        return bool(match(name) or full_name and match(full_name))
 
     def __bool__(self) -> bool:
         return bool(self.matcher)
@@ -39,19 +33,3 @@ class NamePatterns(Iterable[str]):
     def __iter__(self) -> Iterator[str]:
         for matcher in self.matcher:
             yield matcher.pattern
-
-
-class SuiteNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        while '.' in name:
-            if self._match(name):
-                return True
-            name = name.split('.', 1)[1]
-        return False
-
-
-class TestNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        return self._match(name)

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/stats.py

@@ -13,6 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import timedelta
+
 from robot.utils import (Sortable, elapsed_time_to_string, html_escape,
                          is_string, normalize)
 
@@ -31,14 +33,10 @@ class Stat(Sortable):
         #: or name of the tag for
         #: :class:`~robot.model.tagstatistics.TagStatistics`
         self.name = name
-        #: Number of passed tests.
         self.passed = 0
-        #: Number of failed tests.
         self.failed = 0
-        #: Number of skipped tests.
         self.skipped = 0
-        #: Number of milliseconds it took to execute.
-        self.elapsed = 0
+        self.elapsed = timedelta()
         self._norm_name = normalize(name, ignore='_')
 
     def get_attributes(self, include_label=False, include_elapsed=False,
@@ -49,8 +47,7 @@ class Stat(Sortable):
         if include_label:
             attrs['label'] = self.name
         if include_elapsed:
-            attrs['elapsed'] = elapsed_time_to_string(self.elapsed,
-                                                      include_millis=False)
+            attrs['elapsed'] = elapsed_time_to_string(self.elapsed, include_millis=False)
         if exclude_empty:
             attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None))
         if values_as_strings:
@@ -83,7 +80,7 @@ class Stat(Sortable):
             self.failed += 1
 
     def _update_elapsed(self, test):
-        self.elapsed += test.elapsedtime
+        self.elapsed += test.elapsed_time
 
     @property
     def _sort_key(self):
@@ -106,12 +103,9 @@ class SuiteStat(Stat):
     type = 'suite'
 
     def __init__(self, suite):
-        Stat.__init__(self, suite.longname)
-        #: Identifier of the suite, e.g. `s1-s2`.
+        super().__init__(suite.full_name)
         self.id = suite.id
-        #: Number of milliseconds it took to execute this suite,
-        #: including sub-suites.
-        self.elapsed = suite.elapsedtime
+        self.elapsed = suite.elapsed_time
         self._name = suite.name
 
     def _get_custom_attrs(self):
@@ -131,7 +125,7 @@ class TagStat(Stat):
     type = 'tag'
 
     def __init__(self, name, doc='', links=None, combined=None):
-        Stat.__init__(self, name)
+        super().__init__(name)
         #: Documentation of tag as a string.
         self.doc = doc
         #: List of tuples in which the first value is the link URL and
@@ -164,7 +158,7 @@ class TagStat(Stat):
 class CombinedTagStat(TagStat):
 
     def __init__(self, pattern, name=None, doc='', links=None):
-        TagStat.__init__(self, name or pattern, doc, links, combined=pattern)
+        super().__init__(name or pattern, doc, links, combined=pattern)
         self.pattern = TagPattern.from_string(pattern)
 
     def match(self, tags):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/tags.py

@@ -105,7 +105,7 @@ class Tags(Sequence[str]):
 
 class TagPatterns(Sequence['TagPattern']):
 
-    def __init__(self, patterns: Iterable[str]):
+    def __init__(self, patterns: Iterable[str] = ()):
         self._patterns = tuple(TagPattern.from_string(p) for p in Tags(patterns))
 
     def match(self, tags: Iterable[str]) -> bool:

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/testcase.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from pathlib import Path
 from typing import Any, Generic, Sequence, Type, TYPE_CHECKING, TypeVar
 
@@ -22,7 +21,7 @@ from robot.utils import setter
 from .body import Body, BodyItem
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .modelobject import DataDict, ModelObject
 from .tags import Tags
 
@@ -35,7 +34,7 @@ TC = TypeVar('TC', bound='TestCase')
 KW = TypeVar('KW', bound='Keyword', covariant=True)
 
 
-class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else object):
+class TestCase(ModelObject, Generic[KW]):
     """Base model for a single test case.
 
     Extended by :class:`robot.running.model.TestCase` and
@@ -43,7 +42,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
     """
     body_class = Body
     # See model.TestSuite on removing the type ignore directive
-    fixture_class: Type[KW] = Keyword # type: ignore
+    fixture_class: Type[KW] = Keyword    # type: ignore
     repr_args = ('name',)
     __slots__ = ['parent', 'name', 'doc', 'timeout', 'lineno', '_setup', '_teardown']
 
@@ -121,7 +120,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return bool(self._setup)
 
     @property
-    def teardown(self) -> Keyword:
+    def teardown(self) -> KW:
         """Test teardown as a :class:`~.model.keyword.Keyword` object.
 
         See :attr:`setup` for more information.
@@ -144,19 +143,6 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0
-
-        Use :attr:`body`, :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup] + list(self.body) + [self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """Test case id in format like ``s1-t3``.
@@ -171,11 +157,16 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return f'{self.parent.id}-t{index + 1}'
 
     @property
-    def longname(self) -> str:
-        """Test name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Test name prefixed with the full name of the parent suite."""
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @property
     def source(self) -> 'Path|None':

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/testsuite.py

@@ -13,18 +13,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Generic, Iterator, Sequence, Type, TypeVar
 
+from robot.errors import DataError
 from robot.utils import seq2str, setter
 
 from .configurer import SuiteConfigurer
 from .filter import Filter, EmptySuiteRemover
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .metadata import Metadata
 from .modelobject import DataDict, ModelObject
 from .tagsetter import TagSetter
@@ -36,14 +36,14 @@ KW = TypeVar('KW', bound=Keyword, covariant=True)
 TC = TypeVar('TC', bound=TestCase, covariant=True)
 
 
-class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else object):
+class TestSuite(ModelObject, Generic[KW, TC]):
     """Base model for single suite.
 
     Extended by :class:`robot.running.model.TestSuite` and
     :class:`robot.result.model.TestSuite`.
     """
     # FIXME: Type Ignore declarations: Typevars only accept subclasses of the bound class
-    # assiging `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
+    # assigning `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
     # made impossible to instantiate directly, and the assignments can be replaced with
     # KnownAtRuntime
     fixture_class: Type[KW] = Keyword  # type: ignore
@@ -56,7 +56,7 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
                  doc: str = '',
                  metadata: 'Mapping[str, str]|None' = None,
                  source: 'Path|str|None' = None,
-                 rpa: 'bool|None' = None,
+                 rpa: 'bool|None' = False,
                  parent: 'TestSuite|None' = None):
         self._name = name
         self.doc = doc
@@ -191,17 +191,51 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
             suite.adjust_source(relative_to, root)
 
     @property
-    def longname(self) -> str:
-        """Suite name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Suite name prefixed with the full name of the possible parent suite.
+
+        Just :attr:`name` of the suite if it has no :attr:`parent`.
+        """
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @setter
     def metadata(self, metadata: 'Mapping[str, str]|None') -> Metadata:
         """Free suite metadata as a :class:`~.metadata.Metadata` object."""
         return Metadata(metadata)
 
+    def validate_execution_mode(self) -> 'bool|None':
+        """Validate that suite execution mode is set consistently.
+
+        Raise an exception if the execution mode is not set (i.e. the :attr:`rpa`
+        attribute is ``None``) and child suites have conflicting execution modes.
+
+        The execution mode is returned. New in RF 6.1.1.
+        """
+        if self.rpa is None:
+            rpa = name = None
+            for suite in self.suites:
+                suite.validate_execution_mode()
+                if rpa is None:
+                    rpa = suite.rpa
+                    name = suite.full_name
+                elif rpa is not suite.rpa:
+                    mode1, mode2 = ('tasks', 'tests') if rpa else ('tests', 'tasks')
+                    raise DataError(
+                        f"Conflicting execution modes: Suite '{name}' has {mode1} but "
+                        f"suite '{suite.full_name}' has {mode2}. Resolve the conflict "
+                        f"or use '--rpa' or '--norpa' options to set the execution "
+                        f"mode explicitly."
+                    )
+            self.rpa = rpa
+        return self.rpa
+
     @setter
     def suites(self, suites: 'Sequence[TestSuite|DataDict]') -> 'TestSuites[TestSuite[KW, TC]]':
         return TestSuites['TestSuite'](self.__class__, self, suites)
@@ -282,19 +316,6 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0.
-
-        Use :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup, self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """An automatically generated unique id.
@@ -331,9 +352,7 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
 
     @property
     def has_tests(self) -> bool:
-        if self.tests:
-            return True
-        return any(s.has_tests for s in self.suites)
+        return bool(self.tests) or any(s.has_tests for s in self.suites)
 
     def set_tags(self, add: Sequence[str] = (), remove: Sequence[str] = (),
                  persist: bool = False):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/model/visitor.py

@@ -21,7 +21,7 @@ and the :mod:`result model <robot.result.model>`, but the objects passed to
 the visitor methods are slightly different depending on the model they are
 used with. The main differences are that on the execution side keywords do
 not have child keywords nor messages, and that only the result objects have
-status related attributes like :attr:`status` and :attr:`starttime`.
+status related attributes like :attr:`status` and :attr:`start_time`.
 
 This module contains :class:`SuiteVisitor` that implements the core logic to
 visit a test suite structure, and the :mod:`~robot.result` package contains
@@ -80,19 +80,19 @@ Type hints
 
 Visitor methods have type hints to give more information about the model objects
 they receive to editors. Because visitors can be used with both running and result
-models, the types that are used are base classes from the :mod:`robot.model`
-module. Actual visitors may want to import appropriate types from
-:mod:`robot.running.model` or from :mod:`robot.result.model` modules instead.
-For example, this code that prints failed tests uses result side model objects::
+models, the types that are used as type hints are base classes from the
+:mod:`robot.model` module. Actual visitor implementations can import appropriate
+types from the :mod:`robot.running` or the :mod:`robot.result` module instead.
+For example, this visitor uses the result side model objects::
 
     from robot.api import SuiteVisitor
-    from robot.result.model import TestCase, TestSuite
+    from robot.result import TestCase, TestSuite
 
 
     class FailurePrinter(SuiteVisitor):
 
         def start_suite(self, suite: TestSuite):
-            print(f"{suite.longname}: {suite.statistics.failed} failed")
+            print(f"{suite.full_name}: {suite.statistics.failed} failed")
 
         def visit_test(self, test: TestCase):
             if test.failed:
@@ -107,7 +107,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from robot.model import (Break, BodyItem, Continue, Error, For, If, IfBranch,
                              Keyword, Message, Return, TestCase, TestSuite, Try,
-                             TryBranch, While)
+                             TryBranch, Var, While)
     from robot.result import ForIteration, WhileIteration
 
 
@@ -178,10 +178,15 @@ class SuiteVisitor:
         the body of the keyword
         """
         if self.start_keyword(keyword) is not False:
+            self._possible_setup(keyword)
             self._possible_body(keyword)
             self._possible_teardown(keyword)
             self.end_keyword(keyword)
 
+    def _possible_setup(self, item: 'BodyItem'):
+        if getattr(item, 'has_setup', False):
+            item.setup.visit(self)    # type: ignore
+
     def _possible_body(self, item: 'BodyItem'):
         if hasattr(item, 'body'):
             item.body.visit(self)    # type: ignore
@@ -422,6 +427,28 @@ class SuiteVisitor:
         """
         self.end_body_item(iteration)
 
+    def visit_var(self, var: 'Var'):
+        """Visits a VAR elements."""
+        if self.start_var(var) is not False:
+            self._possible_body(var)
+            self.end_var(var)
+
+    def start_var(self, var: 'Var') -> 'bool|None':
+        """Called when a VAR element starts.
+
+        By default, calls :meth:`start_body_item` which, by default, does nothing.
+
+        Can return explicit ``False`` to stop visiting.
+        """
+        return self.start_body_item(var)
+
+    def end_var(self, var: 'Var'):
+        """Called when a VAR element ends.
+
+        By default, calls :meth:`end_body_item` which, by default, does nothing.
+        """
+        self.end_body_item(var)
+
     def visit_return(self, return_: 'Return'):
         """Visits a RETURN elements."""
         if self.start_return(return_) is not False:

robotframework-7.0a1/src/robot/output/console/dotted.py

@@ -0,0 +1,90 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import sys
+
+from robot.model import SuiteVisitor
+from robot.result import TestCase, TestSuite
+from robot.utils import plural_or_not as s, secs_to_timestr
+
+from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
+
+
+class DottedOutput(LoggerApi):
+
+    def __init__(self, width=78, colors='AUTO', stdout=None, stderr=None):
+        self.width = width
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self.markers_on_row = 0
+
+    def start_suite(self, data, result):
+        if not data.parent:
+            count = data.test_count
+            ts = ('test' if not data.rpa else 'task') + s(count)
+            self.stdout.write(f"Running suite '{result.name}' with {count} {ts}.\n")
+            self.stdout.write('=' * self.width + '\n')
+
+    def end_test(self, data, result):
+        if self.markers_on_row == self.width:
+            self.stdout.write('\n')
+            self.markers_on_row = 0
+        self.markers_on_row += 1
+        if result.passed:
+            self.stdout.write('.')
+        elif result.skipped:
+            self.stdout.highlight('s', 'SKIP')
+        elif result.tags.robot('exit'):
+            self.stdout.write('x')
+        else:
+            self.stdout.highlight('F', 'FAIL')
+
+    def end_suite(self, data, result):
+        if not data.parent:
+            self.stdout.write('\n')
+            StatusReporter(self.stdout, self.width).report(result)
+            self.stdout.write('\n')
+
+    def message(self, msg):
+        if msg.level in ('WARN', 'ERROR'):
+            self.stderr.error(msg.message, msg.level)
+
+    def output_file(self, name, path):
+        self.stdout.write(f"{name+':':8} {path}\n")
+
+
+class StatusReporter(SuiteVisitor):
+
+    def __init__(self, stream, width):
+        self.stream = stream
+        self.width = width
+
+    def report(self, suite: TestSuite):
+        suite.visit(self)
+        stats = suite.statistics
+        ts = ('test' if not suite.rpa else 'task') + s(stats.total)
+        elapsed = secs_to_timestr(suite.elapsed_time)
+        self.stream.write(f"{'=' * self.width}\nRun suite '{suite.name}' with "
+                          f"{stats.total} {ts} in {elapsed}.\n\n")
+        ed = 'ED' if suite.status != 'SKIP' else 'PED'
+        self.stream.highlight(suite.status + ed, suite.status)
+        self.stream.write(f'\n{stats.message}\n')
+
+    def visit_test(self, test: TestCase):
+        if test.failed and not test.tags.robot('exit'):
+            self.stream.write('-' * self.width + '\n')
+            self.stream.highlight('FAIL')
+            self.stream.write(f': {test.full_name}\n{test.message.strip()}\n')

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/output/console/quiet.py

@@ -16,9 +16,10 @@
 import sys
 
 from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
 
 
-class QuietOutput:
+class QuietOutput(LoggerApi):
 
     def __init__(self, colors='AUTO', stderr=None):
         self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
@@ -28,5 +29,5 @@ class QuietOutput:
             self._stderr.error(msg.message, msg.level)
 
 
-class NoOutput:
+class NoOutput(LoggerApi):
     pass