errors.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.
 
 
 
try:
    unicode
except NameError:
    unicode = str
 
 
# Return codes from Robot and Rebot.
# RC below 250 is the number of failed critical tests and exactly 250
# means that number or more such failures.
INFO_PRINTED    = 251   # --help or --version
DATA_ERROR      = 252   # Invalid data or cli args
STOPPED_BY_USER = 253   # KeyboardInterrupt or SystemExit
FRAMEWORK_ERROR = 255   # Unexpected error
 
 
 
class RobotError(Exception):
 
    def __init__(self, message='', details=''):
        Exception.__init__(self, message)
        self.detailsdetails = details
 
    @property
    message = property
    
    def message(self):
        return unicode(self)
 
 
 
class FrameworkError(RobotError):
 
 
 
class DataError(RobotError):
 
 
 
class VariableError(DataError):
 
 
 
class KeywordError(DataError):
 
 
 
class TimeoutError(RobotError):
 
    def __init__(self, message='', test_timeout=True):
        RobotError.__init__(self, message)
        self.test_timeouttest_timeout = test_timeout
 
    @property
    keyword_timeout = property
    
    def keyword_timeout(self):
        return not self.test_timeouttest_timeout
 
 
 
class Information(RobotError):
 
 
 
class ExecutionStatus(RobotError):
 
    def __init__(self, message, test_timeout=False, keyword_timeout=False,
                 syntax=False, exit=False, continue_on_failure=False,
                 return_value=None):
        if '\r\n' in message:
            message = message.replace('\r\n', '\n')
        from robotide.lib.robot.utils import cut_long_message
        RobotError.__init__(self, cut_long_message(message))
        self.test_timeouttest_timeout = test_timeout
        self.keyword_timeoutkeyword_timeout = keyword_timeout
        self.syntaxsyntax = syntax
        self.exitexit = exit
        self._continue_on_failure_continue_on_failure = continue_on_failure
        self.return_valuereturn_value = return_value
 
    @property
    timeout = property
    
    def timeout(self):
        return self.test_timeouttest_timeout or self.keyword_timeoutkeyword_timeout
 
    @property
    dont_continue = property
    
    def dont_continue(self):
        return self.timeouttimeouttimeout or self.syntaxsyntax or self.exitexit
 
    @property
    continue_on_failure = property
    
    def continue_on_failure(self):
        return self._continue_on_failure_continue_on_failure
 
    @continue_on_failure.setter
    
    def continue_on_failure(self, continue_on_failure):
        self._continue_on_failure_continue_on_failure = continue_on_failure
        for child in getattr(self, '_errors', []):
            if child is not self:
                child.continue_on_failure = continue_on_failure
 
    def can_continue(self, teardown=False, templated=False, dry_run=False):
        if dry_run:
            return True
        if self.syntaxsyntax or self.exitexit or self.test_timeouttest_timeout:
            return False
        if templated:
            return True
        if self.keyword_timeoutkeyword_timeout:
            return False
        if teardown:
            return True
        return self.continue_on_failurecontinue_on_failurecontinue_on_failurecontinue_on_failure
 
    def get_errors(self):
        return [self]
 
    @property
    status = property
    
    def status(self):
        return 'FAIL'
 
 
 
class ExecutionFailed(ExecutionStatus):
 
 
class HandlerExecutionFailed(ExecutionFailed):
 
    def __init__(self, details):
        error = details.error
        timeout = isinstance(error, TimeoutError)
        test_timeout = timeout and error.test_timeout
        keyword_timeout = timeout and error.keyword_timeout
        syntax = (isinstance(error, DataError)
                  and not isinstance(error, (KeywordError, VariableError)))
        exit_on_failure = self._get_get(error, 'EXIT_ON_FAILURE')
        continue_on_failure = self._get_get(error, 'CONTINUE_ON_FAILURE')
        ExecutionFailed.__init__(self, details.message, test_timeout,
                                 keyword_timeout, syntax, exit_on_failure,
                                 continue_on_failure)
        self.full_messagefull_message = details.message
        self.tracebacktraceback = details.traceback
 
    def _get(self, error, attr):
        return bool(getattr(error, 'ROBOT_' + attr, False))
 
 
