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 robot.conf import RebotSettings
from robot.errors import DataError
from robot.model import ModelModifier
from robot.output import LOGGER
from robot.result import ExecutionResult, Result
 
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)
        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):
        self._write_write('XUnit', XUnitWriter(result).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)
        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
            modifier = ModelModifier(self._settings_settings.pre_rebot_modifiers,
                                     self._settings_settings.process_empty_suite,
                                     LOGGER)
            self._result_result.suite.visit(modifier)
            self._result_result.configure(self._settings_settings.status_rc,
                                   self._settings_settings.suite_config,
                                   self._settings_settings.statistics_config)
            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,
                                     expand_keywords=self._settings_settings.expand_keywords,
                                     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