start implementation on new architecture

test/util_test.py

@@ -1,17 +1,118 @@
 import unittest
+from typing import Iterator
 
 from . import test_data
 
 from sia import util
 
 class UtilTest(unittest.TestCase):
-    def test_get_valid_root_elements_single(self):
-        valid_elements = util.get_valid_root_elements(test_data.echo_action_schema)
-        self.assertEqual(valid_elements, {'test_tag'})
+    def test_stop_before_value(self):
+        # Helper function to create iterator from list
+        def create_iterator(items: list) -> Iterator[str]:
+            for item in items:
+                yield item
 
-    def test_split_response_single_element(self):
-        response = "Some reasoning here\n<test_tag>content</test_tag>"
-        valid_elements = {'test_tag'}
-        result = util.split_response(response, valid_elements)
-        self.assertEqual(result.reasoning, "Some reasoning here")
-        self.assertEqual(result.actions, "<test_tag>content</test_tag>")
+        # Test case 1: Stop value in middle of sequence
+        input_sequence = ['hello', 'world', 'STOP', 'ignored']
+        result = list(util.stop_before_value(create_iterator(input_sequence), 'STOP'))
+        self.assertEqual(result, ['hello', 'world'])
+
+        # Test case 2: Stop value not in sequence
+        input_sequence = ['hello', 'world']
+        result = list(util.stop_before_value(create_iterator(input_sequence), 'STOP'))
+        self.assertEqual(result, ['hello', 'world'])
+
+        # Test case 3: Stop value at start of sequence
+        input_sequence = ['STOP', 'ignored']
+        result = list(util.stop_before_value(create_iterator(input_sequence), 'STOP'))
+        self.assertEqual(result, [])
+
+        # Test case 4: Stop value as part of an item
+        input_sequence = ['hello', 'woSTOPrld', 'ignored']
+        result = list(util.stop_before_value(create_iterator(input_sequence), 'STOP'))
+        self.assertEqual(result, ['hello', 'wo'])
+
+        # Test case 5: Empty sequence
+        input_sequence = []
+        result = list(util.stop_before_value(create_iterator(input_sequence), 'STOP'))
+        self.assertEqual(result, [])
+
+    def test_none_value(self):
+        """Test that None values are converted to empty strings"""
+        self.assertEqual(util.escape_text_for_xml(None), '')
+
+    def test_number_values(self):
+        """Test that numbers are properly converted to strings and wrapped in CDATA"""
+        self.assertEqual(util.escape_text_for_xml(42), '<![CDATA[42]]>')
+        self.assertEqual(util.escape_text_for_xml(3.14), '<![CDATA[3.14]]>')
+        self.assertEqual(util.escape_text_for_xml(-100), '<![CDATA[-100]]>')
+        self.assertEqual(util.escape_text_for_xml(0), '<![CDATA[0]]>')
+
+    def test_simple_strings(self):
+        """Test that simple strings are wrapped in CDATA"""
+        self.assertEqual(util.escape_text_for_xml('hello'), '<![CDATA[hello]]>')
+        self.assertEqual(util.escape_text_for_xml(''), '<![CDATA[]]>')
+        self.assertEqual(util.escape_text_for_xml('  '), '<![CDATA[  ]]>')
+
+    def test_strings_with_special_characters(self):
+        """Test strings containing XML special characters but no CDATA end sequence"""
+        self.assertEqual(util.escape_text_for_xml('<hello>'), '<![CDATA[<hello>]]>')
+        self.assertEqual(util.escape_text_for_xml('a & b'), '<![CDATA[a & b]]>')
+        self.assertEqual(util.escape_text_for_xml('"quoted"'), '<![CDATA["quoted"]]>')
+        self.assertEqual(util.escape_text_for_xml("'single'"), "<![CDATA['single']]>")
+        self.assertEqual(util.escape_text_for_xml('<![CDATA['), '<![CDATA[<![CDATA[]]>')
+
+    def test_strings_with_cdata_end_sequence(self):
+        """Test strings containing CDATA end sequence are properly escaped"""
+        # Simple case with just the CDATA end sequence
+        self.assertEqual(util.escape_text_for_xml(']]>'), ']]&gt;')
+        
+        # CDATA end sequence with other special characters
+        self.assertEqual(
+            util.escape_text_for_xml('Text with ]]> and <tags> & ampersands'),
+            'Text with ]]&gt; and &lt;tags&gt; &amp; ampersands'
+        )
+        
+        # Multiple CDATA end sequences
+        self.assertEqual(
+            util.escape_text_for_xml('Multiple ]]> end ]]> sequences'),
+            'Multiple ]]&gt; end ]]&gt; sequences'
+        )
+
+    def test_multiline_strings(self):
+        """Test multiline strings are properly handled"""
+        multiline = """Line 1
+        Line 2
+        Line 3"""
+        self.assertEqual(util.escape_text_for_xml(multiline), '<![CDATA[Line 1\n        Line 2\n        Line 3]]>')
+        
+        multiline_with_cdata = """Line 1
+        Line ]]> 2
+        Line 3"""
+        self.assertEqual(
+            util.escape_text_for_xml(multiline_with_cdata),
+            'Line 1\n        Line ]]&gt; 2\n        Line 3'
+        )
+
+    def test_edge_cases(self):
+        """Test edge cases and unusual inputs"""
+        # Empty string
+        self.assertEqual(util.escape_text_for_xml(''), '<![CDATA[]]>')
+        
+        # String with only whitespace
+        self.assertEqual(util.escape_text_for_xml('\n\t '), '<![CDATA[\n\t ]]>')
+        
+        # String with Unicode characters
+        self.assertEqual(util.escape_text_for_xml('Hello 世界'), '<![CDATA[Hello 世界]]>')
+        
+        # String with control characters
+        self.assertEqual(util.escape_text_for_xml('Hello\0World'), '<![CDATA[Hello\0World]]>')
+        
+        # Very long string
+        long_string = 'x' * 1000
+        self.assertEqual(util.escape_text_for_xml(long_string), f'<![CDATA[{long_string}]]>')
+
+    def test_boolean_values(self):
+        """Test boolean values are properly converted"""
+        self.assertEqual(util.escape_text_for_xml(True), '<![CDATA[True]]>')
+        self.assertEqual(util.escape_text_for_xml(False), '<![CDATA[False]]>')