status.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.errors import PassExecution
from robot.model import TagPatterns
from robot.utils import html_escape, test_or_task
 
 
class Failure:
 
    def __init__(self):
        self.setupsetup = None
        self.testtest = None
        self.teardownteardown = None
        self.setup_skippedsetup_skipped = None
        self.test_skippedtest_skipped = None
        self.teardown_skippedteardown_skipped = None
 
    def __bool__(self):
        return bool(
            self.setupsetup or self.testtest or self.teardownteardown or
            self.setup_skippedsetup_skipped or self.test_skippedtest_skipped or self.teardown_skippedteardown_skipped
        )
 
 
class Exit:
 
    def __init__(self, failure_mode=False, error_mode=False, skip_teardown_mode=False):
        self.failure_modefailure_mode = failure_mode
        self.error_modeerror_mode = error_mode
        self.skip_teardown_modeskip_teardown_mode = skip_teardown_mode
        self.failurefailure = False
        self.errorerror = False
        self.fatalfatal = False
 
    def failure_occurred(self, fatal=False):
        if fatal:
            self.fatalfatal = True
        if self.failure_modefailure_mode:
            self.failurefailure = True
 
    def error_occurred(self):
        if self.error_modeerror_mode:
            self.errorerror = True
 
    @property
    teardown_allowed = property
    
    def teardown_allowed(self):
        return not (self.skip_teardown_modeskip_teardown_mode and self)
 
    def __bool__(self):
        return bool(self.failurefailure or self.errorerror or self.fatalfatal)
 
 
class _ExecutionStatus:
 
    def __init__(self, parent, exit=None):
        self.parentparent = parent
        self.exitexit = exit if exit is not None else parent.exit
        self.failurefailure = Failure()
        self.skippedskipped = False
        self._teardown_allowed_teardown_allowed = False
        self._rpa_rpa = False
 
    @property
    failed = property
    
    def failed(self):
        return bool(self.parentparent and self.parentparent.failed or self.failurefailure or self.exitexit)
 
    @property
    passed = property
    
    def passed(self):
        return not self.failedfailedfailed
 
    def setup_executed(self, error=None):
        if error and not isinstance(error, PassExecution):
            msg = str(error)
            if error.skip:
                self.failurefailure.setup_skipped = msg
                self.skippedskipped = True
            elif self._skip_on_failure_skip_on_failure():
                self.failurefailure.test = self._skip_on_fail_msg_skip_on_fail_msg(f'Setup failed:\n{msg}')
                self.skippedskipped = True
            else:
                self.failurefailure.setup = msg
                self.exitexit.failure_occurred(error.exit)
        self._teardown_allowed_teardown_allowed = True
 
    def teardown_executed(self, error=None):
        if error and not isinstance(error, PassExecution):
            msg = str(error)
            if error.skip:
                self.failurefailure.teardown_skipped = msg
                self.skippedskipped = True
            elif self._skip_on_failure_skip_on_failure():
                self.failurefailure.test = self._skip_on_fail_msg_skip_on_fail_msg(f'Teardown failed:\n{msg}')
                self.skippedskipped = True
            else:
                self.failurefailure.teardown = msg
                self.exitexit.failure_occurred(error.exit)
 
    def failure_occurred(self):
        self.exitexit.failure_occurred()
 
    def error_occurred(self):
        self.exitexit.error_occurred()
 
    @property
    teardown_allowed = property
    
    def teardown_allowed(self):
        return self.exitexit.teardown_allowed and self._teardown_allowed_teardown_allowed
 
    @property
    status = property
    
    def status(self):
        if self.skippedskipped or (self.parentparent and self.parentparent.skipped):
            return 'SKIP'
        if self.failedfailedfailed:
            return 'FAIL'
        return 'PASS'
 
    def _skip_on_failure(self):
        return False
 
    def _skip_on_fail_msg(self, msg):
        return msg
 
    @property
    message = property
    
    def message(self):
        if self.failurefailure or self.exitexit:
            return self._my_message_my_message()
        if self.parentparent and not self.parentparent.passed:
            return self._parent_message_parent_message()
        return ''
 
    def _my_message(self):
        raise NotImplementedError
 
    def _parent_message(self):
        return ParentMessage(self.parentparent).message
 
 
class SuiteStatus(_ExecutionStatus):
 
    def __init__(self, parent=None, exit_on_failure=False, exit_on_error=False,
                 skip_teardown_on_exit=False):
        if parent is None:
            exit = Exit(exit_on_failure, exit_on_error, skip_teardown_on_exit)
        else:
            exit = None
        super().__init__(parent, exit)
 
    def _my_message(self):
        return SuiteMessage(self).message
 
 
