SkipTagsAggregator and PatternPairAggregator now subclass SimpleTextAggregator

tests/test_pattern_pair_aggregator.py

@@ -38,14 +38,14 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.aggregator.on_pattern_match("code_pattern", self.code_handler)
 
     async def test_pattern_match_and_removal(self):
-        # First part doesn't complete the pattern
-        result = await self.aggregator.aggregate("Hello <test>pattern")
-        self.assertIsNone(result)
-        self.assertEqual(self.aggregator.text.text, "Hello <test>pattern")
-        self.assertEqual(self.aggregator.text.type, "test_pattern")
+        # Feed text character by character
+        full_text = "Hello <test>pattern content</test>!"
+        result = None
 
-        # Second part completes the pattern and includes an exclamation point
-        result = await self.aggregator.aggregate(" content</test>!")
+        for char in full_text:
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
 
         # Verify the handler was called with correct PatternMatch object
         self.test_handler.assert_called_once()
@@ -56,27 +56,49 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(call_args.text, "pattern content")
 
         # The exclamation point should be treated as a sentence boundary,
-        # so the result should include just text up to and including "!"
+        # but with lookahead, we need more text or flush() to confirm
+        self.assertIsNone(result)  # Waiting for lookahead after "!"
+
+        # Next sentence should provide the lookahead and trigger the previous sentence
+        for char in " This is another sentence.":
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
+
         self.assertEqual(result.text, "Hello !")
         self.assertEqual(result.type, "sentence")
 
-        # Next sentence should be processed separately. Spaces around the sentence
-        # should be stripped in the returned Aggregation.
-        result = await self.aggregator.aggregate(" This is another sentence.")
+        # Now flush to get the remaining sentence
+        result = await self.aggregator.flush()
         self.assertEqual(result.text, "This is another sentence.")
 
         # Buffer should be empty after returning a complete sentence
         self.assertEqual(self.aggregator.text.text, "")
 
     async def test_pattern_match_and_aggregate(self):
-        # First part doesn't complete the pattern
-        result = await self.aggregator.aggregate("Here is code <code>pattern")
+        # Feed text character by character until we get the first aggregation
+        result = None
+        for char in "Here is code <code>pattern content</code>":
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
+
+        # First result should be "Here is code" when pattern starts
         self.assertEqual(result.text, "Here is code")
-        self.assertEqual(self.aggregator.text.text, "<code>pattern")
+        self.assertEqual(self.aggregator.text.text, "<code>pattern content</code>")
         self.assertEqual(self.aggregator.text.type, "code_pattern")
 
-        # Second part completes the pattern and includes an exclamation point
-        result = await self.aggregator.aggregate(" content</code>")
+        # Continue feeding to complete the pattern
+        result = None
+        for char in "":  # Already fed all chars, just need to check state
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
+
+        # Since we already fed all characters, we need to trigger pattern completion
+        # by checking what's in the buffer - the pattern should have been processed
+        # Let's continue with a space to trigger the next check
+        result = await self.aggregator.aggregate(" ")
 
         # Verify the handler was called with correct PatternMatch object
         self.code_handler.assert_called_once()
@@ -89,7 +111,15 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(result.type, "code_pattern")
 
         # Next sentence should be processed separately
-        result = await self.aggregator.aggregate(" This is another sentence.")
+        # With lookahead, we need to flush to get the final sentence
+        for char in "This is another sentence.":
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
+
+        self.assertIsNone(result)  # Waiting for lookahead after "."
+
+        result = await self.aggregator.flush()
         self.assertEqual(result.text, "This is another sentence.")
         self.assertEqual(result.type, "sentence")
 
@@ -97,8 +127,12 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(self.aggregator.text.text, "")
 
     async def test_incomplete_pattern(self):
-        # Add text with incomplete pattern
-        result = await self.aggregator.aggregate("Hello <test>pattern content")
+        # Feed text character by character with incomplete pattern
+        result = None
+        for char in "Hello <test>pattern content":
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
 
         # No complete pattern yet, so nothing should be returned
         self.assertIsNone(result)
@@ -136,9 +170,13 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.aggregator.on_pattern_match("voice", voice_handler)
         self.aggregator.on_pattern_match("emphasis", emphasis_handler)
 
-        # Test with multiple patterns in one text block
+        # Feed text character by character
         text = "Hello <voice>female</voice> I am <em>very</em> excited to meet you!"
-        result = await self.aggregator.aggregate(text)
+        result = None
+        for char in text:
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
 
         # Both handlers should be called with correct data
         voice_handler.assert_called_once()
@@ -151,6 +189,10 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(emphasis_match.type, "emphasis")
         self.assertEqual(emphasis_match.text, "very")
 
+        # With lookahead, we need to flush to get the final sentence
+        self.assertIsNone(result)  # Waiting for lookahead after "!"
+
+        result = await self.aggregator.flush()
         # Voice pattern should be removed, emphasis pattern should remain
         self.assertEqual(result.text, "Hello  I am <em>very</em> excited to meet you!")
 
@@ -158,8 +200,13 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(self.aggregator.text.text, "")
 
     async def test_handle_interruption(self):
-        # Start with incomplete pattern
-        result = await self.aggregator.aggregate("Hello <test>pattern")
+        # Feed text character by character with incomplete pattern
+        result = None
+        for char in "Hello <test>pattern":
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
+
         self.assertIsNone(result)
 
         # Simulate interruption
@@ -172,20 +219,24 @@ class TestPatternPairAggregator(unittest.IsolatedAsyncioTestCase):
         self.test_handler.assert_not_called()
 
     async def test_pattern_across_sentences(self):
-        # Test pattern that spans multiple sentences
-        result = await self.aggregator.aggregate("Hello <test>This is sentence one.")
+        # Feed text character by character - pattern spans multiple sentences
+        full_text = "Hello <test>This is sentence one. This is sentence two.</test> Final sentence."
+        result = None
 
-        # First sentence contains start of pattern but no end, so no complete pattern yet
-        self.assertIsNone(result)
-
-        # Add second part with pattern end
-        result = await self.aggregator.aggregate(" This is sentence two.</test> Final sentence.")
+        for char in full_text:
+            result = await self.aggregator.aggregate(char)
+            if result:
+                break
 
         # Handler should be called with entire content
         self.test_handler.assert_called_once()
         call_args = self.test_handler.call_args[0][0]
         self.assertEqual(call_args.text, "This is sentence one. This is sentence two.")
 
+        # With lookahead, we need to flush to get the final sentence
+        self.assertIsNone(result)  # Waiting for lookahead after "."
+
+        result = await self.aggregator.flush()
         # Pattern should be removed, resulting in text with sentences merged
         self.assertEqual(result.text, "Hello  Final sentence.")