robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/jsmodelbuilders.py

@@ -13,17 +13,19 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import re
+
 from robot.output import LEVELS
+from robot.result import Error, Keyword, Message, Return
 
 from .jsbuildingcontext import JsBuildingContext
 from .jsexecutionresult import JsExecutionResult
 
-
 STATUSES = {'FAIL': 0, 'PASS': 1, 'SKIP': 2, 'NOT RUN': 3}
 KEYWORD_TYPES = {'KEYWORD': 0, 'SETUP': 1, 'TEARDOWN': 2,
                  'FOR': 3, 'ITERATION': 4, 'IF': 5, 'ELSE IF': 6, 'ELSE': 7,
-                 'RETURN': 8, 'TRY': 9, 'EXCEPT': 10, 'FINALLY': 11, 'WHILE': 12,
-                 'CONTINUE': 13, 'BREAK': 14, 'ERROR': 15}
+                 'RETURN': 8, 'VAR': 9, 'TRY': 10, 'EXCEPT': 11, 'FINALLY': 12,
+                 'WHILE': 13, 'CONTINUE': 14, 'BREAK': 15, 'ERROR': 16}
 
 
 class JsModelBuilder:
@@ -47,49 +49,61 @@ class JsModelBuilder:
         )
 
 
-class _Builder:
+class Builder:
+    robot_note = re.compile('<span class="robot-note">(.*)</span>')
 
-    def __init__(self, context):
+    def __init__(self, context: JsBuildingContext):
         self._context = context
         self._string = self._context.string
         self._html = self._context.html
         self._timestamp = self._context.timestamp
 
-    def _get_status(self, item):
+    def _get_status(self, item, note_only=False):
         model = (STATUSES[item.status],
-                 self._timestamp(item.starttime),
-                 item.elapsedtime)
-        msg = getattr(item, 'message', '')
+                 self._timestamp(item.start_time),
+                 round(item.elapsed_time.total_seconds() * 1000))
+        msg = item.message
         if not msg:
             return model
-        elif msg.startswith('*HTML*'):
-            msg = self._string(msg[6:].lstrip(), escape=False)
+        if note_only:
+            if msg.startswith('*HTML*'):
+                match = self.robot_note.search(msg)
+                if match:
+                    index = self._string(match.group(1))
+                    return model + (index,)
+            return model
+        if msg.startswith('*HTML*'):
+            index = self._string(msg[6:].lstrip(), escape=False)
         else:
-            msg = self._string(msg)
-        return model + (msg,)
+            index = self._string(msg)
+        return model + (index,)
 
-    def _build_keywords(self, steps, split=False):
+    def _build_body(self, body, split=False):
         splitting = self._context.start_splitting_if_needed(split)
-        # tuple([<listcomp>>]) is faster than tuple(<genex>) with short lists.
-        model = tuple([self._build_keyword(step) for step in steps])
+        # tuple([<listcomp>]) is faster than tuple(<genex>) with short lists.
+        model = tuple([self._build_body_item(item) for item in body])
         return model if not splitting else self._context.end_splitting(model)
 
-    def _build_keyword(self, step):
+    def _build_body_item(self, item):
         raise NotImplementedError
 
 
-class SuiteBuilder(_Builder):
+class SuiteBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
+        super().__init__(context)
         self._build_suite = self.build
         self._build_test = TestBuilder(context).build
-        self._build_keyword = KeywordBuilder(context).build
+        self._build_body_item = BodyItemBuilder(context).build
 
     def build(self, suite):
         with self._context.prune_input(suite.tests, suite.suites):
             stats = self._get_statistics(suite)  # Must be done before pruning
-            kws = [kw for kw in (suite.setup, suite.teardown) if kw]
+            fixture = []
+            if suite.has_setup:
+                fixture.append(suite.setup)
+            if suite.has_teardown:
+                fixture.append(suite.teardown)
             return (self._string(suite.name, attr=True),
                     self._string(suite.source),
                     self._context.relative_source(suite.source),
@@ -98,7 +112,7 @@ class SuiteBuilder(_Builder):
                     self._get_status(suite),
                     tuple(self._build_suite(s) for s in suite.suites),
                     tuple(self._build_test(t) for t in suite.tests),
-                    tuple(self._build_keyword(k, split=True) for k in kws),
+                    tuple(self._build_body_item(kw, split=True) for kw in fixture),
                     stats)
 
     def _yield_metadata(self, suite):
