ClaudeFlow ported, needs cleanup

tests/conftest.py

@@ -0,0 +1,190 @@
+"""Pytest configuration and shared fixtures for CleverClaude tests."""
+
+import asyncio
+import tempfile
+from collections.abc import AsyncGenerator, Generator
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+import pytest_asyncio
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.pool import StaticPool
+
+from cleverclaude.config.settings import Settings
+from cleverclaude.database.models import Base
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create an instance of the default event loop for the test session."""
+    loop = asyncio.new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest.fixture
+def temp_dir() -> Generator[Path]:
+    """Create a temporary directory for test files."""
+    with tempfile.TemporaryDirectory(prefix="cleverclaude_test_") as temp_path:
+        yield Path(temp_path)
+
+
+@pytest.fixture
+def test_settings(temp_dir: Path) -> Settings:
+    """Create test settings with temporary directories."""
+    config_dir = temp_dir / ".cleverclaude"
+    config_dir.mkdir(exist_ok=True)
+
+    return Settings(
+        app=Settings.AppConfig(name="CleverClaude Test", version="2.0.0-test", environment="testing", debug=True),
+        database=Settings.DatabaseConfig(url=f"sqlite+aiosqlite:///{config_dir}/test.db", echo=False),
+        redis=Settings.RedisConfig(
+            url="redis://localhost:6379/15"  # Test database
+        ),
+        agents=Settings.AgentsConfig(max_agents=10, default_timeout=30, health_check_interval=5),
+        swarm=Settings.SwarmConfig(default_topology="mesh", max_swarm_size=5, coordination_timeout=30),
+        api=Settings.APIConfig(
+            host="127.0.0.1",
+            port=8080,  # Different port for testing
+            docs_enabled=False,
+        ),
+        monitoring=Settings.MonitoringConfig(metrics_enabled=False, log_level="DEBUG", log_format="json"),
+    )
+
+
+@pytest_asyncio.fixture
+async def async_engine(test_settings: Settings):
+    """Create async SQLAlchemy engine for testing."""
+    engine = create_async_engine(
+        test_settings.database.url,
+        echo=test_settings.database.echo,
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+
+    # Create all tables
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    yield engine
+
+    # Clean up
+    await engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def async_session(async_engine) -> AsyncGenerator[AsyncSession]:
+    """Create async database session for testing."""
+    async with AsyncSession(async_engine, expire_on_commit=False) as session:
+        yield session
+
+
+@pytest.fixture
+def mock_redis():
+    """Create a mock Redis client."""
+    mock = MagicMock()
+    mock.get = AsyncMock()
+    mock.set = AsyncMock()
+    mock.delete = AsyncMock()
+    mock.exists = AsyncMock()
+    mock.keys = AsyncMock()
+    mock.expire = AsyncMock()
+    mock.ping = AsyncMock(return_value=True)
+    return mock
+
+
+@pytest.fixture
+def mock_agent():
+    """Create a mock agent for testing."""
+    mock = AsyncMock()
+    mock.agent_id = "test_agent_123"
+    mock.name = "Test Agent"
+    mock.agent_type = "researcher"
+    mock.status = "active"
+    mock.capabilities = {"research", "analysis"}
+    mock.created_at = "2024-01-01T12:00:00Z"
+    mock.health_status = {"cpu_usage": 25.5, "memory_usage": 150.2, "task_count": 3, "status": "healthy"}
+    return mock
+
+
+@pytest.fixture
+def mock_swarm():
+    """Create a mock swarm for testing."""
+    mock = AsyncMock()
+    mock.swarm_id = "test_swarm_456"
+    mock.name = "Test Swarm"
+    mock.topology = "mesh"
+    mock.state = "active"
+    mock.agents = []
+    mock.tasks = []
+    mock.created_at = "2024-01-01T12:00:00Z"
+    mock.metrics = {"total_agents": 3, "active_agents": 2, "completed_tasks": 15, "efficiency_score": 85.5}
+    return mock
+
+
+@pytest.fixture
+def mock_mcp_client():
+    """Create a mock MCP client for testing."""
+    mock = AsyncMock()
+    mock.is_connected = True
+    mock.available_tools = [
+        "swarm_init",
+        "agent_spawn",
+        "task_orchestrate",
+        "memory_usage",
+        "neural_train",
+        "performance_report",
+    ]
+    mock.execute_tool = AsyncMock()
+    mock.get_tool_info = AsyncMock()
+    mock.connect = AsyncMock()
+    mock.disconnect = AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def mock_task():
+    """Create a mock task for testing."""
+    return {
+        "task_id": "test_task_789",
+        "type": "research_query",
+        "status": "pending",
+        "priority": "medium",
+        "data": {"query": "Test research query", "scope": "general", "depth": "standard"},
+        "created_at": "2024-01-01T12:00:00Z",
+        "assigned_agent": None,
+        "result": None,
+    }
+
+
+@pytest.fixture(autouse=True)
+def setup_test_environment(test_settings: Settings, monkeypatch):
+    """Set up test environment variables."""
+    monkeypatch.setenv("CLEVERCLAUDE_ENVIRONMENT", "testing")
+    monkeypatch.setenv("CLEVERCLAUDE_DEBUG", "true")
+    monkeypatch.setenv("CLEVERCLAUDE_CONFIG_DIR", str(test_settings.database.url.split("///")[1].rsplit("/", 1)[0]))
+
+    # Override settings
+    monkeypatch.setattr("cleverclaude.config.settings.get_settings", lambda: test_settings)
+
+
+@pytest.fixture
+def cleanup_tasks():
+    """Cleanup any remaining asyncio tasks after tests."""
+    yield
+
+    # Cancel any remaining tasks
+    tasks = [task for task in asyncio.all_tasks() if not task.done()]
+    for task in tasks:
+        task.cancel()
+
+    if tasks:
+        asyncio.gather(*tasks, return_exceptions=True)
+
+
+# Marker definitions
+pytest.mark.unit = pytest.mark.unit
+pytest.mark.integration = pytest.mark.integration
+pytest.mark.async_test = pytest.mark.asyncio
+pytest.mark.slow = pytest.mark.slow