test: add agent test coverage and standardize test suite (#2051)

- Add 104 comprehensive tests for agent system
- Integrate agent tests into CI/CD pipeline
- Standardize tests with @pytest.mark.unit markers
- Fix cross-platform path compatibility
- Clean up unused imports and dependencies

tests/test_cache.py

@@ -1,20 +1,20 @@
-import unittest
 import json
-from unittest.mock import patch, MagicMock
-from application.cache import gen_cache_key, stream_cache, gen_cache
+from unittest.mock import MagicMock, patch
+
+import pytest
+from application.cache import gen_cache, gen_cache_key, stream_cache
 from application.utils import get_hash
 
 
-# Test for gen_cache_key function
+@pytest.mark.unit
 def test_make_gen_cache_key():
     messages = [
-        {'role': 'user', 'content': 'test_user_message'},
-        {'role': 'system', 'content': 'test_system_message'},
+        {"role": "user", "content": "test_user_message"},
+        {"role": "system", "content": "test_system_message"},
     ]
     model = "test_docgpt"
     tools = None
-    
-    # Manually calculate the expected hash
+
     messages_str = json.dumps(messages)
     tools_str = json.dumps(tools) if tools else ""
     expected_combined = f"{model}_{messages_str}_{tools_str}"
@@ -23,112 +23,100 @@ def test_make_gen_cache_key():
 
     assert cache_key == expected_hash
 
-def test_gen_cache_key_invalid_message_format():
-    # Test when messages is not a list
-    with unittest.TestCase.assertRaises(unittest.TestCase, ValueError) as context:
-        gen_cache_key("This is not a list", model="docgpt", tools=None)
-    assert str(context.exception) == "All messages must be dictionaries."
 
-# Test for gen_cache decorator
-@patch('application.cache.get_redis_instance')  # Mock the Redis client
+@pytest.mark.unit
+def test_gen_cache_key_invalid_message_format():
+    with pytest.raises(ValueError, match="All messages must be dictionaries."):
+        gen_cache_key("This is not a list", model="docgpt", tools=None)
+
+
+@pytest.mark.unit
+@patch("application.cache.get_redis_instance")
 def test_gen_cache_hit(mock_make_redis):
-    # Arrange
     mock_redis_instance = MagicMock()
     mock_make_redis.return_value = mock_redis_instance
-    mock_redis_instance.get.return_value = b"cached_result"  # Simulate a cache hit
+    mock_redis_instance.get.return_value = b"cached_result"
 
     @gen_cache
     def mock_function(self, model, messages, stream, tools):
         return "new_result"
 
-    messages = [{'role': 'user', 'content': 'test_user_message'}]
+    messages = [{"role": "user", "content": "test_user_message"}]
     model = "test_docgpt"
 
-    # Act
     result = mock_function(None, model, messages, stream=False, tools=None)
 
-    # Assert
-    assert result == "cached_result"  # Should return cached result
-    mock_redis_instance.get.assert_called_once()  # Ensure Redis get was called
-    mock_redis_instance.set.assert_not_called()  # Ensure the function result is not cached again
+    assert result == "cached_result"
+    mock_redis_instance.get.assert_called_once()
+    mock_redis_instance.set.assert_not_called()
 
 
-@patch('application.cache.get_redis_instance')  # Mock the Redis client
+@pytest.mark.unit
+@patch("application.cache.get_redis_instance")
 def test_gen_cache_miss(mock_make_redis):
-    # Arrange
     mock_redis_instance = MagicMock()
     mock_make_redis.return_value = mock_redis_instance
-    mock_redis_instance.get.return_value = None  # Simulate a cache miss
+    mock_redis_instance.get.return_value = None
 
     @gen_cache
     def mock_function(self, model, messages, steam, tools):
         return "new_result"
 
     messages = [
-        {'role': 'user', 'content': 'test_user_message'},
-        {'role': 'system', 'content': 'test_system_message'},
+        {"role": "user", "content": "test_user_message"},
+        {"role": "system", "content": "test_system_message"},
     ]
     model = "test_docgpt"
-    # Act
+
     result = mock_function(None, model, messages, stream=False, tools=None)
 
-    # Assert
     assert result == "new_result"
-    mock_redis_instance.get.assert_called_once() 
+    mock_redis_instance.get.assert_called_once()
 
-@patch('application.cache.get_redis_instance')  
+
+@pytest.mark.unit
+@patch("application.cache.get_redis_instance")
 def test_stream_cache_hit(mock_make_redis):
-    # Arrange
     mock_redis_instance = MagicMock()
     mock_make_redis.return_value = mock_redis_instance
 
-    cached_chunk = json.dumps(["chunk1", "chunk2"]).encode('utf-8')
+    cached_chunk = json.dumps(["chunk1", "chunk2"]).encode("utf-8")
     mock_redis_instance.get.return_value = cached_chunk
 
     @stream_cache
     def mock_function(self, model, messages, stream, tools):
         yield "new_chunk"
 
-    messages = [{'role': 'user', 'content': 'test_user_message'}]
+    messages = [{"role": "user", "content": "test_user_message"}]
     model = "test_docgpt"
 
-    # Act
     result = list(mock_function(None, model, messages, stream=True, tools=None))
 
-    # Assert
-    assert result == ["chunk1", "chunk2"]  # Should return cached chunks
+    assert result == ["chunk1", "chunk2"]
     mock_redis_instance.get.assert_called_once()
     mock_redis_instance.set.assert_not_called()
 
 
-@patch('application.cache.get_redis_instance')
+@pytest.mark.unit
+@patch("application.cache.get_redis_instance")
 def test_stream_cache_miss(mock_make_redis):
-    # Arrange
     mock_redis_instance = MagicMock()
     mock_make_redis.return_value = mock_redis_instance
-    mock_redis_instance.get.return_value = None  # Simulate a cache miss
+    mock_redis_instance.get.return_value = None
 
     @stream_cache
     def mock_function(self, model, messages, stream, tools):
         yield "new_chunk"
 
     messages = [
-        {'role': 'user', 'content': 'This is the context'},
-        {'role': 'system', 'content': 'Some other message'},
-        {'role': 'user', 'content': 'What is the answer?'}
+        {"role": "user", "content": "This is the context"},
+        {"role": "system", "content": "Some other message"},
+        {"role": "user", "content": "What is the answer?"},
     ]
     model = "test_docgpt"
 
-    # Act
     result = list(mock_function(None, model, messages, stream=True, tools=None))
 
-    # Assert
     assert result == ["new_chunk"]
-    mock_redis_instance.get.assert_called_once()  
-    mock_redis_instance.set.assert_called_once()  
-
-
-
-    
-
-
+    mock_redis_instance.get.assert_called_once()
+    mock_redis_instance.set.assert_called_once()