robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/model/visitor.py

@@ -105,9 +105,9 @@ removed altogether if they get in the way.
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from robot.model import (Break, BodyItem, Continue, Error, For, If, IfBranch,
-                             Keyword, Message, Return, TestCase, TestSuite, Try,
-                             TryBranch, Var, While)
+    from robot.model import (Break, BodyItem, Continue, Error, For, Group, If,
+                             IfBranch, Keyword, Message, Return, TestCase, TestSuite,
+                             Try, TryBranch, Var, While)
     from robot.result import ForIteration, WhileIteration
 
 
@@ -427,6 +427,32 @@ class SuiteVisitor:
         """
         self.end_body_item(iteration)
 
+    def visit_group(self, group: 'Group'):
+        """Visits GROUP elements.
+
+        Can be overridden to allow modifying the passed in ``group`` without
+        calling :meth:`start_group` or :meth:`end_group` nor visiting body.
+        """
+        if self.start_group(group) is not False:
+            group.body.visit(self)
+            self.end_group(group)
+
+    def start_group(self, group: 'Group') -> 'bool|None':
+        """Called when a GROUP element starts.
+
+        By default, calls :meth:`start_body_item` which, by default, does nothing.
+
+        Can return explicit ``False`` to stop visiting.
+        """
+        return self.start_body_item(group)
+
+    def end_group(self, group: 'Group'):
+        """Called when a GROUP element ends.
+
+        By default, calls :meth:`end_body_item` which, by default, does nothing.
+        """
+        self.end_body_item(group)
+
     def visit_var(self, var: 'Var'):
         """Visits a VAR elements."""
         if self.start_var(var) is not False:

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/__init__.py

@@ -19,7 +19,8 @@ Not part of the public API, and also subject to change in the future when
 test execution is refactored.
 """
 
-from .output import Output
 from .logger import LOGGER
-from .xmllogger import XmlLogger
 from .loggerhelper import LEVELS, Message
+from .loglevel import LogLevel
+from .output import Output
+from .xmllogger import XmlLogger

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/console/dotted.py

@@ -14,14 +14,17 @@
 #  limitations under the License.
 
 import sys
+from typing import TYPE_CHECKING
 
 from robot.model import SuiteVisitor
-from robot.result import TestCase, TestSuite
 from robot.utils import plural_or_not as s, secs_to_timestr
 
 from .highlighting import HighlightingStream
 from ..loggerapi import LoggerApi
 
+if TYPE_CHECKING:
+    from robot.result import TestCase, TestSuite
+
 
 class DottedOutput(LoggerApi):
 
@@ -72,7 +75,7 @@ class StatusReporter(SuiteVisitor):
         self.stream = stream
         self.width = width
 
-    def report(self, suite: TestSuite):
+    def report(self, suite: 'TestSuite'):
         suite.visit(self)
         stats = suite.statistics
         ts = ('test' if not suite.rpa else 'task') + s(stats.total)
@@ -83,7 +86,7 @@ class StatusReporter(SuiteVisitor):
         self.stream.highlight(suite.status + ed, suite.status)
         self.stream.write(f'\n{stats.message}\n')
 
-    def visit_test(self, test: TestCase):
+    def visit_test(self, test: 'TestCase'):
         if test.failed and not test.tags.robot('exit'):
             self.stream.write('-' * self.width + '\n')
             self.stream.highlight('FAIL')

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/console/highlighting.py

@@ -19,7 +19,6 @@
 
 import errno
 import os
-import socket
 import sys
 from contextlib import contextmanager
 try:
@@ -44,10 +43,12 @@ from robot.utils import console_encode, isatty, WINDOWS
 class HighlightingStream:
 
     def __init__(self, stream, colors='AUTO', links='AUTO'):
-        self.stream = stream
+        self.stream = stream or NullStream()
         self._highlighter = self._get_highlighter(stream, colors, links)
 
     def _get_highlighter(self, stream, colors, links):
