test(agents): update tests for refactored agents

- Update test_zumbi.py to use InvestigatorAgent with new interface
- Update test_anita.py to use AnalystAgent with new interface
- Create test_tiradentes_reporter.py for ReporterAgent
- Fix all agent initialization parameters to match new pattern
- Update all message actions to use new naming convention
- Add tests for initialize() and shutdown() methods
- Update assertions to match new agent properties

This ensures test compatibility with the refactored agent architecture

tests/unit/agents/test_anita.py

@@ -10,10 +10,10 @@ from unittest.mock import Mock, AsyncMock, patch, MagicMock
 from uuid import uuid4
 
 from src.agents.anita import (
-    AnitaAgent,
+    AnalystAgent,
     PatternResult,
     CorrelationResult,
-    PatternAnalysisRequest,
+    AnalysisRequest,
 )
 from src.agents.deodoro import (
     AgentContext,
@@ -170,11 +170,10 @@ def anita_agent(mock_transparency_api, mock_spectral_analyzer):
     with patch("src.agents.anita.TransparencyAPIClient", return_value=mock_transparency_api), \
          patch("src.agents.anita.SpectralAnalyzer", return_value=mock_spectral_analyzer):
         
-        agent = AnitaAgent(
-            pattern_significance_threshold=0.7,
-            correlation_threshold=0.6,
-            max_analysis_depth=5,
-            semantic_similarity_threshold=0.8
+        agent = AnalystAgent(
+            min_correlation_threshold=0.3,
+            significance_threshold=0.05,
+            trend_detection_window=6
         )
         return agent
 
@@ -186,10 +185,9 @@ class TestAnitaAgent:
     def test_agent_initialization(self, anita_agent):
         """Test Anita agent initialization."""
         assert anita_agent.name == "Anita"
-        assert anita_agent.pattern_significance_threshold == 0.7
-        assert anita_agent.correlation_threshold == 0.6
-        assert anita_agent.max_analysis_depth == 5
-        assert anita_agent.semantic_similarity_threshold == 0.8
+        assert anita_agent.correlation_threshold == 0.3
+        assert anita_agent.significance_threshold == 0.05
+        assert anita_agent.trend_window == 6
         
         # Check capabilities
         expected_capabilities = [
@@ -210,7 +208,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="investigator_agent",
             recipient="Anita",
-            action="analyze_temporal_patterns",
+            action="analyze",
             payload={
                 "data_type": "expenses",
                 "time_window": "2024-01-01:2024-06-30",
@@ -241,7 +239,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="analyst_agent",
             recipient="Anita",
-            action="detect_correlations",
+            action="analyze",
             payload={
                 "variables": ["contract_values", "expense_amounts", "supplier_count"],
                 "correlation_methods": ["pearson", "spearman", "mutual_information"],
@@ -278,7 +276,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="master_agent",
             recipient="Anita", 
-            action="semantic_route",
+            action="analyze",
             payload={
                 "queries": queries,
                 "route_to_specialists": True,
@@ -305,7 +303,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="tiradentes_agent",
             recipient="Anita",
-            action="analyze_supplier_concentration",
+            action="analyze",
             payload={
                 "analysis_scope": "ministry_level",
                 "include_geographic_analysis": True,
@@ -335,7 +333,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="machado_agent",
             recipient="Anita",
-            action="analyze_network_patterns",
+            action="analyze",
             payload={
                 "network_type": "supplier_ministry_relationships",
                 "include_centrality_measures": True,
@@ -366,7 +364,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="investigator_agent", 
             recipient="Anita",
-            action="score_anomalies",
+            action="analyze",
             payload={
                 "data_points": [
                     {"value": 1000000, "date": "2024-01-01", "entity": "supplier_a"},
@@ -398,7 +396,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="analyst_agent",
             recipient="Anita",
-            action="forecast_trends",
+            action="analyze",
             payload={
                 "historical_data": {
                     "2024-01": 1000000,
@@ -438,7 +436,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="quality_agent",
             recipient="Anita",
-            action="analyze_temporal_patterns",
+            action="analyze",
             payload={
                 "data_type": "contracts",
                 "significance_filter": True
@@ -460,7 +458,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="comprehensive_analyst",
             recipient="Anita",
-            action="multi_dimensional_analysis",
+            action="analyze",
             payload={
                 "dimensions": ["temporal", "geographic", "categorical", "financial"],
                 "interaction_analysis": True,
@@ -498,7 +496,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="test_agent",
             recipient="Anita",
-            action="analyze_temporal_patterns",
+            action="analyze",
             payload={"data_type": "contracts"}
         )
         
@@ -519,7 +517,7 @@ class TestAnitaAgent:
             AgentMessage(
                 sender="concurrent_tester",
                 recipient="Anita",
-                action="analyze_temporal_patterns",
+                action="analyze",
                 payload={"data_type": f"data_stream_{i}"}
             )
             for i in range(3)
@@ -542,7 +540,7 @@ class TestAnitaAgent:
         message = AgentMessage(
             sender="cache_tester",
             recipient="Anita",
-            action="analyze_temporal_patterns",
+            action="analyze",
             payload={
                 "data_type": "expenses",
                 "cache_results": True,

tests/unit/agents/test_tiradentes.py

@@ -9,10 +9,10 @@ from unittest.mock import Mock, AsyncMock, patch, MagicMock
 from uuid import uuid4
 
 from src.agents.tiradentes import (
-    TiradentesAgent,
-    InvestigationRequest,
-    AnomalyReport,
-    CorruptionIndicator,
+    ReporterAgent,
+    ReportRequest,
+    ReportType,
+    ReportFormat,
 )
 from src.agents.deodoro import (
     AgentContext,
@@ -138,33 +138,31 @@ def agent_context():
 
 
 @pytest.fixture
-def tiradentes_agent(mock_data_service, mock_ai_service):
-    """Create Tiradentes agent with mocked dependencies."""
-    with patch("src.agents.tiradentes.DataService", return_value=mock_data_service), \
-         patch("src.agents.tiradentes.AIService", return_value=mock_ai_service):
-        
-        agent = TiradentesAgent(
-            anomaly_threshold=0.7,
-            correlation_threshold=0.8,
-            max_investigation_depth=3
-        )
-        return agent
+def tiradentes_agent():
+    """Create Tiradentes agent (ReporterAgent)."""
+    agent = ReporterAgent(
+        default_language="pt",
+        max_report_length=10000
+    )
+    return agent
 
 
 class TestTiradentesAgent:
-    """Test suite for Tiradentes (Investigation Agent)."""
+    """Test suite for Tiradentes (Reporter Agent)."""
     
     @pytest.mark.unit
     def test_agent_initialization(self, tiradentes_agent):
         """Test Tiradentes agent initialization."""
         assert tiradentes_agent.name == "Tiradentes"
-        assert tiradentes_agent.anomaly_threshold == 0.7
-        assert tiradentes_agent.correlation_threshold == 0.8
-        assert tiradentes_agent.max_investigation_depth == 3
+        assert tiradentes_agent.default_language == "pt"
+        assert tiradentes_agent.max_length == 10000
         
         # Check capabilities
         expected_capabilities = [
-            "anomaly_detection",
+            "investigation_report_generation",
+            "pattern_analysis_reporting",
+            "executive_summary_creation",
+            "multi_format_rendering",
             "corruption_analysis", 
             "investigation_planning",
             "pattern_recognition",

tests/unit/agents/test_tiradentes_reporter.py

@@ -0,0 +1,285 @@
+"""
+Unit tests for Tiradentes Agent (ReporterAgent) - Report generation specialist.
+Tests report generation, formatting, and multi-language support.
+"""
+
+import pytest
+from datetime import datetime
+from unittest.mock import Mock, AsyncMock, patch, MagicMock
+
+from src.agents.tiradentes import (
+    ReporterAgent,
+    ReportRequest,
+    ReportType,
+    ReportFormat,
+)
+from src.agents.deodoro import (
+    AgentContext,
+    AgentMessage,
+    AgentResponse,
+    AgentStatus,
+)
+from src.core.exceptions import AgentExecutionError
+
+
+@pytest.fixture
+def investigation_results():
+    """Sample investigation results from Zumbi agent."""
+    return {
+        "anomalies": [
+            {
+                "anomaly_type": "price_anomaly",
+                "severity": 0.85,
+                "confidence": 0.92,
+                "description": "Contract value 3.5x above market average",
+                "explanation": "Significant price deviation detected",
+                "evidence": {
+                    "contract_id": "123/2024",
+                    "value": 5000000.0,
+                    "market_average": 1428571.0
+                },
+                "recommendations": [
+                    "Review pricing justification",
+                    "Compare with similar contracts"
+                ]
+            }
+        ],
+        "summary": {
+            "total_records": 100,
+            "anomalies_found": 3,
+            "investigation_id": "inv-123"
+        }
+    }
+
+
+@pytest.fixture
+def analysis_results():
+    """Sample analysis results from Anita agent."""
+    return {
+        "patterns": [
+            {
+                "pattern_type": "temporal",
+                "description": "End-of-year spending spike",
+                "significance": 0.78,
+                "confidence": 0.85,
+                "insights": ["Budget execution rush", "Possible inefficiency"],
+                "evidence": {
+                    "period": "Q4 2023",
+                    "increase_percentage": 145
+                }
+            }
+        ],
+        "correlations": [
+            {
+                "correlation_type": "vendor_concentration",
+                "variables": ["vendor_id", "contract_count"],
+                "correlation_coefficient": 0.82,
+                "significance_level": "high"
+            }
+        ]
+    }
+
+
+@pytest.fixture
+def agent_context():
+    """Create agent context for testing."""
+    return AgentContext(
+        investigation_id="test-report-123",
+        user_id="test_user",
+        session_id="test_session",
+        metadata={"purpose": "testing"}
+    )
+
+
+@pytest.fixture
+def tiradentes_agent():
+    """Create Tiradentes agent (ReporterAgent)."""
+    return ReporterAgent(
+        default_language="pt",
+        max_report_length=10000
+    )
+
+
+class TestTiradentesReporterAgent:
+    """Test suite for Tiradentes (Reporter Agent)."""
+    
+    @pytest.mark.unit
+    def test_agent_initialization(self, tiradentes_agent):
+        """Test Tiradentes agent initialization."""
+        assert tiradentes_agent.name == "Tiradentes"
+        assert tiradentes_agent.default_language == "pt"
+        assert tiradentes_agent.max_length == 10000
+        
+        # Check capabilities
+        expected_capabilities = [
+            "investigation_report_generation",
+            "pattern_analysis_reporting",
+            "executive_summary_creation",
+            "multi_format_rendering"
+        ]
+        
+        for capability in expected_capabilities:
+            assert capability in tiradentes_agent.capabilities
+    
+    @pytest.mark.unit
+    async def test_initialize_and_shutdown(self, tiradentes_agent):
+        """Test agent lifecycle methods."""
+        await tiradentes_agent.initialize()
+        await tiradentes_agent.shutdown()
+        # Should complete without errors
+    
+    @pytest.mark.unit
+    async def test_generate_investigation_report(
+        self, tiradentes_agent, agent_context, investigation_results
+    ):
+        """Test generation of investigation report."""
+        message = AgentMessage(
+            sender="test",
+            recipient="Tiradentes",
+            action="generate_report",
+            payload={
+                "report_type": "investigation_report",
+                "format": "markdown",
+                "investigation_results": investigation_results,
+                "target_audience": "technical",
+                "include_visualizations": True
+            }
+        )
+        
+        response = await tiradentes_agent.process(message, agent_context)
+        
+        assert isinstance(response, AgentResponse)
+        assert response.agent_name == "Tiradentes"
+        assert response.status == AgentStatus.COMPLETED
+        assert "content" in response.result
+        assert "anomalies" in response.result["content"].lower()
+    
+    @pytest.mark.unit
+    async def test_generate_analysis_report(
+        self, tiradentes_agent, agent_context, analysis_results
+    ):
+        """Test generation of analysis report."""
+        message = AgentMessage(
+            sender="test",
+            recipient="Tiradentes",
+            action="generate_report",
+            payload={
+                "report_type": "analysis_report",
+                "format": "markdown",
+                "analysis_results": analysis_results,
+                "language": "pt",
+                "detailed_findings": True
+            }
+        )
+        
+        response = await tiradentes_agent.process(message, agent_context)
+        
+        assert response.status == AgentStatus.COMPLETED
+        assert "patterns" in response.result["content"].lower()
+    
+    @pytest.mark.unit
+    async def test_generate_executive_summary(
+        self, tiradentes_agent, agent_context, investigation_results, analysis_results
+    ):
+        """Test generation of executive summary."""
+        message = AgentMessage(
+            sender="test",
+            recipient="Tiradentes",
+            action="generate_report",
+            payload={
+                "report_type": "executive_summary",
+                "format": "executive_summary",
+                "investigation_results": investigation_results,
+                "analysis_results": analysis_results,
+                "target_audience": "executive"
+            }
+        )
+        
+        response = await tiradentes_agent.process(message, agent_context)
+        
+        assert response.status == AgentStatus.COMPLETED
+        # Executive summary should be concise
+        assert len(response.result["content"]) < 5000
+    
+    @pytest.mark.unit
+    async def test_invalid_action(self, tiradentes_agent, agent_context):
+        """Test handling of invalid action."""
+        message = AgentMessage(
+            sender="test",
+            recipient="Tiradentes",
+            action="invalid_action",
+            payload={}
+        )
+        
+        response = await tiradentes_agent.process(message, agent_context)
+        
+        assert response.status == AgentStatus.ERROR
+        assert "Unsupported action" in response.error
+    
+    @pytest.mark.unit
+    async def test_missing_data_error(self, tiradentes_agent, agent_context):
+        """Test error when no data provided."""
+        message = AgentMessage(
+            sender="test",
+            recipient="Tiradentes",
+            action="generate_report",
+            payload={
+                "report_type": "investigation_report",
+                "format": "markdown"
+                # Missing investigation_results and analysis_results
+            }
+        )
+        
+        response = await tiradentes_agent.process(message, agent_context)
+        
+        assert response.status == AgentStatus.ERROR
+        assert "No data provided" in response.error
+    
+    @pytest.mark.unit
+    async def test_multi_language_support(
+        self, tiradentes_agent, agent_context, investigation_results
+    ):
+        """Test report generation in different languages."""
+        languages = ["pt", "en"]
+        
+        for lang in languages:
+            message = AgentMessage(
+                sender="test",
+                recipient="Tiradentes",
+                action="generate_report",
+                payload={
+                    "report_type": "investigation_report",
+                    "format": "markdown",
+                    "investigation_results": investigation_results,
+                    "language": lang
+                }
+            )
+            
+            response = await tiradentes_agent.process(message, agent_context)
+            
+            assert response.status == AgentStatus.COMPLETED
+            assert response.result["metadata"]["language"] == lang
+    
+    @pytest.mark.unit
+    async def test_report_format_rendering(
+        self, tiradentes_agent, agent_context, investigation_results
+    ):
+        """Test different report format rendering."""
+        formats = ["markdown", "html", "json"]
+        
+        for fmt in formats:
+            message = AgentMessage(
+                sender="test",
+                recipient="Tiradentes",
+                action="generate_report",
+                payload={
+                    "report_type": "investigation_report",
+                    "format": fmt,
+                    "investigation_results": investigation_results
+                }
+            )
+            
+            response = await tiradentes_agent.process(message, agent_context)
+            
+            assert response.status == AgentStatus.COMPLETED
+            assert response.result["metadata"]["format"] == fmt

tests/unit/agents/test_zumbi.py

@@ -1,28 +1,92 @@
 """
-Unit tests for Zumbi Agent - Resistance and freedom analysis specialist.
+Unit tests for Zumbi Agent (InvestigatorAgent) - Anomaly detection specialist.
 """
 
 import pytest
-from unittest.mock import AsyncMock
-from src.agents.zumbi import ZumbiAgent
-from src.agents.deodoro import AgentContext, AgentMessage, AgentStatus
+from unittest.mock import AsyncMock, patch, MagicMock
+from src.agents.zumbi import InvestigatorAgent
+from src.agents.deodoro import AgentContext, AgentMessage, AgentResponse, AgentStatus
 
 @pytest.fixture
 def zumbi_agent():
-    return ZumbiAgent()
+    """Create an InvestigatorAgent instance for testing."""
+    return InvestigatorAgent(
+        price_anomaly_threshold=2.5,
+        concentration_threshold=0.7,
+        duplicate_similarity_threshold=0.85
+    )
+
+@pytest.fixture
+def mock_transparency_client():
+    """Mock TransparencyAPIClient."""
+    client = AsyncMock()
+    client.search_contracts.return_value = [
+        {
+            "numeroContratoCompra": "123/2024",
+            "valorTotalCompra": 100000.0,
+            "dataPublicacaoContrato": "01/01/2024",
+            "orgaoEntidade": {"nome": "Ministério Teste"},
+            "fornecedor": {"nome": "Empresa ABC", "cnpj": "12345678901234"}
+        }
+    ]
+    return client
 
 class TestZumbiAgent:
     @pytest.mark.unit
     def test_agent_initialization(self, zumbi_agent):
+        """Test that the agent is properly initialized."""
         assert zumbi_agent.name == "Zumbi"
-        assert "resistance_analysis" in zumbi_agent.capabilities
+        assert "price_anomaly_detection" in zumbi_agent.capabilities
+        assert "spectral_analysis" in zumbi_agent.capabilities
+        assert zumbi_agent.price_threshold == 2.5
+        assert zumbi_agent.concentration_threshold == 0.7
+    
+    @pytest.mark.unit
+    async def test_initialize(self, zumbi_agent):
+        """Test agent initialization method."""
+        await zumbi_agent.initialize()
+        # Should complete without errors
+    
+    @pytest.mark.unit
+    async def test_shutdown(self, zumbi_agent):
+        """Test agent shutdown method."""
+        await zumbi_agent.shutdown()
+        # Should complete without errors
+    
+    @pytest.mark.unit
+    async def test_process_investigation(self, zumbi_agent, mock_transparency_client):
+        """Test processing an investigation request."""
+        with patch('src.agents.zumbi.TransparencyAPIClient', return_value=mock_transparency_client):
+            context = AgentContext(investigation_id="test-123")
+            message = AgentMessage(
+                sender="test",
+                recipient="Zumbi",
+                action="investigate",
+                payload={
+                    "query": "contratos suspeitos",
+                    "max_records": 10
+                }
+            )
+            
+            response = await zumbi_agent.process(message, context)
+            
+            assert isinstance(response, AgentResponse)
+            assert response.agent_name == "Zumbi"
+            assert response.status == AgentStatus.COMPLETED
+            assert "anomalies" in response.result
     
     @pytest.mark.unit
-    async def test_resistance_analysis(self, zumbi_agent):
-        context = AgentContext(investigation_id="resistance-test")
+    async def test_process_invalid_action(self, zumbi_agent):
+        """Test processing with invalid action."""
+        context = AgentContext(investigation_id="test-123")
         message = AgentMessage(
-            sender="test", recipient="Zumbi", action="analyze_resistance_patterns",
-            payload={"movement_id": "social_movement_001"}
+            sender="test",
+            recipient="Zumbi",
+            action="invalid_action",
+            payload={}
         )
+        
         response = await zumbi_agent.process(message, context)
-        assert response.status == AgentStatus.COMPLETED
+        
+        assert response.status == AgentStatus.ERROR
+        assert "Unsupported action" in response.error