robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/result/modeldeprecation.py

@@ -13,28 +13,34 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import warnings
+
 from robot.model import Tags
 
 
 def deprecated(method):
     def wrapper(self, *args, **kws):
         """Deprecated."""
+        warnings.warn(f"'robot.result.{type(self).__name__}.{method.__name__}' is "
+                      f"deprecated and will be removed in Robot Framework 8.0.",
+                      stacklevel=1)
         return method(self, *args, **kws)
     return wrapper
 
 
 class DeprecatedAttributesMixin:
     __slots__ = []
+    _log_name = ''
 
     @property
     @deprecated
     def name(self):
-        return ''
+        return self._log_name
 
     @property
     @deprecated
     def kwname(self):
-        return self.name
+        return self._log_name
 
     @property
     @deprecated
@@ -63,5 +69,5 @@ class DeprecatedAttributesMixin:
 
     @property
     @deprecated
-    def message(self):
+    def doc(self):
         return ''

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/result/resultbuilder.py

@@ -13,35 +13,43 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from pathlib import Path
+
 from robot.errors import DataError
 from robot.model import SuiteVisitor
 from robot.utils import ET, ETSource, get_error_message
 
-from .executionresult import Result, CombinedResult
-from .flattenkeywordmatcher import (FlattenByNameMatcher, FlattenByTypeMatcher,
-                                    FlattenByTagMatcher)
+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
 
 
 def ExecutionResult(*sources, **options):
     """Factory method to constructs :class:`~.executionresult.Result` objects.
 
-    :param sources: XML source(s) containing execution results.
-        Can be specified as paths, opened file objects, or strings/bytes
-        containing XML directly. Support for bytes is new in RF 3.2.
+    :param sources: XML or JSON source(s) containing execution results.
+        Can be specified as paths (``pathlib.Path`` or ``str``), opened file
+        objects, or strings/bytes containing XML/JSON directly.
     :param options: Configuration options.
         Using ``merge=True`` causes multiple results to be combined so that
         tests in the latter results replace the ones in the original.
         Setting ``rpa`` either to ``True`` (RPA mode) or ``False`` (test
-        automation) sets execution mode explicitly. By default it is got
+        automation) sets execution mode explicitly. By default, it is got
         from processed output files and conflicting modes cause an error.
         Other options are passed directly to the
         :class:`ExecutionResultBuilder` object used internally.
     :returns: :class:`~.executionresult.Result` instance.
 
-    Should be imported by external code via the :mod:`robot.api` package.
-    See the :mod:`robot.result` package for a usage example.
+    A source is considered to be JSON in these cases:
+    - It is a path with a ``.json`` suffix.
+    - It is an open file that has a ``name`` attribute with a ``.json`` suffix.
+    - It is string or bytes starting with ``{`` and ending with ``}``.
+
+    This method should be imported by external code via the :mod:`robot.api`
+    package. See the :mod:`robot.result` package for a usage example.
     """
     if not sources:
         raise DataError('One or more data source needed.')
@@ -66,13 +74,27 @@ def _combine_results(sources, options):
 
 
 def _single_result(source, options):
+    if is_json_source(source):
+        return _json_result(source, options)
+    return _xml_result(source, options)
+
+
+def _json_result(source, options):
+    try:
+        suite = TestSuite.from_json(source)
+    except Exception:
+        raise DataError(f"Reading JSON source '{source}' failed: {get_error_message()}")
+    return Result(source, suite, rpa=options.pop('rpa', None))
+
+
+def _xml_result(source, options):
     ets = ETSource(source)
     result = Result(source, rpa=options.pop('rpa', None))
     try:
         return ExecutionResultBuilder(ets, **options).build(result)
     except IOError as err:
         error = err.strerror
-    except:
+    except Exception:
         error = get_error_message()
     raise DataError(f"Reading XML source '{ets}' failed: {error}")
 