@@ -111,63 +125,76 @@ class SuiteBuilder(_Builder):
         return (stats.total, stats.passed, stats.failed, stats.skipped)
 
 
-class TestBuilder(_Builder):
+class TestBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
-        self._build_keyword = KeywordBuilder(context).build
+        super().__init__(context)
+        self._build_body_item = BodyItemBuilder(context).build
 
     def build(self, test):
-        kws = self._get_keywords(test)
+        body = self._get_body_items(test)
         with self._context.prune_input(test.body):
             return (self._string(test.name, attr=True),
                     self._string(test.timeout),
                     self._html(test.doc),
                     tuple(self._string(t) for t in test.tags),
                     self._get_status(test),
-                    self._build_keywords(kws, split=True))
+                    self._build_body(body, split=True))
 
-    def _get_keywords(self, test):
-        kws = []
-        if test.setup:
-            kws.append(test.setup)
-        kws.extend(test.body.flatten())
-        if test.teardown:
-            kws.append(test.teardown)
-        return kws
+    def _get_body_items(self, test):
+        body = test.body.flatten()
+        if test.has_setup:
+            body.insert(0, test.setup)
+        if test.has_teardown:
+            body.append(test.teardown)
+        return body
 
 
-class KeywordBuilder(_Builder):
+class BodyItemBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
-        self._build_keyword = self.build
+        super().__init__(context)
+        self._build_body_item = self.build
         self._build_message = MessageBuilder(context).build
 
     def build(self, item, split=False):
-        if item.type == item.MESSAGE:
+        if isinstance(item, Message):
             return self._build_message(item)
-        return self.build_keyword(item, split)
-
-    def build_keyword(self, kw, split=False):
+        with self._context.prune_input(item.body):
+            if isinstance (item, Keyword):
+                return self._build_keyword(item, split)
+            if isinstance(item, (Return, Error)):
+                return self._build(item, args='    '.join(item.values), split=split)
+            return self._build(item, item._log_name, split=split)
+
+    def _build_keyword(self, kw: Keyword, split):
         self._context.check_expansion(kw)
-        items = kw.body.flatten()
-        if getattr(kw, 'has_teardown', False):
-            items.append(kw.teardown)
-        with self._context.prune_input(kw.body):
-            return (KEYWORD_TYPES[kw.type],
-                    self._string(kw.kwname, attr=True),
-                    self._string(kw.libname, attr=True),
-                    self._string(kw.timeout),
-                    self._html(kw.doc),
-                    self._string(', '.join(kw.args)),
-                    self._string(', '.join(kw.assign)),
-                    self._string(', '.join(kw.tags)),
-                    self._get_status(kw),
-                    self._build_keywords(items, split))
-
-
-class MessageBuilder(_Builder):
+        body = kw.body.flatten()
+        if kw.has_setup:
+            body.insert(0, kw.setup)
+        if kw.has_teardown:
+            body.append(kw.teardown)
+        return self._build(kw, kw.name, kw.owner, kw.timeout, kw.doc,
+                           '    '.join(kw.args), '    '.join(kw.assign),
+                           ', '.join(kw.tags), body, split=split)
+
+    def _build(self, item, name='', owner='', timeout='', doc='', args='', assign='',
+               tags='', body=None, split=False):
+        if body is None:
+            body = item.body.flatten()
+        return (KEYWORD_TYPES[item.type],
+                self._string(name, attr=True),
+                self._string(owner, attr=True),
+                self._string(timeout),
+                self._html(doc),
+                self._string(args),
+                self._string(assign),
+                self._string(tags),
+                self._get_status(item, note_only=True),
+                self._build_body(body, split))
+
+
+class MessageBuilder(Builder):
 
     def build(self, msg):
         if msg.level in ('WARN', 'ERROR'):
@@ -196,10 +223,10 @@ class StatisticsBuilder:
                      for stat in stats)
 
 
-class ErrorsBuilder(_Builder):
+class ErrorsBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
+        super().__init__(context)
         self._build_message = ErrorMessageBuilder(context).build
 
     def build(self, errors):

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/logreportwriters.py

@@ -13,10 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from pathlib import Path
 from os.path import basename, splitext
 
 from robot.htmldata import HtmlFileWriter, ModelWriter, LOG, REPORT
-from robot.utils import file_writer, is_string
+from robot.utils import file_writer
 
 from .jswriter import JsResultWriter, SplitLogWriter
 
@@ -27,9 +28,9 @@ class _LogReportWriter:
     def __init__(self, js_model):
         self._js_model = js_model
 
