Inheritance diagram for run_tests.TestSuite:

Public Member Functions
def	__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)

def	build_xml_doc (self, encoding=None)

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

def	to_file (file_descriptor, test_suites, prettyprint=True, encoding=None)

Public Attributes
	name

	test_cases

	timestamp

	hostname

	id

	package

	file

	log

	url

	stdout

	stderr

	properties

Static Private Member Functions
def	_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()

def 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()

def 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()

def 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()

def 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()

def run_tests.TestSuite._clean_illegal_xml_chars ( string_to_clean )

staticprivate

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

Definition at line 164 of file run_tests.py.

◆ test_cases

run_tests.TestSuite.test_cases

Definition at line 171 of file run_tests.py.

◆ timestamp

run_tests.TestSuite.timestamp

Definition at line 172 of file run_tests.py.

◆ hostname

run_tests.TestSuite.hostname

Definition at line 173 of file run_tests.py.

◆ id

run_tests.TestSuite.id

Definition at line 174 of file run_tests.py.

◆ package

run_tests.TestSuite.package

Definition at line 175 of file run_tests.py.

◆ file

run_tests.TestSuite.file

Definition at line 176 of file run_tests.py.

◆ log

run_tests.TestSuite.log

Definition at line 177 of file run_tests.py.

◆ url

run_tests.TestSuite.url

Definition at line 178 of file run_tests.py.

◆ stdout

run_tests.TestSuite.stdout

Definition at line 179 of file run_tests.py.

◆ stderr

run_tests.TestSuite.stderr

Definition at line 180 of file run_tests.py.

◆ properties

run_tests.TestSuite.properties

Definition at line 181 of file run_tests.py.

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

run_tests.py

Public Member Functions

Static Public Member Functions

Public Attributes

Static Private Member Functions