Add support for multiple sub-elements (failure/error/skipped) in testcase

Signed-off-by: Martin Rakovec <martin.rakovec@comap-control.com>

Author: martinrakovec-comap

junit_xml/__init__.py

@@ -198,36 +198,38 @@ def build_xml_doc(self, encoding=None):
 
             # failures
             for failure in case.failures:
-                attrs = {"type": "failure"}
-                if failure['message']:
-                    attrs['message'] = decode(failure['message'], encoding)
-                if failure['type']:
-                    attrs['type'] = decode(failure['type'], encoding)
-                failure_element = ET.Element("failure", attrs)
-                if failure['output']:
-                    failure_element.text = decode(failure['output'], encoding)
-                test_case_element.append(failure_element)
+                if failure["output"] or failure["message"]:
+                    attrs = {"type": "failure"}
+                    if failure["message"]:
+                        attrs["message"] = decode(failure["message"], encoding)
+                    if failure["type"]:
+                        attrs["type"] = decode(failure["type"], encoding)
+                    failure_element = ET.Element("failure", attrs)
+                    if failure["output"]:
+                        failure_element.text = decode(failure["output"], encoding)
+                    test_case_element.append(failure_element)
 
             # errors
             for error in case.errors:
-                attrs = {"type": "error"}
-                if error['message']:
-                    attrs['message'] = decode(error['message'], encoding)
-                if error['type']:
-                    attrs['type'] = decode(error['type'], encoding)
-                error_element = ET.Element("error", attrs)
-                if error['output']:
-                    error_element.text = decode(error['output'], encoding)
-                test_case_element.append(error_element)
+                if error["message"] or error["output"]:
+                    attrs = {"type": "error"}
+                    if error["message"]:
+                        attrs["message"] = decode(error["message"], encoding)
+                    if error["type"]:
+                        attrs["type"] = decode(error["type"], encoding)
+                    error_element = ET.Element("error", attrs)
+                    if error["output"]:
+                        error_element.text = decode(error["output"], encoding)
+                    test_case_element.append(error_element)
 
             # skippeds
             for skipped in case.skipped:
                 attrs = {"type": "skipped"}
-                if skipped['message']:
-                    attrs['message'] = decode(skipped['message'], encoding)
+                if skipped["message"]:
+                    attrs["message"] = decode(skipped["message"], encoding)
                 skipped_element = ET.Element("skipped", attrs)
-                if skipped['output']:
-                    skipped_element.text = decode(skipped['output'], encoding)
+                if skipped["output"]:
+                    skipped_element.text = decode(skipped["output"], encoding)
                 test_case_element.append(skipped_element)
 
             # test stdout
@@ -377,6 +379,7 @@ def __init__(
         line=None,
         log=None,
         url=None,
+        allow_multiple_subelements=False,
     ):
         self.name = name
         self.assertions = assertions
