jarviscore-framework 0.1.0__py3-none-any.whl

tests/test_agent.py

@@ -0,0 +1,165 @@
+"""
+Tests for Agent base class.
+"""
+import pytest
+from jarviscore.core.agent import Agent
+
+
+# Test agent implementations
+class ValidAgent(Agent):
+    """Valid agent for testing."""
+    role = "test_agent"
+    capabilities = ["testing", "validation"]
+
+    async def execute_task(self, task):
+        return {"status": "success", "output": "test result"}
+
+
+class NoRoleAgent(Agent):
+    """Agent without role (should fail validation)."""
+    capabilities = ["testing"]
+
+    async def execute_task(self, task):
+        return {"status": "success"}
+
+
+class NoCapabilitiesAgent(Agent):
+    """Agent without capabilities (should fail validation)."""
+    role = "no_caps"
+
+    async def execute_task(self, task):
+        return {"status": "success"}
+
+
+class TestAgentInitialization:
+    """Test agent initialization and validation."""
+
+    def test_valid_agent_creation(self):
+        """Test creating a valid agent."""
+        agent = ValidAgent()
+
+        assert agent.role == "test_agent"
+        assert agent.capabilities == ["testing", "validation"]
+        assert agent.agent_id.startswith("test_agent-")
+        assert len(agent.agent_id.split("-")[1]) == 8  # 8-char UUID
+
+    def test_agent_with_custom_id(self):
+        """Test creating agent with custom ID."""
+        agent = ValidAgent(agent_id="custom-agent-123")
+
+        assert agent.agent_id == "custom-agent-123"
+        assert agent.role == "test_agent"
+
+    def test_agent_without_role_fails(self):
+        """Test that agent without role raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            NoRoleAgent()
+
+        assert "must define 'role' class attribute" in str(exc_info.value)
+
+    def test_agent_without_capabilities_fails(self):
+        """Test that agent without capabilities raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            NoCapabilitiesAgent()
+
+        assert "must define 'capabilities' class attribute" in str(exc_info.value)
+
+    def test_agent_mesh_initially_none(self):
+        """Test that agent._mesh is initially None."""
+        agent = ValidAgent()
+        assert agent._mesh is None
+
+
+class TestAgentTaskHandling:
+    """Test agent task handling capabilities."""
+
+    def test_can_handle_by_role(self):
+        """Test agent can handle task by role."""
+        agent = ValidAgent()
+
+        task = {"role": "test_agent", "task": "Do something"}
+        assert agent.can_handle(task) is True
+
+    def test_can_handle_by_capability(self):
+        """Test agent can handle task by capability."""
+        agent = ValidAgent()
+
+        task1 = {"capability": "testing", "task": "Run tests"}
+        assert agent.can_handle(task1) is True
+
+        task2 = {"capability": "validation", "task": "Validate data"}
+        assert agent.can_handle(task2) is True
+
+    def test_cannot_handle_wrong_role(self):
+        """Test agent rejects task with wrong role."""
+        agent = ValidAgent()
+
+        task = {"role": "different_agent", "task": "Do something"}
+        assert agent.can_handle(task) is False
+
+    def test_cannot_handle_wrong_capability(self):
+        """Test agent rejects task with wrong capability."""
+        agent = ValidAgent()
+
+        task = {"capability": "unknown_capability", "task": "Do something"}
+        assert agent.can_handle(task) is False
+
+    def test_can_handle_no_role_or_capability(self):
+        """Test agent behavior when task has no role or capability."""
+        agent = ValidAgent()
+
+        task = {"task": "Do something"}
+        assert agent.can_handle(task) is False
+
+
+class TestAgentExecution:
+    """Test agent task execution."""
+
+    @pytest.mark.asyncio
+    async def test_execute_task_implementation(self):
+        """Test that execute_task can be called and returns result."""
+        agent = ValidAgent()
+
+        task = {"task": "Test task"}
+        result = await agent.execute_task(task)
+
+        assert result["status"] == "success"
+        assert result["output"] == "test result"
+
+
+class TestAgentLifecycle:
+    """Test agent setup and teardown lifecycle."""
+
+    @pytest.mark.asyncio
+    async def test_setup_hook(self):
+        """Test agent setup hook."""
+        agent = ValidAgent()
+        await agent.setup()  # Should not raise
+
+    @pytest.mark.asyncio
+    async def test_teardown_hook(self):
+        """Test agent teardown hook."""
+        agent = ValidAgent()
+        await agent.teardown()  # Should not raise
+
+
+class TestAgentRepresentation:
+    """Test agent string representations."""
+
+    def test_repr(self):
+        """Test agent __repr__."""
+        agent = ValidAgent(agent_id="test-123")
+        repr_str = repr(agent)
+
+        assert "ValidAgent" in repr_str
+        assert "test-123" in repr_str
+        assert "test_agent" in repr_str
+        assert "testing" in repr_str
+
+    def test_str(self):
+        """Test agent __str__."""
+        agent = ValidAgent(agent_id="test-123")
+        str_repr = str(agent)
+
+        assert "test_agent" in str_repr
+        assert "test-123" in str_repr

