robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/output/logger.py

@@ -20,10 +20,28 @@ from robot.errors import DataError
 
 from .console import ConsoleOutput
 from .filelogger import FileLogger
-from .loggerhelper import AbstractLogger, AbstractLoggerProxy
+from .loggerhelper import AbstractLogger
 from .stdoutlogsplitter import StdoutLogSplitter
 
 
+def start_body_item(method):
+    def wrapper(self, *args):
+        # TODO: Could _prev_log_message_handlers be used also here?
+        self._started_keywords += 1
+        self.log_message = self._log_message
+        method(self, *args)
+    return wrapper
+
+
+def end_body_item(method):
+    def wrapper(self, *args):
+        self._started_keywords -= 1
+        method(self, *args)
+        if not self._started_keywords:
+            self.log_message = self.message
+    return wrapper
+
+
 class Logger(AbstractLogger):
     """A global logger proxy to delegating messages to registered loggers.
 
@@ -83,7 +101,6 @@ class Logger(AbstractLogger):
         self._console_logger = self._wrap_and_relay(logger)
 
     def _wrap_and_relay(self, logger):
-        logger = LoggerProxy(logger)
         self._relay_cached_messages(logger)
         return logger
 
@@ -127,8 +144,7 @@ class Logger(AbstractLogger):
 
     def unregister_logger(self, *loggers):
         for logger in loggers:
-            self._other_loggers = [proxy for proxy in self._other_loggers
-                                   if proxy.logger is not logger]
+            self._other_loggers = [l for l in self._other_loggers if l is not logger]
 
     def disable_message_cache(self):
         self._message_cache = None
@@ -196,44 +212,219 @@ class Logger(AbstractLogger):
     def disable_library_import_logging(self):
         self.log_message = self._prev_log_message_handlers.pop()
 
-    def start_suite(self, suite):
+    def start_suite(self, data, result):
         for logger in self.start_loggers:
-            logger.start_suite(suite)
+            logger.start_suite(data, result)
 
-    def end_suite(self, suite):
+    def end_suite(self, data, result):
         for logger in self.end_loggers:
-            logger.end_suite(suite)
+            logger.end_suite(data, result)
 
-    def start_test(self, test):
+    def start_test(self, data, result):
         for logger in self.start_loggers:
-            logger.start_test(test)
+            logger.start_test(data, result)
 
-    def end_test(self, test):
+    def end_test(self, data, result):
         for logger in self.end_loggers:
-            logger.end_test(test)
+            logger.end_test(data, result)
 
-    def start_keyword(self, keyword):
-        # TODO: Could _prev_log_message_handlers be used also here?
-        self._started_keywords += 1
-        self.log_message = self._log_message
+    @start_body_item
+    def start_keyword(self, data, result):
         for logger in self.start_loggers:
-            logger.start_keyword(keyword)
+            logger.start_keyword(data, result)
 
-    def end_keyword(self, keyword):
-        self._started_keywords -= 1
+    @end_body_item
+    def end_keyword(self, data, result):
         for logger in self.end_loggers:
-            logger.end_keyword(keyword)
-        if not self._started_keywords:
-            self.log_message = self.message
+            logger.end_keyword(data, result)
+
+    @start_body_item
+    def start_user_keyword(self, data, implementation, result):
+        for logger in self.start_loggers:
+            logger.start_user_keyword(data, implementation, result)
+
+    @end_body_item
+    def end_user_keyword(self, data, implementation, result):
+        for logger in self.end_loggers:
+            logger.end_user_keyword(data, implementation, result)
+
+    @start_body_item
+    def start_library_keyword(self, data, implementation, result):
+        for logger in self.start_loggers:
+            logger.start_library_keyword(data, implementation, result)
+
+    @end_body_item
+    def end_library_keyword(self, data, implementation, result):
+        for logger in self.end_loggers:
+            logger.end_library_keyword(data, implementation, result)
+
+    @start_body_item
+    def start_invalid_keyword(self, data, implementation, result):
+        for logger in self.start_loggers:
+            logger.start_invalid_keyword(data, implementation, result)
+
+    @end_body_item
+    def end_invalid_keyword(self, data, implementation, result):
+        for logger in self.end_loggers:
+            logger.end_invalid_keyword(data, implementation, result)
+
+    @start_body_item
+    def start_for(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_for(data, result)
+
+    @end_body_item
+    def end_for(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_for(data, result)
+
+    @start_body_item
+    def start_for_iteration(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_for_iteration(data, result)
+
+    @end_body_item
+    def end_for_iteration(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_for_iteration(data, result)
+
+    @start_body_item
+    def start_while(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_while(data, result)
+
+    @end_body_item
+    def end_while(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_while(data, result)
+
+    @start_body_item
+    def start_while_iteration(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_while_iteration(data, result)
+
+    @end_body_item
+    def end_while_iteration(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_while_iteration(data, result)
+
+    @start_body_item
+    def start_if(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_if(data, result)
+
+    @end_body_item
+    def end_if(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_if(data, result)
+
+    @start_body_item
+    def start_if_branch(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_if_branch(data, result)
+
+    @end_body_item
+    def end_if_branch(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_if_branch(data, result)
+
+    @start_body_item
+    def start_try(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_try(data, result)
+
+    @end_body_item
+    def end_try(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_try(data, result)
+
+    @start_body_item
+    def start_try_branch(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_try_branch(data, result)
+
+    @end_body_item
+    def end_try_branch(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_try_branch(data, result)
+
+    @start_body_item
+    def start_var(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_var(data, result)
+
+    @end_body_item
+    def end_var(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_var(data, result)
+
+    @start_body_item
+    def start_break(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_break(data, result)
+
+    @end_body_item
+    def end_break(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_break(data, result)
+
+    @start_body_item
+    def start_continue(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_continue(data, result)
+
+    @end_body_item
+    def end_continue(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_continue(data, result)
+
+    @start_body_item
+    def start_return(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_return(data, result)
+
+    @end_body_item
+    def end_return(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_return(data, result)
+
+    @start_body_item
+    def start_error(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_error(data, result)
+
+    @end_body_item
+    def end_error(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_error(data, result)
 
     def imported(self, import_type, name, **attrs):
         for logger in self:
             logger.imported(import_type, name, attrs)
 
-    def output_file(self, file_type, path):
-        """Finished output, report, log, debug, or xunit file"""
+    def output_file(self, path):
+        for logger in self:
+            logger.output_file(path)
+
+    def report_file(self, path):
         for logger in self:
-            logger.output_file(file_type, path)
+            logger.report_file(path)
+
+    def log_file(self, path):
+        for logger in self:
+            logger.log_file(path)
+
+    def xunit_file(self, path):
+        for logger in self:
+            logger.xunit_file(path)
+
+    def debug_file(self, path):
+        for logger in self:
+            logger.debug_file(path)
+
+    def result_file(self, kind, path):
+        kind_file = getattr(self, f'{kind.lower()}_file')
+        kind_file(path)
 
     def close(self):
         for logger in self:
@@ -241,59 +432,4 @@ class Logger(AbstractLogger):
         self.__init__(register_console_logger=False)
 
 
-class LoggerProxy(AbstractLoggerProxy):
-    _methods = ('start_suite', 'end_suite', 'start_test', 'end_test',
-                'start_keyword', 'end_keyword', 'message', 'log_message',
-                'imported', 'output_file', 'close')
-
-    _start_keyword_methods = {
-        'For': 'start_for',
-        'ForIteration': 'start_for_iteration',
-        'While': 'start_while',
-        'WhileIteration': 'start_while_iteration',
-        'If': 'start_if',
-        'IfBranch': 'start_if_branch',
-        'Try': 'start_try',
-        'TryBranch': 'start_try_branch',
-        'Return': 'start_return',
-        'Continue': 'start_continue',
-        'Break': 'start_break',
-        'Error': 'start_error'
-    }
-    _end_keyword_methods = {
-        'For': 'end_for',
-        'ForIteration': 'end_for_iteration',
-        'While': 'end_while',
-        'WhileIteration': 'end_while_iteration',
-        'If': 'end_if',
-        'IfBranch': 'end_if_branch',
-        'Try': 'end_try',
-        'TryBranch': 'end_try_branch',
-        'Return': 'end_return',
-        'Continue': 'end_continue',
-        'Break': 'end_break',
-        'Error': 'end_error'
-    }
-
-    def start_keyword(self, kw):
-        # Dispatch start_keyword calls to more precise methods when logger
-        # implements them. This horrible hack is needed because internal logger
-        # knows only about keywords. It should be rewritten.
-        name = self._start_keyword_methods.get(type(kw.result).__name__)
-        if name and hasattr(self.logger, name):
-            method = getattr(self.logger, name)
-        else:
-            method = self.logger.start_keyword
-        method(kw)
-
-    def end_keyword(self, kw):
-        # See start_keyword comment for explanation of this horrible hack.
-        name = self._end_keyword_methods.get(type(kw.result).__name__)
-        if name and hasattr(self.logger, name):
-            method = getattr(self.logger, name)
-        else:
-            method = self.logger.end_keyword
-        method(kw)
-
-
 LOGGER = Logger()

robotframework-7.0/src/robot/output/loggerapi.py

@@ -0,0 +1,215 @@
+#  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 pathlib import Path
+from typing import Literal, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from robot import running, result, model
+
+
+class LoggerApi:
+
+    def start_suite(self, data: 'running.TestSuite', result: 'result.TestSuite'):
+        pass
+
+    def end_suite(self, data: 'running.TestSuite', result: 'result.TestSuite'):
+        pass
+
+    def start_test(self, data: 'running.TestCase', result: 'result.TestCase'):
+        pass
+
+    def end_test(self, data: 'running.TestCase', result: 'result.TestCase'):
+        pass
+
+    def start_keyword(self, data: 'running.Keyword', result: 'result.Keyword'):
+        self.start_body_item(data, result)
+
+    def end_keyword(self, data: 'running.Keyword', result: 'result.Keyword'):
+        self.end_body_item(data, result)
+
+    def start_user_keyword(self, data: 'running.Keyword',
+                           implementation: 'running.UserKeyword',
+                           result: 'result.Keyword'):
+        self.start_keyword(data, result)
+
+    def end_user_keyword(self, data: 'running.Keyword',
+                         implementation: 'running.UserKeyword',
+                         result: 'result.Keyword'):
+        self.end_keyword(data, result)
+
+    def start_library_keyword(self, data: 'running.Keyword',
+                              implementation: 'running.LibraryKeyword',
+                              result: 'result.Keyword'):
+        self.start_keyword(data, result)
+
+    def end_library_keyword(self, data: 'running.Keyword',
+                            implementation: 'running.LibraryKeyword',
+                            result: 'result.Keyword'):
+        self.end_keyword(data, result)
+
+    def start_invalid_keyword(self, data: 'running.Keyword',
+                              implementation: 'running.KeywordImplementation',
+                              result: 'result.Keyword'):
+        self.start_keyword(data, result)
+
+    def end_invalid_keyword(self, data: 'running.Keyword',
+                            implementation: 'running.KeywordImplementation',
+                            result: 'result.Keyword'):
+        self.end_keyword(data, result)
+
+    def start_for(self, data: 'running.For', result: 'result.For'):
+        self.start_body_item(data, result)
+
+    def end_for(self, data: 'running.For', result: 'result.For'):
+        self.end_body_item(data, result)
+
+    def start_for_iteration(self, data: 'running.ForIteration',
+                            result: 'result.ForIteration'):
+        self.start_body_item(data, result)
+
+    def end_for_iteration(self, data: 'running.ForIteration',
+                          result: 'result.ForIteration'):
+        self.end_body_item(data, result)
+
+    def start_while(self, data: 'running.While', result: 'result.While'):
+        self.start_body_item(data, result)
+
+    def end_while(self, data: 'running.While', result: 'result.While'):
+        self.end_body_item(data, result)
+
+    def start_while_iteration(self, data: 'running.WhileIteration',
+                              result: 'result.WhileIteration'):
+        self.start_body_item(data, result)
+
+    def end_while_iteration(self, data: 'running.WhileIteration',
+                            result: 'result.WhileIteration'):
+        self.end_body_item(data, result)
+
+    def start_if(self, data: 'running.If', result: 'result.If'):
+        self.start_body_item(data, result)
+
+    def end_if(self, data: 'running.If', result: 'result.If'):
+        self.end_body_item(data, result)
+
+    def start_if_branch(self, data: 'running.IfBranch', result: 'result.IfBranch'):
+        self.start_body_item(data, result)
+
+    def end_if_branch(self, data: 'running.IfBranch', result: 'result.IfBranch'):
+        self.end_body_item(data, result)
+
+    def start_try(self, data: 'running.Try', result: 'result.Try'):
+        self.start_body_item(data, result)
+
+    def end_try(self, data: 'running.Try', result: 'result.Try'):
+        self.end_body_item(data, result)
+
+    def start_try_branch(self, data: 'running.TryBranch', result: 'result.TryBranch'):
+        self.start_body_item(data, result)
+
+    def end_try_branch(self, data: 'running.TryBranch', result: 'result.TryBranch'):
+        self.end_body_item(data, result)
+
+    def start_var(self, data: 'running.Var', result: 'result.Var'):
+        self.start_body_item(data, result)
+
+    def end_var(self, data: 'running.Var', result: 'result.Var'):
+        self.end_body_item(data, result)
+
+    def start_break(self, data: 'running.Break', result: 'result.Break'):
+        self.start_body_item(data, result)
+
+    def end_break(self, data: 'running.Break', result: 'result.Break'):
+        self.end_body_item(data, result)
+
+    def start_continue(self, data: 'running.Continue', result: 'result.Continue'):
+        self.start_body_item(data, result)
+
+    def end_continue(self, data: 'running.Continue', result: 'result.Continue'):
+        self.end_body_item(data, result)
+
+    def start_return(self, data: 'running.Return', result: 'result.Return'):
+        self.start_body_item(data, result)
+
+    def end_return(self, data: 'running.Return', result: 'result.Return'):
+        self.end_body_item(data, result)
+
+    def start_error(self, data: 'running.Error', result: 'result.Error'):
+        self.start_body_item(data, result)
+
+    def end_error(self, data: 'running.Error', result: 'result.Error'):
+        self.end_body_item(data, result)
+
+    def start_body_item(self, data, result):
+        pass
+
+    def end_body_item(self, data, result):
+        pass
+
+    def log_message(self, message: 'model.Message'):
+        pass
+
+    def message(self, message: 'model.Message'):
+        pass
+
+    def output_file(self, path: Path):
+        """Called when XML output file is closed.
+
+        Calls :meth:`result_file` by default.
+        """
+        self.result_file('Output', path)
+
+    def report_file(self, path: Path):
+        """Called when report file is closed.
+
+        Calls :meth:`result_file` by default.
+        """
+        self.result_file('Report', path)
+
+    def log_file(self, path: Path):
+        """Called when log file is closed.
+
+        Calls :meth:`result_file` by default.
+        """
+        self.result_file('Log', path)
+
+    def xunit_file(self, path: Path):
+        """Called when xunit file is closed.
+
+        Calls :meth:`result_file` by default.
+        """
+        self.result_file('XUnit', path)
+
+    def debug_file(self, path: Path):
+        """Called when debug file is closed.
+
+        Calls :meth:`result_file` by default.
+        """
+        self.result_file('Debug', path)
+
+    def result_file(self, kind: Literal['Output', 'Report', 'Log', 'XUnit', 'Debug'],
+                    path: Path):
+        """Called when any result file is closed by default.
+
+        ``kind`` specifies the file type. This method is not called if a result
+        file specific method like :meth:`output_file` is implemented.
+        """
+        pass
+
+    def imported(self, import_type: str, name: str, attrs):
+        pass
+
+    def close(self):
+        pass

{robotframework-6.1.1 → robotframework-7.0}/src/robot/output/loggerhelper.py

@@ -14,10 +14,12 @@
 #  limitations under the License.
 
 import sys
+from datetime import datetime
+from typing import Callable, Literal
 
 from robot.errors import DataError
-from robot.model import Message as BaseMessage
-from robot.utils import get_timestamp, is_string, safe_str, console_encode
+from robot.model import Message as BaseMessage, MessageLevel
+from robot.utils import console_encode, safe_str
 
 
 LEVELS = {
@@ -30,6 +32,7 @@ LEVELS = {
   'DEBUG' : 1,
   'TRACE' : 0,
 }
+PseudoLevel = Literal['HTML', 'CONSOLE']
 
 
 def write_to_console(msg, newline=True, stream='stdout'):
@@ -88,38 +91,35 @@ class AbstractLogger:
 class Message(BaseMessage):
     __slots__ = ['_message']
 
-    def __init__(self, message, level='INFO', html=False, timestamp=None):
-        message = self._normalize_message(message)
+    def __init__(self, message: 'str|Callable[[], str]',
+                 level: 'MessageLevel|PseudoLevel' = 'INFO',
+                 html: bool = False,
+                 timestamp: 'datetime|str|None' = None):
         level, html = self._get_level_and_html(level, html)
-        timestamp = timestamp or get_timestamp()
-        super().__init__(message, level, html, timestamp)
-
-    def _normalize_message(self, msg):
-        if callable(msg):
-            return msg
-        if not is_string(msg):
-            msg = safe_str(msg)
-        if '\r\n' in msg:
-            msg = msg.replace('\r\n', '\n')
-        return msg
-
-    def _get_level_and_html(self, level, html):
+        super().__init__(message, level, html, timestamp or datetime.now())
+
+    def _get_level_and_html(self, level, html) -> 'tuple[MessageLevel, bool]':
         level = level.upper()
         if level == 'HTML':
             return 'INFO', True
         if level == 'CONSOLE':
-            level = 'INFO'
-        if level not in LEVELS:
-            raise DataError("Invalid log level '%s'." % level)
-        return level, html
+            return 'INFO', html
+        if level in LEVELS:
+            return level, html
+        raise DataError(f"Invalid log level '{level}'.")
 
     @property
-    def message(self):
+    def message(self) -> str:
         self.resolve_delayed_message()
         return self._message
 
     @message.setter
-    def message(self, message):
+    def message(self, message: 'str|Callable[[], str]'):
+        if not callable(message):
+            if not isinstance(message, str):
+                message = safe_str(message)
+            if '\r\n' in message:
+                message = message.replace('\r\n', '\n')
         self._message = message
 
     def resolve_delayed_message(self):
@@ -146,36 +146,3 @@ class IsLogged:
             return LEVELS[level.upper()]
         except KeyError:
             raise DataError("Invalid log level '%s'." % level)
-
-
-class AbstractLoggerProxy:
-    _methods = None
-    _no_method = lambda *args: None
-
-    def __init__(self, logger, method_names=None, prefix=None):
-        self.logger = logger
-        for name in method_names or self._methods:
-            # Allow extending classes to implement some of the messages themselves.
-            if hasattr(self, name):
-                if hasattr(logger, name):
-                    continue
-                target = logger
-            else:
-                target = self
-            setattr(target, name, self._get_method(logger, name, prefix))
-
-    def _get_method(self, logger, name, prefix):
-        for method_name in self._get_method_names(name, prefix):
-            if hasattr(logger, method_name):
-                return getattr(logger, method_name)
-        return self._no_method
-
-    def _get_method_names(self, name, prefix):
-        names = [name, self._toCamelCase(name)] if '_' in name else [name]
-        if prefix:
-            names += [prefix + name for name in names]
-        return names
-
-    def _toCamelCase(self, name):
-        parts = name.split('_')
-        return ''.join([parts[0]] + [part.capitalize() for part in parts[1:]])