@@ -106,6 +128,10 @@ class ExecutionResultBuilder:
         with self._source as source:
             self._parse(source, handler.start, handler.end)
         result.handle_suite_teardown_failures()
+        if self._flattened_keywords:
+            # Tags are nowadays written after keyword content, so we cannot
+            # flatten based on them when parsing output.xml.
+            result.suite.visit(FlattenByTags(self._flattened_keywords))
         if not self._include_keywords:
             result.suite.visit(RemoveKeywords())
         return result
@@ -143,49 +169,33 @@ class ExecutionResultBuilder:
         # Performance optimized. Do not change without profiling!
         name_match, by_name = self._get_matcher(FlattenByNameMatcher, flattened)
         type_match, by_type = self._get_matcher(FlattenByTypeMatcher, flattened)
-        tags_match, by_tags = self._get_matcher(FlattenByTagMatcher, flattened)
-        started = -1  # if 0 or more, we are flattening
+        started = -1    # if 0 or more, we are flattening
         tags = []
         containers = {'kw', 'for', 'while', 'iter', 'if', 'try'}
-        inside_kw = 0  # to make sure we don't read tags from a test
-        seen_doc = False
+        inside = 0    # to make sure we don't read tags from a test
         for event, elem in context:
             tag = elem.tag
-            start = event == 'start'
-            end = not start
-            if start:
+            if event == 'start':
                 if tag in containers:
-                    inside_kw += 1
+                    inside += 1
                     if started >= 0:
                         started += 1
-                    elif by_name and name_match(elem.get('name', ''), elem.get('library')):
+                    elif by_name and name_match(elem.get('name', ''), elem.get('owner')
+                                                or elem.get('library')):
                         started = 0
-                        seen_doc = False
                     elif by_type and type_match(tag):
                         started = 0
-                        seen_doc = False
                     tags = []
             else:
                 if tag in containers:
-                    inside_kw -= 1
-                    if started == 0 and not seen_doc:
-                        doc = ET.Element('doc')
-                        doc.text = '_*Content flattened.*_'
-                        yield 'start', doc
-                        yield 'end', doc
-                elif by_tags and inside_kw and started < 0 and tag == 'tag':
-                    tags.append(elem.text or '')
-                    if tags_match(tags):
-                        started = 0
-                        seen_doc = False
-                elif started == 0 and tag == 'doc':
-                    seen_doc = True
-                    elem.text = f"{elem.text or ''}\n\n_*Content flattened.*_".strip()
+                    inside -= 1
+                elif started == 0 and tag == 'status':
+                    elem.text = create_flatten_message(elem.text)
             if started <= 0 or tag == 'msg':
                 yield event, elem
             else:
                 elem.clear()
-            if started >= 0 and end and tag in containers:
+            if started >= 0 and event == 'end' and tag in containers:
                 started -= 1
 
     def _get_matcher(self, matcher_class, flattened):

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/result/xmlelementhandlers.py

@@ -13,6 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import datetime
+
 from robot.errors import DataError
 
 
@@ -47,8 +49,6 @@ class ElementHandler:
 
     def get_child_handler(self, tag):
         if tag not in self.children:
-            if not self.tag:
-                raise DataError(f"Incompatible root element '{tag}'.")
             raise DataError(f"Incompatible child element '{tag}' for '{self.tag}'.")
         return self.element_handlers[tag]
 
@@ -58,13 +58,23 @@ class ElementHandler:
     def end(self, elem, result):
         pass
 
-    def _timestamp(self, elem, attr_name):
-        timestamp = elem.get(attr_name)
-        return timestamp if timestamp != 'N/A' else None
+    def _legacy_timestamp(self, elem, attr_name):
+        ts = elem.get(attr_name)
+        if ts == 'N/A' or not ts:
+            return None
+        ts = ts.ljust(24, '0')
+        return datetime(int(ts[:4]), int(ts[4:6]), int(ts[6:8]),
+                        int(ts[9:11]), int(ts[12:14]), int(ts[15:17]), int(ts[18:24]))
 
 
 class RootHandler(ElementHandler):
