model.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 collections import OrderedDict
from itertools import chain
import warnings
 
from robot import model
from robot.model import BodyItem, Keywords, TotalStatisticsBuilder
from robot.utils import get_elapsed_time, setter
 
from .configurer import SuiteConfigurer
from .messagefilter import MessageFilter
from .modeldeprecation import deprecated, DeprecatedAttributesMixin
from .keywordremover import KeywordRemover
from .suiteteardownfailed import SuiteTeardownFailed, SuiteTeardownFailureHandler
 
 
class Body(model.Body):
    __slots__ = []
 
 
class Branches(model.Branches):
    __slots__ = []
 
 
class Iterations(model.BaseBody):
    __slots__ = ['iteration_class']
 
    def __init__(self, iteration_class, parent=None, items=None):
        self.iteration_classiteration_class = iteration_class
        super().__init__(parent, items)
 
    def create_iteration(self, *args, **kwargs):
        return self.appendappend(self.iteration_classiteration_class(*args, **kwargs))
 
 
@Body.register
@Branches.register
@Iterations.register
class Message(model.Message):
    __slots__ = []
 
 
class StatusMixin:
    __slots__ = []
    PASS = 'PASS'
    FAIL = 'FAIL'
    SKIP = 'SKIP'
    NOT_RUN = 'NOT RUN'
    NOT_SET = 'NOT SET'
 
    @property
    
    elapsedtime = property
    
    def elapsedtime(self):
        return get_elapsed_time(self.starttime, self.endtime)
 
    @property
    
    passed = property
    
    def passed(self):
        return self.statusstatus == self.PASSPASS
 
    @passed.setter
    
    def passed(self, passed):
        self.statusstatus = self.PASSPASS if passed else self.FAILFAIL
 
    @property
    
    failed = property
    
    def failed(self):
        return self.statusstatus == self.FAILFAIL
 
    @failed.setter
    
    def failed(self, failed):
        self.statusstatus = self.FAILFAIL if failed else self.PASSPASS
 
    @property
    
    skipped = property
    
    def skipped(self):
        return self.statusstatus == self.SKIPSKIP
 
    @skipped.setter
    
    def skipped(self, skipped):
        if not skipped:
            raise ValueError("`skipped` value must be truthy, got '%s'." % skipped)
        self.statusstatus = self.SKIPSKIP
 
    @property
    
    not_run = property
    
    def not_run(self):
        return self.statusstatus == self.NOT_RUNNOT_RUN
 
    @not_run.setter
    
    def not_run(self, not_run):
        if not not_run:
            raise ValueError("`not_run` value must be truthy, got '%s'." % not_run)
        self.statusstatus = self.NOT_RUNNOT_RUN
 
 
 
class ForIteration(BodyItem, StatusMixin, DeprecatedAttributesMixin):
    type = BodyItem.ITERATION
    body_class = Body
    repr_args = ('variables',)
    __slots__ = ['variables', 'status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, variables=None, status='FAIL', starttime=None, endtime=None,
                 doc='', parent=None):
        self.variablesvariables = variables or OrderedDict()
        self.parentparent = parent
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    def visit(self, visitor):
        visitor.visit_for_iteration(self)
 
    @property
    @deprecated
    name = property
    
    def name(self):
        return ', '.join('%s = %s' % item for item in self.variablesvariables.items())
 
 
@Body.register
class For(model.For, StatusMixin, DeprecatedAttributesMixin):
    iterations_class = Iterations
    iteration_class = ForIteration
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, variables=(),  flavor='IN', values=(), status='FAIL',
                 starttime=None, endtime=None, doc='', parent=None):
        super().__init__(variables, flavor, values, parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
    @setter
    def body(self, iterations):
        return self.iterations_classiterations_class(self.iteration_classiteration_class, self, iterations)
 
    @property
    @deprecated
    name = property
    
    def name(self):
        return '%s %s [ %s ]' % (' | '.join(self.variablesvariables), self.flavorflavor,
                                 ' | '.join(self.valuesvalues))
 
 
 
class WhileIteration(BodyItem, StatusMixin, DeprecatedAttributesMixin):
    type = BodyItem.ITERATION
    body_class = Body
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, status='FAIL', starttime=None, endtime=None,
                 doc='', parent=None):
        self.parentparent = parent
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
        self.bodybodybody = None
 
    @setter
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    def visit(self, visitor):
        visitor.visit_while_iteration(self)
 
    @property
    @deprecated
    name = property
    
    def name(self):
        return ''
 
 
