run_tests.TestSuite Class Reference

Inheritance diagram for run_tests.TestSuite:

Public Member Functions
	__init__ (self, name, test_cases=None, hostname=None, id=None, package=None, timestamp=None, properties=None, file=None, log=None, url=None, stdout=None, stderr=None)
	build_xml_doc (self, encoding=None)

Static Public Member Functions
	to_xml_string (test_suites, prettyprint=True, encoding=None)
	to_file (file_descriptor, test_suites, prettyprint=True, encoding=None)

Public Attributes
	name = name
	test_cases = test_cases
	timestamp = timestamp
	hostname = hostname
	id = id
	package = package
	file = file
	log = log
	url = url
	stdout = stdout
	stderr = stderr
	properties = properties

Static Protected Member Functions
	_clean_illegal_xml_chars (string_to_clean)

Detailed Description

Suite of test cases.
Can handle unicode strings or binary strings if their encoding is provided.

Definition at line 146 of file run_tests.py.

Constructor & Destructor Documentation

__init__()

run_tests.TestSuite.__init__	(		self,
			name,
			test_cases = None,
			hostname = None,
			id = None,
			package = None,
			timestamp = None,
			properties = None,
			file = None,
			log = None,
			url = None,
			stdout = None,
			stderr = None )

Definition at line 151 of file run_tests.py.

                 stderr=None):
        self.name = name
        if not test_cases:
            test_cases = []
        try:
            iter(test_cases)
        except TypeError:
            raise Exception('test_cases must be a list of test cases')
        self.test_cases = test_cases
        self.timestamp = timestamp
        self.hostname = hostname
        self.id = id
        self.package = package
        self.file = file
        self.log = log
        self.url = url
        self.stdout = stdout
        self.stderr = stderr
        self.properties = properties
 

Member Function Documentation

build_xml_doc()

run_tests.TestSuite.build_xml_doc	(		self,
			encoding = None )

Builds the XML document for the JUnit test suite.
Produces clean unicode strings and decodes non-unicode with the help of encoding.
@param encoding: Used to decode encoded strings.
@return: XML document with unicode string elements