-    def _write_file(self, path, config, template):
+    def _write_file(self, path: Path, config, template):
         outfile = file_writer(path, usage=self.usage) \
-            if is_string(path) else path  # unit test hook
+            if isinstance(path, Path) else path  # unit test hook
         with outfile:
             model_writer = RobotModelWriter(outfile, self._js_model, config)
             writer = HtmlFileWriter(outfile, model_writer)
@@ -39,26 +40,31 @@ class _LogReportWriter:
 class LogWriter(_LogReportWriter):
     usage = 'log'
 
-    def write(self, path, config):
+    def write(self, path: 'Path|str', config):
+        if isinstance(path, str):
+            path = Path(path)
         self._write_file(path, config, LOG)
         if self._js_model.split_results:
-            self._write_split_logs(splitext(path)[0])
+            self._write_split_logs(path)
 
-    def _write_split_logs(self, base):
+    def _write_split_logs(self, path: Path):
         for index, (keywords, strings) in enumerate(self._js_model.split_results,
                                                     start=1):
-            self._write_split_log(index, keywords, strings, '%s-%d.js' % (base, index))
+            name = f'{path.stem}-{index}.js'
+            self._write_split_log(index, keywords, strings, path.with_name(name))
 
-    def _write_split_log(self, index, keywords, strings, path):
+    def _write_split_log(self, index, keywords, strings, path: Path):
         with file_writer(path, usage=self.usage) as outfile:
             writer = SplitLogWriter(outfile)
-            writer.write(keywords, strings, index, basename(path))
+            writer.write(keywords, strings, index, path.name)
 
 
 class ReportWriter(_LogReportWriter):
     usage = 'report'
 
-    def write(self, path, config):
+    def write(self, path: 'Path|str', config):
+        if isinstance(path, str):
+            path = Path(path)
         self._write_file(path, config, REPORT)
 
 

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/outputwriter.py

@@ -13,13 +13,29 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.output.xmllogger import XmlLogger
+from robot.output.xmllogger import XmlLogger, LegacyXmlLogger
 
 
 class OutputWriter(XmlLogger):
 
+    def __init__(self, output, rpa=False, suite_only=False):
+        super().__init__(output, rpa=rpa, generator='Rebot', suite_only=suite_only)
+
+    def start_message(self, msg):
+        self._write_message(msg)
+
+    def close(self):
+        self._writer.end('robot')
+        self._writer.close()
+
+    def end_result(self, result):
+        self.close()
+
+
+class LegacyOutputWriter(LegacyXmlLogger):
+
     def __init__(self, output, rpa=False):
-        XmlLogger.__init__(self, output, rpa=rpa, generator='Rebot')
+        super().__init__(output, rpa=rpa, generator='Rebot')
 
     def start_message(self, msg):
         self._write_message(msg)

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/resultwriter.py

@@ -54,7 +54,7 @@ class ResultWriter:
         settings = settings or RebotSettings(options)
         results = Results(settings, *self._sources)
         if settings.output:
-            self._write_output(results.result, settings.output)
+            self._write_output(results.result, settings.output, settings.legacy_output)
         if settings.xunit:
             self._write_xunit(results.result, settings.xunit)
         if settings.log:
@@ -67,8 +67,8 @@ class ResultWriter:
                                settings.report_config)
         return results.return_code
 
-    def _write_output(self, result, path):
-        self._write('Output', result.save, path)
+    def _write_output(self, result, path, legacy_output=False):
+        self._write('Output', result.save, path, legacy_output)
 
     def _write_xunit(self, result, path):
         self._write('XUnit', XUnitWriter(result).write, path)
@@ -85,7 +85,7 @@ class ResultWriter:
         except DataError as err:
             LOGGER.error(err.message)
         else:
-            LOGGER.output_file(name, path)
+            LOGGER.result_file(name, path)
 
 
 class Results:

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/stringcache.py

@@ -21,16 +21,16 @@ class StringIndex(int):
 
 
 class StringCache:
+    empty = StringIndex(0)
     _compress_threshold = 80
     _use_compressed_threshold = 1.1
-    _zero_index = StringIndex(0)
 
     def __init__(self):
-        self._cache = {('', False): self._zero_index}
+        self._cache = {('', False): self.empty}
 
     def add(self, text, html=False):
         if not text:
-            return self._zero_index
+            return self.empty
         key = (text, html)
         if key not in self._cache:
             self._cache[key] = StringIndex(len(self._cache))

