Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
import json
import logging
from datetime import UTC, datetime, timedelta
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from sqlalchemy import select
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session
import services.async_workflow_service as async_workflow_service_module
from models.account import Account
from models.enums import AppTriggerType, CreatorUserRole, EndUserType, WorkflowRunTriggeredFrom, WorkflowTriggerStatus
from models.model import App, AppMode, EndUser
from models.trigger import WorkflowTriggerLog
from models.workflow import Workflow, WorkflowType
from services.async_workflow_service import AsyncWorkflowService
from services.errors.app import QuotaExceededError, WorkflowNotFoundError
from services.workflow.entities import AsyncTriggerResponse, TriggerData
from services.workflow.queue_dispatcher import QueuePriority
class AsyncWorkflowServiceTestDataFactory:
"""Factory helpers for async workflow service unit tests."""
@staticmethod
def create_trigger_data(
app_id: str = "app-123",
tenant_id: str = "tenant-123",
workflow_id: str | None = "workflow-123",
root_node_id: str = "root-node-123",
) -> TriggerData:
"""Create valid trigger data for async workflow execution tests."""
return TriggerData(
app_id=app_id,
tenant_id=tenant_id,
workflow_id=workflow_id,
root_node_id=root_node_id,
inputs={"name": "dify"},
files=[],
trigger_type=AppTriggerType.UNKNOWN,
trigger_from=WorkflowRunTriggeredFrom.APP_RUN,
trigger_metadata=None,
)
@staticmethod
def create_app(app_id: str = "app-123", tenant_id: str = "tenant-123") -> App:
"""Create an app that can be persisted for trigger lookup tests."""
return App(
id=app_id,
tenant_id=tenant_id,
name="Async workflow app",
description="",
mode=AppMode.WORKFLOW,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
@staticmethod
def create_trigger_log_with_data(
trigger_data: TriggerData,
*,
trigger_log_id: str = "trigger-log-123",
retry_count: int = 0,
status: WorkflowTriggerStatus = WorkflowTriggerStatus.FAILED,
created_at: datetime | None = None,
) -> WorkflowTriggerLog:
"""Create a persistent trigger log with serialized trigger data."""
trigger_log = WorkflowTriggerLog(
tenant_id=trigger_data.tenant_id,
app_id=trigger_data.app_id,
workflow_id=trigger_data.workflow_id or "workflow-123",
workflow_run_id=None,
root_node_id=trigger_data.root_node_id,
trigger_metadata="{}",
trigger_type=trigger_data.trigger_type,
trigger_data=trigger_data.model_dump_json(),
inputs=json.dumps(dict(trigger_data.inputs)),
outputs=None,
status=status,
error="previous-error",
queue_name=QueuePriority.SANDBOX,
celery_task_id=None,
created_by_role=CreatorUserRole.END_USER,
created_by="end-user-123",
retry_count=retry_count,
elapsed_time=None,
total_tokens=None,
triggered_at=None,
finished_at=None,
)
trigger_log.id = trigger_log_id
if created_at is not None:
trigger_log.created_at = created_at
return trigger_log
@staticmethod
def create_workflow(
*, workflow_id: str = "workflow-123", app_id: str = "app-123", tenant_id: str = "tenant-123"
) -> Workflow:
"""Create a mapped workflow for service-return and trigger-log tests."""
return Workflow(
id=workflow_id,
tenant_id=tenant_id,
app_id=app_id,
type=WorkflowType.WORKFLOW,
version="1",
graph="{}",
_features="{}",
created_by="account-123",
)
@staticmethod
def create_account(account_id: str = "account-123") -> Account:
"""Create a mapped account for role-discrimination tests."""
account = Account(name="Account", email=f"{account_id}@example.com")
account.id = account_id
return account
@staticmethod
def create_end_user(end_user_id: str = "end-user-123") -> EndUser:
"""Create a mapped end user for role-discrimination and retry tests."""
return EndUser(
id=end_user_id,
tenant_id="tenant-123",
app_id="app-123",
type=EndUserType.BROWSER,
name="End User",
session_id=f"session-{end_user_id}",
)
@pytest.mark.usefixtures("sqlite_session")
@pytest.mark.parametrize("sqlite_session", [(App, WorkflowTriggerLog)], indirect=True)
class TestAsyncWorkflowService:
@pytest.fixture
def async_workflow_trigger_mocks(self):
"""Shared fixture for async workflow trigger tests.
Yields mocks for:
- dispatcher_manager_class: QueueDispatcherManager class
- dispatcher: dispatcher instance
- quota_service: QuotaService mock
- get_workflow: AsyncWorkflowService._get_workflow method
- professional_task: execute_workflow_professional
- team_task: execute_workflow_team
- sandbox_task: execute_workflow_sandbox
"""
mock_dispatcher = MagicMock()
mock_quota_service = MagicMock()
with (
patch.object(async_workflow_service_module, "QueueDispatcherManager") as mock_dispatcher_manager_class,
patch.object(async_workflow_service_module, "WorkflowService"),
patch.object(
async_workflow_service_module.AsyncWorkflowService,
"_get_workflow",
) as mock_get_workflow,
patch.object(
async_workflow_service_module,
"QuotaService",
new=mock_quota_service,
),
patch.object(async_workflow_service_module, "execute_workflow_professional") as mock_professional_task,
patch.object(async_workflow_service_module, "execute_workflow_team") as mock_team_task,
patch.object(async_workflow_service_module, "execute_workflow_sandbox") as mock_sandbox_task,
):
# Configure dispatcher_manager to return our mock_dispatcher
mock_dispatcher_manager_class.return_value.get_dispatcher.return_value = mock_dispatcher
yield {
"dispatcher_manager_class": mock_dispatcher_manager_class,
"dispatcher": mock_dispatcher,
"quota_service": mock_quota_service,
"get_workflow": mock_get_workflow,
"professional_task": mock_professional_task,
"team_task": mock_team_task,
"sandbox_task": mock_sandbox_task,
}
@pytest.mark.parametrize(
("queue_name", "selected_task_attr"),
[
(QueuePriority.PROFESSIONAL, "execute_workflow_professional"),
(QueuePriority.TEAM, "execute_workflow_team"),
(QueuePriority.SANDBOX, "execute_workflow_sandbox"),
],
)
def test_should_dispatch_to_matching_celery_task_when_triggering_workflow(
self,
queue_name,
selected_task_attr,
async_workflow_trigger_mocks,
sqlite_session: Session,
):
"""Test queue-based task routing and successful async trigger response."""
# Arrange
sqlite_session.add(AsyncWorkflowServiceTestDataFactory.create_app())
sqlite_session.commit()
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
mocks = async_workflow_trigger_mocks
mocks["dispatcher"].get_queue_name.return_value = queue_name
mocks["get_workflow"].return_value = workflow
task_result = MagicMock()
task_result.id = "task-123"
mocks["professional_task"].delay.return_value = task_result
mocks["team_task"].delay.return_value = task_result
mocks["sandbox_task"].delay.return_value = task_result
quota_charge_mock = MagicMock()
mocks["quota_service"].reserve.return_value = quota_charge_mock
user = AsyncWorkflowServiceTestDataFactory.create_account()
# Act
result = AsyncWorkflowService.trigger_workflow_async(
session=sqlite_session, user=user, trigger_data=trigger_data
)
# Assert
assert isinstance(result, AsyncTriggerResponse)
assert result.workflow_trigger_log_id
assert result.task_id == "task-123"
assert result.status == "queued"
assert result.queue == queue_name
mocks["quota_service"].reserve.assert_called_once()
quota_charge_mock.commit.assert_called_once()
assert not sqlite_session.in_transaction()
created_log = sqlite_session.scalar(
select(WorkflowTriggerLog).where(WorkflowTriggerLog.id == result.workflow_trigger_log_id)
)
assert created_log is not None
assert created_log.status == WorkflowTriggerStatus.QUEUED
assert created_log.queue_name == queue_name
assert created_log.created_by_role == CreatorUserRole.ACCOUNT
assert created_log.created_by == "account-123"
assert created_log.trigger_data == trigger_data.model_dump_json()
assert created_log.inputs == json.dumps(dict(trigger_data.inputs))
assert created_log.celery_task_id == "task-123"
task_mocks = {
"execute_workflow_professional": mocks["professional_task"],
"execute_workflow_team": mocks["team_task"],
"execute_workflow_sandbox": mocks["sandbox_task"],
}
for task_attr, task_mock in task_mocks.items():
if task_attr == selected_task_attr:
task_mock.delay.assert_called_once_with({"workflow_trigger_log_id": result.workflow_trigger_log_id})
else:
task_mock.delay.assert_not_called()
def test_should_set_end_user_role_when_triggered_by_end_user(
self, async_workflow_trigger_mocks, sqlite_session: Session
):
"""Test that non-account users are tracked as END_USER in trigger logs."""
# Arrange
sqlite_session.add(AsyncWorkflowServiceTestDataFactory.create_app())
sqlite_session.commit()
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
mocks = async_workflow_trigger_mocks
mocks["dispatcher"].get_queue_name.return_value = QueuePriority.SANDBOX
mocks["get_workflow"].return_value = workflow
task_result = MagicMock(id="task-123")
mocks["sandbox_task"].delay.return_value = task_result
user = AsyncWorkflowServiceTestDataFactory.create_end_user()
# Act
response = AsyncWorkflowService.trigger_workflow_async(
session=sqlite_session, user=user, trigger_data=trigger_data
)
# Assert
created_log = sqlite_session.get(WorkflowTriggerLog, response.workflow_trigger_log_id)
assert created_log is not None
assert created_log.created_by_role == CreatorUserRole.END_USER
assert created_log.created_by == "end-user-123"
def test_should_raise_workflow_not_found_when_app_does_not_exist(self, sqlite_session: Session):
"""Test trigger failure when app lookup returns no result."""
# Arrange
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data(app_id="missing-app")
with (
patch.object(async_workflow_service_module, "QueueDispatcherManager"),
patch.object(async_workflow_service_module, "WorkflowService"),
):
# Act / Assert
with pytest.raises(WorkflowNotFoundError, match="App not found: missing-app"):
AsyncWorkflowService.trigger_workflow_async(
session=sqlite_session,
user=AsyncWorkflowServiceTestDataFactory.create_end_user("user-123"),
trigger_data=trigger_data,
)
def test_should_mark_log_rate_limited_and_reraise_when_quota_exceeded(
self,
async_workflow_trigger_mocks,
caplog: pytest.LogCaptureFixture,
sqlite_session: Session,
):
"""Test quota-exceeded path updates trigger log and preserves the quota exception."""
# Arrange
sqlite_session.add(AsyncWorkflowServiceTestDataFactory.create_app())
sqlite_session.commit()
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
mocks = async_workflow_trigger_mocks
mocks["dispatcher"].get_queue_name.return_value = QueuePriority.TEAM
mocks["get_workflow"].return_value = workflow
mocks["quota_service"].reserve.side_effect = QuotaExceededError(
feature="workflow",
tenant_id="tenant-123",
required=1,
)
caplog.set_level(logging.INFO, logger=async_workflow_service_module.__name__)
# Act / Assert
with pytest.raises(QuotaExceededError) as exc_info:
AsyncWorkflowService.trigger_workflow_async(
session=sqlite_session,
user=AsyncWorkflowServiceTestDataFactory.create_end_user("user-123"),
trigger_data=trigger_data,
)
assert exc_info.value.feature == "workflow"
assert exc_info.value.tenant_id == "tenant-123"
assert exc_info.value.required == 1
assert not sqlite_session.in_transaction()
updated_log = sqlite_session.scalar(select(WorkflowTriggerLog))
assert updated_log is not None
assert updated_log.status == WorkflowTriggerStatus.RATE_LIMITED
assert "Quota limit reached" in updated_log.error
assert (
"Workflow quota exceeded for tenant tenant-123, app app-123, workflow workflow-123, "
f"trigger log {updated_log.id}"
) in caplog.messages
mocks["professional_task"].delay.assert_not_called()
mocks["team_task"].delay.assert_not_called()
mocks["sandbox_task"].delay.assert_not_called()
def test_should_mark_log_failed_and_reraise_when_celery_dispatch_raises(
self,
async_workflow_trigger_mocks,
caplog: pytest.LogCaptureFixture,
sqlite_session: Session,
):
"""Test dispatch failure path marks trigger log FAILED, refunds quota, and re-raises."""
# Arrange
sqlite_session.add(AsyncWorkflowServiceTestDataFactory.create_app())
sqlite_session.commit()
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
mocks = async_workflow_trigger_mocks
mocks["dispatcher"].get_queue_name.return_value = QueuePriority.SANDBOX
mocks["get_workflow"].return_value = workflow
quota_charge_mock = MagicMock()
mocks["quota_service"].reserve.return_value = quota_charge_mock
dispatch_error = RuntimeError("broker unavailable")
mocks["sandbox_task"].delay.side_effect = dispatch_error
caplog.set_level(logging.ERROR, logger=async_workflow_service_module.__name__)
# Act / Assert
with pytest.raises(RuntimeError) as exc_info:
AsyncWorkflowService.trigger_workflow_async(
session=sqlite_session,
user=AsyncWorkflowServiceTestDataFactory.create_end_user("user-123"),
trigger_data=trigger_data,
)
assert exc_info.value is dispatch_error
quota_charge_mock.commit.assert_not_called()
quota_charge_mock.refund.assert_called_once()
assert not sqlite_session.in_transaction()
updated_log = sqlite_session.scalar(select(WorkflowTriggerLog))
assert updated_log is not None
assert updated_log.status == WorkflowTriggerStatus.FAILED
assert updated_log.error is not None
assert "Failed to dispatch workflow task" in updated_log.error
assert "broker unavailable" in updated_log.error
assert (
"Failed to dispatch workflow task for tenant tenant-123, app app-123, workflow workflow-123, "
f"trigger log {updated_log.id}"
) in caplog.text
def test_should_raise_when_reinvoke_target_log_does_not_exist(self, sqlite_session: Session):
"""Test reinvoke_trigger error path when original trigger log is missing."""
# Arrange
# Act / Assert
with pytest.raises(ValueError, match="Trigger log not found: missing-log"):
AsyncWorkflowService.reinvoke_trigger(
session=sqlite_session,
user=AsyncWorkflowServiceTestDataFactory.create_end_user("user-123"),
workflow_trigger_log_id="missing-log",
)
def test_should_update_original_log_and_requeue_when_reinvoking(self, sqlite_session: Session):
"""Test reinvoke flow updates original log state and triggers a new async run."""
# Arrange
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
trigger_log = AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(trigger_data, retry_count=1)
sqlite_session.add(trigger_log)
sqlite_session.commit()
expected_response = AsyncTriggerResponse(
workflow_trigger_log_id="new-trigger-log-456",
task_id="task-456",
status="queued",
queue=QueuePriority.TEAM,
)
with (
patch.object(
async_workflow_service_module.AsyncWorkflowService,
"trigger_workflow_async",
return_value=expected_response,
) as mock_trigger_workflow_async,
):
user = AsyncWorkflowServiceTestDataFactory.create_end_user("user-123")
# Act
response = AsyncWorkflowService.reinvoke_trigger(
session=sqlite_session,
user=user,
workflow_trigger_log_id="trigger-log-123",
)
# Assert
assert response == expected_response
assert not sqlite_session.in_transaction()
sqlite_session.refresh(trigger_log)
assert trigger_log.status == WorkflowTriggerStatus.RETRYING
assert trigger_log.retry_count == 2
assert trigger_log.error is None
assert trigger_log.triggered_at is not None
called_trigger_data = mock_trigger_workflow_async.call_args.args[1]
assert isinstance(called_trigger_data, TriggerData)
assert called_trigger_data.app_id == "app-123"
@pytest.mark.parametrize(
("lookup_id", "tenant_id", "expected_id"),
[
("missing-log", "tenant-123", None),
("trigger-log-123", "tenant-123", "trigger-log-123"),
("trigger-log-123", "other-tenant", None),
],
)
def test_should_return_trigger_log_dict_or_none(
self,
lookup_id: str,
tenant_id: str,
expected_id: str | None,
sqlite_session: Session,
sqlite_engine: Engine,
):
"""Test get_trigger_log returns persisted data with tenant isolation."""
# Arrange
trigger_data = AsyncWorkflowServiceTestDataFactory.create_trigger_data()
sqlite_session.add(AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(trigger_data))
sqlite_session.commit()
with patch.object(async_workflow_service_module, "db", SimpleNamespace(engine=sqlite_engine)):
# Act
result = AsyncWorkflowService.get_trigger_log(lookup_id, tenant_id=tenant_id)
# Assert
assert (result["id"] if result else None) == expected_id
def test_should_return_recent_logs_as_dict_list(self, sqlite_session: Session, sqlite_engine: Engine):
"""Test recent logs are ordered, paginated, and tenant/app scoped."""
# Arrange
now = datetime.now(UTC)
logs = [
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(),
trigger_log_id=f"log-{index}",
created_at=now - timedelta(minutes=index),
)
for index in range(1, 4)
]
logs.extend(
[
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(tenant_id="other-tenant"),
trigger_log_id="other-tenant-log",
created_at=now,
),
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(app_id="other-app"),
trigger_log_id="other-app-log",
created_at=now,
),
]
)
sqlite_session.add_all(logs)
sqlite_session.commit()
with patch.object(async_workflow_service_module, "db", SimpleNamespace(engine=sqlite_engine)):
# Act
result = AsyncWorkflowService.get_recent_logs(
tenant_id="tenant-123",
app_id="app-123",
hours=12,
limit=2,
offset=1,
)
# Assert
assert [log["id"] for log in result] == ["log-2", "log-3"]
def test_should_return_failed_logs_for_retry_as_dict_list(self, sqlite_session: Session, sqlite_engine: Engine):
"""Test retry candidates are status, retry-count, and tenant scoped."""
# Arrange
now = datetime.now(UTC)
candidates = [
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(),
trigger_log_id="failed-log-1",
retry_count=1,
created_at=now - timedelta(minutes=2),
),
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(),
trigger_log_id="rate-limited-log",
retry_count=2,
status=WorkflowTriggerStatus.RATE_LIMITED,
created_at=now - timedelta(minutes=1),
),
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(),
trigger_log_id="retry-limit-log",
retry_count=4,
),
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(tenant_id="other-tenant"),
trigger_log_id="other-tenant-log",
),
AsyncWorkflowServiceTestDataFactory.create_trigger_log_with_data(
AsyncWorkflowServiceTestDataFactory.create_trigger_data(),
trigger_log_id="queued-log",
status=WorkflowTriggerStatus.QUEUED,
),
]
sqlite_session.add_all(candidates)
sqlite_session.commit()
with patch.object(async_workflow_service_module, "db", SimpleNamespace(engine=sqlite_engine)):
# Act
result = AsyncWorkflowService.get_failed_logs_for_retry(tenant_id="tenant-123", max_retry_count=4, limit=20)
# Assert
assert [log["id"] for log in result] == ["failed-log-1", "rate-limited-log"]
@pytest.mark.usefixtures("sqlite_session")
@pytest.mark.parametrize("sqlite_session", [(App, WorkflowTriggerLog)], indirect=True)
class TestAsyncWorkflowServiceGetWorkflow:
def test_should_return_specific_workflow_when_workflow_id_exists(self, sqlite_session: Session):
"""Test _get_workflow returns published workflow by id when provided."""
# Arrange
workflow_service = MagicMock()
app_model = AsyncWorkflowServiceTestDataFactory.create_app()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
workflow_service.get_published_workflow_by_id.return_value = workflow
# Act
result = AsyncWorkflowService._get_workflow(
workflow_service, app_model, workflow_id="workflow-123", session=sqlite_session
)
# Assert
assert result == workflow
workflow_service.get_published_workflow_by_id.assert_called_once_with(
app_model, "workflow-123", session=sqlite_session
)
workflow_service.get_published_workflow.assert_not_called()
def test_should_raise_when_specific_workflow_id_not_found(self, sqlite_session: Session):
"""Test _get_workflow raises WorkflowNotFoundError for unknown workflow id."""
# Arrange
workflow_service = MagicMock()
app_model = AsyncWorkflowServiceTestDataFactory.create_app()
workflow_service.get_published_workflow_by_id.return_value = None
# Act / Assert
with pytest.raises(WorkflowNotFoundError, match="Published workflow not found: workflow-404"):
AsyncWorkflowService._get_workflow(
workflow_service, app_model, workflow_id="workflow-404", session=sqlite_session
)
def test_should_return_default_published_workflow_when_workflow_id_not_provided(self, sqlite_session: Session):
"""Test _get_workflow returns default published workflow when no id is provided."""
# Arrange
workflow_service = MagicMock()
app_model = AsyncWorkflowServiceTestDataFactory.create_app()
workflow = AsyncWorkflowServiceTestDataFactory.create_workflow()
workflow_service.get_published_workflow.return_value = workflow
# Act
result = AsyncWorkflowService._get_workflow(workflow_service, app_model, session=sqlite_session)
# Assert
assert result == workflow
workflow_service.get_published_workflow.assert_called_once_with(app_model, session=sqlite_session)
workflow_service.get_published_workflow_by_id.assert_not_called()
def test_should_raise_when_default_published_workflow_not_found(self, sqlite_session: Session):
"""Test _get_workflow raises WorkflowNotFoundError when app has no published workflow."""
# Arrange
workflow_service = MagicMock()
app_model = AsyncWorkflowServiceTestDataFactory.create_app()
workflow_service.get_published_workflow.return_value = None
# Act / Assert
with pytest.raises(WorkflowNotFoundError, match="No published workflow found for app: app-123"):
AsyncWorkflowService._get_workflow(workflow_service, app_model, session=sqlite_session)