Definition at line 183 of file run_tests.py.

    def build_xml_doc(self, encoding=None):
        """
        Builds the XML document for the JUnit test suite.
        Produces clean unicode strings and decodes non-unicode with the help of encoding.
        @param encoding: Used to decode encoded strings.
        @return: XML document with unicode string elements
        """
 
        # build the test suite element
        test_suite_attributes = dict()
        test_suite_attributes['name'] = self.name
        if any(c.assertions for c in self.test_cases):
            test_suite_attributes['assertions'] = \
                str(sum([int(c.assertions) for c in self.test_cases if c.assertions]))
        test_suite_attributes['disabled'] = \
            str(len([c for c in self.test_cases if not c.is_enabled]))
        test_suite_attributes['failures'] = \
            str(len([c for c in self.test_cases if c.is_failure()]))
        test_suite_attributes['errors'] = \
            str(len([c for c in self.test_cases if c.is_error()]))
        test_suite_attributes['skipped'] = \
            str(len([c for c in self.test_cases if c.is_skipped()]))
        test_suite_attributes['time'] = \
            str(sum(c.elapsed_sec for c in self.test_cases if c.elapsed_sec))
        test_suite_attributes['tests'] = str(len(self.test_cases))
 
        if self.hostname:
            test_suite_attributes['hostname'] = self.hostname
        if self.id:
            test_suite_attributes['id'] = self.id
        if self.package:
            test_suite_attributes['package'] = self.package
        if self.timestamp:
            test_suite_attributes['timestamp'] = self.timestamp
        if self.file:
            test_suite_attributes['file'] = self.file
        if self.log:
            test_suite_attributes['log'] = self.log
        if self.url:
            test_suite_attributes['url'] = self.url
 
        xml_element = ET.Element("testsuite", test_suite_attributes)
 
        # add any properties
        if self.properties:
            props_element = ET.SubElement(xml_element, "properties")
            for k, v in self.properties.items():
                attrs = {
                    'name': k,
                    'value': v
                }
                ET.SubElement(props_element, "property", attrs)
 
        # add test suite stdout
        if self.stdout:
            stdout_element = ET.SubElement(xml_element, "system-out")
            stdout_element.text = self.stdout
 
        # add test suite stderr
        if self.stderr:
            stderr_element = ET.SubElement(xml_element, "system-err")
            stderr_element.text = self.stderr
 
        # test cases
        for case in self.test_cases:
            test_case_attributes = dict()
            test_case_attributes['name'] = case.name
            if case.assertions:
                # Number of assertions in the test case
                test_case_attributes['assertions'] = "%d" % case.assertions
            if case.elapsed_sec:
                test_case_attributes['time'] = "%f" % case.elapsed_sec
            if case.timestamp:
                test_case_attributes['timestamp'] = case.timestamp
            if case.classname:
                test_case_attributes['classname'] = case.classname
            if case.status:
                test_case_attributes['status'] = case.status
            if case.category:
                test_case_attributes['class'] = case.category
            if case.file:
                test_case_attributes['file'] = case.file
            if case.line:
                test_case_attributes['line'] = case.line
            if case.log:
                test_case_attributes['log'] = case.log
            if case.url:
                test_case_attributes['url'] = case.url
 
            test_case_element = ET.SubElement(xml_element, "testcase",
                                              test_case_attributes)
 
            # failures
            if case.is_failure():
                attrs = {'type': 'failure'}
                if case.failure_message:
                    attrs['message'] = case.failure_message
                if case.failure_type:
                    attrs['type'] = case.failure_type
                failure_element = ET.Element("failure", attrs)
                if case.failure_output:
                    failure_element.text = case.failure_output
                test_case_element.append(failure_element)
 
            # errors
            if case.is_error():
                attrs = {'type': 'error'}
                if case.error_message:
                    attrs['message'] = case.error_message
                if case.error_type:
                    attrs['type'] = case.error_type
                error_element = ET.Element("error", attrs)
                if case.error_output:
                    error_element.text = case.error_output
                test_case_element.append(error_element)
 
            # skippeds
            if case.is_skipped():
                attrs = {'type': 'skipped'}
                if case.skipped_message:
                    attrs['message'] = case.skipped_message
                skipped_element = ET.Element("skipped", attrs)
                if case.skipped_output:
                    skipped_element.text = case.skipped_output
                test_case_element.append(skipped_element)
 
            # test stdout
            if case.stdout:
                stdout_element = ET.Element("system-out")
                stdout_element.text = case.stdout
                test_case_element.append(stdout_element)
 
            # test stderr
            if case.stderr:
                stderr_element = ET.Element("system-err")
                stderr_element.text = case.stderr
                test_case_element.append(stderr_element)
 
        return xml_element
 

to_xml_string()

run_tests.TestSuite.to_xml_string ( test_suites, prettyprint = True, encoding = None )

static

Returns the string representation of the JUnit XML document.
@param encoding: The encoding of the input.
@return: unicode string

Definition at line 324 of file run_tests.py.

    def to_xml_string(test_suites, prettyprint=True, encoding=None):
        """
        Returns the string representation of the JUnit XML document.
        @param encoding: The encoding of the input.
        @return: unicode string
        """
 
        try:
            iter(test_suites)
        except TypeError:
            raise Exception('test_suites must be a list of test suites')
 
        xml_element = ET.Element("testsuites")
        attributes = defaultdict(int)
        for ts in test_suites:
            ts_xml = ts.build_xml_doc(encoding=encoding)
            for key in ['failures', 'errors', 'tests', 'disabled']:
                attributes[key] += int(ts_xml.get(key, 0))
            for key in ['time']:
                attributes[key] += float(ts_xml.get(key, 0))
            xml_element.append(ts_xml)
        for key, value in attributes.items():
            xml_element.set(key, str(value))
 
        xml_string = ET.tostring(xml_element, encoding=encoding)
        # is encoded now
        xml_string = TestSuite._clean_illegal_xml_chars(
            xml_string.decode(encoding or 'utf-8'))
        # is unicode now
 
        if prettyprint:
            # minidom.parseString() works just on correctly encoded binary strings
            xml_string = xml_string.encode(encoding or 'utf-8')
            xml_string = xml.dom.minidom.parseString(xml_string)
            # toprettyxml() produces unicode if no encoding is being passed or binary string with an encoding
            xml_string = xml_string.toprettyxml(encoding=encoding)
            if encoding:
                xml_string = xml_string.decode(encoding)
            # is unicode now
        return xml_string
 

