loop-agent-cli 0.1.0__py3-none-any.whl

app/tests/test_dashboard.py

@@ -0,0 +1,27 @@
+"""
+Dashboard API tests
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_dashboard_summary(client):
+    """Test getting dashboard summary"""
+    response = await client.get("/api/v1/dashboard/summary")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert "running_positions" in data
+    assert "today_loops" in data
+    assert "today_candidates" in data
+    assert "today_emails" in data
+    assert "today_replies" in data
+    assert "today_errors" in data
+    
+    assert isinstance(data["running_positions"], int)
+    assert isinstance(data["today_loops"], int)
+    assert isinstance(data["today_candidates"], int)
+    assert isinstance(data["today_emails"], int)
+    assert isinstance(data["today_replies"], int)
+    assert isinstance(data["today_errors"], int)

app/tests/test_outreach.py

@@ -0,0 +1,15 @@
+"""
+Outreach API tests
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_outreach_logs(client):
+    """Test getting outreach logs"""
+    response = await client.get("/api/v1/outreach/logs")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)

app/tests/test_pipelines.py

@@ -0,0 +1,249 @@
+"""
+Pipelines API tests
+"""
+import pytest
+import uuid
+
+
+@pytest.mark.asyncio
+async def test_create_pipeline(client, sample_position_data, sample_candidate_data):
+    """Test creating a new pipeline"""
+    # Create position and candidate first
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id,
+        "status": "discovered",
+        "score": 85.5,
+        "contact_count": 0,
+        "candidate_interest": "high",
+        "notes": "Strong candidate"
+    }
+    
+    response = await client.post("/api/v1/pipelines", json=pipeline_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert data["position_id"] == position_id
+    assert data["candidate_id"] == candidate_id
+    assert data["status"] == "discovered"
+    assert data["score"] == 85.5
+    assert "id" in data
+    assert "created_at" in data
+
+
+@pytest.mark.asyncio
+async def test_create_duplicate_pipeline(client, sample_position_data, sample_candidate_data):
+    """Test creating a duplicate pipeline returns existing one"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id,
+        "status": "discovered"
+    }
+    
+    # Create first time
+    response1 = await client.post("/api/v1/pipelines", json=pipeline_data)
+    assert response1.status_code == 200
+    pipeline_id_1 = response1.json()["id"]
+    
+    # Create duplicate
+    response2 = await client.post("/api/v1/pipelines", json=pipeline_data)
+    assert response2.status_code == 200
+    pipeline_id_2 = response2.json()["id"]
+    
+    # Should return the same pipeline
+    assert pipeline_id_1 == pipeline_id_2
+
+
+@pytest.mark.asyncio
+async def test_get_pipelines(client, sample_position_data, sample_candidate_data):
+    """Test getting all pipelines"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id
+    }
+    await client.post("/api/v1/pipelines", json=pipeline_data)
+    
+    response = await client.get("/api/v1/pipelines")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)
+    assert len(data) >= 1
+
+
+@pytest.mark.asyncio
+async def test_get_pipelines_with_pagination(client, sample_position_data, sample_candidate_data):
+    """Test getting pipelines with pagination"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    # Create multiple candidates and pipelines
+    for i in range(3):
+        cand_data = sample_candidate_data.copy()
+        cand_data["source_id"] = str(20000 + i)
+        cand_data["github_login"] = f"pipeuser{i}"
+        cand_response = await client.post("/api/v1/candidates", json=cand_data)
+        candidate_id = cand_response.json()["id"]
+        
+        pipeline_data = {
+            "position_id": position_id,
+            "candidate_id": candidate_id
+        }
+        await client.post("/api/v1/pipelines", json=pipeline_data)
+    
+    response = await client.get("/api/v1/pipelines?skip=0&limit=2")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 2
+
+
+@pytest.mark.asyncio
+async def test_get_pipeline_by_id(client, sample_position_data, sample_candidate_data):
+    """Test getting a specific pipeline by ID"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id
+    }
+    
+    create_response = await client.post("/api/v1/pipelines", json=pipeline_data)
+    pipeline_id = create_response.json()["id"]
+    
+    response = await client.get(f"/api/v1/pipelines/{pipeline_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == pipeline_id
+
+
+@pytest.mark.asyncio
+async def test_get_pipeline_not_found(client):
+    """Test getting a non-existent pipeline"""
+    fake_id = str(uuid.uuid4())
+    response = await client.get(f"/api/v1/pipelines/{fake_id}")
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_update_pipeline(client, sample_position_data, sample_candidate_data):
+    """Test updating a pipeline"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id
+    }
+    
+    create_response = await client.post("/api/v1/pipelines", json=pipeline_data)
+    pipeline_id = create_response.json()["id"]
+    
+    update_data = {"status": "contacted", "score": 90.0, "notes": "Updated notes"}
+    response = await client.put(f"/api/v1/pipelines/{pipeline_id}", json=update_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "contacted"
+    assert data["score"] == 90.0
+    assert data["notes"] == "Updated notes"
+
+
+@pytest.mark.asyncio
+async def test_update_pipeline_not_found(client):
+    """Test updating a non-existent pipeline"""
+    fake_id = str(uuid.uuid4())
+    update_data = {"status": "contacted"}
+    response = await client.put(f"/api/v1/pipelines/{fake_id}", json=update_data)
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_update_pipeline_status(client, sample_position_data, sample_candidate_data):
+    """Test updating pipeline status"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id
+    }
+    
+    create_response = await client.post("/api/v1/pipelines", json=pipeline_data)
+    pipeline_id = create_response.json()["id"]
+    
+    response = await client.put(f"/api/v1/pipelines/{pipeline_id}/status?status=interview")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "interview"
+
+
+@pytest.mark.asyncio
+async def test_delete_pipeline(client, sample_position_data, sample_candidate_data):
+    """Test deleting a pipeline"""
+    pos_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = pos_response.json()["id"]
+    
+    cand_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = cand_response.json()["id"]
+    
+    pipeline_data = {
+        "position_id": position_id,
+        "candidate_id": candidate_id
+    }
+    
+    create_response = await client.post("/api/v1/pipelines", json=pipeline_data)
+    pipeline_id = create_response.json()["id"]
+    
+    response = await client.delete(f"/api/v1/pipelines/{pipeline_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["message"] == "Pipeline deleted successfully"
+    
+    # Verify it's deleted
+    get_response = await client.get(f"/api/v1/pipelines/{pipeline_id}")
+    assert get_response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_pipeline_not_found(client):
+    """Test deleting a non-existent pipeline"""
+    fake_id = str(uuid.uuid4())
+    response = await client.delete(f"/api/v1/pipelines/{fake_id}")
+    
+    assert response.status_code == 404

app/tests/test_positions.py

@@ -0,0 +1,183 @@
+"""
+Positions API tests
+"""
+import pytest
+import uuid
+
+
+@pytest.mark.asyncio
+async def test_create_position(client, sample_position_data):
+    """Test creating a new position"""
+    response = await client.post("/api/v1/positions", json=sample_position_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert data["title"] == sample_position_data["title"]
+    assert data["company"] == sample_position_data["company"]
+    assert data["status"] == "active"
+    assert "id" in data
+    assert "created_at" in data
+    assert "updated_at" in data
+
+
+@pytest.mark.asyncio
+async def test_get_positions(client, sample_position_data):
+    """Test getting all positions"""
+    # Create a position first
+    await client.post("/api/v1/positions", json=sample_position_data)
+    
+    response = await client.get("/api/v1/positions")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)
+    assert len(data) >= 1
+
+
+@pytest.mark.asyncio
+async def test_get_positions_with_pagination(client, sample_position_data):
+    """Test getting positions with pagination"""
+    # Create multiple positions
+    for i in range(3):
+        data = sample_position_data.copy()
+        data["title"] = f"Position {i}"
+        await client.post("/api/v1/positions", json=data)
+    
+    response = await client.get("/api/v1/positions?skip=0&limit=2")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 2
+
+
+@pytest.mark.asyncio
+async def test_get_positions_with_status_filter(client, sample_position_data):
+    """Test getting positions with status filter"""
+    await client.post("/api/v1/positions", json=sample_position_data)
+    
+    response = await client.get("/api/v1/positions?status=active")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert all(pos["status"] == "active" for pos in data)
+
+
+@pytest.mark.asyncio
+async def test_get_position_by_id(client, sample_position_data):
+    """Test getting a specific position by ID"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    response = await client.get(f"/api/v1/positions/{position_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == position_id
+    assert data["title"] == sample_position_data["title"]
+
+
+@pytest.mark.asyncio
+async def test_get_position_not_found(client):
+    """Test getting a non-existent position"""
+    fake_id = str(uuid.uuid4())
+    response = await client.get(f"/api/v1/positions/{fake_id}")
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_update_position(client, sample_position_data):
+    """Test updating a position"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    update_data = {"title": "Updated Title", "company": "Updated Company"}
+    response = await client.put(f"/api/v1/positions/{position_id}", json=update_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["title"] == "Updated Title"
+    assert data["company"] == "Updated Company"
+
+
+@pytest.mark.asyncio
+async def test_update_position_not_found(client):
+    """Test updating a non-existent position"""
+    fake_id = str(uuid.uuid4())
+    update_data = {"title": "Updated Title"}
+    response = await client.put(f"/api/v1/positions/{fake_id}", json=update_data)
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_position(client, sample_position_data):
+    """Test deleting a position"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    response = await client.delete(f"/api/v1/positions/{position_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["message"] == "Position deleted successfully"
+    
+    # Verify it's deleted
+    get_response = await client.get(f"/api/v1/positions/{position_id}")
+    assert get_response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_position_not_found(client):
+    """Test deleting a non-existent position"""
+    fake_id = str(uuid.uuid4())
+    response = await client.delete(f"/api/v1/positions/{fake_id}")
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_pause_position(client, sample_position_data):
+    """Test pausing a position"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    response = await client.post(f"/api/v1/positions/{position_id}/pause")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "paused"
+    assert data["loop_enabled"] == False
+
+
+@pytest.mark.asyncio
+async def test_resume_position(client, sample_position_data):
+    """Test resuming a paused position"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    # Pause first
+    await client.post(f"/api/v1/positions/{position_id}/pause")
+    
+    # Then resume
+    response = await client.post(f"/api/v1/positions/{position_id}/resume")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "active"
+    assert data["loop_enabled"] == True
+
+
+@pytest.mark.asyncio
+async def test_close_position(client, sample_position_data):
+    """Test closing a position"""
+    create_response = await client.post("/api/v1/positions", json=sample_position_data)
+    position_id = create_response.json()["id"]
+    
+    response = await client.post(f"/api/v1/positions/{position_id}/close")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "closed"

app/tests/test_scheduler.py

@@ -0,0 +1,15 @@
+"""
+Scheduler API tests
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_scheduler_jobs(client):
+    """Test getting scheduler jobs"""
+    response = await client.get("/api/v1/scheduler/jobs")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)

app/tests/test_skills.py

@@ -0,0 +1,15 @@
+"""
+Skills API tests
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_skills(client):
+    """Test getting skills"""
+    response = await client.get("/api/v1/skills")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)

app/tests/test_system.py

@@ -0,0 +1,35 @@
+"""
+System API tests
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_get_system_config(client):
+    """Test getting system configuration"""
+    response = await client.get("/api/v1/system/config")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, dict)
+
+
+@pytest.mark.asyncio
+async def test_root_endpoint(client):
+    """Test root endpoint"""
+    response = await client.get("/")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["message"] == "Recruiting Loop Agent is running!"
+
+
+@pytest.mark.asyncio
+async def test_health_check(client):
+    """Test health check endpoint"""
+    response = await client.get("/health")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"

loop_agent_cli/__init__.py

@@ -0,0 +1,5 @@
+"""
+loop-agent-cli — Typer + Rich CLI for recruit-loop-agent.
+"""
+
+__version__ = "0.1.0"