class ExecutionFailures(ExecutionFailed):
 
    def __init__(self, errors, message=None):
        message = message or self._format_message_format_message([e.message for e in errors])
        ExecutionFailed.__init__(self, message, **self._get_attrs_get_attrs(errors))
        self._errors_errors = errors
 
    def _format_message(self, messages):
        if len(messages) == 1:
            return messages[0]
        prefix = 'Several failures occurred:'
        if any(msg.startswith('*HTML*') for msg in messages):
            prefix = '*HTML* ' + prefix
            messages = self._format_html_messages_format_html_messages(messages)
        return '\n\n'.join(
            [prefix] +
            ['%d) %s' % (i, m) for i, m in enumerate(messages, start=1)]
        )
 
    def _format_html_messages(self, messages):
        from robotide.lib.robot.utils import html_escape
        for msg in messages:
            if msg.startswith('*HTML*'):
                yield msg[6:].lstrip()
            else:
                yield html_escape(msg)
 
    def _get_attrs(self, errors):
        return {
            'test_timeout': any(e.test_timeout for e in errors),
            'keyword_timeout': any(e.keyword_timeout for e in errors),
            'syntax': any(e.syntax for e in errors),
            'exit': any(e.exit for e in errors),
            'continue_on_failure': all(e.continue_on_failure for e in errors)
        }
 
    def get_errors(self):
        return self._errors_errors
 
 
class UserKeywordExecutionFailed(ExecutionFailures):
 
    def __init__(self, run_errors=None, teardown_errors=None):
        errors = self._get_active_errors_get_active_errors(run_errors, teardown_errors)
        message = self._get_message_get_message(run_errors, teardown_errors)
        ExecutionFailures.__init__(self, errors, message)
        if run_errors and not teardown_errors:
            self._errors_errors_errors = run_errors.get_errors()
        else:
            self._errors_errors_errors = [self]
 
    def _get_active_errors(self, *errors):
        return [err for err in errors if err]
 
    def _get_message(self, run_errors, teardown_errors):
        run_msg = run_errors.message if run_errors else ''
        td_msg = teardown_errors.message if teardown_errors else ''
        if not td_msg:
            return run_msg
        if not run_msg:
            return 'Keyword teardown failed:\n%s' % td_msg
        return '%s\n\nAlso keyword teardown failed:\n%s' % (run_msg, td_msg)
 
 
 
class ExecutionPassed(ExecutionStatus):
 
    def __init__(self, message=None, **kwargs):
        ExecutionStatus.__init__(self, message or self._get_message_get_message(), **kwargs)
        self._earlier_failures_earlier_failures = []
 
    def _get_message(self):
        from robotide.lib.robot.utils import printable_name
        return ("Invalid '%s' usage."
                % printable_name(type(self).__name__, code_style=True))
 
    def set_earlier_failures(self, failures):
        if failures:
            self._earlier_failures_earlier_failures = list(failures) + self._earlier_failures_earlier_failures
 
    @property
    earlier_failures = property
    
    def earlier_failures(self):
        if not self._earlier_failures_earlier_failures:
            return None
        return ExecutionFailures(self._earlier_failures_earlier_failures)
 
    @property
    status = property
    
    def status(self):
        return 'PASS' if not self._earlier_failures_earlier_failures else 'FAIL'
 
 
 
class PassExecution(ExecutionPassed):
 
    def __init__(self, message):
        ExecutionPassed.__init__(self, message)
 
 
 
class ContinueForLoop(ExecutionPassed):
 
 
 
class ExitForLoop(ExecutionPassed):
 
 
 
class ReturnFromKeyword(ExecutionPassed):
 
    def __init__(self, return_value=None, failures=None):
        ExecutionPassed.__init__(self, return_value=return_value)
        if failures:
            self.set_earlier_failuresset_earlier_failures(failures)
 
 
 
class RemoteError(RobotError):
 
    def __init__(self, message='', details='', fatal=False, continuable=False):
        RobotError.__init__(self, message, details)
        self.ROBOT_EXIT_ON_FAILUREROBOT_EXIT_ON_FAILURE = fatal
        self.ROBOT_CONTINUE_ON_FAILUREROBOT_CONTINUE_ON_FAILURE = continuable