373 lines
14 KiB
Python
373 lines
14 KiB
Python
|
"""Tests for Phase G — Workflow MVP: step handlers, wait/resume, retry, SSRF, triggers.
|
||
|
|
|
||
|
|
All tests use mocks — no real DB/LLM/Redis/HTTP needed.
|
||
|
|
"""
|
||
|
|
|
||
|
|
from __future__ import annotations
|
||
|
|
|
||
|
|
import asyncio
|
||
|
|
import uuid
|
||
|
|
from datetime import UTC, datetime, timedelta
|
||
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
||
|
|
|
||
|
|
import pytest
|
||
|
|
|
||
|
|
from app.workflows.step_handlers import (
|
||
|
|
StepResult,
|
||
|
|
get_step_handler,
|
||
|
|
get_available_step_types,
|
||
|
|
_is_url_safe,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Step Handler Registry ────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestStepHandlerRegistry:
|
||
|
|
"""Test the step handler registry."""
|
||
|
|
|
||
|
|
def test_all_step_types_registered(self):
|
||
|
|
"""All 10 built-in step types are registered."""
|
||
|
|
types = get_available_step_types()
|
||
|
|
expected = {"agent", "calendar", "crm", "dms", "event", "http", "mail", "search", "wait", "webhook"}
|
||
|
|
assert set(types) == expected
|
||
|
|
|
||
|
|
def test_get_step_handler_returns_callable(self):
|
||
|
|
"""get_step_handler returns a callable for each registered type."""
|
||
|
|
for step_type in get_available_step_types():
|
||
|
|
handler = get_step_handler(step_type)
|
||
|
|
assert handler is not None
|
||
|
|
assert callable(handler)
|
||
|
|
|
||
|
|
def test_get_step_handler_unknown_returns_none(self):
|
||
|
|
"""get_step_handler returns None for unknown step type."""
|
||
|
|
assert get_step_handler("nonexistent") is None
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Wait Step (G-WAIT) ───────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestWaitStep:
|
||
|
|
"""Test the wait/delay step handler."""
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_wait_with_duration(self):
|
||
|
|
"""Wait step with duration_seconds sets resume_at correctly."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "wait", "config": {"duration_seconds": 60}}
|
||
|
|
result = await get_step_handler("wait")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.advance is False
|
||
|
|
assert result.wait_until is not None
|
||
|
|
assert result.wait_reason == "wait"
|
||
|
|
# resume_at should be ~60s in the future
|
||
|
|
now = datetime.now(UTC)
|
||
|
|
delta = result.wait_until - now
|
||
|
|
assert 50 < delta.total_seconds() < 70
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_wait_with_absolute_time(self):
|
||
|
|
"""Wait step with resume_at sets exact resume time."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
future = (datetime.now(UTC) + timedelta(hours=2)).isoformat()
|
||
|
|
step = {"type": "wait", "config": {"resume_at": future}}
|
||
|
|
result = await get_step_handler("wait")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.advance is False
|
||
|
|
assert result.wait_until is not None
|
||
|
|
assert result.wait_reason == "wait"
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_wait_without_config_aborts(self):
|
||
|
|
"""Wait step without duration_seconds or resume_at aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "wait", "config": {}}
|
||
|
|
result = await get_step_handler("wait")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "requires" in result.error
|
||
|
|
|
||
|
|
|
||
|
|
# ─── SSRF Protection (G-HTTP) ────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestSSRFProtection:
|
||
|
|
"""Test the SSRF protection for HTTP and webhook steps."""
|
||
|
|
|
||
|
|
def test_blocks_localhost(self):
|
||
|
|
"""SSRF blocks localhost."""
|
||
|
|
assert _is_url_safe("http://localhost:8080/api") is False
|
||
|
|
assert _is_url_safe("http://127.0.0.1:8080/api") is False
|
||
|
|
|
||
|
|
def test_blocks_private_ips(self):
|
||
|
|
"""SSRF blocks private IP ranges."""
|
||
|
|
assert _is_url_safe("http://192.168.1.1/api") is False
|
||
|
|
assert _is_url_safe("http://10.0.0.1/api") is False
|
||
|
|
assert _is_url_safe("http://172.16.0.1/api") is False
|
||
|
|
|
||
|
|
def test_blocks_non_http_schemes(self):
|
||
|
|
"""SSRF blocks non-http/https schemes."""
|
||
|
|
assert _is_url_safe("ftp://example.com/file") is False
|
||
|
|
assert _is_url_safe("file:///etc/passwd") is False
|
||
|
|
assert _is_url_safe("gopher://example.com") is False
|
||
|
|
|
||
|
|
def test_allows_public_urls(self):
|
||
|
|
"""SSRF allows public HTTP/HTTPS URLs."""
|
||
|
|
assert _is_url_safe("https://api.example.com/webhook") is True
|
||
|
|
assert _is_url_safe("http://example.com/api") is True
|
||
|
|
|
||
|
|
def test_blocks_metadata_endpoint(self):
|
||
|
|
"""SSRF blocks cloud metadata endpoints."""
|
||
|
|
assert _is_url_safe("http://metadata.google.internal/computeMetadata/") is False
|
||
|
|
|
||
|
|
def test_blocks_ipv6_loopback(self):
|
||
|
|
"""SSRF blocks IPv6 loopback."""
|
||
|
|
assert _is_url_safe("http://[::1]:8080/api") is False
|
||
|
|
|
||
|
|
def test_handles_invalid_url(self):
|
||
|
|
"""SSRF handles invalid URLs gracefully."""
|
||
|
|
assert _is_url_safe("") is False
|
||
|
|
assert _is_url_safe("not-a-url") is False
|
||
|
|
|
||
|
|
|
||
|
|
# ─── HTTP Step (G-HTTP) ──────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestHttpStep:
|
||
|
|
"""Test the HTTP request step handler."""
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_http_without_url_aborts(self):
|
||
|
|
"""HTTP step without URL aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "http", "config": {"method": "GET"}}
|
||
|
|
result = await get_step_handler("http")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "url" in result.error.lower()
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_http_with_ssrf_url_aborts(self):
|
||
|
|
"""HTTP step with SSRF-blocked URL aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "http", "config": {"url": "http://127.0.0.1:8080/secret"}}
|
||
|
|
result = await get_step_handler("http")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "ssrf" in result.error.lower()
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Event Step (G-EVT) ──────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestEventStep:
|
||
|
|
"""Test the event publishing step handler."""
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_event_without_name_aborts(self):
|
||
|
|
"""Event step without event_name aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.id = uuid.uuid4()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "event", "config": {"payload": {"key": "value"}}}
|
||
|
|
result = await get_step_handler("event")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "event_name" in result.error
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_event_publishes_successfully(self):
|
||
|
|
"""Event step publishes event to event bus."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.id = uuid.uuid4()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "event", "config": {"event_name": "test.event", "payload": {"key": "value"}}}
|
||
|
|
|
||
|
|
with patch("app.core.event_bus.get_event_bus") as mock_get_bus:
|
||
|
|
mock_bus = MagicMock()
|
||
|
|
mock_bus.publish = AsyncMock()
|
||
|
|
mock_get_bus.return_value = mock_bus
|
||
|
|
|
||
|
|
result = await get_step_handler("event")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.advance is True
|
||
|
|
assert result.output["event_published"] == "test.event"
|
||
|
|
mock_bus.publish.assert_called_once()
|
||
|
|
|
||
|
|
|
||
|
|
# ─── CRM Step (G-CRM) ────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestCrmStep:
|
||
|
|
"""Test the CRM action step handler."""
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_crm_without_action_aborts(self):
|
||
|
|
"""CRM step without action aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "crm", "config": {"data": {"name": "Test"}}}
|
||
|
|
result = await get_step_handler("crm")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "action" in result.error
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_crm_unknown_action_aborts(self):
|
||
|
|
"""CRM step with unknown action aborts."""
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.context = {}
|
||
|
|
step = {"type": "crm", "config": {"action": "invalid_action"}}
|
||
|
|
result = await get_step_handler("crm")(
|
||
|
|
MagicMock(), uuid.uuid4(), instance, step
|
||
|
|
)
|
||
|
|
assert result.abort is True
|
||
|
|
assert "unknown" in result.error.lower()
|
||
|
|
|
||
|
|
|
||
|
|
# ─── StepResult ──────────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestStepResult:
|
||
|
|
"""Test the StepResult class."""
|
||
|
|
|
||
|
|
def test_default_step_result_advances(self):
|
||
|
|
"""Default StepResult advances to next step."""
|
||
|
|
result = StepResult()
|
||
|
|
assert result.advance is True
|
||
|
|
assert result.next_index is None
|
||
|
|
assert result.wait_until is None
|
||
|
|
assert result.error is None
|
||
|
|
assert result.abort is False
|
||
|
|
assert result.output == {}
|
||
|
|
|
||
|
|
def test_step_result_with_wait(self):
|
||
|
|
"""StepResult with wait_until does not advance."""
|
||
|
|
wait_time = datetime.now(UTC) + timedelta(seconds=30)
|
||
|
|
result = StepResult(advance=False, wait_until=wait_time, wait_reason="wait")
|
||
|
|
assert result.advance is False
|
||
|
|
assert result.wait_until == wait_time
|
||
|
|
assert result.wait_reason == "wait"
|
||
|
|
|
||
|
|
def test_step_result_with_error(self):
|
||
|
|
"""StepResult with error but no abort is retryable."""
|
||
|
|
result = StepResult(error="Something failed")
|
||
|
|
assert result.error == "Something failed"
|
||
|
|
assert result.abort is False
|
||
|
|
|
||
|
|
def test_step_result_with_abort(self):
|
||
|
|
"""StepResult with abort stops the workflow."""
|
||
|
|
result = StepResult(error="Fatal error", abort=True)
|
||
|
|
assert result.abort is True
|
||
|
|
assert result.error == "Fatal error"
|
||
|
|
|
||
|
|
def test_step_result_with_branch(self):
|
||
|
|
"""StepResult with next_index branches to specific step."""
|
||
|
|
result = StepResult(next_index=5)
|
||
|
|
assert result.next_index == 5
|
||
|
|
assert result.advance is True # Still advances, just to specific index
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Workflow Engine Resume (G-RUN) ──────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestWorkflowEngineResume:
|
||
|
|
"""Test the WorkflowEngine resume functionality."""
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_resume_non_waiting_instance_returns_unchanged(self):
|
||
|
|
"""Resume on a non-waiting instance returns the instance unchanged."""
|
||
|
|
from app.workflows.engine import WorkflowEngine
|
||
|
|
|
||
|
|
instance = MagicMock()
|
||
|
|
instance.status = "completed"
|
||
|
|
instance.id = uuid.uuid4()
|
||
|
|
instance.workflow_id = uuid.uuid4()
|
||
|
|
instance.current_step_index = 0
|
||
|
|
|
||
|
|
db = MagicMock()
|
||
|
|
engine = WorkflowEngine(db, uuid.uuid4())
|
||
|
|
result = await engine.resume(instance)
|
||
|
|
# Should return _instance_to_dict result, not process
|
||
|
|
assert result is not None
|
||
|
|
|
||
|
|
@pytest.mark.asyncio
|
||
|
|
async def test_find_resumable_workflows_query(self):
|
||
|
|
"""find_resumable_workflows queries for waiting instances with passed resume_at."""
|
||
|
|
from app.workflows.engine import find_resumable_workflows
|
||
|
|
from app.models.workflow import WorkflowInstance
|
||
|
|
|
||
|
|
db = MagicMock()
|
||
|
|
mock_result = MagicMock()
|
||
|
|
mock_result.scalars.return_value.all.return_value = []
|
||
|
|
db.execute = AsyncMock(return_value=mock_result)
|
||
|
|
|
||
|
|
await find_resumable_workflows(db, uuid.uuid4())
|
||
|
|
db.execute.assert_called_once()
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Workflow Schema (G-COND) ───────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestWorkflowSchema:
|
||
|
|
"""Test the extended WorkflowStep schema."""
|
||
|
|
|
||
|
|
def test_step_schema_accepts_new_types(self):
|
||
|
|
"""WorkflowStep schema accepts all new step types."""
|
||
|
|
from app.schemas.workflow import WorkflowStep
|
||
|
|
|
||
|
|
for step_type in ["wait", "http", "mail", "calendar", "dms", "search", "agent", "crm", "event", "webhook"]:
|
||
|
|
step = WorkflowStep(name=f"Test {step_type}", type=step_type, config={})
|
||
|
|
assert step.type == step_type
|
||
|
|
|
||
|
|
def test_step_schema_rejects_unknown_type(self):
|
||
|
|
"""WorkflowStep schema rejects unknown step types."""
|
||
|
|
from app.schemas.workflow import WorkflowStep
|
||
|
|
from pydantic import ValidationError
|
||
|
|
|
||
|
|
with pytest.raises(ValidationError):
|
||
|
|
WorkflowStep(name="Bad", type="unknown_type", config={})
|
||
|
|
|
||
|
|
def test_step_schema_still_accepts_legacy_types(self):
|
||
|
|
"""WorkflowStep schema still accepts legacy step types."""
|
||
|
|
from app.schemas.workflow import WorkflowStep
|
||
|
|
|
||
|
|
for step_type in ["action", "approval", "notification", "condition"]:
|
||
|
|
step = WorkflowStep(name=f"Legacy {step_type}", type=step_type, config={})
|
||
|
|
assert step.type == step_type
|
||
|
|
|
||
|
|
|
||
|
|
# ─── Workflow Model (G-RUN) ─────────────────────────────────────────────────
|
||
|
|
|
||
|
|
|
||
|
|
class TestWorkflowModelDurableFields:
|
||
|
|
"""Test the new durable/resumable fields on WorkflowInstance."""
|
||
|
|
|
||
|
|
def test_workflow_instance_has_resume_fields(self):
|
||
|
|
"""WorkflowInstance model has all G-RUN fields."""
|
||
|
|
from app.models.workflow import WorkflowInstance
|
||
|
|
|
||
|
|
# Check that the model has the new columns
|
||
|
|
assert hasattr(WorkflowInstance, "resume_at")
|
||
|
|
assert hasattr(WorkflowInstance, "resume_reason")
|
||
|
|
assert hasattr(WorkflowInstance, "step_state")
|
||
|
|
assert hasattr(WorkflowInstance, "idempotency_key")
|
||
|
|
assert hasattr(WorkflowInstance, "lock_owner")
|
||
|
|
assert hasattr(WorkflowInstance, "lock_expires_at")
|
||
|
|
assert hasattr(WorkflowInstance, "error_message")
|
||
|
|
assert hasattr(WorkflowInstance, "retry_count")
|
||
|
|
assert hasattr(WorkflowInstance, "max_retries")
|