to_file()

run_tests.TestSuite.to_file ( file_descriptor, test_suites, prettyprint = True, encoding = None )

static

Writes the JUnit XML document to a file.

Definition at line 366 of file run_tests.py.

    def to_file(file_descriptor, test_suites, prettyprint=True, encoding=None):
        """
        Writes the JUnit XML document to a file.
        """
        xml_string = TestSuite.to_xml_string(test_suites,
                                             prettyprint=prettyprint,
                                             encoding=encoding)
        # has problems with encoded str with non-ASCII (non-default-encoding) characters!
        file_descriptor.write(xml_string)
 

_clean_illegal_xml_chars()

run_tests.TestSuite._clean_illegal_xml_chars ( string_to_clean )

staticprotected

Removes any illegal unicode characters from the given XML string.
@see: http://stackoverflow.com/questions/1707890/fast-way-to-filter-illegal-xml-unicode-chars-in-python

Definition at line 377 of file run_tests.py.

    def _clean_illegal_xml_chars(string_to_clean):
        """
        Removes any illegal unicode characters from the given XML string.
        @see: http://stackoverflow.com/questions/1707890/fast-way-to-filter-illegal-xml-unicode-chars-in-python
        """
 
        illegal_unichrs = [(0x00, 0x08), (0x0B, 0x1F), (0x7F, 0x84),
                           (0x86, 0x9F), (0xD800, 0xDFFF), (0xFDD0, 0xFDDF),
                           (0xFFFE, 0xFFFF), (0x1FFFE, 0x1FFFF),
                           (0x2FFFE, 0x2FFFF), (0x3FFFE, 0x3FFFF),
                           (0x4FFFE, 0x4FFFF), (0x5FFFE, 0x5FFFF),
                           (0x6FFFE, 0x6FFFF), (0x7FFFE, 0x7FFFF),
                           (0x8FFFE, 0x8FFFF), (0x9FFFE, 0x9FFFF),
                           (0xAFFFE, 0xAFFFF), (0xBFFFE, 0xBFFFF),
                           (0xCFFFE, 0xCFFFF), (0xDFFFE, 0xDFFFF),
                           (0xEFFFE, 0xEFFFF), (0xFFFFE, 0xFFFFF),
                           (0x10FFFE, 0x10FFFF)]
 
        illegal_ranges = [
            "%s-%s" % (unichr(low), unichr(high))
            for (low, high) in illegal_unichrs if low < sys.maxunicode
        ]
 
        illegal_xml_re = re.compile('[%s]' % ''.join(illegal_ranges))
        return illegal_xml_re.sub('', string_to_clean)
 
 

Member Data Documentation

name

run_tests.TestSuite.name = name

Definition at line 164 of file run_tests.py.

test_cases

run_tests.TestSuite.test_cases = test_cases

Definition at line 171 of file run_tests.py.

timestamp

run_tests.TestSuite.timestamp = timestamp

Definition at line 172 of file run_tests.py.

hostname

run_tests.TestSuite.hostname = hostname

Definition at line 173 of file run_tests.py.

id

run_tests.TestSuite.id = id

Definition at line 174 of file run_tests.py.

package

run_tests.TestSuite.package = package

Definition at line 175 of file run_tests.py.

file

run_tests.TestSuite.file = file

Definition at line 176 of file run_tests.py.

log

run_tests.TestSuite.log = log

Definition at line 177 of file run_tests.py.

url

run_tests.TestSuite.url = url

Definition at line 178 of file run_tests.py.

stdout

run_tests.TestSuite.stdout = stdout

Definition at line 179 of file run_tests.py.

stderr

run_tests.TestSuite.stderr = stderr

Definition at line 180 of file run_tests.py.

properties

run_tests.TestSuite.properties = properties

Definition at line 181 of file run_tests.py.

---

The documentation for this class was generated from the following file:

• run_tests.py