test(cache): add comprehensive tests for cache service

- Add unit tests for all cache operations
- Add integration tests with real Redis instance
- Test compression, TTL expiration, and stampede protection
- Test chat response, session, and investigation caching
- Add concurrent operation tests
- Test cache statistics and monitoring
- Add missing json import to cache_service.py

src/services/cache_service.py

@@ -9,6 +9,7 @@ This service provides:
 """
 
 import hashlib
+import json
 from typing import Optional, Any, Dict, List
 from datetime import datetime, timedelta
 import asyncio

tests/integration/test_cache_service_integration.py

@@ -0,0 +1,299 @@
+"""Integration tests for cache service with real Redis"""
+
+import pytest
+import asyncio
+from datetime import datetime
+import time
+import os
+
+from src.services.cache_service import CacheService, cache_result
+
+# Skip these tests if Redis is not available
+redis_available = os.getenv("REDIS_URL") is not None
+
+@pytest.mark.skipif(not redis_available, reason="Redis not available")
+class TestCacheServiceIntegration:
+    """Integration tests with real Redis instance"""
+    
+    @pytest.fixture
+    async def cache_service(self):
+        """Create real cache service instance"""
+        service = CacheService()
+        await service.initialize()
+        yield service
+        # Cleanup
+        await service.redis.flushdb()
+        await service.close()
+    
+    @pytest.mark.asyncio
+    async def test_basic_operations(self, cache_service):
+        """Test basic get/set/delete operations"""
+        # Set value
+        assert await cache_service.set("test_key", {"data": "value"}, ttl=10)
+        
+        # Get value
+        result = await cache_service.get("test_key")
+        assert result == {"data": "value"}
+        
+        # Delete value
+        assert await cache_service.delete("test_key")
+        
+        # Verify deleted
+        result = await cache_service.get("test_key")
+        assert result is None
+    
+    @pytest.mark.asyncio
+    async def test_ttl_expiration(self, cache_service):
+        """Test TTL expiration"""
+        # Set with 1 second TTL
+        await cache_service.set("expire_key", "value", ttl=1)
+        
+        # Should exist immediately
+        assert await cache_service.get("expire_key") == "value"
+        
+        # Wait for expiration
+        await asyncio.sleep(1.5)
+        
+        # Should be expired
+        assert await cache_service.get("expire_key") is None
+    
+    @pytest.mark.asyncio
+    async def test_compression(self, cache_service):
+        """Test compression for large values"""
+        large_data = {"data": "x" * 10000}  # ~10KB
+        
+        # Set with compression
+        await cache_service.set("compressed_key", large_data, compress=True)
+        
+        # Get with decompression
+        result = await cache_service.get("compressed_key", decompress=True)
+        assert result == large_data
+    
+    @pytest.mark.asyncio
+    async def test_chat_response_caching(self, cache_service):
+        """Test chat response caching workflow"""
+        response = {
+            "message": "This is a test response",
+            "confidence": 0.95,
+            "agent": "test_agent"
+        }
+        
+        # Cache response
+        assert await cache_service.cache_chat_response("Hello world", response, "greeting")
+        
+        # Get cached response
+        cached = await cache_service.get_cached_chat_response("Hello world", "greeting")
+        assert cached == response
+        
+        # Case insensitive and trimmed
+        cached2 = await cache_service.get_cached_chat_response("  hello WORLD  ", "greeting")
+        assert cached2 == response
+    
+    @pytest.mark.asyncio
+    async def test_session_management(self, cache_service):
+        """Test session state management"""
+        session_id = "test_session_123"
+        initial_state = {
+            "user_id": "user_456",
+            "started_at": datetime.utcnow().isoformat(),
+            "context": {"intent": "help"}
+        }
+        
+        # Save session
+        assert await cache_service.save_session_state(session_id, initial_state)
+        
+        # Get session
+        state = await cache_service.get_session_state(session_id)
+        assert state["user_id"] == "user_456"
+        assert state["context"]["intent"] == "help"
+        assert "last_updated" in state
+        
+        # Update field
+        assert await cache_service.update_session_field(session_id, "messages_count", 5)
+        
+        # Verify update
+        state = await cache_service.get_session_state(session_id)
+        assert state["messages_count"] == 5
+        assert state["user_id"] == "user_456"  # Original fields preserved
+    
+    @pytest.mark.asyncio
+    async def test_investigation_caching(self, cache_service):
+        """Test investigation result caching"""
+        investigation_id = "inv_789"
+        results = {
+            "anomalies_found": 3,
+            "contracts_analyzed": 150,
+            "findings": [
+                {"type": "price_anomaly", "severity": "high"},
+                {"type": "vendor_concentration", "severity": "medium"}
+            ]
+        }
+        
+        # Cache investigation
+        assert await cache_service.cache_investigation_result(investigation_id, results)
+        
+        # Retrieve investigation
+        cached = await cache_service.get_cached_investigation(investigation_id)
+        assert cached == results
+    
+    @pytest.mark.asyncio
+    async def test_search_results_caching(self, cache_service):
+        """Test search results caching with filters"""
+        query = "contratos suspeitos"
+        filters = {"year": 2024, "min_value": 100000, "status": "active"}
+        results = [
+            {"id": "1", "title": "Contrato A", "value": 150000},
+            {"id": "2", "title": "Contrato B", "value": 200000}
+        ]
+        
+        # Cache search results
+        assert await cache_service.cache_search_results(query, filters, results)
+        
+        # Get cached results
+        cached = await cache_service.get_cached_search_results(query, filters)
+        assert cached == results
+        
+        # Different filters should not hit cache
+        different_filters = {"year": 2023, "min_value": 100000, "status": "active"}
+        cached2 = await cache_service.get_cached_search_results(query, different_filters)
+        assert cached2 is None
+    
+    @pytest.mark.asyncio
+    async def test_agent_context_management(self, cache_service):
+        """Test agent context storage"""
+        agent_id = "zumbi"
+        session_id = "session_123"
+        context = {
+            "investigation_id": "inv_456",
+            "findings": ["anomaly1", "anomaly2"],
+            "confidence": 0.85
+        }
+        
+        # Save context
+        assert await cache_service.save_agent_context(agent_id, session_id, context)
+        
+        # Get context
+        retrieved = await cache_service.get_agent_context(agent_id, session_id)
+        assert retrieved == context
+    
+    @pytest.mark.asyncio
+    async def test_concurrent_operations(self, cache_service):
+        """Test concurrent cache operations"""
+        async def set_value(key, value):
+            await cache_service.set(key, value)
+            
+        async def get_value(key):
+            return await cache_service.get(key)
+        
+        # Create many concurrent operations
+        tasks = []
+        for i in range(50):
+            tasks.append(set_value(f"concurrent_{i}", f"value_{i}"))
+        
+        await asyncio.gather(*tasks)
+        
+        # Verify all values
+        get_tasks = []
+        for i in range(50):
+            get_tasks.append(get_value(f"concurrent_{i}"))
+        
+        results = await asyncio.gather(*get_tasks)
+        
+        for i, result in enumerate(results):
+            assert result == f"value_{i}"
+    
+    @pytest.mark.asyncio
+    async def test_cache_stats(self, cache_service):
+        """Test cache statistics"""
+        # Add some data
+        await cache_service.cache_chat_response("test1", {"msg": "response1"})
+        await cache_service.save_session_state("session1", {"data": "test"})
+        await cache_service.cache_investigation_result("inv1", {"results": "data"})
+        
+        # Get stats
+        stats = await cache_service.get_cache_stats()
+        
+        assert stats["connected"] is True
+        assert stats["total_keys"] >= 3
+        assert "memory_used" in stats
+        assert "hit_rate" in stats
+        assert stats["keys_by_type"]["chat"] >= 1
+        assert stats["keys_by_type"]["session"] >= 1
+        assert stats["keys_by_type"]["investigation"] >= 1
+    
+    @pytest.mark.asyncio
+    async def test_stampede_protection(self, cache_service):
+        """Test cache stampede protection"""
+        refresh_count = 0
+        
+        async def slow_refresh():
+            nonlocal refresh_count
+            refresh_count += 1
+            await asyncio.sleep(0.1)
+            return {"refreshed": refresh_count}
+        
+        # Set initial value with short TTL
+        await cache_service.set("stampede_key", {"initial": "value"}, ttl=2)
+        
+        # Multiple concurrent requests near expiration
+        await asyncio.sleep(1.5)  # Close to expiration
+        
+        tasks = []
+        for _ in range(10):
+            tasks.append(
+                cache_service.get_with_stampede_protection(
+                    "stampede_key", 
+                    10, 
+                    slow_refresh
+                )
+            )
+        
+        results = await asyncio.gather(*tasks)
+        
+        # All should get same value
+        assert all(r == results[0] for r in results)
+        
+        # Refresh should be called only once or twice (not 10 times)
+        assert refresh_count <= 2
+
+
+@pytest.mark.skipif(not redis_available, reason="Redis not available")
+class TestCacheDecoratorIntegration:
+    """Integration tests for cache decorator"""
+    
+    @pytest.fixture
+    async def cleanup_redis(self):
+        """Clean Redis after tests"""
+        yield
+        service = CacheService()
+        await service.initialize()
+        await service.redis.flushdb()
+        await service.close()
+    
+    @pytest.mark.asyncio
+    async def test_decorator_caching(self, cleanup_redis):
+        """Test function caching with decorator"""
+        call_count = 0
+        
+        @cache_result("expensive", ttl=5)
+        async def expensive_function(param1, param2):
+            nonlocal call_count
+            call_count += 1
+            await asyncio.sleep(0.1)  # Simulate expensive operation
+            return {"result": f"{param1}-{param2}", "count": call_count}
+        
+        # First call - should execute
+        result1 = await expensive_function("test", "123")
+        assert result1["count"] == 1
+        
+        # Second call - should use cache
+        result2 = await expensive_function("test", "123")
+        assert result2["count"] == 1  # Same count, not executed again
+        
+        # Different parameters - should execute
+        result3 = await expensive_function("test", "456")
+        assert result3["count"] == 2
+        
+        # Original parameters again - should use cache
+        result4 = await expensive_function("test", "123")
+        assert result4["count"] == 1

tests/unit/test_cache_service.py

@@ -0,0 +1,335 @@
+"""Unit tests for cache service"""
+
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from datetime import datetime
+import zlib
+
+from src.services.cache_service import CacheService, cache_result
+from src.core.exceptions import CacheError
+
+
+class TestCacheService:
+    """Test CacheService functionality"""
+    
+    @pytest.fixture
+    async def cache_service(self):
+        """Create cache service instance"""
+        service = CacheService()
+        # Mock Redis
+        service.redis = AsyncMock()
+        service._initialized = True
+        yield service
+        
+    @pytest.fixture
+    async def uninitialized_cache(self):
+        """Create uninitialized cache service"""
+        service = CacheService()
+        yield service
+    
+    def test_generate_key_short(self, cache_service):
+        """Test key generation for short inputs"""
+        key = cache_service._generate_key("test", "arg1", "arg2")
+        assert key == "cidadao:test:arg1:arg2"
+    
+    def test_generate_key_long(self, cache_service):
+        """Test key generation for long inputs (should hash)"""
+        long_arg = "a" * 200
+        key = cache_service._generate_key("test", long_arg)
+        assert key.startswith("cidadao:test:")
+        assert len(key) < 100  # Should be hashed
+        
+    @pytest.mark.asyncio
+    async def test_initialize_success(self):
+        """Test successful initialization"""
+        service = CacheService()
+        
+        with patch('redis.asyncio.ConnectionPool.from_url') as mock_pool:
+            with patch('redis.asyncio.Redis') as mock_redis:
+                mock_redis_instance = AsyncMock()
+                mock_redis_instance.ping = AsyncMock(return_value=True)
+                mock_redis.return_value = mock_redis_instance
+                
+                await service.initialize()
+                
+                assert service._initialized is True
+                mock_redis_instance.ping.assert_called_once()
+    
+    @pytest.mark.asyncio
+    async def test_initialize_failure(self):
+        """Test initialization failure"""
+        service = CacheService()
+        
+        with patch('redis.asyncio.ConnectionPool.from_url') as mock_pool:
+            mock_pool.side_effect = Exception("Connection failed")
+            
+            with pytest.raises(CacheError):
+                await service.initialize()
+    
+    @pytest.mark.asyncio
+    async def test_get_success(self, cache_service):
+        """Test successful get operation"""
+        cache_service.redis.get.return_value = '{"key": "value"}'
+        
+        result = await cache_service.get("test_key")
+        assert result == {"key": "value"}
+        cache_service.redis.get.assert_called_once_with("test_key")
+    
+    @pytest.mark.asyncio
+    async def test_get_compressed(self, cache_service):
+        """Test get with decompression"""
+        original = '{"key": "value"}'
+        compressed = zlib.compress(original.encode())
+        cache_service.redis.get.return_value = compressed
+        
+        result = await cache_service.get("test_key", decompress=True)
+        assert result == {"key": "value"}
+    
+    @pytest.mark.asyncio
+    async def test_get_not_found(self, cache_service):
+        """Test get when key doesn't exist"""
+        cache_service.redis.get.return_value = None
+        
+        result = await cache_service.get("test_key")
+        assert result is None
+    
+    @pytest.mark.asyncio
+    async def test_get_redis_error(self, cache_service):
+        """Test get with Redis error"""
+        cache_service.redis.get.side_effect = Exception("Redis error")
+        
+        result = await cache_service.get("test_key")
+        assert result is None
+    
+    @pytest.mark.asyncio
+    async def test_set_success_with_ttl(self, cache_service):
+        """Test successful set operation with TTL"""
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        result = await cache_service.set("test_key", {"data": "value"}, ttl=300)
+        assert result is True
+        cache_service.redis.setex.assert_called_once()
+        
+    @pytest.mark.asyncio
+    async def test_set_success_without_ttl(self, cache_service):
+        """Test successful set operation without TTL"""
+        cache_service.redis.set = AsyncMock(return_value=True)
+        
+        result = await cache_service.set("test_key", {"data": "value"})
+        assert result is True
+        cache_service.redis.set.assert_called_once()
+    
+    @pytest.mark.asyncio
+    async def test_set_with_compression(self, cache_service):
+        """Test set with compression for large values"""
+        large_value = {"data": "x" * 2000}  # Large enough to trigger compression
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        result = await cache_service.set("test_key", large_value, ttl=300, compress=True)
+        assert result is True
+        
+        # Verify compression was applied
+        call_args = cache_service.redis.setex.call_args[0]
+        compressed_value = call_args[2]
+        # Should be compressed (smaller than original JSON)
+        assert len(compressed_value) < len(str(large_value))
+    
+    @pytest.mark.asyncio
+    async def test_delete_success(self, cache_service):
+        """Test successful delete operation"""
+        cache_service.redis.delete.return_value = 1
+        
+        result = await cache_service.delete("test_key")
+        assert result is True
+        cache_service.redis.delete.assert_called_once_with("test_key")
+    
+    @pytest.mark.asyncio
+    async def test_delete_key_not_found(self, cache_service):
+        """Test delete when key doesn't exist"""
+        cache_service.redis.delete.return_value = 0
+        
+        result = await cache_service.delete("test_key")
+        assert result is False
+    
+    @pytest.mark.asyncio
+    async def test_cache_chat_response(self, cache_service):
+        """Test caching chat response"""
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        response = {"message": "Test response"}
+        result = await cache_service.cache_chat_response("Hello", response, "greeting")
+        
+        assert result is True
+        cache_service.redis.setex.assert_called_once()
+        
+        # Check TTL is correct
+        call_args = cache_service.redis.setex.call_args[0]
+        assert call_args[1] == 300  # TTL_CHAT_RESPONSE
+    
+    @pytest.mark.asyncio
+    async def test_get_cached_chat_response(self, cache_service):
+        """Test getting cached chat response"""
+        cached_data = {
+            "response": {"message": "Cached response"},
+            "cached_at": datetime.utcnow().isoformat(),
+            "hit_count": 5
+        }
+        cache_service.redis.get.return_value = str(cached_data)
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        # Mock loads to return the cached data
+        with patch('src.services.cache_service.loads', return_value=cached_data):
+            result = await cache_service.get_cached_chat_response("Hello", "greeting")
+        
+        assert result == {"message": "Cached response"}
+        # Should increment hit count
+        assert cache_service.redis.setex.called
+    
+    @pytest.mark.asyncio
+    async def test_save_session_state(self, cache_service):
+        """Test saving session state"""
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        state = {"user_id": "123", "context": "test"}
+        result = await cache_service.save_session_state("session_123", state)
+        
+        assert result is True
+        cache_service.redis.setex.assert_called_once()
+        
+        # Check TTL
+        call_args = cache_service.redis.setex.call_args[0]
+        assert call_args[1] == 86400  # TTL_SESSION
+    
+    @pytest.mark.asyncio
+    async def test_get_session_state(self, cache_service):
+        """Test getting session state"""
+        state = {"user_id": "123", "context": "test"}
+        cache_service.redis.get.return_value = str(state)
+        
+        with patch('src.services.cache_service.loads', return_value=state):
+            result = await cache_service.get_session_state("session_123")
+        
+        assert result == state
+    
+    @pytest.mark.asyncio
+    async def test_update_session_field(self, cache_service):
+        """Test updating session field"""
+        existing_state = {"user_id": "123", "context": "test"}
+        cache_service.redis.get.return_value = str(existing_state)
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        with patch('src.services.cache_service.loads', return_value=existing_state):
+            result = await cache_service.update_session_field("session_123", "new_field", "value")
+        
+        assert result is True
+        # Verify the updated state was saved
+        cache_service.redis.setex.assert_called_once()
+    
+    @pytest.mark.asyncio
+    async def test_cache_investigation_result(self, cache_service):
+        """Test caching investigation result"""
+        cache_service.redis.setex = AsyncMock(return_value=True)
+        
+        result_data = {"findings": ["anomaly1", "anomaly2"]}
+        result = await cache_service.cache_investigation_result("inv_123", result_data)
+        
+        assert result is True
+        call_args = cache_service.redis.setex.call_args[0]
+        assert call_args[1] == 3600  # TTL_INVESTIGATION
+    
+    @pytest.mark.asyncio
+    async def test_get_cache_stats(self, cache_service):
+        """Test getting cache statistics"""
+        cache_service.redis.info = AsyncMock()
+        cache_service.redis.info.side_effect = [
+            {"keyspace_hit_ratio": 0.85, "total_connections_received": 100},
+            {"used_memory_human": "10M"}
+        ]
+        cache_service.redis.dbsize = AsyncMock(return_value=1000)
+        cache_service.redis.scan_iter = AsyncMock()
+        cache_service.redis.scan_iter.return_value.__aiter__.return_value = iter(["key1", "key2"])
+        
+        stats = await cache_service.get_cache_stats()
+        
+        assert stats["connected"] is True
+        assert stats["total_keys"] == 1000
+        assert stats["memory_used"] == "10M"
+        assert "hit_rate" in stats
+    
+    @pytest.mark.asyncio
+    async def test_cache_stampede_protection(self, cache_service):
+        """Test cache stampede protection mechanism"""
+        # Mock pipeline
+        pipeline = AsyncMock()
+        pipeline.execute.return_value = ['{"value": "test"}', 5]  # value, TTL
+        cache_service.redis.pipeline.return_value = pipeline
+        
+        refresh_called = False
+        async def refresh_callback():
+            nonlocal refresh_called
+            refresh_called = True
+            return {"value": "refreshed"}
+        
+        with patch('src.services.cache_service.loads', return_value={"value": "test"}):
+            result = await cache_service.get_with_stampede_protection(
+                "test_key", 
+                300, 
+                refresh_callback
+            )
+        
+        assert result == {"value": "test"}
+        # Refresh might be called based on random factor
+    
+    @pytest.mark.asyncio
+    async def test_auto_initialization(self, uninitialized_cache):
+        """Test automatic initialization on first operation"""
+        with patch.object(uninitialized_cache, 'initialize') as mock_init:
+            mock_init.return_value = None
+            uninitialized_cache._initialized = True
+            uninitialized_cache.redis = AsyncMock()
+            uninitialized_cache.redis.get.return_value = None
+            
+            await uninitialized_cache.get("test_key")
+            mock_init.assert_called_once()
+
+
+class TestCacheDecorator:
+    """Test cache_result decorator"""
+    
+    @pytest.mark.asyncio
+    async def test_cache_decorator_hit(self):
+        """Test cache decorator with cache hit"""
+        mock_cache = AsyncMock()
+        mock_cache._generate_key.return_value = "test_key"
+        mock_cache.get.return_value = {"cached": "result"}
+        
+        with patch('src.services.cache_service.CacheService', return_value=mock_cache):
+            @cache_result("test", ttl=60)
+            async def test_function(arg1, arg2):
+                return {"result": f"{arg1}-{arg2}"}
+            
+            result = await test_function("a", "b")
+            
+        assert result == {"cached": "result"}
+        mock_cache.get.assert_called_once()
+        mock_cache.set.assert_not_called()
+    
+    @pytest.mark.asyncio
+    async def test_cache_decorator_miss(self):
+        """Test cache decorator with cache miss"""
+        mock_cache = AsyncMock()
+        mock_cache._generate_key.return_value = "test_key"
+        mock_cache.get.return_value = None
+        mock_cache.set.return_value = True
+        
+        with patch('src.services.cache_service.CacheService', return_value=mock_cache):
+            @cache_result("test", ttl=60)
+            async def test_function(arg1, arg2):
+                return {"result": f"{arg1}-{arg2}"}
+            
+            result = await test_function("a", "b")
+            
+        assert result == {"result": "a-b"}
+        mock_cache.get.assert_called_once()
+        mock_cache.set.assert_called_once_with("test_key", {"result": "a-b"}, 60)