-    children = frozenset(('robot',))
+    children = frozenset(('robot', 'suite'))
+
+    def get_child_handler(self, tag):
+        try:
+            return super().get_child_handler(tag)
+        except DataError:
+            raise DataError(f"Incompatible root element '{tag}'.")
 
 
 @ElementHandler.register
@@ -106,7 +116,8 @@ class TestHandler(ElementHandler):
     tag = 'test'
     # 'tags' is for RF < 4 compatibility.
     children = frozenset(('doc', 'tags', 'tag', 'timeout', 'status', 'kw', 'if', 'for',
-                          'try', 'while', 'return', 'break', 'continue', 'error', 'msg'))
+                          'try', 'while', 'variable', 'return', 'break', 'continue',
+                          'error', 'msg'))
 
     def start(self, elem, result):
         lineno = elem.get('line')
@@ -121,7 +132,7 @@ 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', 'return', 'break', 'continue', 'error'))
+                          'while', 'variable', 'return', 'break', 'continue', 'error'))
 
     def start(self, elem, result):
         elem_type = elem.get('type')
@@ -136,9 +147,15 @@ class KeywordHandler(ElementHandler):
             body = result.body
         except AttributeError:
             body = self._get_body_for_suite_level_keyword(result)
-        return body.create_keyword(kwname=elem.get('name', ''),
-                                   libname=elem.get('library'),
-                                   sourcename=elem.get('sourcename'))
+        return body.create_keyword(**self._get_keyword_attrs(elem))
+
+    def _get_keyword_attrs(self, elem):
+        # 'library' and 'sourcename' are RF < 7 compatibility.
+        return {
+            'name': elem.get('name', ''),
+            'owner': elem.get('owner') or elem.get('library'),
+            'source_name': elem.get('source_name') or elem.get('sourcename')
+        }
 
     def _get_body_for_suite_level_keyword(self, result):
         # Someone, most likely a listener, has created a `<kw>` element on suite level.
@@ -149,24 +166,22 @@ class KeywordHandler(ElementHandler):
         kw_type = 'teardown' if result.tests or result.suites else 'setup'
         keyword = getattr(result, kw_type)
         if not keyword:
-            keyword.config(kwname=f'Implicit {kw_type}', status=keyword.PASS)
+            keyword.config(name=f'Implicit {kw_type}', status=keyword.PASS)
         return keyword.body
 
     def _create_setup(self, elem, result):
-        return result.setup.config(kwname=elem.get('name', ''),
-                                   libname=elem.get('library'))
+        return result.setup.config(**self._get_keyword_attrs(elem))
 
     def _create_teardown(self, elem, result):
-        return result.teardown.config(kwname=elem.get('name', ''),
-                                      libname=elem.get('library'))
+        return result.teardown.config(**self._get_keyword_attrs(elem))
 
     # RF < 4 compatibility.
 
     def _create_for(self, elem, result):
-        return result.body.create_keyword(kwname=elem.get('name'), type='FOR')
+        return result.body.create_keyword(name=elem.get('name'), type='FOR')
 
     def _create_foritem(self, elem, result):
-        return result.body.create_keyword(kwname=elem.get('name'), type='ITERATION')
+        return result.body.create_keyword(name=elem.get('name'), type='ITERATION')
 
     _create_iteration = _create_foritem
 
@@ -201,7 +216,7 @@ class WhileHandler(ElementHandler):
 class IterationHandler(ElementHandler):
     tag = 'iter'
     children = frozenset(('var', 'doc', 'status', 'kw', 'if', 'for', 'msg', 'try',
-                          'while', 'return', 'break', 'continue', 'error'))
+                          'while', 'variable', 'return', 'break', 'continue', 'error'))
 
     def start(self, elem, result):
         return result.body.create_iteration()
