robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → robotframework-7.0a1}/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.1.1 → robotframework-7.0a1}/src/robot/result/resultbuilder.py

@@ -15,7 +15,7 @@
 
 from robot.errors import DataError
 from robot.model import SuiteVisitor
-from robot.utils import ET, ETSource, get_error_message
+from robot.utils import ET, ETSource, get_error_message, html_escape
 
 from .executionresult import Result, CombinedResult
 from .flattenkeywordmatcher import (FlattenByNameMatcher, FlattenByTypeMatcher,
@@ -144,50 +144,48 @@ class ExecutionResultBuilder:
         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':
+                    inside -= 1
+                elif by_tags and inside 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()
+                elif started == 0 and tag == 'status':
+                    elem.text = self._create_flattened_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 _create_flattened_message(self, original):
+        if not original:
+            start = ''
+        elif original.startswith('*HTML*'):
+            start = original[6:].strip() + '<hr>'
+        else:
+            start = html_escape(original) + '<hr>'
+        return f'*HTML* {start}<span class="robot-note">Content flattened.</span>'
+
     def _get_matcher(self, matcher_class, flattened):
         matcher = matcher_class(flattened)
         return matcher.match, bool(matcher)

{robotframework-6.1.1 → robotframework-7.0a1}/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
 
 
@@ -58,9 +60,13 @@ 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):
@@ -106,7 +112,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 +128,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 +143,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 +162,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 +212,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 +231,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 +257,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 +309,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 +338,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 +353,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 +418,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 +461,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.1.1 → robotframework-7.0a1}/src/robot/running/__init__.py

@@ -111,7 +111,7 @@ 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,
-                    ResourceFile, TestCase, TestSuite, Try, TryBranch, While)
+                    ResourceFile, TestCase, TestSuite, Try, TryBranch, Var, While)
 from .runkwregister import RUN_KW_REGISTER
 from .testlibraries import TestLibrary
 from .usererrorhandler import UserErrorHandler

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

@@ -0,0 +1,101 @@
+#  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
+from .typeconverters import TypeConverter
+
+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

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/arguments/argumentmapper.py

@@ -13,17 +13,21 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import TYPE_CHECKING
+
 from robot.errors import DataError
 
+if TYPE_CHECKING:
+    from .argumentspec import ArgumentSpec
+
 
 class ArgumentMapper:
 
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
+    def __init__(self, arg_spec: 'ArgumentSpec'):
+        self.arg_spec = arg_spec
 
     def map(self, positional, named, replace_defaults=True):
-        template = KeywordCallTemplate(self._argspec)
+        template = KeywordCallTemplate(self.arg_spec)
         template.fill_positional(positional)
         template.fill_named(named)
         if replace_defaults:
@@ -33,19 +37,18 @@ class ArgumentMapper:
 
 class KeywordCallTemplate:
 
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
-        self.args = [None if arg not in argspec.defaults
-                     else DefaultValue(argspec.defaults[arg])
-                     for arg in argspec.positional]
+    def __init__(self, arg_spec: 'ArgumentSpec'):
+        self.arg_spec = arg_spec
+        self.args = [None if arg not in arg_spec.defaults
+                     else DefaultValue(arg_spec.defaults[arg])
+                     for arg in arg_spec.positional]
         self.kwargs = []
 
     def fill_positional(self, positional):
         self.args[:len(positional)] = positional
 
     def fill_named(self, named):
-        spec = self._argspec
+        spec = self.arg_spec
         for name, value in named:
             if name in spec.positional_or_named:
                 index = spec.positional_or_named.index(name)
@@ -53,7 +56,7 @@ class KeywordCallTemplate:
             elif spec.var_named or name in spec.named_only:
                 self.kwargs.append((name, value))
             else:
-                raise DataError("Non-existing named argument '%s'." % name)
+                raise DataError(f"Non-existing named argument '{name}'.")
         named_names = {name for name, _ in named}
         for name in spec.named_only:
             if name not in named_names:
@@ -77,5 +80,4 @@ class DefaultValue:
         try:
             return variables.replace_scalar(self.value)
         except DataError as err:
-            raise DataError('Resolving argument default values failed: %s'
-                            % err.message)
+            raise DataError(f'Resolving argument default values failed: {err}')