robotframework 6.1.1__zip → 7.0__zip

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

@@ -16,9 +16,10 @@
 import sys
 
 from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
 
 
-class QuietOutput:
+class QuietOutput(LoggerApi):
 
     def __init__(self, colors='AUTO', stderr=None):
         self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
@@ -28,5 +29,5 @@ class QuietOutput:
             self._stderr.error(msg.message, msg.level)
 
 
-class NoOutput:
+class NoOutput(LoggerApi):
     pass

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

@@ -16,58 +16,58 @@
 import sys
 
 from robot.errors import DataError
-from robot.utils import (get_console_length, getshortdoc, isatty,
-                         pad_console_length)
+from robot.utils import get_console_length, getshortdoc, isatty, pad_console_length
 
 from .highlighting import HighlightingStream
+from ..loggerapi import LoggerApi
 
 
-class VerboseOutput:
+class VerboseOutput(LoggerApi):
 
     def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
                  stderr=None):
-        self._writer = VerboseWriter(width, colors, markers, stdout, stderr)
-        self._started = False
-        self._started_keywords = 0
-        self._running_test = False
-
-    def start_suite(self, suite):
-        if not self._started:
-            self._writer.suite_separator()
-            self._started = True
-        self._writer.info(suite.longname, suite.doc, start_suite=True)
-        self._writer.suite_separator()
-
-    def end_suite(self, suite):
-        self._writer.info(suite.longname, suite.doc)
-        self._writer.status(suite.status)
-        self._writer.message(suite.full_message)
-        self._writer.suite_separator()
-
-    def start_test(self, test):
-        self._writer.info(test.name, test.doc)
-        self._running_test = True
-
-    def end_test(self, test):
-        self._writer.status(test.status, clear=True)
-        self._writer.message(test.message)
-        self._writer.test_separator()
-        self._running_test = False
-
-    def start_keyword(self, kw):
-        self._started_keywords += 1
-
-    def end_keyword(self, kw):
-        self._started_keywords -= 1
-        if self._running_test and not self._started_keywords:
-            self._writer.keyword_marker(kw.status)
+        self.writer = VerboseWriter(width, colors, markers, stdout, stderr)
+        self.started = False
+        self.started_keywords = 0
+        self.running_test = False
+
+    def start_suite(self, data, result):
+        if not self.started:
+            self.writer.suite_separator()
+            self.started = True
+        self.writer.info(data.full_name, result.doc, start_suite=True)
+        self.writer.suite_separator()
+
+    def end_suite(self, data, result):
+        self.writer.info(data.full_name, result.doc)
+        self.writer.status(result.status)
+        self.writer.message(result.full_message)
+        self.writer.suite_separator()
+
+    def start_test(self, data, result):
+        self.writer.info(result.name, result.doc)
+        self.running_test = True
+
+    def end_test(self, data, result):
+        self.writer.status(result.status, clear=True)
+        self.writer.message(result.message)
+        self.writer.test_separator()
+        self.running_test = False
+
+    def start_body_item(self, data, result):
+        self.started_keywords += 1
+
+    def end_body_item(self, data, result):
+        self.started_keywords -= 1
+        if self.running_test and not self.started_keywords:
+            self.writer.keyword_marker(result.status)
 
     def message(self, msg):
         if msg.level in ('WARN', 'ERROR'):
-            self._writer.error(msg.message, msg.level, clear=self._running_test)
+            self.writer.error(msg.message, msg.level, clear=self.running_test)
 
-    def output_file(self, name, path):
-        self._writer.output(name, path)
+    def result_file(self, kind, path):
+        self.writer.output(kind, path)
 
 
 class VerboseWriter:
@@ -75,10 +75,10 @@ class VerboseWriter:
 
     def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
                  stderr=None):
-        self._width = width
-        self._stdout = HighlightingStream(stdout or sys.__stdout__, colors)
-        self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
-        self._keyword_marker = KeywordMarker(self._stdout, markers)
+        self.width = width
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self._keyword_marker = KeywordMarker(self.stdout, markers)
         self._last_info = None
 
     def info(self, name, doc, start_suite=False):
@@ -88,18 +88,18 @@ class VerboseWriter:
         self._keyword_marker.reset_count()
 
     def _write_info(self):
-        self._stdout.write(self._last_info)
+        self.stdout.write(self._last_info)
 
     def _get_info_width_and_separator(self, start_suite):
         if start_suite:
-            return self._width, '\n'
-        return self._width - self._status_length - 1, ' '
+            return self.width, '\n'
+        return self.width - self._status_length - 1, ' '
 
     def _get_info(self, name, doc, width):
         if get_console_length(name) > width:
             return pad_console_length(name, width)
         doc = getshortdoc(doc, linesep=' ')
-        info = '%s :: %s' % (name, doc) if doc else name
+        info = f'{name} :: {doc}' if doc else name
         return pad_console_length(info, width)
 
     def suite_separator(self):
@@ -109,14 +109,14 @@ class VerboseWriter:
         self._fill('-')
 
     def _fill(self, char):
