[validations] fix: prevent cifmw_validations_xml_filter hang

Issue: The validations playbook was hanging indefinitely when
creating JUnit XML files for validation results.

Root cause: ET.tostring() with encoding='utf-8' returned bytes,
which Ansible's copy module couldn't serialize in a template
context, causing an indefinite hang.

Solution: Changed encoding parameter to 'unicode', which returns
str directly, allowing Ansible to process it normally.

Testing:
- Created reproduction test proving filter returns bytes (problematic)
- Applied the fix
- Verified filter now returns str
- Added 11 comprehensive unit tests covering:
  * Return type verification (critical for the fix)
  * Normal test cases (empty, single, multiple)
  * Malformed input handling (missing fields, long errors)
  * XML validity and proper escaping
  * Performance with 100+ tests
- All 11 tests PASS
- Ansible playbook completes successfully

Signed-off-by: Harshita Goel <hgoel@redhat.com>

Author: hgoelredhat

roles/validations/filter_plugins/cifmw_validations_xml_filter.py

@@ -88,7 +88,7 @@ def __map_xml_results(cls, test_results):
             if "error" in data:
                 ET.SubElement(tc_elm, "failure", attrib={"message": data["error"]})
         ET.indent(tree, "  ")
-        return ET.tostring(root_elm, encoding="utf-8", xml_declaration=True)
+        return ET.tostring(root_elm, encoding="unicode", xml_declaration=True)
 
     def filters(self):
         return {

roles/validations/tests/unit/plugins/filter/test_cifmw_validations_xml_filter.py

@@ -0,0 +1,149 @@
+#!/usr/bin/python3
+"""
+Unit tests for cifmw_validations_xml_filter.
+
+These tests verify that the filter:
+1. Returns str (not bytes) - CRITICAL for the fix
+2. Handles normal cases
+3. Handles malformed/edge-case input gracefully
+4. Generates valid XML output
+"""
+
+import pytest
+import sys
+import xml.etree.ElementTree as ET
+
+sys.path.insert(0, 'roles/validations/filter_plugins')
+from cifmw_validations_xml_filter import FilterModule
+
+
+class TestFilterReturnType:
+    """CRITICAL: Tests to verify the fix for the hang issue"""
+    
+    def setup_method(self):
+        self.filter_module = FilterModule()
+        self.filter_func = self.filter_module.filters()['cifmw_validations_xml_filter']
+    
+    def test_returns_string_not_bytes(self):
+        """
+        ⚠️ CRITICAL TEST ⚠️
+        
+        Ensure filter returns str, not bytes.
+        
+        Before fix: encoding='utf-8' → returns bytes → Ansible hangs
+        After fix: encoding='unicode' → returns str → Ansible works
+        """
+        result = self.filter_func({})
+        assert isinstance(result, str), \
+            f"CRITICAL: Filter must return str, not {type(result).__name__}. " \
+            "Returning bytes causes Ansible to hang!"
+    
+    def test_empty_results(self):
+        """Test with empty test results"""
+        result = self.filter_func({})
+        assert isinstance(result, str)
+        assert '<?xml' in result
+        assert 'tests="0"' in result
+    
+    def test_single_passing_test(self):
+        """Test with single passing test"""
+        result = self.filter_func({"test-1": {"time": 1.5}})
+        assert isinstance(result, str)
+        assert '<testcase name="test-1"' in result
+        assert 'tests="1"' in result
+        assert 'failures="0"' in result
+    
+    def test_single_failing_test(self):
+        """Test with single failing test"""
+        result = self.filter_func({
+            "test-1": {"time": 1.0, "error": "Test failed"}
+        })
+        assert 'failures="1"' in result
+        assert 'error' in result.lower() or 'failure' in result.lower()
+    
+    def test_multiple_mixed_tests(self):
+        """Test with multiple passing and failing tests"""
+        result = self.filter_func({
+            "test-1": {"time": 1.0},
+            "test-2.yml": {"time": 2.0, "error": "failed"},
+            "test-3.yaml": {"time": 1.5}
+        })
+        assert 'tests="3"' in result
+        assert 'failures="1"' in result
+    
+    def test_valid_xml_output(self):
+        """Verify output is valid, parseable XML"""
+        result = self.filter_func({
+            "test-1": {"time": 1.0, "error": "err"},
+            "test-2": {"time": 2.0}
+        })
+        
+        # Should be parseable as XML (not corrupted)
+        root = ET.fromstring(result)
+        assert root.tag == 'testsuites'
+        
+        # Verify structure
+        ts = root.find('testsuite')
+        assert ts is not None
+        assert ts.attrib['name'] == 'validations'
+        assert ts.attrib['tests'] == '2'
+        assert ts.attrib['failures'] == '1'
+
+
+class TestMalformedInput:
+    """Tests with edge-case/malformed input to ensure robustness"""
+    
+    def setup_method(self):
+        self.filter_module = FilterModule()
+        self.filter_func = self.filter_module.filters()['cifmw_validations_xml_filter']
+    
+    def test_missing_time_field(self):
+        """Test with missing time field in some results"""
+        result = self.filter_func({
+            "test-1": {"error": "some error"},
+            "test-2": {"time": 1.5}
+        })
+        assert isinstance(result, str)
+        assert 'tests="2"' in result
+    
+    def test_very_long_error_message(self):
+        """Test with very long error message (5000+ chars)"""
+        long_error = "x" * 5000
+        result = self.filter_func({
+            "test-1": {"time": 1.0, "error": long_error}
+        })
+        assert isinstance(result, str)
+        root = ET.fromstring(result)
+        assert root is not None
+    
+    def test_xml_special_characters_in_error(self):
+        """Test with XML special characters that need escaping"""
+        result = self.filter_func({
+            "test-1": {"time": 1.0, "error": "<tag> & special > chars"}
+        })
+        assert isinstance(result, str)
+        # Should be properly escaped by ElementTree
+        root = ET.fromstring(result)
+        assert root is not None
+    
+    def test_unicode_characters(self):
+        """Test with unicode characters"""
+        result = self.filter_func({
+            "test-unicode": {"time": 1.0, "error": "Error message"}
+        })
+        assert isinstance(result, str)
+        assert 'tests="1"' in result
+    
+    def test_large_number_of_tests(self):
+        """Test with large number of test cases (100+)"""
+        large_test_data = {
+            f"test-{i}": {"time": 0.1 * i}
+            for i in range(100)
+        }
+        result = self.filter_func(large_test_data)
+        assert isinstance(result, str)
+        assert 'tests="100"' in result
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])