@Body.register
class While(model.While, StatusMixin, DeprecatedAttributesMixin):
    iterations_class = Iterations
    iteration_class = WhileIteration
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, condition=None, limit=None, parent=None, status='FAIL',
                 starttime=None, endtime=None, doc=''):
        super().__init__(condition, limit, parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
    @setter
    def body(self, iterations):
        return self.iterations_classiterations_class(self.iteration_classiteration_class, self, iterations)
 
    @property
    @deprecated
    name = property
    
    def name(self):
        parts = []
        if self.conditioncondition:
            parts.append(self.conditioncondition)
        if self.limitlimit:
            parts.append(f'limit={self.limit}')
        return ' | '.join(parts)
 
 
class IfBranch(model.IfBranch, StatusMixin, DeprecatedAttributesMixin):
    body_class = Body
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, type=BodyItem.IF, condition=None, status='FAIL',
                 starttime=None, endtime=None, doc='', parent=None):
        super().__init__(type, condition, parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
    @property
    @deprecated
    name = property
    
    def name(self):
        return self.conditioncondition
 
 
@Body.register
class If(model.If, StatusMixin, DeprecatedAttributesMixin):
    branch_class = IfBranch
    branches_class = Branches
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, status='FAIL', starttime=None, endtime=None, doc='', parent=None):
        super().__init__(parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
 
class TryBranch(model.TryBranch, StatusMixin, DeprecatedAttributesMixin):
    body_class = Body
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, type=BodyItem.TRY, patterns=(), pattern_type=None, variable=None,
                 status='FAIL', starttime=None, endtime=None, doc='', parent=None):
        super().__init__(type, patterns, pattern_type, variable, parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
    @property
    @deprecated
    name = property
    
    def name(self):
        patterns = list(self.patternspatterns)
        if self.pattern_typepattern_type:
            patterns.append(f'type={self.pattern_type}')
        parts = []
        if patterns:
            parts.append(' | '.join(patterns))
        if self.variablevariable:
            parts.append(f'AS {self.variable}')
        return ' '.join(parts)
 
 
@Body.register
class Try(model.Try, StatusMixin, DeprecatedAttributesMixin):
    branch_class = TryBranch
    branches_class = Branches
    __slots__ = ['status', 'starttime', 'endtime', 'doc']
 
    def __init__(self, status='FAIL', starttime=None, endtime=None, doc='', parent=None):
        super().__init__(parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.docdoc = doc
 
 
@Body.register
class Return(model.Return, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'starttime', 'endtime']
    body_class = Body
 
    def __init__(self, values=(), status='FAIL', starttime=None, endtime=None, parent=None):
        super().__init__(values, parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.bodybodybody = None
 
    @setter
    
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    @deprecated
    args = property
    
    def args(self):
        return self.valuesvalues
 
    @property
    @deprecated
    doc = property
    
    def doc(self):
        return ''
 
 
@Body.register
class Continue(model.Continue, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'starttime', 'endtime']
    body_class = Body
 
    def __init__(self, status='FAIL', starttime=None, endtime=None, parent=None):
        super().__init__(parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.bodybodybody = None
 
    @setter
    
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    @deprecated
    args = property
    
    def args(self):
        return ()
 
    @property
    @deprecated
    doc = property
    
    def doc(self):
        return ''
 
 
@Body.register
class Break(model.Break, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'starttime', 'endtime']
    body_class = Body
 
    def __init__(self, status='FAIL', starttime=None, endtime=None, parent=None):
        super().__init__(parent)
        self.statusstatusstatus = status
        self.starttimestarttime = starttime
        self.endtimeendtime = endtime
        self.bodybodybody = None
 
    @setter
    
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    @deprecated
    args = property
    
    def args(self):
        return ()
 
    @property
    @deprecated
    doc = property
    
    def doc(self):
        return ''
 
 
@Body.register
@Branches.register
@Iterations.register
 
class Keyword(model.Keyword, StatusMixin):
    body_class = Body
    __slots__ = ['kwname', 'libname', 'status', 'starttime', 'endtime', 'message',
                 'sourcename']
 
    def __init__(self, kwname='', libname='', doc='', args=(), assign=(), tags=(),
                 timeout=None, type=BodyItem.KEYWORD, status='FAIL', starttime=None,
                 endtime=None, parent=None, sourcename=None):
        super().__init__(None, doc, args, assign, tags, timeout, type, parent)
        #: Name of the keyword without library or resource name.
        self.kwnamekwname = kwname
        #: Name of the library or resource containing this keyword.
        self.libnamelibname = libname
        #: Execution status as a string. ``PASS``, ``FAIL``, ``SKIP`` or ``NOT RUN``.
        self.statusstatusstatus = status
        #: Keyword execution start time in format ``%Y%m%d %H:%M:%S.%f``.
        self.starttimestarttime = starttime
        #: Keyword execution end time in format ``%Y%m%d %H:%M:%S.%f``.
        self.endtimeendtime = endtime
        #: Keyword status message. Used only if suite teardowns fails.
        self.messagemessage = ''
        #: Original name of keyword with embedded arguments.
        self.sourcenamesourcename = sourcename
        self.bodybodybody = None
 
    @setter
    
    def body(self, body):
        return self.body_classbody_class(self, body)
 
    @property
    
    keywords = property
    
    def keywords(self):
        keywords = self.bodybodybody.filter(messages=False)
        if self.teardownteardownteardownteardown:
            keywords.append(self.teardownteardownteardownteardown)
        return Keywords(self, keywords)
 
    @keywords.setter
    
    def keywords(self, keywords):
        Keywords.raise_deprecation_error()
 
    @property
    
    messages = property
    
    def messages(self):
        return self.bodybodybody.filter(messages=True)
 
    @property
    
    children = property
    
    def children(self):
        warnings.warn("'Keyword.children' is deprecated. Use 'Keyword.body' instead.")
        return list(self.bodybodybody)
 
    @property
    
    name = property
    
    def name(self):
        if not self.libnamelibname:
            return self.kwnamekwname
        return '%s.%s' % (self.libnamelibname, self.kwnamekwname)
 
    @name.setter
    
    def name(self, name):
        if name is not None:
            raise AttributeError("Cannot set 'name' attribute directly. "
                                 "Set 'kwname' and 'libname' separately instead.")
        self.kwnamekwname = None
        self.libnamelibname = None
 
 
 
class TestCase(model.TestCase, StatusMixin):
    __slots__ = ['status', 'message', 'starttime', 'endtime']
    body_class = Body
    fixture_class = Keyword
 
    def __init__(self, name='', doc='', tags=None, timeout=None, lineno=None,
                 status='FAIL', message='', starttime=None, endtime=None,
                 parent=None):
        super().__init__(name, doc, tags, timeout, lineno, parent)
        #: Status as a string ``PASS`` or ``FAIL``. See also :attr:`passed`.
        self.statusstatusstatus = status
        #: Test message. Typically a failure message but can be set also when
        #: test passes.
        self.messagemessage = message
        #: Test case execution start time in format ``%Y%m%d %H:%M:%S.%f``.
        self.starttimestarttime = starttime
        #: Test case execution end time in format ``%Y%m%d %H:%M:%S.%f``.
        self.endtimeendtime = endtime
 
    @property
    not_run = property
    
    def not_run(self):
        return False
 
    @property
    critical = property
    
    def critical(self):
        warnings.warn("'TestCase.critical' is deprecated and always returns 'True'.")
        return True
 
 
 
class TestSuite(model.TestSuite, StatusMixin):
    __slots__ = ['message', 'starttime', 'endtime']
    test_class = TestCase
    fixture_class = Keyword
 
    def __init__(self, name='', doc='', metadata=None, source=None, message='',
                 starttime=None, endtime=None, rpa=False, parent=None):
        super().__init__(name, doc, metadata, source, rpa, parent)
        #: Possible suite setup or teardown error message.
        self.messagemessage = message
        #: Suite execution start time in format ``%Y%m%d %H:%M:%S.%f``.
        self.starttimestarttime = starttime
        #: Suite execution end time in format ``%Y%m%d %H:%M:%S.%f``.
        self.endtimeendtime = endtime
 
    @property
    
    passed = property
    
    def passed(self):
        return self.statusstatusstatusstatus == self.PASSPASS
 
    @property
    
    failed = property
    
    def failed(self):
        return self.statusstatusstatusstatus == self.FAILFAIL
 
    @property
    
    skipped = property
    
    def skipped(self):
        return self.statusstatusstatusstatus == self.SKIPSKIP
 
    @property
    not_run = property
    
    def not_run(self):
        return False
 
    @property
    
    status = property
    
    def status(self):
        stats = self.statisticsstatisticsstatistics  # Local variable avoids recreating stats.
        if stats.failed:
            return self.FAILFAIL
        if stats.passed:
            return self.PASSPASS
        return self.SKIPSKIP
 
    @property
    
    statistics = property
    
    def statistics(self):
        return TotalStatisticsBuilder(self, self.rparpa).stats
 
    @property
    
    full_message = property
    
    def full_message(self):
        if not self.messagemessage:
            return self.stat_messagestat_messagestat_message
        return '%s\n\n%s' % (self.messagemessage, self.stat_messagestat_messagestat_message)
 
    @property
    
    stat_message = property
    
    def stat_message(self):
        return self.statisticsstatisticsstatistics.message
 
    @property
    
    elapsedtime = property
    
    def elapsedtime(self):
        if self.starttimestarttime and self.endtimeendtime:
            return get_elapsed_time(self.starttimestarttime, self.endtimeendtime)
        return sum(child.elapsedtime for child in
                   chain(self.suitessuitessuites, self.teststeststests, (self.setupsetupsetupsetup, self.teardownteardownteardownteardown)))
 
    
    def remove_keywords(self, how):
        self.visitvisit(KeywordRemover(how))
 
    
    def filter_messages(self, log_level='TRACE'):
        self.visitvisit(MessageFilter(log_level))
 
    
    def configure(self, **options):
        model.TestSuite.configure(self)    # Parent validates call is allowed.
        self.visitvisit(SuiteConfigurer(**options))
 
    
    def handle_suite_teardown_failures(self):
        self.visitvisit(SuiteTeardownFailureHandler())
 
    
    def suite_teardown_failed(self, error):
        self.visitvisit(SuiteTeardownFailed(error))
 
    
    def suite_teardown_skipped(self, message):
        self.visitvisit(SuiteTeardownFailed(message, skipped=True))