tests/test_autoagent.py

@@ -0,0 +1,140 @@
+"""
+Tests for AutoAgent profile.
+"""
+import pytest
+from jarviscore.profiles.autoagent import AutoAgent
+
+
+class ValidAutoAgent(AutoAgent):
+    """Valid AutoAgent for testing."""
+    role = "test_auto"
+    capabilities = ["testing"]
+    system_prompt = "You are a test agent that performs testing tasks."
+
+
+class NoPromptAutoAgent(AutoAgent):
+    """AutoAgent without system_prompt (should fail)."""
+    role = "no_prompt"
+    capabilities = ["testing"]
+
+
+class TestAutoAgentInitialization:
+    """Test AutoAgent initialization."""
+
+    def test_valid_autoagent_creation(self):
+        """Test creating a valid AutoAgent."""
+        agent = ValidAutoAgent()
+
+        assert agent.role == "test_auto"
+        assert agent.capabilities == ["testing"]
+        assert agent.system_prompt == "You are a test agent that performs testing tasks."
+
+    def test_autoagent_without_system_prompt_fails(self):
+        """Test that AutoAgent without system_prompt raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            NoPromptAutoAgent()
+
+        assert "must define 'system_prompt'" in str(exc_info.value)
+
+    def test_autoagent_execution_components_initially_none(self):
+        """Test that execution components are initially None."""
+        agent = ValidAutoAgent()
+
+        assert agent.llm is None
+        assert agent.codegen is None
+        assert agent.sandbox is None
+        assert agent.repair is None
+
+
+class TestAutoAgentSetup:
+    """Test AutoAgent setup."""
+
+    @pytest.mark.asyncio
+    async def test_autoagent_setup(self):
+        """Test AutoAgent setup hook."""
+        agent = ValidAutoAgent()
+        await agent.setup()
+
+        # Day 1: Just verify it runs without error
+        # Day 4: Will test actual LLM initialization
+
+
+class TestAutoAgentExecution:
+    """Test AutoAgent task execution."""
+
+    @pytest.mark.asyncio
+    async def test_execute_task_without_setup_fails(self):
+        """Test AutoAgent execute_task fails gracefully without setup."""
+        agent = ValidAutoAgent()
+
+        task = {"task": "Test task description"}
+        result = await agent.execute_task(task)
+
+        # Day 4: Should fail gracefully when components not initialized
+        assert result["status"] == "failure"
+        assert "Fatal error" in result.get("error", "")
+
+    @pytest.mark.asyncio
+    async def test_execute_task_with_mock_components(self):
+        """Test AutoAgent with mocked execution components."""
+        from unittest.mock import Mock, AsyncMock
+
+        agent = ValidAutoAgent()
+
+        # Mock the execution components
+        agent.codegen = Mock()
+        agent.codegen.generate = AsyncMock(return_value="result = 42")
+
+        agent.sandbox = Mock()
+        agent.sandbox.execute = AsyncMock(return_value={
+            "status": "success",
+            "output": 42
+        })
+
+        agent.repair = Mock()  # Not called if execution succeeds
+
+        # Mock result handler (Phase 1)
+        agent.result_handler = Mock()
+        agent.result_handler.process_result = Mock(return_value={
+            'result_id': 'test-result-id',
+            'status': 'success'
+        })
+
+        # Mock code registry (Phase 3)
+        agent.code_registry = Mock()
+        agent.code_registry.register = Mock(return_value='test-function-id')
+
+        task = {"task": "Calculate 21 * 2"}
+        result = await agent.execute_task(task)
+
+        # Should succeed with mocked components
+        assert result["status"] == "success"
+        assert result["output"] == 42
+        assert result["code"] == "result = 42"
+
+
+class TestAutoAgentInheritance:
+    """Test AutoAgent inheritance from Profile and Agent."""
+
+    def test_autoagent_inherits_agent_methods(self):
+        """Test that AutoAgent inherits Agent methods."""
+        agent = ValidAutoAgent()
+
+        # Should have Agent methods
+        assert hasattr(agent, "can_handle")
+        assert hasattr(agent, "execute_task")
+        assert hasattr(agent, "setup")
+        assert hasattr(agent, "teardown")
+
+    def test_autoagent_can_handle_tasks(self):
+        """Test that AutoAgent can check task compatibility."""
+        agent = ValidAutoAgent()
+
+        task1 = {"role": "test_auto", "task": "Do something"}
+        assert agent.can_handle(task1) is True
+
+        task2 = {"capability": "testing", "task": "Run tests"}
+        assert agent.can_handle(task2) is True
+
+        task3 = {"role": "different", "task": "Won't handle"}
+        assert agent.can_handle(task3) is False

tests/test_autoagent_day4.py

@@ -0,0 +1,186 @@
+"""
+Tests for Day 4: AutoAgent with Code Generation
+
+Tests the complete execution pipeline:
+- LLM client initialization
+- Code generation
+- Sandbox execution
+- Autonomous repair
+"""
+import pytest
+import asyncio
+from jarviscore.profiles import AutoAgent
+from jarviscore.execution import (
+    create_llm_client,
+    create_search_client,
+    create_code_generator,
+    create_sandbox_executor,
+    create_autonomous_repair
+)
+
+
+class SimpleAgent(AutoAgent):
+    """Test agent for unit tests."""
+    role = "test_agent"
+    capabilities = ["testing"]
+    system_prompt = "You are a test agent."
+
+
+def test_autoagent_initialization():
+    """Test AutoAgent can be instantiated."""
+    agent = SimpleAgent()
+    assert agent.role == "test_agent"
+    assert agent.capabilities == ["testing"]
+    assert agent.system_prompt == "You are a test agent."
+
+
+@pytest.mark.asyncio
+async def test_execution_components_creation():
+    """Test all execution components can be created."""
+    # LLM client (no config, just instantiation test)
+    llm = create_llm_client({})
+    assert llm is not None
+
+    # Search client
+    search = create_search_client()
+    assert search is not None
+
+    # Code generator
+    codegen = create_code_generator(llm, search)
+    assert codegen is not None
+
+    # Sandbox executor
+    sandbox = create_sandbox_executor(timeout=60, search_client=search)
+    assert sandbox is not None
+
+    # Autonomous repair
+    repair = create_autonomous_repair(codegen)
+    assert repair is not None
+
+
+@pytest.mark.asyncio
+async def test_sandbox_simple_execution():
+    """Test sandbox can execute simple code."""
+    from jarviscore.execution import SandboxExecutor
+
+    sandbox = SandboxExecutor(timeout=10)
+
+    code = """
+# Simple calculation
+result = 2 + 2
+"""
+
+    result = await sandbox.execute(code)
+
+    assert result['status'] == 'success'
+    assert result['output'] == 4
+
+
+@pytest.mark.asyncio
+async def test_sandbox_async_execution():
+    """Test sandbox can execute async code."""
+    from jarviscore.execution import SandboxExecutor
+
+    sandbox = SandboxExecutor(timeout=10)
+
+    code = """
+import asyncio
+
+async def main():
+    await asyncio.sleep(0.01)
+    return 42
+
+# The result will be extracted by sandbox's _execute_async
+"""
+
+    result = await sandbox.execute(code)
+
+    assert result['status'] == 'success'
+    assert result['output'] == 42
+
+
+@pytest.mark.asyncio
+async def test_sandbox_error_handling():
+    """Test sandbox properly handles errors."""
+    from jarviscore.execution import SandboxExecutor
+
+    sandbox = SandboxExecutor(timeout=10)
+
+    code = """
+# This will raise an error
+result = 1 / 0
+"""
+
+    result = await sandbox.execute(code)
+
+    assert result['status'] == 'failure'
+    assert 'ZeroDivisionError' in result.get('error_type', '')
+
+
+@pytest.mark.asyncio
+async def test_code_generator_validation():
+    """Test code generator validates syntax."""
+    from jarviscore.execution import CodeGenerator, UnifiedLLMClient
+
+    llm = UnifiedLLMClient({})
+    codegen = CodeGenerator(llm, None)
+
+    # Test syntax validation
+    valid_code = "result = 42"
+    codegen._validate_code(valid_code)  # Should not raise
+
+    invalid_code = "result = if 42"
+    with pytest.raises(ValueError):
+        codegen._validate_code(invalid_code)
+
+
+@pytest.mark.asyncio
+async def test_code_generator_cleaning():
+    """Test code generator cleans markdown blocks."""
+    from jarviscore.execution import CodeGenerator, UnifiedLLMClient
+
+    llm = UnifiedLLMClient({})
+    codegen = CodeGenerator(llm, None)
+
+    # Test cleaning markdown blocks
+    markdown_code = """
+```python
+result = 42
+```
+"""
+
+    cleaned = codegen._clean_code(markdown_code)
+    assert cleaned == "result = 42"
+
+
+def test_autoagent_requires_system_prompt():
+    """Test AutoAgent requires system_prompt."""
+    with pytest.raises(ValueError) as exc_info:
+        class BadAgent(AutoAgent):
+            role = "bad"
+            capabilities = ["test"]
+            # Missing system_prompt
+
+        BadAgent()
+
+    assert "system_prompt" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_search_client_initialization():
+    """Test search client can be created and initialized."""
+    from jarviscore.execution import InternetSearch
+
+    search = InternetSearch()
+    await search.initialize()
+
+    assert search.session is not None
+    assert not search.session.closed
+
+    await search.close()
+    assert search.session is None
+
+
+if __name__ == "__main__":
+    # Run tests with pytest
+    pytest.main([__file__, "-v"])