{robotframework-6.1.1 → robotframework-7.0}/src/robot/reporting/xunitwriter.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.result import ResultVisitor
+from robot.result import ResultVisitor, TestCase, TestSuite
 from robot.utils import XmlWriter
 
 
@@ -38,32 +38,34 @@ class XUnitFileWriter(ResultVisitor):
     def __init__(self, xml_writer):
         self._writer = xml_writer
 
-    def start_suite(self, suite):
+    def start_suite(self, suite: TestSuite):
         stats = suite.statistics  # Accessing property only once.
         attrs = {'name': suite.name,
-                 'tests': f'{stats.total}',
+                 'tests': str(stats.total),
                  'errors': '0',
-                 'failures': f'{stats.failed}',
-                 'skipped': f'{stats.skipped}',
-                 'time': self._time_as_seconds(suite.elapsedtime),
-                 'timestamp' : self._starttime_to_isoformat(suite.starttime)}
+                 'failures': str(stats.failed),
+                 'skipped': str(stats.skipped),
+                 'time': format(suite.elapsed_time.total_seconds(), '.3f'),
+                 'timestamp': suite.start_time.isoformat() if suite.start_time else None}
         self._writer.start('testsuite', attrs)
 
-    def end_suite(self, suite):
+    def end_suite(self, suite: TestSuite):
         if suite.metadata or suite.doc:
             self._writer.start('properties')
             if suite.doc:
-                self._writer.element('property', attrs={'name': 'Documentation', 'value': suite.doc})
+                self._writer.element('property', attrs={'name': 'Documentation',
+                                                        'value': suite.doc})
             for meta_name, meta_value in suite.metadata.items():
-                self._writer.element('property', attrs={'name': meta_name, 'value': meta_value})
+                self._writer.element('property', attrs={'name': meta_name,
+                                                        'value': meta_value})
             self._writer.end('properties')
         self._writer.end('testsuite')
 
-    def visit_test(self, test):
+    def visit_test(self, test: TestCase):
         self._writer.start('testcase',
-                           {'classname': test.parent.longname,
+                           {'classname': test.parent.full_name,
                             'name': test.name,
-                            'time': self._time_as_seconds(test.elapsedtime)})
+                            'time': format(test.elapsed_time.total_seconds(), '.3f')})
         if test.failed:
             self._writer.element('failure', attrs={'message': test.message,
                                                    'type': 'AssertionError'})
@@ -72,9 +74,6 @@ class XUnitFileWriter(ResultVisitor):
                                                    'type': 'SkipExecution'})
         self._writer.end('testcase')
 
-    def _time_as_seconds(self, millis):
-        return format(millis / 1000, '.3f')
-
     def visit_keyword(self, kw):
         pass
 
@@ -86,8 +85,3 @@ class XUnitFileWriter(ResultVisitor):
 
     def end_result(self, result):
         self._writer.close()
-
-    def _starttime_to_isoformat(self, stime):
-        if not stime:
-            return None
-        return f'{stime[:4]}-{stime[4:6]}-{stime[6:8]}T{stime[9:22]}000'

{robotframework-6.1.1 → robotframework-7.0}/src/robot/result/__init__.py

