stats.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.utils import (Sortable, elapsed_time_to_string, html_escape,
                         is_string, normalize, py2to3, unicode)
 
from .tags import TagPattern
 
 
@py2to3
 
class Stat(Sortable):
 
    def __init__(self, name):
        #: Human readable identifier of the object these statistics
        #: belong to. Either `All Tests` or `Critical Tests` for
        #: :class:`~robot.model.totalstatistics.TotalStatistics`,
        #: long name of the suite for
        #: :class:`~robot.model.suitestatistics.SuiteStatistics`
        #: or name of the tag for
        #: :class:`~robot.model.tagstatistics.TagStatistics`
        self.namename = name
        #: Number of passed tests.
        self.passedpassed = 0
        #: Number of failed tests.
        self.failedfailed = 0
        #: Number of milliseconds it took to execute.
        self.elapsedelapsed = 0
        self._norm_name_norm_name = normalize(name, ignore='_')
 
    def get_attributes(self, include_label=False, include_elapsed=False,
                       exclude_empty=True, values_as_strings=False,
                       html_escape=False):
        attrs = {'pass': self.passedpassed, 'fail': self.failedfailed}
        attrs.update(self._get_custom_attrs_get_custom_attrs())
        if include_label:
            attrs['label'] = self.namename
        if include_elapsed:
            attrs['elapsed'] = elapsed_time_to_string(self.elapsedelapsed,
                                                      include_millis=False)
        if exclude_empty:
            attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None))
        if values_as_strings:
            attrs = dict((k, unicode(v if v is not None else ''))
                         for k, v in attrs.items())
        if html_escape:
            attrs = dict((k, self._html_escape_html_escape(v)) for k, v in attrs.items())
        return attrs
 
    def _get_custom_attrs(self):
        return {}
 
    def _html_escape(self, item):
        return html_escape(item) if is_string(item) else item
 
    @property
    total = property
    
    def total(self):
        return self.passedpassed + self.failedfailed
 
    def add_test(self, test):
        self._update_stats_update_stats(test)
        self._update_elapsed_update_elapsed(test)
 
    def _update_stats(self, test):
        if test.passed:
            self.passedpassed += 1
        else:
            self.failedfailed += 1
 
    def _update_elapsed(self, test):
        self.elapsedelapsed += test.elapsedtime
 
    @property
    _sort_key = property
    
    def _sort_key(self):
        return self._norm_name_norm_name
 
    def __nonzero__(self):
        return not self.failedfailed
 
    def visit(self, visitor):
        visitor.visit_stat(self)
 
 
 
class TotalStat(Stat):
    type = 'total'
 
 
 
class SuiteStat(Stat):
    type = 'suite'
 
    def __init__(self, suite):
        Stat.__init__(self, suite.longname)
        #: Identifier of the suite, e.g. `s1-s2`.
        self.idid = suite.id
        #: Number of milliseconds it took to execute this suite,
        #: including sub-suites.
        self.elapsedelapsedelapsed = suite.elapsedtime
        self._name_name = suite.name
 
    def _get_custom_attrs(self):
        return {'id': self.idid, 'name': self._name_name}
 
    def _update_elapsed(self, test):
        pass
 
    def add_stat(self, other):
        self.passed += other.passed
        self.failed += other.failed
 
 
 
class TagStat(Stat):
    type = 'tag'
 
    def __init__(self, name, doc='', links=None, critical=False,
                 non_critical=False, combined=None):
        Stat.__init__(self, name)
        #: Documentation of tag as a string.
        self.docdoc = doc
        #: List of tuples in which the first value is the link URL and
        #: the second is the link title. An empty list by default.
        self.linkslinks = links or []
        #: ``True`` if tag is considered critical, ``False`` otherwise.
        self.criticalcritical = critical
        #: ``True`` if tag is considered non-critical, ``False`` otherwise.
        self.non_criticalnon_critical = non_critical
        #: Pattern as a string if the tag is combined, ``None`` otherwise.
        self.combinedcombined = combined
 
    @property
    
    info = property
    
    def info(self):
        if self.criticalcritical:
            return 'critical'
        if self.non_criticalnon_critical:
            return 'non-critical'
        if self.combinedcombined:
            return 'combined'
        return ''
 
    def _get_custom_attrs(self):
        return {'doc': self.docdoc, 'links': self._get_links_as_string_get_links_as_string(),
                'info': self.infoinfoinfo, 'combined': self.combinedcombined}
 
    def _get_links_as_string(self):
        return ':::'.join('%s:%s' % (title, url) for url, title in self.linkslinks)
 
    @property
    _sort_key = property
    
    def _sort_key(self):
        return (not self.criticalcritical,
                not self.non_criticalnon_critical,
                not self.combinedcombined,
                self._norm_name_norm_name)
 
 
class CombinedTagStat(TagStat):
 
    def __init__(self, pattern, name=None, doc='', links=None):
        TagStat.__init__(self, name or pattern, doc, links, combined=pattern)
        self.patternpattern = TagPattern(pattern)
 
    def match(self, tags):
        return self.patternpattern.match(tags)
 
 
class CriticalTagStat(TagStat):
 
    def __init__(self, tag_pattern, name=None, critical=True, doc='',
                 links=None):
        TagStat.__init__(self, name or unicode(tag_pattern), doc, links,
                         critical=critical, non_critical=not critical)
        self.patternpattern = tag_pattern
 
    def match(self, tags):
        return self.patternpattern.match(tags)