Added web agent

test/base_agent_test.py

@@ -2,6 +2,7 @@ import unittest
 from datetime import datetime
 from unittest.mock import Mock, MagicMock, patch
 import xml.etree.ElementTree as ET
+import logging
 
 from sia.web_io_buffer import WebIOBuffer
 from sia.working_memory import WorkingMemory
@@ -47,38 +48,48 @@ class BaseAgentTest(unittest.TestCase):
         self.mock_metrics = Mock(spec=SystemMetrics)
         self.mock_validator = Mock(spec=XMLValidator)
         self.io_buffer = WebIOBuffer()
+        self.working_memory = WorkingMemory()
         
-        # Mock metrics context
-        metrics_elem = ET.Element("context")
-        metrics_elem.set("time", "2024-10-31T12:00:00Z")
-        metrics_elem.set("cpu", "10")
-        metrics_elem.set("gpu", "20")
-        metrics_elem.set("memory_used", "1000")
-        metrics_elem.set("memory_total", "2000")
-        metrics_elem.set("disk_used", "5000")
-        metrics_elem.set("disk_total", "10000")
-        metrics_elem.set("context", "50")
-        metrics_elem.set("stdin", "0")
-        self.mock_metrics.generate_context.return_value = metrics_elem
+        # Create parser with IO buffer
+        self.parser = ResponseParser(self.io_buffer)
         
-        # Create test agent with mocked components
-        with patch('sia.base_agent.LlmEngine') as mock_llm_class, \
-             patch('sia.base_agent.SystemMetrics') as mock_metrics_class, \
-             patch('sia.base_agent.XMLValidator') as mock_validator_class:
+        # Mock metrics context generator
+        def generate_context(context_size):
+            metrics_elem = ET.Element("context")
+            metrics_elem.set("time", "2024-10-31T12:00:00Z")
+            metrics_elem.set("cpu", "10")
+            metrics_elem.set("gpu", "20")
+            metrics_elem.set("memory_used", "1000")
+            metrics_elem.set("memory_total", "2000")
+            metrics_elem.set("disk_used", "5000")
+            metrics_elem.set("disk_total", "10000")
+            metrics_elem.set("context", str(int(context_size * 100)))
+            metrics_elem.set("stdin", "0")
+            return metrics_elem
             
-            mock_llm_class.return_value = self.mock_llm
-            mock_metrics_class.return_value = self.mock_metrics
-            mock_validator_class.return_value = self.mock_validator
-            
-            self.agent = TestBaseAgent(
-                model_path="/test/model",
-                system_prompt="test prompt",
-                action_schema="test schema",
-                io_buffer=self.io_buffer
-            )
+        self.mock_metrics.generate_context.side_effect = generate_context
+        
+        # Create test agent with required components
+        self.agent = TestBaseAgent(
+            action_schema="test schema",
+            working_memory=self.working_memory,
+            system_metrics=self.mock_metrics,
+            llm=self.mock_llm,
+            validator=self.mock_validator,
+            parser=self.parser
+        )
         
         # Set timestamp for entries
         self.test_timestamp = datetime(2024, 10, 31, 12, 0, 0)
+        
+        # Capture logging output
+        self.log_records = []
+        logging.getLogger().handlers = []
+        logging.getLogger().addHandler(self.log_handler)
+        
+    def log_handler(self, record):
+        """Capture log records for testing."""
+        self.log_records.append(record)
     
     def tearDown(self):
         """Clean up resources."""
@@ -87,13 +98,11 @@ class BaseAgentTest(unittest.TestCase):
             
     def test_initialization(self):
         """Test agent initialization and component setup."""
-        self.assertIsInstance(self.agent._working_memory, WorkingMemory)
+        self.assertEqual(self.agent._working_memory, self.working_memory)
         self.assertEqual(self.agent._metrics, self.mock_metrics)
         self.assertEqual(self.agent._llm, self.mock_llm)
         self.assertEqual(self.agent._validator, self.mock_validator)
-        self.assertEqual(self.agent._io_buffer, self.io_buffer)
-        self.assertIsInstance(self.agent._parser, ResponseParser)
-        self.assertEqual(self.agent._system_prompt, "test prompt")
+        self.assertEqual(self.agent._parser, self.parser)
         self.assertEqual(self.agent._action_schema, "test schema")
         
     def test_cleanup(self):
@@ -107,16 +116,17 @@ class BaseAgentTest(unittest.TestCase):
         
         # Parse context and verify structure
         root = ET.fromstring(context)
-        self.assertEqual(root.tag, "state")
+        self.assertEqual(root.tag, "context")
         
-        # Check metrics element
-        context_elem = root.find("context")
-        self.assertIsNotNone(context_elem)
-        self.assertEqual(context_elem.get("cpu"), "10")
-        self.assertEqual(context_elem.get("gpu"), "20")
+        # Check metrics
+        self.assertEqual(root.get("cpu"), "10")
+        self.assertEqual(root.get("gpu"), "20")
+        
+        # Check context size is 0 (empty memory)
+        self.assertEqual(root.get("context"), "0")
         
         # Check no memory entries
-        self.assertEqual(len(root.findall("*")), 1)  # Only metrics element
+        self.assertEqual(len(list(root)), 0)
         
     def test_compile_context_with_entries(self):
         """Test context compilation with working memory entries."""
@@ -129,8 +139,8 @@ class BaseAgentTest(unittest.TestCase):
         # Parse and verify context
         root = ET.fromstring(context)
         
-        # Check metrics and entry are present
-        self.assertEqual(len(root.findall("*")), 2)  # Metrics + reasoning
+        # Check context size reflects one entry
+        self.assertEqual(root.get("context"), "1")
         
         # Verify entry content
         reasoning_elem = root.find("reasoning")
@@ -152,11 +162,12 @@ class BaseAgentTest(unittest.TestCase):
         context = self.agent._compile_context()
         root = ET.fromstring(context)
         
-        # Verify all entries present
-        self.assertEqual(len(root.findall("reasoning")), 3)
+        # Check context size reflects three entries
+        self.assertEqual(root.get("context"), "3")
         
         # Verify entry order maintained
         reasoning_elems = root.findall("reasoning")
+        self.assertEqual(len(reasoning_elems), 3)
         for i, elem in enumerate(reasoning_elems):
             self.assertEqual(elem.get("id"), f"id-{i}")
             self.assertEqual(elem.text, f"<![CDATA[test {i}]]>")