@@ -38,7 +38,8 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 """
 
 from .executionresult import Result
-from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword, Message,
-                    Return, TestCase, TestSuite, Try, TryBranch, While, WhileIteration)
+from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
+                    Message, Return, TestCase, TestSuite, Try, TryBranch, Var, While,
+                    WhileIteration)
 from .resultbuilder import ExecutionResult, ExecutionResultBuilder
 from .visitor import ResultVisitor

{robotframework-6.1.1 → robotframework-7.0}/src/robot/result/configurer.py

@@ -14,7 +14,7 @@
 #  limitations under the License.
 
 from robot import model
-from robot.utils import is_string, secs_to_timestamp, timestamp_to_secs
+from robot.utils import is_string, parse_timestamp
 
 
 class SuiteConfigurer(model.SuiteConfigurer):
@@ -32,11 +32,11 @@ class SuiteConfigurer(model.SuiteConfigurer):
 
     def __init__(self, remove_keywords=None, log_level=None, start_time=None,
                  end_time=None, **base_config):
-        model.SuiteConfigurer.__init__(self, **base_config)
+        super().__init__(**base_config)
         self.remove_keywords = self._get_remove_keywords(remove_keywords)
         self.log_level = log_level
-        self.start_time = self._get_time(start_time)
-        self.end_time = self._get_time(end_time)
+        self.start_time = self._to_datetime(start_time)
+        self.end_time = self._to_datetime(end_time)
 
     def _get_remove_keywords(self, value):
         if value is None:
@@ -45,14 +45,13 @@ class SuiteConfigurer(model.SuiteConfigurer):
             return [value]
         return value
 
-    def _get_time(self, timestamp):
+    def _to_datetime(self, timestamp):
         if not timestamp:
             return None
         try:
-            secs = timestamp_to_secs(timestamp, seps=' :.-_')
+            return parse_timestamp(timestamp)
         except ValueError:
             return None
-        return secs_to_timestamp(secs, millis=True)
 
     def visit_suite(self, suite):
         model.SuiteConfigurer.visit_suite(self, suite)
@@ -66,6 +65,10 @@ class SuiteConfigurer(model.SuiteConfigurer):
 
     def _set_times(self, suite):
         if self.start_time:
-            suite.starttime = self.start_time
+            suite.end_time = suite.end_time    # Preserve original value.
+            suite.elapsed_time = None          # Force re-calculation.
+            suite.start_time = self.start_time
         if self.end_time:
-            suite.endtime = self.end_time
+            suite.start_time = suite.start_time
+            suite.elapsed_time = None
+            suite.end_time = self.end_time

{robotframework-6.1.1 → robotframework-7.0}/src/robot/result/executionresult.py

@@ -13,6 +13,8 @@
 #  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.model import Statistics
 
@@ -20,6 +22,28 @@ from .executionerrors import ExecutionErrors
 from .model import TestSuite
 
 
+def is_json_source(source):
+    if isinstance(source, bytes):
+        # Latin-1 is most likely not the right encoding, but decoding bytes with it
+        # always succeeds and characters we care about will be correct as well.
+        source = source.decode('Latin-1')
+    if isinstance(source, str):
+        source = source.strip()
+        first, last = (source[0], source[-1]) if source else ('', '')
+        if (first, last) == ('{', '}'):
+            return True
+        if (first, last) == ('<', '>'):
+            return False
+        path = Path(source)
+    elif isinstance(source, Path):
+        path = source
+    elif hasattr(source, 'name') and isinstance(source.name, str):
+        path = Path(source.name)
+    else:
+        return False
+    return bool(path and path.suffix.lower() == '.json')
+
+
 class Result:
     """Test execution results.
 
@@ -96,14 +120,38 @@ class Result:
         self._status_rc = status_rc
         self._stat_config = stat_config or {}
 
-    def save(self, path=None):
-        """Save results as a new output XML file.
-
-        :param path: Path to save results to. If omitted, overwrites the
-            original file.
+    def save(self, target=None, legacy_output=False):
+        """Save results as XML or JSON file.
+
+        :param target: Target where to save results to. Can be a path
+            (``pathlib.Path`` or ``str``) or an open file object. If omitted,
+            uses the :attr:`source` which overwrites the original file.
+        :param legacy_output: Save result in Robot Framework 6.x compatible
+            format. New in Robot Framework 7.0.
+
+        File type is got based on the ``target``. The type is JSON if the ``target``
+        is a path that has a ``.json`` suffix or if it is an open file that has
+        a ``name`` attribute with a ``.json`` suffix. Otherwise, the type is XML.
+
+        Notice that saved JSON files only contain suite information, no statics
+        or errors like XML files. This is likely to change in the future so
+        that JSON files get a new root object with the current suite as a child
+        and statics and errors as additional children. Robot Framework's own
+        functions and methods accepting JSON results will continue to work
+        also with JSON files containing only a suite.
         """
-        from robot.reporting.outputwriter import OutputWriter
-        self.visit(OutputWriter(path or self.source, rpa=self.rpa))
+        from robot.reporting.outputwriter import LegacyOutputWriter, OutputWriter
+
+        target = target or self.source
+        if not target:
+            raise ValueError('Path required.')
+        if is_json_source(target):
+            # This writes only suite information, not stats or errors. This
+            # should be changed when we add JSON support to execution.
+            self.suite.to_json(target)
+        else:
+            writer = OutputWriter if not legacy_output else LegacyOutputWriter
+            self.visit(writer(target, rpa=self.rpa))
 
     def visit(self, visitor):
         """An entry point to visit the whole result object.
@@ -142,7 +190,7 @@ class CombinedResult(Result):
     """Combined results of multiple test executions."""
 
     def __init__(self, results=None):
-        Result.__init__(self)
+        super().__init__()
         for result in results or ():
             self.add_result(result)