test: add comprehensive backend test suite

backend/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for API endpoints."""

backend/tests/conftest.py

@@ -0,0 +1,58 @@
+"""Pytest configuration and fixtures."""
+
+import asyncio
+from typing import AsyncGenerator, Generator
+
+import pytest
+from fastapi.testclient import TestClient
+from httpx import AsyncClient, ASGITransport
+
+from app.main import app, create_app
+
+
+@pytest.fixture(scope="session")
+def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
+    """Create event loop for async tests."""
+    loop = asyncio.new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest.fixture
+def client() -> Generator[TestClient, None, None]:
+    """Create sync test client."""
+    with TestClient(app) as c:
+        yield c
+
+
+@pytest.fixture
+async def async_client() -> AsyncGenerator[AsyncClient, None]:
+    """Create async test client."""
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+@pytest.fixture
+def sample_task() -> dict:
+    """Sample task data for testing."""
+    return {
+        "task_id": "test_task_001",
+        "task_name": "Extract Product Info",
+        "task_type": "extraction",
+        "target_fields": ["name", "price", "description"],
+        "target_url": "https://example.com/product/123",
+    }
+
+
+@pytest.fixture
+def sample_action() -> dict:
+    """Sample action data for testing."""
+    return {
+        "action_type": "extract_field",
+        "parameters": {
+            "field_name": "price",
+            "selector": ".product-price",
+        },
+        "confidence": 0.95,
+    }

backend/tests/test_agents/__init__.py

@@ -0,0 +1 @@
+"""Test agents package."""

backend/tests/test_agents/test_coordinator.py

@@ -0,0 +1,36 @@
+"""Tests for agent coordinator."""
+
+import pytest
+from app.agents.coordinator import AgentCoordinator
+from app.agents.planner import PlannerAgent
+from app.agents.navigator import NavigatorAgent
+from app.agents.extractor import ExtractorAgent
+from app.agents.verifier import VerifierAgent
+
+
+def test_coordinator_creation() -> None:
+    """Test creating agent coordinator."""
+    coordinator = AgentCoordinator()
+    assert coordinator is not None
+
+
+def test_agent_registration() -> None:
+    """Test registering agents with coordinator."""
+    coordinator = AgentCoordinator()
+    planner = PlannerAgent("planner_1")
+    
+    coordinator.register_agent("custom_planner", planner)
+    assert coordinator.get_agent("custom_planner") is planner
+
+
+def test_all_agents_instantiation() -> None:
+    """Test all agent types can be instantiated."""
+    planner = PlannerAgent("planner")
+    navigator = NavigatorAgent("navigator")
+    extractor = ExtractorAgent("extractor")
+    verifier = VerifierAgent("verifier")
+    
+    assert planner.agent_id == "planner"
+    assert navigator.agent_id == "navigator"
+    assert extractor.agent_id == "extractor"
+    assert verifier.agent_id == "verifier"

backend/tests/test_api/__init__.py

@@ -0,0 +1 @@
+"""Test API package."""

backend/tests/test_api/test_agents.py

@@ -0,0 +1,24 @@
+"""Tests for agent endpoints."""
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_list_agents(client: TestClient) -> None:
+    """Test listing available agents."""
+    response = client.get("/api/agents/types/")
+    assert response.status_code == 200
+    data = response.json()
+    assert "agents" in data
+
+
+def test_run_agent(client: TestClient, sample_task: dict) -> None:
+    """Test running an agent."""
+    run_request = {
+        "agent_type": "planner",
+        "episode_id": "test-episode-123",
+        "task_context": sample_task,
+    }
+    response = client.post("/api/agents/run", json=run_request)
+    # 200 for success, 500 for coordinator errors (expected without full setup)
+    assert response.status_code in [200, 500]

backend/tests/test_api/test_episode.py

@@ -0,0 +1,48 @@
+"""Tests for episode endpoints."""
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_reset_episode(client: TestClient, sample_task: dict) -> None:
+    """Test resetting an episode."""
+    reset_request = {"task_id": sample_task["task_id"]}
+    response = client.post("/api/episode/reset", json=reset_request)
+    assert response.status_code == 201
+    data = response.json()
+    assert "episode_id" in data
+    assert "observation" in data
+
+
+def test_step_episode(client: TestClient, sample_task: dict, sample_action: dict) -> None:
+    """Test stepping through an episode."""
+    # First reset
+    reset_request = {"task_id": sample_task["task_id"]}
+    reset_response = client.post("/api/episode/reset", json=reset_request)
+    assert reset_response.status_code == 201
+    episode_id = reset_response.json()["episode_id"]
+    
+    # Then step
+    step_data = {
+        "episode_id": episode_id,
+        "action": sample_action,
+    }
+    response = client.post("/api/episode/step", json=step_data)
+    assert response.status_code == 200
+    data = response.json()
+    assert "observation" in data
+    assert "reward" in data
+
+
+def test_get_state(client: TestClient, sample_task: dict) -> None:
+    """Test getting episode state."""
+    # First reset
+    reset_request = {"task_id": sample_task["task_id"]}
+    reset_response = client.post("/api/episode/reset", json=reset_request)
+    episode_id = reset_response.json()["episode_id"]
+    
+    # Get state
+    response = client.get(f"/api/episode/state/{episode_id}")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["episode_id"] == episode_id

backend/tests/test_api/test_health.py

@@ -0,0 +1,20 @@
+"""Tests for health check endpoints."""
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_health_endpoint(client: TestClient) -> None:
+    """Test health check returns OK."""
+    response = client.get("/api/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "healthy"
+
+
+def test_ready_endpoint(client: TestClient) -> None:
+    """Test readiness check."""
+    response = client.get("/api/ready")
+    assert response.status_code == 200
+    data = response.json()
+    assert "ready" in data

backend/tests/test_api/test_tools.py

@@ -0,0 +1,24 @@
+"""Tests for tool endpoints."""
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_list_tools(client: TestClient) -> None:
+    """Test listing available tools."""
+    response = client.get("/api/tools/registry")
+    assert response.status_code == 200
+    data = response.json()
+    assert "tools" in data
+
+
+def test_tool_test_endpoint(client: TestClient) -> None:
+    """Test tool testing endpoint."""
+    test_request = {
+        "tool_name": "navigate_to",
+        "parameters": {"url": "https://example.com"},
+        "dry_run": True,
+    }
+    response = client.post("/api/tools/test", json=test_request)
+    # Either success or tool not found is acceptable
+    assert response.status_code in [200, 404]

backend/tests/test_core/__init__.py

@@ -0,0 +1 @@
+"""Test core package."""

backend/tests/test_core/test_action.py

@@ -0,0 +1,77 @@
+"""Tests for action model."""
+
+import pytest
+from app.core.action import Action, ActionType
+
+
+def test_action_creation() -> None:
+    """Test creating an action."""
+    action = Action(
+        action_type=ActionType.EXTRACT_FIELD,
+        parameters={"field_name": "price", "selector": ".price"},
+        confidence=0.9,
+    )
+    assert action.action_type == ActionType.EXTRACT_FIELD
+    assert action.confidence == 0.9
+
+
+def test_action_factory_methods() -> None:
+    """Test action factory methods."""
+    nav_action = Action.navigate("https://example.com")
+    assert nav_action.action_type == ActionType.NAVIGATE
+    assert nav_action.parameters["url"] == "https://example.com"
+    
+    extract_action = Action.extract_field("price", ".product-price")
+    assert extract_action.action_type == ActionType.EXTRACT_FIELD
+    assert extract_action.parameters["field_name"] == "price"
+    
+    done_action = Action.done(success=True, message="Task completed")
+    assert done_action.action_type == ActionType.DONE
+    assert done_action.parameters["success"] is True
+
+
+def test_action_validation() -> None:
+    """Test action parameter validation."""
+    # Valid action
+    action = Action(
+        action_type=ActionType.NAVIGATE,
+        parameters={"url": "https://example.com"},
+    )
+    errors = action.validate_params()
+    assert len(errors) == 0
+    
+    # Invalid action - missing required param
+    invalid_action = Action(
+        action_type=ActionType.NAVIGATE,
+        parameters={},
+    )
+    errors = invalid_action.validate_params()
+    assert len(errors) > 0
+    assert "url" in errors[0]
+
+
+def test_action_confidence_bounds() -> None:
+    """Test confidence is bounded to 0-1 by Pydantic validation."""
+    import pytest
+    from pydantic import ValidationError
+    
+    # Values > 1.0 should raise validation error
+    with pytest.raises(ValidationError):
+        Action(
+            action_type=ActionType.WAIT,
+            confidence=1.5,
+        )
+    
+    # Values < 0.0 should raise validation error
+    with pytest.raises(ValidationError):
+        Action(
+            action_type=ActionType.WAIT,
+            confidence=-0.5,
+        )
+    
+    # Valid boundary values should work
+    action_max = Action(action_type=ActionType.WAIT, confidence=1.0)
+    assert action_max.confidence == 1.0
+    
+    action_min = Action(action_type=ActionType.WAIT, confidence=0.0)
+    assert action_min.confidence == 0.0

backend/tests/test_core/test_env.py

@@ -0,0 +1,20 @@
+"""Tests for environment."""
+
+import pytest
+from app.core.env import WebScraperEnv
+
+
+def test_env_creation() -> None:
+    """Test creating environment."""
+    env = WebScraperEnv(episode_id="test-episode-001")
+    assert env is not None
+    assert env.episode_id == "test-episode-001"
+
+
+@pytest.mark.asyncio
+async def test_env_reset() -> None:
+    """Test environment reset."""
+    env = WebScraperEnv(episode_id="test-episode-002")
+    observation, info = await env.reset(task_id="test_task", seed=42)
+    assert observation is not None
+    assert observation.step_number == 0

backend/tests/test_core/test_observation.py

@@ -0,0 +1,72 @@
+"""Tests for observation model."""
+
+import pytest
+from app.core.observation import Observation, TaskContext, ExtractedField, MemoryContext
+
+
+def test_observation_creation() -> None:
+    """Test creating an observation."""
+    obs = Observation(
+        episode_id="ep_001",
+        task_id="task_001",
+        step_number=0,
+    )
+    assert obs.episode_id == "ep_001"
+    assert obs.step_number == 0
+    assert obs.extraction_progress == 0.0
+
+
+def test_observation_with_task_context() -> None:
+    """Test observation with task context."""
+    task_ctx = TaskContext(
+        task_id="task_001",
+        task_name="Extract Product",
+        task_type="extraction",
+        target_fields=["name", "price"],
+        required_fields=["name"],
+    )
+    obs = Observation(
+        episode_id="ep_001",
+        task_id="task_001",
+        step_number=0,
+        task_context=task_ctx,
+    )
+    assert obs.task_context is not None
+    assert obs.task_context.task_name == "Extract Product"
+
+
+def test_observation_extraction_tracking() -> None:
+    """Test extraction progress tracking."""
+    obs = Observation(
+        episode_id="ep_001",
+        task_id="task_001",
+        step_number=1,
+        extracted_so_far=[
+            ExtractedField(field_name="name", value="Test Product", confidence=0.95),
+        ],
+        fields_remaining=["price", "description"],
+    )
+    assert len(obs.extracted_so_far) == 1
+    assert obs.is_field_extracted("name")
+    assert not obs.is_field_extracted("price")
+    
+    extraction_dict = obs.get_extraction_dict()
+    assert extraction_dict["name"] == "Test Product"
+
+
+def test_observation_context_summary() -> None:
+    """Test context summary generation."""
+    obs = Observation(
+        episode_id="ep_001",
+        task_id="task_001",
+        step_number=5,
+        current_url="https://example.com",
+        extraction_progress=0.5,
+        extracted_so_far=[
+            ExtractedField(field_name="name", value="Test"),
+        ],
+        fields_remaining=["price"],
+    )
+    summary = obs.get_context_summary()
+    assert "Step 5" in summary
+    assert "example.com" in summary

backend/tests/test_core/test_reward.py

@@ -0,0 +1,22 @@
+"""Tests for reward computation."""
+
+import pytest
+from app.core.reward import RewardEngine, RewardBreakdown
+
+
+def test_reward_engine_creation() -> None:
+    """Test creating reward engine."""
+    engine = RewardEngine()
+    assert engine is not None
+
+
+def test_reward_breakdown() -> None:
+    """Test reward breakdown structure."""
+    breakdown = RewardBreakdown(
+        accuracy=0.8,
+        efficiency=0.6,
+        cost=-0.1,
+        total=0.7,
+    )
+    assert breakdown.total == 0.7
+    assert breakdown.accuracy == 0.8