robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/result/model.py

@@ -55,20 +55,21 @@ from .suiteteardownfailed import SuiteTeardownFailed, SuiteTeardownFailureHandle
 IT = TypeVar('IT', bound='IfBranch|TryBranch')
 FW = TypeVar('FW', bound='ForIteration|WhileIteration')
 BodyItemParent = Union['TestSuite', 'TestCase', 'Keyword', 'For', 'ForIteration', 'If',
-                       'IfBranch', 'Try', 'TryBranch', 'While', 'WhileIteration', None]
+                       'IfBranch', 'Try', 'TryBranch', 'While', 'WhileIteration',
+                       'Group', None]
 
 
-class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+class Body(model.BaseBody['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var', 'Return',
                           'Continue', 'Break', 'Message', 'Error']):
     __slots__ = ()
 
 
-class Branches(model.BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+class Branches(model.BaseBranches['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var', 'Return',
                                   'Continue', 'Break', 'Message', 'Error', IT]):
     __slots__ = ()
 
 
-class Iterations(model.BaseIterations['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+class Iterations(model.BaseIterations['Keyword', 'For', 'While', 'Group', 'If', 'Try', 'Var', 'Return',
                                       'Continue', 'Break', 'Message', 'Error', FW]):
     __slots__ = ()
 
@@ -79,16 +80,10 @@ class Iterations(model.BaseIterations['Keyword', 'For', 'While', 'If', 'Try', 'V
 class Message(model.Message):
     __slots__ = ()
 
-    def to_dict(self) -> DataDict:
-        data: DataDict = {
-            'type': self.type,
-            'message': self.message,
-            'level': self.level,
-            'html': self.html,
-        }
-        if self.timestamp:
-            data['timestamp'] = self.timestamp.isoformat()
-        return data
+    def to_dict(self, include_type=True) -> DataDict:
+        if not include_type:
+            return super().to_dict()
+        return {'type': self.type, **super().to_dict()}
 
 
 class StatusMixin:
@@ -407,6 +402,33 @@ class While(model.While, StatusMixin, DeprecatedAttributesMixin):
         return {**super().to_dict(), **StatusMixin.to_dict(self)}
 
 
+@Body.register
+class Group(model.Group, StatusMixin, DeprecatedAttributesMixin):
+    body_class = Body
+    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
+
+    def __init__(self, name: str = '',
+                 status: str = 'FAIL',
+                 message: str = '',
+                 start_time: 'datetime|str|None' = None,
+                 end_time: 'datetime|str|None' = None,
+                 elapsed_time: 'timedelta|int|float|None' = None,
+                 parent: BodyItemParent = None):
+        super().__init__(name, parent)
+        self.status = status
+        self.message = message
+        self.start_time = start_time
+        self.end_time = end_time
+        self.elapsed_time = elapsed_time
+
+    @property
+    def _log_name(self):
+        return self.name
+
+    def to_dict(self) -> DataDict:
+        return {**super().to_dict(), **StatusMixin.to_dict(self)}
+
+
 class IfBranch(model.IfBranch, StatusMixin, DeprecatedAttributesMixin):
     body_class = Body
     __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
@@ -740,10 +762,10 @@ class Keyword(model.Keyword, StatusMixin):
 
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
-        """Possible keyword body as a :class:`~.Body` object.
+        """Keyword body as a :class:`~.Body` object.
 
         Body can consist of child keywords, messages, and control structures
-        such as IF/ELSE. Library keywords typically have an empty body.
+        such as IF/ELSE.
         """
         return self.body_class(self, body)
 
@@ -936,7 +958,12 @@ class TestCase(model.TestCase[Keyword], StatusMixin):
         return self.body_class(self, body)
 
     def to_dict(self) -> DataDict:
-        return {**super().to_dict(), **StatusMixin.to_dict(self)}
+        return {'id': self.id, **super().to_dict(), **StatusMixin.to_dict(self)}
+
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'TestCase':
+        data.pop('id', None)
+        return super().from_dict(data)
 
 
 class TestSuite(model.TestSuite[Keyword, TestCase], StatusMixin):
@@ -1089,7 +1116,52 @@ class TestSuite(model.TestSuite[Keyword, TestCase], StatusMixin):
         self.visit(SuiteTeardownFailed(message, skipped=True))
 
     def to_dict(self) -> DataDict:
-        return {**super().to_dict(), **StatusMixin.to_dict(self)}
+        return {'id': self.id, **super().to_dict(), **StatusMixin.to_dict(self)}
+
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'TestSuite':
+        """Create suite based on result data in a dictionary.
+
+        ``data`` can either contain only the suite data got, for example, from
+        the :meth:`to_dict` method, or it can contain full result data with
+        execution errors and other such information in addition to the suite data.
+        In the latter case only the suite data is used, though.
+
+        Support for full result data is new in Robot Framework 7.2.
+        """
+        if 'suite' in data:
+            data = data['suite']
+        # `body` on the suite level means that a listener has logged something or
+        # executed a keyword in a `start/end_suite` method. Throwing such data
+        # away isn't great, but it's better than data being invalid and properly
+        # handling it would be complicated. We handle such XML outputs (see
+        # `xmlelementhandlers`), but with JSON there can even be one `body` in
+        # the beginning and other at the end, and even preserving them both
+        # would be hard.
+        data.pop('body', None)
+        data.pop('id', None)
+        return super().from_dict(data)
+
+    @classmethod
+    def from_json(cls, source: 'str|bytes|TextIO|Path') -> 'TestSuite':
+        """Create suite based on results in JSON.
+
+        The data is given as the ``source`` parameter. It can be:
+
+        - a string containing the data directly,
+        - an open file object where to read the data from, or
+        - a path (``pathlib.Path`` or string) to a UTF-8 encoded file to read.
+
+        Supports JSON produced by :meth:`to_json` that contains only the suite
+        information, as well as full result JSON that contains also execution
+        errors and other information. In the latter case errors and all other
+        information is silently ignored, though. If that is a problem,
+        :class:`~robot.result.resultbuilder.ExecutionResult` should be used
+        instead.
+
+        Support for full result JSON is new in Robot Framework 7.2.
+        """
+        return super().from_json(source)
 
     @overload
     def to_xml(self, file: None = None) -> str:

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/result/resultbuilder.py

@@ -21,7 +21,6 @@ from .executionresult import CombinedResult, is_json_source, Result
 from .flattenkeywordmatcher import (create_flatten_message, FlattenByNameMatcher,
                                     FlattenByTypeMatcher, FlattenByTags)
 from .merger import Merger
-from .model import TestSuite
 from .xmlelementhandlers import XmlElementHandler
 
 
@@ -79,13 +78,11 @@ def _single_result(source, options):
 
 def _json_result(source, options):
     try:
-        suite = TestSuite.from_json(source)
+        return Result.from_json(source, rpa=options.get('rpa'))
     except IOError as err:
         error = err.strerror
     except Exception:
         error = get_error_message()
-    else:
-        return Result(source, suite, rpa=options.pop('rpa', None))
     raise DataError(f"Reading JSON source '{source}' failed: {error}")
 
 
@@ -102,7 +99,7 @@ def _xml_result(source, options):
 
 
 class ExecutionResultBuilder:
-    """Builds :class:`~.executionresult.Result` objects based on output files.
+    """Builds :class:`~.executionresult.Result` objects based on XML output files.
 
     Instead of using this builder directly, it is recommended to use the
     :func:`ExecutionResult` factory method.

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/result/xmlelementhandlers.py

@@ -86,8 +86,7 @@ class RobotHandler(ElementHandler):
     children = frozenset(('suite', 'statistics', 'errors'))
 
     def start(self, elem, result):
-        generator = elem.get('generator', 'unknown').split()[0].upper()
-        result.generated_by_robot = generator == 'ROBOT'
+        result.generator = elem.get('generator', 'unknown')
         result.generation_time = self._parse_generation_time(elem.get('generated'))
         if result.rpa is None:
             result.rpa = elem.get('rpa', 'false') == 'true'
@@ -120,7 +119,7 @@ class SuiteHandler(ElementHandler):
     def get_child_handler(self, tag):
         if tag == 'status':
             return StatusHandler(set_status=False)
-        return ElementHandler.get_child_handler(self, tag)
+        return super().get_child_handler(tag)
 
 
 @ElementHandler.register
@@ -128,7 +127,7 @@ class TestHandler(ElementHandler):
     tag = 'test'
     # 'tags' is for RF < 4 compatibility.
     children = frozenset(('doc', 'tags', 'tag', 'timeout', 'status', 'kw', 'if', 'for',
-                          'try', 'while', 'variable', 'return', 'break', 'continue',
+                          'try', 'while', 'group', 'variable', 'return', 'break', 'continue',
                           'error', 'msg'))
 
     def start(self, elem, result):
@@ -144,7 +143,8 @@ class KeywordHandler(ElementHandler):
     # 'arguments', 'assign' and 'tags' are for RF < 4 compatibility.
     children = frozenset(('doc', 'arguments', 'arg', 'assign', 'var', 'tags', 'tag',
                           'timeout', 'status', 'msg', 'kw', 'if', 'for', 'try',
-                          'while', 'variable', 'return', 'break', 'continue', 'error'))
+                          'while', 'group', 'variable', 'return', 'break', 'continue',
+                          'error'))
 
     def start(self, elem, result):
         elem_type = elem.get('type')
@@ -228,12 +228,22 @@ class WhileHandler(ElementHandler):
 class IterationHandler(ElementHandler):
     tag = 'iter'
     children = frozenset(('var', 'doc', 'status', 'kw', 'if', 'for', 'msg', 'try',
-                          'while', 'variable', 'return', 'break', 'continue', 'error'))
+                          'while', 'group', 'variable', 'return', 'break', 'continue', 'error'))
 
     def start(self, elem, result):
         return result.body.create_iteration()
 
 
+@ElementHandler.register
+class GroupHandler(ElementHandler):
+    tag = 'group'
+    children = frozenset(('status', 'kw', 'if', 'for', 'try', 'while', 'group', 'msg',
+                          'variable', 'return', 'break', 'continue', 'error'))
+
+    def start(self, elem, result):
+        return result.body.create_group(name=elem.get('name', ''))
+
+
 @ElementHandler.register
 class IfHandler(ElementHandler):
     tag = 'if'
@@ -246,8 +256,9 @@ class IfHandler(ElementHandler):
 @ElementHandler.register
 class BranchHandler(ElementHandler):
     tag = 'branch'
-    children = frozenset(('status', 'kw', 'if', 'for', 'try', 'while', 'msg', 'doc',
-                          'variable', 'return', 'pattern', 'break', 'continue', 'error'))
+    children = frozenset(('status', 'kw', 'if', 'for', 'try', 'while', 'group', 'msg',
+                          'doc', 'variable', 'return', 'pattern', 'break', 'continue',
+                          'error'))
 
     def start(self, elem, result):
         if 'variable' in elem.attrib:    # RF < 7.0 compatibility.
@@ -314,7 +325,7 @@ class BreakHandler(ElementHandler):
 @ElementHandler.register
 class ErrorHandler(ElementHandler):
     tag = 'error'
-    children = frozenset(('status', 'msg', 'value'))
+    children = frozenset(('status', 'msg', 'value', 'kw'))
 
     def start(self, elem, result):
         return result.body.create_error()

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/run.py

@@ -31,13 +31,14 @@ that can be used programmatically. Other code is for internal usage.
 """
 
 import sys
+from threading import current_thread
 
 if __name__ == '__main__' and 'robot' not in sys.modules:
     import pythonpathsetter
 
 from robot.conf import RobotSettings
 from robot.model import ModelModifier
-from robot.output import LOGGER, pyloggingconf
+from robot.output import librarylogger, LOGGER, pyloggingconf
 from robot.reporting import ResultWriter
 from robot.running.builder import TestSuiteBuilder
 from robot.utils import Application, text
@@ -238,7 +239,6 @@ Options
                           pattern. Documentation is shown in `Test Details` and
                           also as a tooltip in `Statistics by Tag`. Pattern can
                           use `*`, `?` and `[]` as wildcards like --test.
-                          Documentation can contain formatting like --doc.
                           Examples: --tagdoc mytag:Example
                                     --tagdoc "owner-*:Original author"
     --tagstatlink pattern:link:title *  Add external links into `Statistics by
@@ -403,6 +403,17 @@ ROBOT_SYSLOG_LEVEL        Log level to use when writing to the syslog file.
 ROBOT_INTERNAL_TRACES     When set to any non-empty value, Robot Framework's
                           internal methods are included in error tracebacks.
 
+Return Codes
+============
+
+0                         All tests passed.
+1-249                     Returned number of tests failed.
+250                       250 or more failures.
+251                       Help or version information printed.
+252                       Invalid data or command line options.
+253                       Execution stopped by user.
+255                       Unexpected internal error.
+
 Examples
 ========
 
@@ -459,16 +470,17 @@ class RobotFramework(Application):
             old_max_assign_length = text.MAX_ASSIGN_LENGTH
             text.MAX_ERROR_LINES = settings.max_error_lines
             text.MAX_ASSIGN_LENGTH = settings.max_assign_length
+            librarylogger.LOGGING_THREADS[0] = current_thread().name
             try:
                 result = suite.run(settings)
             finally:
                 text.MAX_ERROR_LINES = old_max_error_lines
                 text.MAX_ASSIGN_LENGTH = old_max_assign_length
-            LOGGER.info("Tests execution ended. Statistics:\n%s"
-                        % result.suite.stat_message)
+                librarylogger.LOGGING_THREADS[0] = 'MainThread'
+            LOGGER.info(f"Tests execution ended. "
+                        f"Statistics:\n{result.suite.stat_message}")
             if settings.log or settings.report or settings.xunit:
-                writer = ResultWriter(settings.output if settings.log
-                                      else result)
+                writer = ResultWriter(settings.output if settings.log else result)
                 writer.write_results(settings.get_rebot_settings())
         return result.return_code
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/__init__.py

@@ -120,7 +120,7 @@ from .context import EXECUTION_CONTEXTS
 from .keywordimplementation import KeywordImplementation
 from .invalidkeyword import InvalidKeyword
 from .librarykeyword import LibraryKeyword
-from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
+from .model import (Break, Continue, Error, For, ForIteration, Group, If, IfBranch, Keyword,
                     Return, TestCase, TestSuite, Try, TryBranch, Var, While,
                     WhileIteration)
 from .resourcemodel import Import, ResourceFile, UserKeyword, Variable

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/arguments/embedded.py

@@ -68,7 +68,7 @@ class EmbeddedArguments:
 
 
 class EmbeddedArgumentParser:
-    _regexp_extension = re.compile(r'(?<!\\)\(\?.+\)')
+    _inline_flag = re.compile(r'\(\?[aiLmsux]+(-[imsx]+)?\)')
     _regexp_group_start = re.compile(r'(?<!\\)\((.*?)\)')
     _escaped_curly = re.compile(r'(\\+)([{}])')
     _regexp_group_escape = r'(?:\1)'
@@ -104,7 +104,7 @@ class EmbeddedArgumentParser:
         return name, pattern, custom
 
     def _format_custom_regexp(self, pattern: str) -> str:
-        for formatter in (self._regexp_extensions_are_not_allowed,
+        for formatter in (self._remove_inline_flags,
                           self._make_groups_non_capturing,
                           self._unescape_curly_braces,
                           self._escape_escapes,
@@ -112,10 +112,11 @@ class EmbeddedArgumentParser:
             pattern = formatter(pattern)
         return pattern
 
-    def _regexp_extensions_are_not_allowed(self, pattern: str) -> str:
-        if self._regexp_extension.search(pattern):
-            raise DataError('Regexp extensions are not allowed in embedded arguments.')
-        return pattern
+    def _remove_inline_flags(self, pattern: str) -> str:
+        # Inline flags are included in custom regexp stored separately, but they
+        # must be removed from the full pattern.
+        match = self._inline_flag.match(pattern)
+        return pattern if match is None else pattern[match.end():]
 
     def _make_groups_non_capturing(self, pattern: str) -> str:
         return self._regexp_group_start.sub(self._regexp_group_escape, pattern)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/arguments/typeconverters.py

@@ -51,7 +51,18 @@ class TypeConverter:
                  languages: 'Languages|None' = None):
         self.type_info = type_info
         self.custom_converters = custom_converters
-        self.languages = languages or Languages()
+        self.languages = languages
+
+    @property
+    def languages(self) -> Languages:
+        # Initialize only when needed to save time especially with Libdoc.
+        if self._languages is None:
+            self._languages = Languages()
+        return self._languages
+
+    @languages.setter
+    def languages(self, languages: 'Languages|None'):
+        self._languages = languages
 
     @classmethod
     def register(cls, converter: 'type[TypeConverter]') -> 'type[TypeConverter]':
@@ -749,7 +760,8 @@ class LiteralConverter(TypeConverter):
         return type_info.type is Literal
 
     def no_conversion_needed(self, value: Any) -> bool:
-        return False
+        return any(value == expected and type(value) is type(expected)
+                   for expected, _ in self.converters)
 
     def _handles_value(self, value):
         return True

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/arguments/typeinfo.py

@@ -175,8 +175,7 @@ class TypeInfo(metaclass=SetterAwareType):
         - a sequence of supported type hints to create a union from such as
           ``[int, float]`` or ``('int', 'list[int]')``
 
-        In special cases, for example with dictionaries or sequences, using the
-        more specialized methods like :meth:`from_dict` or :meth:`from_sequence`
+        In special cases using a more specialized method like :meth:`from_sequence`
         may be more appropriate than using this generic method.
         """
         if hint is NOT_SET:
@@ -283,6 +282,26 @@ class TypeInfo(metaclass=SetterAwareType):
             ``ValueError`` is conversion fails.
         :return: Converted value.
         """
+        converter = self.get_converter(custom_converters, languages)
+        return converter.convert(value, name, kind)
+
+    def get_converter(self,
+                      custom_converters: 'CustomArgumentConverters|dict|None' = None,
+                      languages: 'LanguagesLike' = None) -> TypeConverter:
+        """Get argument converter for this ``TypeInfo``.
+
+        :param custom_converters: Custom argument converters.
+        :param languages: Language configuration. During execution, uses the
+            current language configuration by default.
+        :raises: ``TypeError`` if there is no converter for this type.
+        :return: ``TypeConverter``.
+
+        The :meth:`convert` method handles the common conversion case, but this
+        method can be used if the converter is needed multiple times or its
+        needed also for other purposes than conversion.
+
+        New in Robot Framework 7.2.
+        """
         if isinstance(custom_converters, dict):
             custom_converters = CustomArgumentConverters.from_dict(custom_converters)
         if not languages and EXECUTION_CONTEXTS.current:
@@ -291,8 +310,8 @@ class TypeInfo(metaclass=SetterAwareType):
             languages = Languages(languages)
         converter = TypeConverter.converter_for(self, custom_converters, languages)
         if not converter:
-            raise TypeError(f"No converter found for '{self}'.")
-        return converter.convert(value, name, kind)
+            raise TypeError(f"Cannot convert type '{self}'.")
+        return converter
 
     def __str__(self):
         if self.is_union:

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/bodyrunner.py

@@ -56,9 +56,18 @@ class BodyRunner:
                 self._run = exception.can_continue(self._context, self._templated)
         if passed:
             raise passed
+        if errors and self._templated:
+            errors = self._handle_skip_with_templates(errors, result)
         if errors:
             raise ExecutionFailures(errors)
 
+    def _handle_skip_with_templates(self, errors, result):
+        if len(result.body) == 1 or not any(e.skip for e in errors):
+            return errors
+        if all(item.skipped for item in result.body):
+            raise ExecutionFailed('All iterations skipped.', skip=True)
+        return [e for e in errors if not e.skip]
+
 
 class KeywordRunner:
 
@@ -133,6 +142,8 @@ class ForInRunner:
                 if not failed.can_continue(self._context, self._templated):
                     break
         if errors:
+            if self._templated and len(errors) > 1 and all(e.skip for e in errors):
+                raise ExecutionFailed('All iterations skipped.', skip=True)
             raise ExecutionFailures(errors)
         return executed
 
@@ -452,6 +463,36 @@ class WhileRunner:
             raise DataError(f'Invalid WHILE loop condition: {msg}')
 
 
+class GroupRunner:
+
+    def __init__(self, context, run=True, templated=False):
+        self._context = context
+        self._run = run
+        self._templated = templated
+
+    def run(self, data, result):
+        if self._run:
+            error = self._initialize(data, result)
+            run = error is None
+        else:
+            error = None
+            run = False
+        with StatusReporter(data, result, self._context, run=run):
+            runner = BodyRunner(self._context, run, self._templated)
+            runner.run(data, result)
+            if error:
+                raise error
+
+    def _initialize(self, data, result):
+        if data.error:
+            return DataError(data.error, syntax=True)
+        try:
+            result.name = self._context.variables.replace_string(result.name)
+        except DataError as err:
+            return err
+        return None
+
+
 class IfRunner:
     _dry_run_stack = []
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/builder/settings.py

@@ -50,7 +50,8 @@ class TestDefaults:
     def __init__(self, parent: 'TestDefaults|None' = None,
                  setup: 'FixtureDict|None' = None,
                  teardown: 'FixtureDict|None' = None,
-                 tags: 'Sequence[str]' = (), timeout: 'str|None' = None):
+                 tags: 'Sequence[str]' = (),
+                 timeout: 'str|None' = None):
         self.parent = parent
         self.setup = setup
         self.teardown = teardown