class TestStatus(_ExecutionStatus):
 
    def __init__(self, parent, test, skip_on_failure=None, rpa=False):
        super().__init__(parent)
        self._test_test = test
        self._skip_on_failure_tags_skip_on_failure_tags = skip_on_failure
        self._rpa_rpa_rpa = rpa
 
    def test_failed(self, message=None, error=None):
        if error is not None:
            message = str(error)
            skip = error.skip
            fatal = error.exit
        else:
            skip = fatal = False
        if skip:
            self.test_skippedtest_skipped(message)
        elif self._skip_on_failure_skip_on_failure_skip_on_failure():
            self.failurefailure.test = self._skip_on_fail_msg_skip_on_fail_msg_skip_on_fail_msg(message)
            self.skippedskippedskipped = True
        else:
            self.failurefailure.test = message
            self.exitexit.failure_occurred(fatal)
 
    def test_skipped(self, message):
        self.skippedskippedskipped = True
        self.failurefailure.test_skipped = message
 
    @property
    skip_on_failure_after_tag_changes = property
    
    def skip_on_failure_after_tag_changes(self):
        if not self.skippedskippedskipped and self.failedfailedfailed and self._skip_on_failure_skip_on_failure_skip_on_failure():
            self.failurefailure.test = self._skip_on_fail_msg_skip_on_fail_msg_skip_on_fail_msg(self.failurefailure.test)
            self.skippedskippedskipped = True
            return True
        return False
 
    def _skip_on_failure(self):
        return (self._test_test.tags.robot('skip-on-failure')
                or self._skip_on_failure_tags_skip_on_failure_tags
                and TagPatterns(self._skip_on_failure_tags_skip_on_failure_tags).match(self._test_test.tags))
 
    def _skip_on_fail_msg(self, msg):
        return test_or_task(
            "{Test} failed but skip-on-failure mode was active and it was marked "
            "skipped.\n\nOriginal failure:\n%s" % msg, rpa=self._rpa_rpa_rpa
        )
 
    def _my_message(self):
        return TestMessage(self).message
 
 
class _Message:
    setup_message = NotImplemented
    setup_skipped_message = NotImplemented
    teardown_skipped_message = NotImplemented
    teardown_message = NotImplemented
    also_teardown_message = NotImplemented
 
    def __init__(self, status):
        self.failurefailure = status.failure
        self.skippedskipped = status.skipped
 
    @property
    message = property
    
    def message(self):
        message = self._get_message_before_teardown_get_message_before_teardown()
        return self._get_message_after_teardown_get_message_after_teardown(message)
 
    def _get_message_before_teardown(self):
        if self.failurefailure.setup_skipped:
            return self._format_setup_or_teardown_message_format_setup_or_teardown_message(
                self.setup_skipped_messagesetup_skipped_message, self.failurefailure.setup_skipped)
        if self.failurefailure.setup:
            return self._format_setup_or_teardown_message_format_setup_or_teardown_message(
                self.setup_messagesetup_message, self.failurefailure.setup)
        return self.failurefailure.test_skipped or self.failurefailure.test or ''
 
    def _format_setup_or_teardown_message(self, prefix, message):
        if message.startswith('*HTML*'):
            prefix = '*HTML* ' + prefix
            message = message[6:].lstrip()
        return prefix % message
 
    def _get_message_after_teardown(self, message):
        if not (self.failurefailure.teardown or self.failurefailure.teardown_skipped):
            return message
        if not message:
            if self.failurefailure.teardown:
                prefix, msg = self.teardown_messageteardown_message, self.failurefailure.teardown
            else:
                prefix, msg = self.teardown_skipped_messageteardown_skipped_message, self.failurefailure.teardown_skipped
            return self._format_setup_or_teardown_message_format_setup_or_teardown_message(prefix, msg)
        return self._format_message_with_teardown_message_format_message_with_teardown_message(message)
 
    def _format_message_with_teardown_message(self, message):
        teardown = self.failurefailure.teardown or self.failurefailure.teardown_skipped
        if teardown.startswith('*HTML*'):
            teardown = teardown[6:].lstrip()
            if not message.startswith('*HTML*'):
                message = '*HTML* ' + html_escape(message)
        elif message.startswith('*HTML*'):
            teardown = html_escape(teardown)
        if self.failurefailure.teardown:
            return self.also_teardown_messagealso_teardown_message % (message, teardown)
        return self.also_teardown_skip_message % (teardown, message)
 
 
class TestMessage(_Message):
    setup_message = 'Setup failed:\n%s'
    teardown_message = 'Teardown failed:\n%s'
    setup_skipped_message = '%s'
    teardown_skipped_message = '%s'
    also_teardown_message = '%s\n\nAlso teardown failed:\n%s'
    also_teardown_skip_message = 'Skipped in teardown:\n%s\n\nEarlier message:\n%s'
    exit_on_fatal_message = 'Test execution stopped due to a fatal error.'
    exit_on_failure_message = \
        'Failure occurred and exit-on-failure mode is in use.'
    exit_on_error_message = 'Error occurred and exit-on-error mode is in use.'
 
    def __init__(self, status):
        _Message.__init__(self, status)
        self.exitexit = status.exit
 
    @property
    message = property
    
    def message(self):
        message = super().message
        if message:
            return message
        if self.exitexit.failure:
            return self.exit_on_failure_messageexit_on_failure_message
        if self.exitexit.fatal:
            return self.exit_on_fatal_messageexit_on_fatal_message
        if self.exitexit.error:
            return self.exit_on_error_messageexit_on_error_message
        return ''
 
 
class SuiteMessage(_Message):
    setup_message = 'Suite setup failed:\n%s'
    setup_skipped_message = 'Skipped in suite setup:\n%s'
    teardown_skipped_message = 'Skipped in suite teardown:\n%s'
    teardown_message = 'Suite teardown failed:\n%s'
    also_teardown_message = '%s\n\nAlso suite teardown failed:\n%s'
    also_teardown_skip_message = 'Skipped in suite teardown:\n%s\n\nEarlier message:\n%s'
 
 
class ParentMessage(SuiteMessage):
    setup_message = 'Parent suite setup failed:\n%s'
    setup_skipped_message = 'Skipped in parent suite setup:\n%s'
    teardown_skipped_message = 'Skipped in parent suite teardown:\n%s'
    teardown_message = 'Parent suite teardown failed:\n%s'
    also_teardown_message = '%s\n\nAlso parent suite teardown failed:\n%s'
 
    def __init__(self, status):
        while status.parent and status.parent.failed:
            status = status.parent
        SuiteMessage.__init__(self, status)