+        if not stream:
+            return NoHighlighting()
         options = {'AUTO': Highlighter if isatty(stream) else NoHighlighting,
                    'ON': Highlighter,
                    'OFF': NoHighlighting,
@@ -103,7 +104,7 @@ class HighlightingStream:
     def error(self, message, level):
         self.write('[ ', flush=False)
         self.highlight(level, flush=False)
-        self.write(' ] %s\n' % message)
+        self.write(f' ] {message}\n')
 
     @contextmanager
     def _highlighting(self, status):
@@ -120,10 +121,19 @@ class HighlightingStream:
             highlighter.reset()
 
     def result_file(self, kind, path):
-        path = self._highlighter.link(path)
+        path = self._highlighter.link(path) if path else 'NONE'
         self.write(f"{kind + ':':8} {path}\n")
 
 
+class NullStream:
+
+    def write(self, text):
+        pass
+
+    def flush(self):
+        pass
+
+
 def Highlighter(stream, links=True):
     if os.sep == '/':
         return AnsiHighlighter(stream, links)
@@ -163,12 +173,7 @@ class AnsiHighlighter:
             uri = path.as_uri()
         except ValueError:
             return path
-        # Add the host name to the URI to support opening links remotely.
-        # Windows Terminal doesn't yet support the host component, though:
-        # https://github.com/microsoft/terminal/issues/14116
-        if uri[:8] == 'file:///' and not WINDOWS:
-            uri = f'file://{socket.getfqdn()}/{uri[8:]}'
-        # The hyperlink format is documented here:
+        # Terminal hyperlink syntax is documented here:
         # https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
         return f'\033]8;;{uri}\033\\{path}\033]8;;\033\\'
 
@@ -178,6 +183,9 @@ class AnsiHighlighter:
 
 class NoHighlighting(AnsiHighlighter):
 
+    def __init__(self, stream=None, links=True):
+        super().__init__(stream, links)
+
     def link(self, path):
         return path
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/debugfile.py

@@ -20,7 +20,7 @@ from robot.utils import file_writer, seq2str2
 
 from .logger import LOGGER
 from .loggerapi import LoggerApi
-from .loggerhelper import IsLogged
+from .loglevel import LogLevel
 
 
 def DebugFile(path):
@@ -45,7 +45,7 @@ class _DebugFileWriter(LoggerApi):
         self._kw_level = 0
         self._separator_written_last = False
         self._outfile = outfile
-        self._is_logged = IsLogged('DEBUG')
+        self._is_logged = LogLevel('DEBUG').is_logged
 
     def start_suite(self, data, result):
         self._separator('SUITE')
@@ -91,7 +91,7 @@ class _DebugFileWriter(LoggerApi):
         self._kw_level -= 1
 
     def log_message(self, msg):
-        if self._is_logged(msg.level):
+        if self._is_logged(msg):
             self._write(f'{msg.timestamp} - {msg.level} - {msg.message}')
 
     def close(self):

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/filelogger.py

@@ -15,21 +15,25 @@
 
 from robot.utils import file_writer
 
-from .loggerhelper import AbstractLogger
 from .loggerapi import LoggerApi
+from .loggerhelper import AbstractLogger
+from .loglevel import LogLevel
 
 
 class FileLogger(AbstractLogger, LoggerApi):
 
     def __init__(self, path, level):
-        super().__init__(level)
+        self._log_level = LogLevel(level)
         self._writer = self._get_writer(path)  # unit test hook
 
     def _get_writer(self, path):
         return file_writer(path, usage='syslog')
 
+    def set_level(self, level):
+        self._log_level.set(level)
+
     def message(self, msg):
-        if self._is_logged(msg.level) and not self._writer.closed:
+        if self._log_level.is_logged(msg) and not self._writer.closed:
             entry = '%s | %s | %s\n' % (msg.timestamp, msg.level.ljust(5),
                                         msg.message)
             self._writer.write(entry)

robotframework-7.2b1/src/robot/output/jsonlogger.py

@@ -0,0 +1,338 @@
+#  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.
+
+import json
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from pathlib import Path
+from typing import TextIO
+
+from robot.version import get_full_version
+
+
+class JsonLogger:
+
+    def __init__(self, file: TextIO, rpa: bool = False):
+        self.writer = JsonWriter(file)
+        self.writer.start_dict(generator=get_full_version('Robot'),
+                               generated=datetime.now().isoformat(),
+                               rpa=Raw(self.writer.encode(rpa)))
+        self.containers = []
+
+    def start_suite(self, suite):
+        if not self.containers:
+            name = 'suite'
+            container = None
+        else:
+            name = None
+            container = 'suites'
+        self._start(container, name, id=suite.id)
+
+    def end_suite(self, suite):
+        self._end(name=suite.name,
+                  doc=suite.doc,
+                  metadata=suite.metadata,
+                  source=suite.source,
+                  rpa=suite.rpa,
+                  **self._status(suite))
+
+    def start_test(self, test):
+        self._start('tests', id=test.id)
+
+    def end_test(self, test):
+        self._end(name=test.name,
+                  doc=test.doc,
+                  tags=test.tags,
+                  lineno=test.lineno,
+                  timeout=str(test.timeout) if test.timeout else None,
+                  **self._status(test))
+
+    def start_keyword(self, kw):
+        if kw.type in ('SETUP', 'TEARDOWN'):
+            self._end_container()
+            name = kw.type.lower()
+            container = None
+        else:
+            name = None
+            container = 'body'
+        self._start(container, name)
+
+    def end_keyword(self, kw):
+        self._end(name=kw.name,
+                  owner=kw.owner,
+                  source_name=kw.source_name,
+                  args=[str(a) for a in kw.args],
+                  assign=kw.assign,
+                  tags=kw.tags,
+                  doc=kw.doc,
+                  timeout=str(kw.timeout) if kw.timeout else None,
+                  **self._status(kw))
+
+    def start_for(self, item):
+        self._start(type=item.type)
+
+    def end_for(self, item):
+        self._end(flavor=item.flavor,
+                  start=item.start,
+                  mode=item.mode,
+                  fill=UnlessNone(item.fill),
+                  assign=item.assign,
+                  values=item.values,
+                  **self._status(item))
+
+    def start_for_iteration(self, item):
+        self._start(type=item.type)
+
+    def end_for_iteration(self, item):
+        self._end(assign=item.assign, **self._status(item))
+
+    def start_while(self, item):
+        self._start(type=item.type)
+
+    def end_while(self, item):
+        self._end(condition=item.condition,
+                  limit=item.limit,
+                  on_limit=item.on_limit,
+                  on_limit_message=item.on_limit_message,
+                  **self._status(item))
+
+    def start_while_iteration(self, item):
+        self._start(type=item.type)
+
+    def end_while_iteration(self, item):
+        self._end(**self._status(item))
+
+    def start_if(self, item):
+        self._start(type=item.type)
+
+    def end_if(self, item):
+        self._end(**self._status(item))
+
+    def start_if_branch(self, item):
+        self._start(type=item.type)
+
+    def end_if_branch(self, item):
+        self._end(condition=item.condition, **self._status(item))
+
+    def start_try(self, item):
+        self._start(type=item.type)
+
+    def end_try(self, item):
+        self._end(**self._status(item))
+
+    def start_try_branch(self, item):
+        self._start(type=item.type)
+
+    def end_try_branch(self, item):
+        self._end(patterns=item.patterns,
+                  pattern_type=item.pattern_type,
+                  assign=item.assign,
+                  **self._status(item))
+
+    def start_group(self, item):
+        self._start(type=item.type)
+
+    def end_group(self, item):
+        self._end(name=item.name,
+                  **self._status(item))
+
+    def start_var(self, item):
+        self._start(type=item.type)
+
+    def end_var(self, item):
+        self._end(name=item.name,
+                  scope=item.scope,
+                  separator=UnlessNone(item.separator),
+                  value=item.value,
+                  **self._status(item))
+
+    def start_return(self, item):
+        self._start(type=item.type)
+
+    def end_return(self, item):
+        self._end(values=item.values, **self._status(item))
+
+    def start_continue(self, item):
+        self._start(type=item.type)
+
+    def end_continue(self, item):
+        self._end(**self._status(item))
+
+    def start_break(self, item):
+        self._start(type=item.type)
+
+    def end_break(self, item):
+        self._end(**self._status(item))
+
+    def start_error(self, item):
+        self._start(type=item.type)
+
+    def end_error(self, item):
+        self._end(values=item.values, **self._status(item))
+
+    def message(self, msg):
+        self._dict(**msg.to_dict())
+
+    def errors(self, messages):
+        self._list('errors', [m.to_dict(include_type=False) for m in messages])
+
+    def statistics(self, stats):
+        data = stats.to_dict()
+        self._start(None, 'statistics')
+        self._dict(None, 'total', **data['total'])
+        self._list('suites', data['suites'])
+        self._list('tags', data['tags'])
+        self._end()
+
+    def close(self):
+        self.writer.end_dict()
+        self.writer.close()
+
+    def _status(self, item):
+        return {'status': item.status,
+                'message': item.message,
+                'start_time': item.start_time.isoformat() if item.start_time else None,
+                'elapsed_time': Raw(format(item.elapsed_time.total_seconds(), 'f'))}
+
+    def _dict(self, container: 'str|None' = 'body', name: 'str|None' = None, /,
+              **items):
+        self._start(container, name, **items)
+        self._end()
+
+    def _list(self, name: 'str|None', items: list):
+        self.writer.start_list(name)
+        for item in items:
+            self._dict(None, None, **item)
+        self.writer.end_list()
+
+    def _start(self, container: 'str|None' = 'body', name: 'str|None' = None, /,
+               **items):
+        if container:
+            self._start_container(container)
+        self.writer.start_dict(name, **items)
+        self.containers.append(None)
+
+    def _start_container(self, container):
+        if self.containers[-1] != container:
+            if self.containers[-1]:
+                self.writer.end_list()
+            self.writer.start_list(container)
+            self.containers[-1] = container
+
+    def _end(self, **items):
+        self._end_container()
+        self.containers.pop()
+        self.writer.end_dict(**items)
+
+    def _end_container(self):
+        if self.containers[-1]:
+            self.writer.end_list()
+            self.containers[-1] = None
+
+
+class JsonWriter:
+
+    def __init__(self, file):
+        self.encode = json.JSONEncoder(check_circular=False,
+                                       separators=(',', ':'),
+                                       default=self._handle_custom).encode
+        self.file = file
+        self.comma = False
+        self.newline = False
+
+    def _handle_custom(self, value):
+        if isinstance(value, Path):
+            return str(value)
+        if isinstance(value, Mapping):
+            return dict(value)
+        if isinstance(value, Sequence):
+            return list(value)
+        raise TypeError(type(value).__name__)
+
+    def start_dict(self, name=None, /, **items):
+        self._start(name, '{')
+        self.items(**items)
+
+    def _start(self, name, char):
+        self._newline(newline=name is not None)
+        self._name(name)
+        self._write(char)
+        self.comma = False
+
+    def _newline(self, comma: 'bool|None' = None, newline: 'bool|None' = None):
+        if (self.comma if comma is None else comma):
+            self._write(',')
+        if (self.newline if newline is None else newline):
+            self._write('\n')
+        self.newline = True
+
+    def _name(self, name):
+        if name:
+            self._write(f'"{name}":')
+
+    def _write(self, text):
+        self.file.write(text)
+
+    def end_dict(self, **items):
+        self.items(**items)
+        self._end('}')
+
+    def _end(self, char, newline=True):
+        self._newline(comma=False, newline=newline)
+        self._write(char)
+        self.comma = True
+
+    def start_list(self, name=None, /):
+        self._start(name, '[')
+
+    def end_list(self):
+        self._end(']', newline=False)
+
+    def items(self, **items):
+        for name, value in items.items():
+            self._item(value, name)
+
+    def _item(self, value, name=None):
+        if isinstance(value, UnlessNone) and value:
+            value = value.value
+        elif not (value or value == 0 and not isinstance(value, bool)):
+            return
+        if isinstance(value, Raw):
+            value = value.value
+        else:
+            value = self.encode(value)
+        self._newline()
+        self._name(name)
+        self._write(value)
+        self.comma = True
+
+    def close(self):
+        self._write('\n')
+        self.file.close()
+
+
+class Raw:
+
+    def __init__(self, value):
+        self.value = value
+
+
+class UnlessNone:
+
+    def __init__(self, value):
+        self.value = value
+
+    def __bool__(self):
+        return self.value is not None

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/output/librarylogger.py

@@ -19,29 +19,30 @@ This is exposed via :py:mod:`robot.api.logger`. Implementation must reside
 here to avoid cyclic imports.
 """
 
-import threading
-from typing import Callable
+from threading import current_thread
+from typing import Any
+
+from robot.utils import safe_str
 
 from .logger import LOGGER
 from .loggerhelper import Message, write_to_console
 
 
-LOGGING_THREADS = ('MainThread', 'RobotFrameworkTimeoutThread')
+# This constant is used by BackgroundLogger.
+# https://github.com/robotframework/robotbackgroundlogger
+LOGGING_THREADS = ['MainThread', 'RobotFrameworkTimeoutThread']
 
 
-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
-    if callable(msg):
-        msg = str(msg)
+def write(msg: Any, level: str, html: bool = False):
+    if not isinstance(msg, str):
+        msg = safe_str(msg)
     if level.upper() not in ('TRACE', 'DEBUG', 'INFO', 'HTML', 'WARN', 'ERROR'):
         if level.upper() == 'CONSOLE':
             level = 'INFO'
             console(msg)
         else:
-            raise RuntimeError("Invalid log level '%s'." % level)
-    if threading.current_thread().name in LOGGING_THREADS:
+            raise RuntimeError(f"Invalid log level '{level}'.")
+    if current_thread().name in LOGGING_THREADS:
         LOGGER.log_message(Message(msg, level, html))