robotframework 6.1rc1__zip → 7.0__zip

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

@@ -13,12 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 import inspect
 import asyncio
 from contextlib import contextmanager
 
-from robot.errors import DataError
+from robot.errors import DataError, ExecutionFailed
 
 
 class Asynchronous:
@@ -37,15 +36,20 @@ class Asynchronous:
             self._loop_ref.close()
 
     def run_until_complete(self, coroutine):
-        return self.event_loop.run_until_complete(coroutine)
+        task = self.event_loop.create_task(coroutine)
+        try:
+            return self.event_loop.run_until_complete(task)
+        except ExecutionFailed as e:
+            if e.dont_continue:
+                task.cancel()
+                # wait for task and its children to cancel
+                self.event_loop.run_until_complete(asyncio.gather(task, return_exceptions=True))
+            raise e
 
     def is_loop_required(self, obj):
         return inspect.iscoroutine(obj) and not self._is_loop_running()
 
     def _is_loop_running(self):
-        # ensure 3.6 compatibility
-        if sys.version_info.minor == 6:
-            return asyncio._get_running_loop() is not None
         try:
             asyncio.get_running_loop()
         except RuntimeError:
@@ -108,6 +112,10 @@ class _ExecutionContext:
         self.user_keywords = []
         self.asynchronous = asynchronous
 
+    @property
+    def languages(self):
+        return self.namespace.languages
+
     @contextmanager
     def suite_teardown(self):
         self.in_suite_teardown = True
@@ -150,7 +158,7 @@ class _ExecutionContext:
     def warn_on_invalid_private_call(self, handler):
         parent = self.user_keywords[-1] if self.user_keywords else None
         if not parent or parent.source != handler.source:
-            self.warn(f"Keyword '{handler.longname}' is private and should only "
+            self.warn(f"Keyword '{handler.full_name}' is private and should only "
                       f"be called by keywords in the same file.")
 
     @contextmanager
@@ -174,34 +182,37 @@ class _ExecutionContext:
     def continue_on_failure(self, default=False):
         parents = ([self.test] if self.test else []) + self.user_keywords
         for index, parent in enumerate(reversed(parents)):
-            if (parent.tags.robot('recursive-stop-on-failure')
-                    or index == 0 and parent.tags.robot('stop-on-failure')):
+            robot = parent.tags.robot
+            if index == 0 and robot('stop-on-failure'):
+                return False
+            if index == 0 and robot('continue-on-failure'):
+                return True
+            if robot('recursive-stop-on-failure'):
                 return False
-            if (parent.tags.robot('recursive-continue-on-failure')
-                    or index == 0 and parent.tags.robot('continue-on-failure')):
+            if robot('recursive-continue-on-failure'):
                 return True
         return default or self.in_teardown
 
     @property
     def allow_loop_control(self):
-        for step in reversed(self.steps):
+        for _, step in reversed(self.steps):
             if step.type == 'ITERATION':
                 return True
-            if step.type == 'KEYWORD' and step.libname != 'BuiltIn':
+            if step.type == 'KEYWORD' and step.owner != 'BuiltIn':
                 return False
         return False
 
-    def end_suite(self, suite):
+    def end_suite(self, data, result):
         for name in ['${PREV_TEST_NAME}',
                      '${PREV_TEST_STATUS}',
                      '${PREV_TEST_MESSAGE}']:
             self.variables.set_global(name, self.variables[name])
-        self.output.end_suite(suite)
-        self.namespace.end_suite(suite)
+        self.output.end_suite(data, result)
+        self.namespace.end_suite(data)
         EXECUTION_CONTEXTS.end_suite()
 
     def set_suite_variables(self, suite):
-        self.variables['${SUITE_NAME}'] = suite.longname
+        self.variables['${SUITE_NAME}'] = suite.full_name
         self.variables['${SUITE_SOURCE}'] = str(suite.source or '')
         self.variables['${SUITE_DOCUMENTATION}'] = suite.doc
         self.variables['${SUITE_METADATA}'] = suite.metadata.copy()
@@ -210,13 +221,14 @@ class _ExecutionContext:
         self.variables['${SUITE_STATUS}'] = status
         self.variables['${SUITE_MESSAGE}'] = message
 
-    def start_test(self, test):
-        self.test = test
-        self._add_timeout(test.timeout)
+    def start_test(self, data, result):
+        self.test = result
+        self._add_timeout(result.timeout)
         self.namespace.start_test()
-        self.variables.set_test('${TEST_NAME}', test.name)
-        self.variables.set_test('${TEST_DOCUMENTATION}', test.doc)
-        self.variables.set_test('@{TEST_TAGS}', list(test.tags))
+        self.variables.set_test('${TEST_NAME}', result.name)
+        self.variables.set_test('${TEST_DOCUMENTATION}', result.doc)
+        self.variables.set_test('@{TEST_TAGS}', list(result.tags))
+        self.output.start_test(data, result)
 
     def _add_timeout(self, timeout):
         if timeout:
@@ -236,19 +248,89 @@ class _ExecutionContext:
         self.variables.set_suite('${PREV_TEST_MESSAGE}', test.message)
         self.timeout_occurred = False
 
-    def start_keyword(self, keyword):
-        self.steps.append(keyword)
+    def start_body_item(self, data, result, implementation=None):
+        self.steps.append((data, result))
         if len(self.steps) > self._started_keywords_threshold:
             raise DataError('Maximum limit of started keywords and control '
                             'structures exceeded.')
-        self.output.start_keyword(keyword)
-
-    def end_keyword(self, keyword):
-        self.output.end_keyword(keyword)
+        output = self.output
+        args = (data, result)
+        if implementation:
+            if implementation.error:
+                method = output.start_invalid_keyword
+            elif implementation.type == implementation.LIBRARY_KEYWORD:
+                method = output.start_library_keyword
+            else:
+                method = output.start_user_keyword
+            args = (data, implementation, result)
+        elif result.type in (result.ELSE, result.ITERATION):
+            method = {
+                result.IF_ELSE_ROOT: output.start_if_branch,
+                result.TRY_EXCEPT_ROOT: output.start_try_branch,
+                result.FOR: output.start_for_iteration,
+                result.WHILE: output.start_while_iteration,
+            }[result.parent.type]
+        else:
+            method = {
+                result.FOR: output.start_for,
+                result.WHILE: output.start_while,
+                result.IF_ELSE_ROOT: output.start_if,
+                result.IF: output.start_if_branch,
+                result.ELSE: output.start_if_branch,
+                result.ELSE_IF: output.start_if_branch,
+                result.TRY_EXCEPT_ROOT: output.start_try,
+                result.TRY: output.start_try_branch,
+                result.EXCEPT: output.start_try_branch,
+                result.FINALLY: output.start_try_branch,
+                result.VAR: output.start_var,
+                result.BREAK: output.start_break,
+                result.CONTINUE: output.start_continue,
+                result.RETURN: output.start_return,
+                result.ERROR: output.start_error,
+            }[result.type]
+        method(*args)
+
+    def end_body_item(self, data, result, implementation=None):
+        output = self.output
+        args = (data, result)
+        if implementation:
+            if implementation.error:
+                method = output.end_invalid_keyword
+            elif implementation.type == implementation.LIBRARY_KEYWORD:
+                method = output.end_library_keyword
+            else:
+                method = output.end_user_keyword
+            args = (data, implementation, result)
+        elif result.type in (result.ELSE, result.ITERATION):
+            method = {
+                result.IF_ELSE_ROOT: output.end_if_branch,
+                result.TRY_EXCEPT_ROOT: output.end_try_branch,
+                result.FOR: output.end_for_iteration,
+                result.WHILE: output.end_while_iteration,
+            }[result.parent.type]
+        else:
+            method = {
+                result.FOR: output.end_for,
+                result.WHILE: output.end_while,
+                result.IF_ELSE_ROOT: output.end_if,
+                result.IF: output.end_if_branch,
+                result.ELSE: output.end_if_branch,
+                result.ELSE_IF: output.end_if_branch,
+                result.TRY_EXCEPT_ROOT: output.end_try,
+                result.TRY: output.end_try_branch,
+                result.EXCEPT: output.end_try_branch,
+                result.FINALLY: output.end_try_branch,
+                result.VAR: output.end_var,
+                result.BREAK: output.end_break,
+                result.CONTINUE: output.end_continue,
+                result.RETURN: output.end_return,
+                result.ERROR: output.end_error,
+            }[result.type]
+        method(*args)
         self.steps.pop()
 
-    def get_runner(self, name):
-        return self.namespace.get_runner(name)
+    def get_runner(self, name, recommend_on_failure=True):
+        return self.namespace.get_runner(name, recommend_on_failure)
 
     def trace(self, message):
         self.output.trace(message)

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

@@ -14,24 +14,26 @@
 #  limitations under the License.
 
 from robot.errors import DataError
-from robot.utils import get_error_message, is_bytes, is_list_like, is_string, type_name
+from robot.utils import get_error_message, is_list_like, type_name
 
 from .arguments import PythonArgumentParser
+from .context import EXECUTION_CONTEXTS
 
 
 def no_dynamic_method(*args):
     return None
 
 
-class _DynamicMethod:
+class DynamicMethod:
     _underscore_name = NotImplemented
 
-    def __init__(self, lib):
-        self.method = self._get_method(lib)
+    def __init__(self, instance):
+        self.instance = instance
+        self.method = self._get_method(instance)
 
-    def _get_method(self, lib):
+    def _get_method(self, instance):
         for name in self._underscore_name, self._camelCaseName:
-            method = getattr(lib, name, None)
+            method = getattr(instance, name, None)
             if callable(method):
                 return method
         return no_dynamic_method
@@ -45,28 +47,31 @@ class _DynamicMethod:
     def name(self):
         return self.method.__name__
 
-    def __call__(self, *args):
+    def __call__(self, *args, **kwargs):
         try:
-            return self._handle_return_value(self.method(*args))
-        except:
-            raise DataError("Calling dynamic method '%s' failed: %s"
-                            % (self.name, get_error_message()))
+            ctx = EXECUTION_CONTEXTS.current
+            result = self.method(*args, **kwargs)
+            if ctx and ctx.asynchronous.is_loop_required(result):
+                result = ctx.asynchronous.run_until_complete(result)
+            return self._handle_return_value(result)
+        except Exception:
+            raise DataError(f"Calling dynamic method '{self.name}' failed: "
+                            f"{get_error_message()}")
 
     def _handle_return_value(self, value):
         raise NotImplementedError
 
     def _to_string(self, value, allow_tuple=False, allow_none=False):
-        if is_string(value):
+        if isinstance(value, str):
             return value
-        if is_bytes(value):
+        if isinstance(value, bytes):
             return value.decode('UTF-8')
         if allow_tuple and is_list_like(value) and len(value) > 0:
             return tuple(value)
         if allow_none and value is None:
             return value
-        or_tuple = ' or a non-empty tuple' if allow_tuple else ''
-        raise DataError('Return value must be a string%s, got %s.'
-                        % (or_tuple, type_name(value)))
+        allowed = 'a string or a non-empty tuple' if allow_tuple else 'a string'
+        raise DataError(f'Return value must be {allowed}, got {type_name(value)}.')
 
     def _to_list(self, value):
         if value is None:
@@ -80,14 +85,15 @@ class _DynamicMethod:
             return [self._to_string(item, allow_tuples)
                     for item in self._to_list(value)]
         except DataError:
-            raise DataError('Return value must be a list of strings%s.'
-                            % (' or non-empty tuples' if allow_tuples else ''))
+            allowed = 'strings or non-empty tuples' if allow_tuples else 'strings'
+            raise DataError(f'Return value must be a list of {allowed}, '
+                            f'got {type_name(value)}.')
 
     def __bool__(self):
         return self.method is not no_dynamic_method
 
 
-class GetKeywordNames(_DynamicMethod):
+class GetKeywordNames(DynamicMethod):
     _underscore_name = 'get_keyword_names'
 
     def _handle_return_value(self, value):
@@ -102,52 +108,74 @@ class GetKeywordNames(_DynamicMethod):
                 yield name
 
 
-class RunKeyword(_DynamicMethod):
+class RunKeyword(DynamicMethod):
     _underscore_name = 'run_keyword'
 
-    @property
-    def supports_kwargs(self):
-        spec = PythonArgumentParser().parse(self.method)
-        return len(spec.positional) == 3
-
+    def __init__(self, instance, keyword_name: 'str|None' = None,
+                 supports_named_args: 'bool|None' = None):
+        super().__init__(instance)
+        self.keyword_name = keyword_name
+        self._supports_named_args = supports_named_args
 
-class GetKeywordDocumentation(_DynamicMethod):
+    @property
+    def supports_named_args(self) -> bool:
+        if self._supports_named_args is None:
+            spec = PythonArgumentParser().parse(self.method)
+            self._supports_named_args = len(spec.positional) == 3
+        return self._supports_named_args
+
+    def __call__(self, *positional, **named):
+        if self.supports_named_args:
+            args = (self.keyword_name, positional, named)
+        elif named:
+            # This should never happen.
+            raise ValueError(f"'named' should not be used when named-argument "
+                             f"support is not enabled, got {named}.")
+        else:
+            args = (self.keyword_name, positional)
+        return self.method(*args)
+
+
+class GetKeywordDocumentation(DynamicMethod):
     _underscore_name = 'get_keyword_documentation'
 
     def _handle_return_value(self, value):
         return self._to_string(value or '')
 
 
-class GetKeywordArguments(_DynamicMethod):
+class GetKeywordArguments(DynamicMethod):
     _underscore_name = 'get_keyword_arguments'
 
-    def __init__(self, lib):
-        _DynamicMethod.__init__(self, lib)
-        self._supports_kwargs = RunKeyword(lib).supports_kwargs
+    def __init__(self, instance, supports_named_args: 'bool|None' = None):
+        super().__init__(instance)
+        if supports_named_args is None:
+            self.supports_named_args = RunKeyword(instance).supports_named_args
+        else:
+            self.supports_named_args = supports_named_args
 
     def _handle_return_value(self, value):
         if value is None:
-            if self._supports_kwargs:
+            if self.supports_named_args:
                 return ['*varargs', '**kwargs']
             return ['*varargs']
         return self._to_list_of_strings(value, allow_tuples=True)
 
 
-class GetKeywordTypes(_DynamicMethod):
+class GetKeywordTypes(DynamicMethod):
     _underscore_name = 'get_keyword_types'
 
     def _handle_return_value(self, value):
         return value if self else {}
 
 
-class GetKeywordTags(_DynamicMethod):
+class GetKeywordTags(DynamicMethod):
     _underscore_name = 'get_keyword_tags'
 
     def _handle_return_value(self, value):
         return self._to_list_of_strings(value)
 
 
-class GetKeywordSource(_DynamicMethod):
+class GetKeywordSource(DynamicMethod):
     _underscore_name = 'get_keyword_source'
 
     def _handle_return_value(self, value):

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

@@ -13,16 +13,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import copy
-import os.path
 import os
 
 from robot.output import LOGGER
 from robot.errors import FrameworkError, DataError
-from robot.utils import normpath, seq2str, seq2str2, is_string
+from robot.utils import normpath, seq2str, seq2str2
 
 from .builder import ResourceFileBuilder
-from .handlerstore import HandlerStore
 from .testlibraries import TestLibrary
 
 
@@ -41,15 +38,27 @@ class Importer:
 
     def close_global_library_listeners(self):
         for lib in self._library_cache.values():
-            lib.close_global_listeners()
+            lib.scope_manager.close_global_listeners()
 
     def import_library(self, name, args, alias, variables):
-        lib = TestLibrary(name, args, variables, create_handlers=False)
-        positional, named = lib.positional_args, lib.named_args
-        lib = self._import_library(name, positional, named, lib)
+        lib = TestLibrary.from_name(name, args=args, variables=variables,
+                                    create_keywords=False)
+        positional, named = lib.init.positional, lib.init.named
+        args_str = seq2str2(positional + [f'{n}={named[n]}' for n in named])
+        key = (name, positional, named)
+        if key in self._library_cache:
+            LOGGER.info(f"Found library '{name}' with arguments {args_str} "
+                        f"from cache.")
+            lib = self._library_cache[key]
+        else:
+            lib.create_keywords()
+            if lib.scope is not lib.scope.GLOBAL:
+                lib.instance = None
+            self._library_cache[key] = lib
+            self._log_imported_library(name, args_str, lib)
         if alias:
             alias = variables.replace_scalar(alias)
-            lib = self._copy_library(lib, alias)
+            lib = lib.copy(name=alias)
             LOGGER.info(f"Imported library '{name}' with name '{alias}'.")
         return lib
 
@@ -69,46 +78,15 @@ class Importer:
             raise DataError(f"Invalid resource file extension '{extension}'. "
                             f"Supported extensions are {extensions}.")
 
-    def _import_library(self, name, positional, named, lib):
-        args = positional + [f'{name}={value}' for name, value in named]
-        key = (name, positional, named)
-        if key in self._library_cache:
-            LOGGER.info(f"Found library '{name}' with arguments {seq2str2(args)} "
-                        f"from cache.")
-            return self._library_cache[key]
-        lib.create_handlers()
-        self._library_cache[key] = lib
-        self._log_imported_library(name, args, lib)
-        return lib
-
-    def _log_imported_library(self, name, args, lib):
-        type = lib.__class__.__name__.replace('Library', '').lower()[1:]
-        listener = ', with listener' if lib.has_listener else ''
-        LOGGER.info(f"Imported library '{name}' with arguments {seq2str2(args)} "
-                    f"(version {lib.version or '<unknown>'}, {type} type, "
-                    f"{lib.scope} scope, {len(lib)} keywords{listener}).")
-        if not lib:
+    def _log_imported_library(self, name, args_str, lib):
+        kind = type(lib).__name__.replace('Library', '').lower()
+        listener = ', with listener' if lib.listeners else ''
+        LOGGER.info(f"Imported library '{name}' with arguments {args_str} "
+                    f"(version {lib.version or '<unknown>'}, {kind} type, "
+                    f"{lib.scope.name} scope, {len(lib.keywords)} keywords{listener}).")
+        if not (lib.keywords or lib.listeners):
             LOGGER.warn(f"Imported library '{name}' contains no keywords.")
 
-    def _copy_library(self, orig, name):
-        # This is pretty ugly. Hopefully we can remove cache and copying
-        # altogether in 3.0 and always just re-import libraries:
-        # https://github.com/robotframework/robotframework/issues/2106
-        lib = copy.copy(orig)
-        lib.name = name
-        lib.scope = type(lib.scope)(lib)
-        lib.reset_instance()
-        lib.handlers = HandlerStore()
-        for handler in orig.handlers._normal.values():
-            handler = copy.copy(handler)
-            handler.library = lib
-            lib.handlers.add(handler)
-        for handler in orig.handlers._embedded:
-            handler = copy.copy(handler)
-            handler.library = lib
-            lib.handlers.add(handler, embedded=True)
-        return lib
-
 
 class ImportCache:
     """Keeps track on and optionally caches imported items.
@@ -122,7 +100,7 @@ class ImportCache:
         self._items = []
 
     def __setitem__(self, key, item):
-        if not is_string(key) and not isinstance(key, tuple):
+        if not isinstance(key, (str, tuple)):
             raise FrameworkError('Invalid key for ImportCache')
         key = self._norm_path_key(key)
         if key not in self._keys:
@@ -154,4 +132,4 @@ class ImportCache:
         return key
 
     def _is_path(self, key):
-        return is_string(key) and os.path.isabs(key) and os.path.exists(key)
+        return isinstance(key, str) and os.path.isabs(key) and os.path.exists(key)

robotframework-7.0/src/robot/running/invalidkeyword.py

@@ -0,0 +1,67 @@
+#  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 robot.errors import DataError
+from robot.result import Keyword as KeywordResult
+from robot.variables import VariableAssignment
+
+from .arguments import EmbeddedArguments
+from .model import Keyword as KeywordData
+from .statusreporter import StatusReporter
+from .keywordimplementation import KeywordImplementation
+
+
+class InvalidKeyword(KeywordImplementation):
+    """Represents an invalid keyword call.
+
+    Keyword may not have been found, there could have been multiple matches,
+    or the keyword call itself could have been invalid.
+    """
+    type = KeywordImplementation.INVALID_KEYWORD
+
+    def _get_embedded(self, name) -> 'EmbeddedArguments|None':
+        try:
+            return super()._get_embedded(name)
+        except DataError:
+            return None
+
+    def create_runner(self, name, languages=None):
+        return InvalidKeywordRunner(self, name)
+
+    def bind(self, data: KeywordData) -> 'InvalidKeyword':
+        return self.copy(parent=data.parent)
+
+
+class InvalidKeywordRunner:
+
+    def __init__(self, keyword: InvalidKeyword, name: 'str|None' = None):
+        self.keyword = keyword
+        self.name = name or keyword.name
+        if not keyword.error:
+            raise ValueError("Executed 'InvalidKeyword' instance requires 'error'.")
+
+    def run(self, data: KeywordData, result: KeywordResult, context, run=True):
+        kw = self.keyword.bind(data)
+        result.config(name=self.name,
+                      owner=kw.owner.name if kw.owner else None,
+                      args=data.args,
+                      assign=tuple(VariableAssignment(data.assign)),
+                      type=data.type)
+        with StatusReporter(data, result, context, run, implementation=kw):
+            # 'error' is can be set to 'None' by a listener that handles it.
+            if run and kw.error is not None:
+                raise DataError(kw.error)
+
+    dry_run = run