-        self._stdout.write('%s\n' % (char * self._width))
+        self.stdout.write(f'{char * self.width}\n')
 
     def status(self, status, clear=False):
         if self._should_clear_markers(clear):
             self._clear_status()
-        self._stdout.write('| ', flush=False)
-        self._stdout.highlight(status, flush=False)
-        self._stdout.write(' |\n')
+        self.stdout.write('| ', flush=False)
+        self.stdout.highlight(status, flush=False)
+        self.stdout.write(' |\n')
 
     def _should_clear_markers(self, clear):
         return clear and self._keyword_marker.marking_enabled
@@ -126,12 +126,12 @@ class VerboseWriter:
         self._write_info()
 
     def _clear_info(self):
-        self._stdout.write('\r%s\r' % (' ' * self._width))
+        self.stdout.write(f"\r{' ' * self.width}\r")
         self._keyword_marker.reset_count()
 
     def message(self, message):
         if message:
-            self._stdout.write(message.strip() + '\n')
+            self.stdout.write(message.strip() + '\n')
 
     def keyword_marker(self, status):
         if self._keyword_marker.marker_count == self._status_length:
@@ -142,18 +142,18 @@ class VerboseWriter:
     def error(self, message, level, clear=False):
         if self._should_clear_markers(clear):
             self._clear_info()
-        self._stderr.error(message, level)
+        self.stderr.error(message, level)
         if self._should_clear_markers(clear):
             self._write_info()
 
     def output(self, name, path):
-        self._stdout.write('%-8s %s\n' % (name+':', path))
+        self.stdout.write(f"{name+':':8} {path}\n")
 
 
 class KeywordMarker:
 
     def __init__(self, highlighter, markers):
-        self._highlighter = highlighter
+        self.highlighter = highlighter
         self.marking_enabled = self._marking_enabled(markers, highlighter)
         self.marker_count = 0
 
@@ -164,13 +164,13 @@ class KeywordMarker:
         try:
             return options[markers.upper()]
         except KeyError:
-            raise DataError("Invalid console marker value '%s'. Available "
-                            "'AUTO', 'ON' and 'OFF'." % markers)
+            raise DataError(f"Invalid console marker value '{markers}'. "
+                            f"Available 'AUTO', 'ON' and 'OFF'.")
 
     def mark(self, status):
         if self.marking_enabled:
             marker, status = ('.', 'PASS') if status != 'FAIL' else ('F', 'FAIL')
-            self._highlighter.highlight(marker, status)
+            self.highlighter.highlight(marker, status)
             self.marker_count += 1
 
     def reset_count(self):

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

@@ -13,10 +13,13 @@
 #  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.utils import get_timestamp, file_writer, seq2str2
+from robot.utils import file_writer, seq2str2
 
 from .logger import LOGGER
+from .loggerapi import LoggerApi
 from .loggerhelper import IsLogged
 
 
@@ -34,7 +37,7 @@ def DebugFile(path):
         return _DebugFileWriter(outfile)
 
 
-class _DebugFileWriter:
+class _DebugFileWriter(LoggerApi):
     _separators = {'SUITE': '=', 'TEST': '-', 'KEYWORD': '~'}
 
     def __init__(self, outfile):
@@ -44,64 +47,76 @@ class _DebugFileWriter:
         self._outfile = outfile
         self._is_logged = IsLogged('DEBUG')
 
-    def start_suite(self, suite):
+    def start_suite(self, data, result):
         self._separator('SUITE')
-        self._start('SUITE', suite.longname)
+        self._start('SUITE', data.full_name, result.start_time)
         self._separator('SUITE')
 
-    def end_suite(self, suite):
+    def end_suite(self, data, result):
         self._separator('SUITE')
-        self._end('SUITE', suite.longname, suite.elapsedtime)
+        self._end('SUITE', data.full_name, result.end_time, result.elapsed_time)
         self._separator('SUITE')
         if self._indent == 0:
-            LOGGER.output_file('Debug', self._outfile.name)
+            LOGGER.debug_file(Path(self._outfile.name))
             self.close()
 
-    def start_test(self, test):
+    def start_test(self, data, result):
         self._separator('TEST')
-        self._start('TEST', test.name)
+        self._start('TEST', result.name, result.start_time)
         self._separator('TEST')
 
-    def end_test(self, test):
+    def end_test(self, data, result):
         self._separator('TEST')
-        self._end('TEST', test.name, test.elapsedtime)
+        self._end('TEST', result.name, result.end_time, result.elapsed_time)
         self._separator('TEST')
 
-    def start_keyword(self, kw):
+    def start_keyword(self, data, result):
+        if self._kw_level == 0:
+            self._separator('KEYWORD')
+        self._start(result.type, result.full_name, result.start_time, seq2str2(result.args))
+        self._kw_level += 1
+
+    def end_keyword(self, data, result):
+        self._end(result.type, result.full_name, result.end_time, result.elapsed_time)
+        self._kw_level -= 1
+
+    def start_body_item(self, data, result):
         if self._kw_level == 0:
             self._separator('KEYWORD')