@@ -220,9 +235,11 @@ class IfHandler(ElementHandler):
 class BranchHandler(ElementHandler):
     tag = 'branch'
     children = frozenset(('status', 'kw', 'if', 'for', 'try', 'while', 'msg', 'doc',
-                          'return', 'pattern', 'break', 'continue', 'error'))
+                          'variable', 'return', 'pattern', 'break', 'continue', 'error'))
 
     def start(self, elem, result):
+        if 'variable' in elem.attrib:    # RF < 7.0 compatibility.
+            elem.attrib['assign'] = elem.attrib.pop('variable')
         return result.body.create_branch(**elem.attrib)
 
 
@@ -244,10 +261,21 @@ class PatternHandler(ElementHandler):
         result.patterns += (elem.text or '',)
 
 
+@ElementHandler.register
+class VariableHandler(ElementHandler):
+    tag = 'variable'
+    children = frozenset(('var', 'status', 'msg', 'kw'))
+
+    def start(self, elem, result):
+        return result.body.create_var(name=elem.get('name', ''),
+                                      scope=elem.get('scope'),
+                                      separator=elem.get('separator'))
+
+
 @ElementHandler.register
 class ReturnHandler(ElementHandler):
     tag = 'return'
-    children = frozenset(('status', 'value', 'msg', 'kw'))
+    children = frozenset(('value', 'status', 'msg', 'kw'))
 
     def start(self, elem, result):
         return result.body.create_return()
@@ -285,11 +313,23 @@ class MessageHandler(ElementHandler):
     tag = 'msg'
 
     def end(self, elem, result):
-        html_true = ('true', 'yes')    # 'yes' is compatibility for RF < 4.
-        result.body.create_message(elem.text or '',
-                                   elem.get('level', 'INFO'),
-                                   elem.get('html') in html_true,
-                                   self._timestamp(elem, 'timestamp'))
+        self._create_message(elem, result.body.create_message)
+
+    def _create_message(self, elem, creator):
+        if 'time' in elem.attrib:    # RF >= 7
+            timestamp = elem.attrib['time']
+        else:                        # RF < 7
+            timestamp = self._legacy_timestamp(elem, 'timestamp')
+        creator(elem.text or '',
+                elem.get('level', 'INFO'),
+                elem.get('html') in ('true', 'yes'),   # 'yes' is RF < 4 compatibility
+                timestamp)
+
+
+class ErrorMessageHandler(MessageHandler):
+
+    def end(self, elem, result):
+        self._create_message(elem, result.messages.create)
 
 
 @ElementHandler.register
@@ -302,8 +342,12 @@ class StatusHandler(ElementHandler):
     def end(self, elem, result):
         if self.set_status:
             result.status = elem.get('status', 'FAIL')
-        result.starttime = self._timestamp(elem, 'starttime')
-        result.endtime = self._timestamp(elem, 'endtime')
+        if 'start' in elem.attrib:    # RF >= 7
+            result.start_time = elem.attrib['start']
+            result.elapsed_time = float(elem.attrib['elapsed'])
+        else:                         # RF < 7
+            result.start_time = self._legacy_timestamp(elem, 'starttime')
+            result.end_time = self._legacy_timestamp(elem, 'endtime')
         if elem.text:
             result.message = elem.text
 
@@ -313,7 +357,13 @@ class DocHandler(ElementHandler):
     tag = 'doc'
 
     def end(self, elem, result):
-        result.doc = elem.text or ''
+        try:
+            result.doc = elem.text or ''
+        except AttributeError:
+            # With RF < 7 control structures can have `<doc>` containing information
+            # about flattening or removing date. Nowadays, they don't have `doc`
+            # attribute at all and `message` is used for this information.
+            result.message = elem.text or ''
 
 
 @ElementHandler.register
@@ -372,12 +422,12 @@ class VarHandler(ElementHandler):
 
     def end(self, elem, result):
         value = elem.text or ''
-        if result.type == result.KEYWORD:
+        if result.type in (result.KEYWORD, result.FOR):
             result.assign += (value,)