@@ -396,41 +399,70 @@ def __init__(
         self.errors = []
         self.failures = []
         self.skipped = []
+        self.allow_multiple_subalements = allow_multiple_subelements
 
     def add_error_info(self, message=None, output=None, error_type=None):
         """Adds an error message, output, or both to the test case"""
-        if message or output or error_type:
-            error = {}
-            error['message'] = message
-            error['output'] = output
-            error['type'] = error_type
+        error = {}
+        error["message"] = message
+        error["output"] = output
+        error["type"] = error_type
+        if self.allow_multiple_subalements:
+            if message or output:
+                self.errors.append(error)
+        elif not len(self.errors):
             self.errors.append(error)
+        else:
+            if message:
+                self.errors[0]["message"] = message
+            if output:
+                self.errors[0]["output"] = output
+            if error_type:
+                self.errors[0]["type"] = error_type
 
     def add_failure_info(self, message=None, output=None, failure_type=None):
         """Adds a failure message, output, or both to the test case"""
-        if message or output or failure_type:
-            failure = {}
-            failure['message'] = message
-            failure['output'] = output
-            failure['type'] = failure_type
+        failure = {}
+        failure["message"] = message
+        failure["output"] = output
+        failure["type"] = failure_type
+        if self.allow_multiple_subalements:
+            if message or output:
+                self.failures.append(failure)
+        elif not len(self.failures):
             self.failures.append(failure)
+        else:
+            if message:
+                self.failures[0]["message"] = message
+            if output:
+                self.failures[0]["output"] = output
+            if failure_type:
+                self.failures[0]["type"] = failure_type
 
     def add_skipped_info(self, message=None, output=None):
         """Adds a skipped message, output, or both to the test case"""
-        if message or output:
-            skipped = {}
-            skipped['message'] = message
-            skipped['output'] = output
+        skipped = {}
+        skipped["message"] = message
+        skipped["output"] = output
+        if self.allow_multiple_subalements:
+            if message or output:
+                self.skipped.append(skipped)
+        elif not len(self.skipped):
             self.skipped.append(skipped)
+        else:
+            if message:
+                self.skipped[0]["message"] = message
+            if output:
+                self.skipped[0]["output"] = output
 
     def is_failure(self):
         """returns true if this test case is a failure"""
-        return (len(self.failures) > 0)
+        return sum(1 for f in self.failures if f["message"] or f["output"]) > 0
 
     def is_error(self):
         """returns true if this test case is an error"""
-        return (len(self.errors) > 0)
+        return sum(1 for e in self.errors if e["message"] or e["output"]) > 0
 
     def is_skipped(self):
         """returns true if this test case has been skipped"""
-        return (len(self.skipped) > 0)
+        return len(self.skipped) > 0

tests/asserts.py

@@ -11,6 +11,9 @@ def verify_test_case(  # noqa: E302
     skipped_output=None,
     stdout=None,
     stderr=None,
+    errors=None,
+    failures=None,
+    skipped=None,
 ):
     for k, v in expected_attributes.items():
         assert test_case_element.attributes[k].value == v
@@ -23,38 +26,58 @@ def verify_test_case(  # noqa: E302
         if stdout:
             assert test_case_element.getElementsByTagName("system-out")[0].firstChild.nodeValue.strip() == stdout
 
-        errors = test_case_element.getElementsByTagName("error")
+        _errors = test_case_element.getElementsByTagName("error")
         if error_message or error_output:
-            assert len(errors) > 0
+            assert len(_errors) > 0
+        elif errors:
+            assert len(errors) == len(_errors)
         else:
-            assert len(errors) == 0
+            assert len(_errors) == 0
 
         if error_message:
-            assert errors[0].attributes["message"].value == error_message
+            assert _errors[0].attributes["message"].value == error_message
 
-        if error_type and errors:
-            assert errors[0].attributes["type"].value == error_type
+        if error_type and _errors:
+            assert _errors[0].attributes["type"].value == error_type
 
         if error_output:
-            assert errors[0].firstChild.nodeValue.strip() == error_output
+            assert _errors[0].firstChild.nodeValue.strip() == error_output
 
-        failures = test_case_element.getElementsByTagName("failure")
+        for error_exp, error_r in zip(errors or [], _errors):
+            assert error_r.attributes["message"].value == error_exp["message"]
+            assert error_r.firstChild.nodeValue.strip() == error_exp["output"]
+            assert error_r.attributes["type"].value == error_exp["type"]
+
+        _failures = test_case_element.getElementsByTagName("failure")
         if failure_message or failure_output:
-            assert len(failures) > 0
+            assert len(_failures) > 0
+        elif failures:
+            assert len(failures) == len(_failures)
         else:
-            assert len(failures) == 0
+            assert len(_failures) == 0
 
         if failure_message:
-            assert failures[0].attributes["message"].value == failure_message
+            assert _failures[0].attributes["message"].value == failure_message
 
-        if failure_type and failures:
-            assert failures[0].attributes["type"].value == failure_type
+        if failure_type and _failures:
+            assert _failures[0].attributes["type"].value == failure_type
 
         if failure_output:
-            assert failures[0].firstChild.nodeValue.strip() == failure_output
+            assert _failures[0].firstChild.nodeValue.strip() == failure_output
+
+        for failure_exp, failure_r in zip(failures or [], _failures):
+            assert failure_r.attributes["message"].value == failure_exp["message"]
+            assert failure_r.firstChild.nodeValue.strip() == failure_exp["output"]
+            assert failure_r.attributes["type"].value == failure_exp["type"]
 
-        skipped = test_case_element.getElementsByTagName("skipped")
+        _skipped = test_case_element.getElementsByTagName("skipped")
         if skipped_message or skipped_output:
-            assert len(skipped) > 0
+            assert len(_skipped) > 0
+        elif skipped:
+            assert len(skipped) == len(_skipped)
         else:
-            assert len(skipped) == 0
+            assert len(_skipped) == 0
+
+        for skipped_exp, skipped_r in zip(skipped or [], _skipped):
+            assert skipped_r.attributes["message"].value == skipped_exp["message"]
+            assert skipped_r.firstChild.nodeValue.strip() == skipped_exp["output"]

tests/test_test_case.py

@@ -258,3 +258,67 @@ def test_init_unicode():
         error_message=decode("Skipped error äöü", "utf-8"),
         error_output=decode("I skippäd with an error!", "utf-8"),
     )
+
+
+def test_multiple_errors():
+    """Tests multiple errors in one test case"""
+    tc = Case("Multiple error", allow_multiple_subelements=True)
+    tc.add_error_info("First error", "First error message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0],
+        {"name": "Multiple error"},
+        errors=[{"message": "First error", "output": "First error message", "type": "error"}],
+    )
+    tc.add_error_info("Second error", "Second error message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0],
+        {"name": "Multiple error"},
+        errors=[
+            {"message": "First error", "output": "First error message", "type": "error"},
+            {"message": "Second error", "output": "Second error message", "type": "error"},
+        ],
+    )
+
+
+def test_multiple_failures():
+    """Tests multiple failures in one test case"""
+    tc = Case("Multiple failures", allow_multiple_subelements=True)
+    tc.add_failure_info("First failure", "First failure message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0],
+        {"name": "Multiple failures"},
+        failures=[{"message": "First failure", "output": "First failure message", "type": "failure"}],
+    )
+    tc.add_failure_info("Second failure", "Second failure message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0],
+        {"name": "Multiple failures"},
+        failures=[
+            {"message": "First failure", "output": "First failure message", "type": "failure"},
+            {"message": "Second failure", "output": "Second failure message", "type": "failure"},
+        ],
+    )
+
+
+def test_multiple_skipped():
+    """Tests multiple skipped messages in one test case"""
+    tc = Case("Multiple skipped", allow_multiple_subelements=True)
+    tc.add_skipped_info("First skipped", "First skipped message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0], {"name": "Multiple skipped"}, skipped=[{"message": "First skipped", "output": "First skipped message"}]
+    )
+    tc.add_skipped_info("Second skipped", "Second skipped message")
+    (_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
+    verify_test_case(
+        tcs[0],
+        {"name": "Multiple skipped"},
+        skipped=[
+            {"message": "First skipped", "output": "First skipped message"},
+            {"message": "Second skipped", "output": "Second skipped message"},
+        ],
+    )