-        self._start(kw.type, kw.name, kw.args)
+        self._start(result.type, result._log_name, result.start_time)
         self._kw_level += 1
 
-    def end_keyword(self, kw):
-        self._end(kw.type, kw.name, kw.elapsedtime)
+    def end_body_item(self, data, result):
+        self._end(result.type, result._log_name, result.end_time, result.elapsed_time)
         self._kw_level -= 1
 
     def log_message(self, msg):
         if self._is_logged(msg.level):
-            self._write(msg.message, level=msg.level, timestamp=msg.timestamp)
+            self._write(f'{msg.timestamp} - {msg.level} - {msg.message}')
 
     def close(self):
         if not self._outfile.closed:
             self._outfile.close()
 
-    def _start(self, type_, name, args=''):
-        args = ' ' + seq2str2(args)
-        self._write('+%s START %s: %s%s' % ('-'*self._indent, type_, name, args))
+    def _start(self, type, name, timestamp, extra=''):
+        if extra:
+            extra = f' {extra}'
+        indent = '-' * self._indent
+        self._write(f'{timestamp} - INFO - +{indent} START {type}: {name}{extra}')
         self._indent += 1
 
-    def _end(self, type_, name, elapsed):
+    def _end(self, type, name, timestamp, elapsed):
         self._indent -= 1
-        self._write('+%s END %s: %s (%s)' % ('-'*self._indent, type_, name, elapsed))
+        indent = '-' * self._indent
+        elapsed = elapsed.total_seconds()
+        self._write(f'{timestamp} - INFO - +{indent} END {type}: {name} ({elapsed} s)')
 
     def _separator(self, type_):
         self._write(self._separators[type_] * 78, separator=True)
 
-    def _write(self, text, separator=False, level='INFO', timestamp=None):
+    def _write(self, text, separator=False):
         if separator and self._separator_written_last:
             return
-        if not separator:
-            text = '%s - %s - %s' % (timestamp or get_timestamp(), level, text)
         self._outfile.write(text.rstrip() + '\n')
         self._outfile.flush()
         self._separator_written_last = separator

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

@@ -16,9 +16,10 @@
 from robot.utils import file_writer
 
 from .loggerhelper import AbstractLogger
+from .loggerapi import LoggerApi
 
 
-class FileLogger(AbstractLogger):
+class FileLogger(AbstractLogger, LoggerApi):
 
     def __init__(self, path, level):
         super().__init__(level)
@@ -33,26 +34,28 @@ class FileLogger(AbstractLogger):
                                         msg.message)
             self._writer.write(entry)
 
-    def start_suite(self, suite):
-        self.info("Started suite '%s'." % suite.name)
+    def start_suite(self, data, result):
+        self.info("Started suite '%s'." % result.name)
 
-    def end_suite(self, suite):
-        self.info("Ended suite '%s'." % suite.name)
+    def end_suite(self, data, result):
+        self.info("Ended suite '%s'." % result.name)
 
-    def start_test(self, test):
-        self.info("Started test '%s'." % test.name)
+    def start_test(self, data, result):
+        self.info("Started test '%s'." % result.name)
 
-    def end_test(self, test):
-        self.info("Ended test '%s'." % test.name)
+    def end_test(self, data, result):
+        self.info("Ended test '%s'." % result.name)
 
-    def start_keyword(self, kw):
-        self.debug(lambda: "Started keyword '%s'." % kw.name)
+    def start_body_item(self, data, result):
+        self.debug(lambda: "Started keyword '%s'." % result.name
+                   if result.type in result.KEYWORD_TYPES else result._log_name)
 
-    def end_keyword(self, kw):
-        self.debug(lambda: "Ended keyword '%s'." % kw.name)
+    def end_body_item(self, data, result):
+        self.debug(lambda: "Ended keyword '%s'." % result.name
+                   if result.type in result.KEYWORD_TYPES else result._log_name)
 
-    def output_file(self, name, path):
-        self.info('%s: %s' % (name, path))
+    def result_file(self, kind, path):
+        self.info('%s: %s' % (kind, path))
 
     def close(self):
         self._writer.close()

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

@@ -20,6 +20,7 @@ here to avoid cyclic imports.
 """
 
 import threading
+from typing import Callable
 
 from .logger import LOGGER
 from .loggerhelper import Message, write_to_console
@@ -28,7 +29,7 @@ from .loggerhelper import Message, write_to_console
 LOGGING_THREADS = ('MainThread', 'RobotFrameworkTimeoutThread')
 
 
-def write(msg, level, html=False):
+def write(msg: 'str | Callable[[], str]', level: str, html: bool = False):
     # Callable messages allow lazy logging internally, but we don't want to
     # expose this functionality publicly. See the following issue for details:
     # https://github.com/robotframework/robotframework/issues/1505
@@ -66,5 +67,5 @@ def error(msg, html=False):
     write(msg, 'ERROR', html)
 
 
-def console(msg, newline=True, stream='stdout'):
+def console(msg: str, newline: bool = True, stream: str = 'stdout'):
     write_to_console(msg, newline, stream)