resultwriter.py

Go to the documentation of this file.

#  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 robotide.lib.robot.conf import RebotSettings
from robotide.lib.robot.errors import DataError
from robotide.lib.robot.model import ModelModifier
from robotide.lib.robot.output import LOGGER
from robotide.lib.robot.result import ExecutionResult, Result
from robotide.lib.robot.utils import unic
 
from .jsmodelbuilders import JsModelBuilder
from .logreportwriters import LogWriter, ReportWriter
from .xunitwriter import XUnitWriter
 
 
 
class ResultWriter():
 
    def __init__(self, *sources):
        self._sources_sources = sources
 
    
    def write_results(self, settings=None, **options):
        settings = settings or RebotSettings(options)
        results = Results(settings, *self._sources_sources)
        if settings.output:
            self._write_output_write_output(results.result, settings.output)
        if settings.xunit:
            self._write_xunit_write_xunit(results.result, settings.xunit,
                              settings.xunit_skip_noncritical)
        if settings.log:
            config = dict(settings.log_config,
                          minLevel=results.js_result.min_level)
            self._write_log_write_log(results.js_result, settings.log, config)
        if settings.report:
            results.js_result.remove_data_not_needed_in_report()
            self._write_report_write_report(results.js_result, settings.report,
                               settings.report_config)
        return results.return_code
 
    def _write_output(self, result, path):
        self._write_write('Output', result.save, path)
 
    def _write_xunit(self, result, path, skip_noncritical):
        self._write_write('XUnit', XUnitWriter(result, skip_noncritical).write, path)
 
    def _write_log(self, js_result, path, config):
        self._write_write('Log', LogWriter(js_result).write, path, config)
 
    def _write_report(self, js_result, path, config):
        self._write_write('Report', ReportWriter(js_result).write, path, config)
 
    def _write(self, name, writer, path, *args):
        try:
            writer(path, *args)
        except DataError as err:
            LOGGER.error(err.message)
        except EnvironmentError as err:
            # `err.filename` can be different than `path` at least if reading
            # log/report templates or writing split log fails.
            # `unic` is needed due to http://bugs.jython.org/issue1825.
            LOGGER.error("Writing %s file '%s' failed: %s: %s" %
                         (name.lower(), path, err.strerror, unic(err.filename)))
        else:
            LOGGER.output_file(name, path)
 
 
class Results():
 
    def __init__(self, settings, *sources):
        self._settings_settings = settings
        self._sources_sources = sources
        if len(sources) == 1 and isinstance(sources[0], Result):
            self._result_result = sources[0]
            self._prune_prune = False
            self.return_codereturn_code = self._result_result.return_code
        else:
            self._result_result = None
            self._prune_prune = True
            self.return_codereturn_code = -1
        self._js_result_js_result = None
 
    @property
    result = property
    
    def result(self):
        if self._result_result is None:
            include_keywords = bool(self._settings_settings.log or self._settings_settings.output)
            flattened = self._settings_settings.flatten_keywords
            self._result_result = ExecutionResult(include_keywords=include_keywords,
                                           flattened_keywords=flattened,
                                           merge=self._settings_settings.merge,
                                           rpa=self._settings_settings.rpa,
                                           *self._sources_sources)
            if self._settings_settings.rpa is None:
                self._settings_settings.rpa = self._result_result.rpa
            self._result_result.configure(self._settings_settings.status_rc,
                                   self._settings_settings.suite_config,
                                   self._settings_settings.statistics_config)
            modifier = ModelModifier(self._settings_settings.pre_rebot_modifiers,
                                     self._settings_settings.process_empty_suite,
                                     LOGGER)
            self._result_result.suite.visit(modifier)
            self.return_codereturn_code = self._result_result.return_code
        return self._result_result
 
    @property
    js_result = property
    
    def js_result(self):
        if self._js_result_js_result is None:
            builder = JsModelBuilder(log_path=self._settings_settings.log,
                                     split_log=self._settings_settings.split_log,
                                     prune_input_to_save_memory=self._prune_prune)
            self._js_result_js_result = builder.build_from(self.resultresultresult)
            if self._prune_prune:
                self._result_result = None
        return self._js_result_js_result