-        elif result.type == result.FOR:
-            result.variables += (value,)
         elif result.type == result.ITERATION:
-            result.variables[elem.get('name')] = value
+            result.assign[elem.get('name')] = value
+        elif result.type == result.VAR:
+            result.value += (value,)
         else:
             raise DataError(f"Invalid element '{elem}' for result '{result!r}'.")
 
@@ -415,16 +465,6 @@ class ErrorsHandler(ElementHandler):
         return ErrorMessageHandler()
 
 
-class ErrorMessageHandler(ElementHandler):
-
-    def end(self, elem, result):
-        html_true = ('true', 'yes')    # 'yes' is compatibility for RF < 4.
-        result.messages.create(elem.text or '',
-                               elem.get('level', 'INFO'),
-                               elem.get('html') in html_true,
-                               self._timestamp(elem, 'timestamp'))
-
-
 @ElementHandler.register
 class StatisticsHandler(ElementHandler):
     tag = 'statistics'

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/run.py

@@ -176,6 +176,8 @@ Options
                           can also be further processed with Rebot tool. Can be
                           disabled by giving a special value `NONE`.
                           Default: output.xml
+    --legacyoutput        Create XML output file in format compatible with
+                          Robot Framework 6.x and earlier.
  -l --log file            HTML log file. Can be disabled by giving a special
                           value `NONE`. Default: log.html
                           Examples: `--log mylog.html`, `-l NONE`
@@ -444,11 +446,11 @@ class RobotFramework(Application):
                                    lang=settings.languages,
                                    allow_empty_suite=settings.run_empty_suite)
         suite = builder.build(*datasources)
-        settings.rpa = suite.rpa
         if settings.pre_run_modifiers:
             suite.visit(ModelModifier(settings.pre_run_modifiers,
                                       settings.run_empty_suite, LOGGER))
         suite.configure(**settings.suite_config)
+        settings.rpa = suite.validate_execution_mode()
         with pyloggingconf.robot_handler_enabled(settings.log_level):
             old_max_error_lines = text.MAX_ERROR_LINES
             old_max_assign_length = text.MAX_ASSIGN_LENGTH

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/running/__init__.py

@@ -32,6 +32,12 @@ The public API of this module consists of the following objects:
   :mod:`robot.running.model` module. These classes are typically only needed
   in type hints.
 
+* Keyword implementation related classes :class:`~robot.running.resourcemodel.UserKeyword`,
+  :class:`~robot.running.librarykeyword.LibraryKeyword`,
+  :class:`~robot.running.invalidkeyword.InvalidKeyword` and their common base class
+  :class:`~robot.running.keywordimplementation.KeywordImplementation`. Also these
+  classes are mainly needed in type hints.
+
 * :class:`~robot.running.builder.settings.TestDefaults` that is part of the
   `external parsing API`__ and also typically needed only in type hints.
 
@@ -43,6 +49,7 @@ the :mod:`robot.api` package.
 
 .. note:: Prior to Robot Framework 6.1, only some classes in
           :mod:`robot.running.model` were exposed via :mod:`robot.running`.
+          Keyword implementation related classes are new in Robot Framework 7.0.
 
 Examples
 --------
@@ -110,9 +117,12 @@ the results is possible using the
 from .arguments import ArgInfo, ArgumentSpec, TypeConverter, TypeInfo
 from .builder import ResourceFileBuilder, TestDefaults, TestSuiteBuilder
 from .context import EXECUTION_CONTEXTS
-from .model import (Break, Continue, Error, For, If, IfBranch, Keyword, Return,
-                    TestCase, TestSuite, Try, TryBranch, While)
+from .keywordimplementation import KeywordImplementation
+from .invalidkeyword import InvalidKeyword
+from .librarykeyword import LibraryKeyword
+from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
+                    Return, TestCase, TestSuite, Try, TryBranch, Var, While,
+                    WhileIteration)
+from .resourcemodel import ResourceFile, UserKeyword
 from .runkwregister import RUN_KW_REGISTER
 from .testlibraries import TestLibrary
-from .usererrorhandler import UserErrorHandler
-from .userkeyword import UserLibrary

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/running/arguments/__init__.py

@@ -16,7 +16,8 @@
 from .argumentmapper import DefaultValue
 from .argumentparser import (DynamicArgumentParser, PythonArgumentParser,
                              UserKeywordArgumentParser)
-from .argumentspec import ArgInfo, ArgumentSpec, TypeInfo
+from .argumentspec import ArgInfo, ArgumentSpec
 from .embedded import EmbeddedArguments
 from .customconverters import CustomArgumentConverters
 from .typeconverters import TypeConverter
+from .typeinfo import TypeInfo

robotframework-7.0/src/robot/running/arguments/argumentconverter.py

@@ -0,0 +1,100 @@
+#  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.
+
+from typing import TYPE_CHECKING
+
+from robot.variables import contains_variable
+
+from .typeinfo import TypeInfo
+
+if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
+
+    from .argumentspec import ArgumentSpec
+    from .customconverters import CustomArgumentConverters
+
+
+class ArgumentConverter:
+
+    def __init__(self, arg_spec: 'ArgumentSpec',
+                 custom_converters: 'CustomArgumentConverters',
+                 dry_run: bool = False,
+                 languages: 'LanguagesLike' = None):
+        self.spec = arg_spec
+        self.custom_converters = custom_converters
+        self.dry_run = dry_run
+        self.languages = languages
+
+    def convert(self, positional, named):
+        return self._convert_positional(positional), self._convert_named(named)
+
+    def _convert_positional(self, positional):
+        names = self.spec.positional
+        converted = [self._convert(name, value)
+                     for name, value in zip(names, positional)]
+        if self.spec.var_positional:
+            converted.extend(self._convert(self.spec.var_positional, value)
+                             for value in positional[len(names):])
+        return converted
+
+    def _convert_named(self, named):
+        names = set(self.spec.positional) | set(self.spec.named_only)
+        var_named = self.spec.var_named
+        return [(name, self._convert(name if name in names else var_named, value))
+                for name, value in named]
+
+    def _convert(self, name, value):
+        spec = self.spec
+        if (spec.types is None
+                or self.dry_run and contains_variable(value, identifiers='$@&%')):
+            return value
+        conversion_error = None
+        # Don't convert None if argument has None as a default value.
+        # Python < 3.11 adds None to type hints automatically when using None as
+        # a default value which preserves None automatically. This code keeps
+        # the same behavior also with newer Python versions. We can consider
+        # changing this once Python 3.11 is our minimum supported version.
+        if value is None and name in spec.defaults and spec.defaults[name] is None:
+            return value
+        # Primarily convert arguments based on type hints.
+        if name in spec.types:
+            info: TypeInfo = spec.types[name]
+            try:
+                return info.convert(value, name, self.custom_converters, self.languages)
+            except ValueError as err:
+                conversion_error = err
+            except TypeError:
+                pass
+        # Try conversion also based on the default value type. We probably should
+        # do this only if there is no explicit type hint, but Python < 3.11
+        # handling `arg: type = None` differently than newer versions would mean
+        # that conversion behavior depends on the Python version. Once Python 3.11
+        # is our minimum supported version, we can consider reopening
+        # https://github.com/robotframework/robotframework/issues/4881
+        if name in spec.defaults:
+            typ = type(spec.defaults[name])
+            if typ == str:      # Don't convert arguments to strings.
+                info = TypeInfo()
+            elif typ == int:    # Try also conversion to float.
+                info = TypeInfo.from_sequence([int, float])
+            else:
+                info = TypeInfo.from_type(typ)
+            try:
+                return info.convert(value, name, languages=self.languages)
+            except (ValueError, TypeError):
+                pass
+        if conversion_error:
+            raise conversion_error
+        return value