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 uuid
from typing import Literal
from unittest.mock import ANY, MagicMock, patch
import pytest
import sqlalchemy as sa
from faker import Faker
from sqlalchemy.orm import Session
from core.app.entities.app_invoke_entities import InvokeFrom
from enums import DeploymentEdition
from models import App
from models.enums import EndUserType
from models.model import EndUser
from models.workflow import Workflow
from models.workflow import WorkflowType as ModelWorkflowType
from services.app_generate_service import AppGenerateService
from services.billing_client import billing
from services.errors.app import WorkflowIdFormatError, WorkflowNotFoundError
from tests.e2e_tests.containers.helpers import generate_valid_password
class TestAppGenerateService:
"""Integration tests for AppGenerateService using testcontainers."""
@pytest.fixture
def mock_external_service_dependencies(self):
"""Mock setup for external service dependencies."""
with (
patch("services.billing_service.BillingService", autospec=True) as mock_billing_service,
patch("services.app_generate_service.WorkflowService", autospec=True) as mock_workflow_service,
patch("services.app_generate_service.RateLimit", autospec=True) as mock_rate_limit,
patch("services.app_generate_service.CompletionAppGenerator", autospec=True) as mock_completion_generator,
patch("services.app_generate_service.ChatAppGenerator", autospec=True) as mock_chat_generator,
patch("services.app_generate_service.AgentChatAppGenerator", autospec=True) as mock_agent_chat_generator,
patch(
"services.app_generate_service.AdvancedChatAppGenerator", autospec=True
) as mock_advanced_chat_generator,
patch("services.app_generate_service.WorkflowAppGenerator", autospec=True) as mock_workflow_generator,
patch(
"services.app_generate_service.MessageBasedAppGenerator", autospec=True
) as mock_message_based_generator,
patch(
"services.account.login_adapters.SystemFeatureService", autospec=True
) as mock_account_feature_service,
patch("services.app_generate_service.dify_config") as mock_dify_config,
patch("services.quota_service.dify_config") as mock_quota_dify_config,
patch("configs.dify_config") as mock_global_dify_config,
):
# Setup default mock returns for billing service
mock_billing_service.quota_reserve.return_value = billing.QuotaReserveReply(
reservation_id="test-reservation-id", available=100, reserved=1
)
mock_billing_service.quota_commit.return_value = billing.QuotaCommitReply(
available=99, reserved=0, refunded=0
)
# Setup default mock returns for workflow service
mock_workflow_service_instance = mock_workflow_service.return_value
graph = json.dumps(
{
"nodes": [
{"id": "start", "data": {"type": "start", "title": "Start", "variables": []}},
{"id": "end", "data": {"type": "end", "title": "End", "outputs": []}},
],
"edges": [{"source": "start", "target": "end"}],
}
)
published_workflow = Workflow(id=str(uuid.uuid4()), version="1", graph=graph)
mock_workflow_service_instance.get_published_workflow.return_value = published_workflow
draft_workflow = Workflow(id=str(uuid.uuid4()), version="draft", graph=graph)
mock_workflow_service_instance.get_draft_workflow.return_value = draft_workflow
mock_workflow_service_instance.get_published_workflow_by_id.return_value = published_workflow
# Setup default mock returns for rate limiting
mock_rate_limit_instance = mock_rate_limit.return_value
mock_rate_limit_instance.enter.return_value = "test_request_id"
mock_rate_limit_instance.generate.return_value = ["test_response"]
mock_rate_limit_instance.exit.return_value = None
# Setup default mock returns for app generators
mock_completion_generator_instance = mock_completion_generator.return_value
mock_completion_generator_instance.generate.return_value = ["completion_response"]
mock_completion_generator.convert_to_event_stream.return_value = ["completion_stream"]
mock_chat_generator_instance = mock_chat_generator.return_value
mock_chat_generator_instance.generate.return_value = ["chat_response"]
mock_chat_generator.convert_to_event_stream.return_value = ["chat_stream"]
mock_agent_chat_generator_instance = mock_agent_chat_generator.return_value
mock_agent_chat_generator_instance.generate.return_value = ["agent_chat_response"]
mock_agent_chat_generator.convert_to_event_stream.return_value = ["agent_chat_stream"]
mock_advanced_chat_generator_instance = mock_advanced_chat_generator.return_value
mock_advanced_chat_generator_instance.generate.return_value = ["advanced_chat_response"]
mock_advanced_chat_generator_instance.single_iteration_generate.return_value = ["single_iteration_response"]
mock_advanced_chat_generator_instance.single_loop_generate.return_value = ["single_loop_response"]
mock_advanced_chat_generator.retrieve_events.return_value = ["advanced_chat_events"]
mock_advanced_chat_generator_instance.convert_to_event_stream.return_value = ["advanced_chat_stream"]
mock_advanced_chat_generator.convert_to_event_stream.return_value = ["advanced_chat_stream"]
mock_workflow_generator_instance = mock_workflow_generator.return_value
mock_workflow_generator_instance.generate.return_value = ["workflow_response"]
mock_workflow_generator_instance.single_iteration_generate.return_value = [
"workflow_single_iteration_response"
]
mock_workflow_generator_instance.single_loop_generate.return_value = ["workflow_single_loop_response"]
mock_workflow_generator.convert_to_event_stream.return_value = ["workflow_stream"]
mock_message_based_generator.retrieve_events.return_value = ["workflow_events"]
# Setup default mock returns for account service
mock_account_feature_service.is_registration_allowed.return_value = True
# Setup dify_config mock returns
mock_dify_config.DEPLOYMENT_EDITION = DeploymentEdition.COMMUNITY
mock_dify_config.APP_MAX_ACTIVE_REQUESTS = 100
mock_dify_config.APP_DEFAULT_ACTIVE_REQUESTS = 100
mock_dify_config.APP_DAILY_RATE_LIMIT = 1000
mock_quota_dify_config.DEPLOYMENT_EDITION = DeploymentEdition.COMMUNITY
mock_global_dify_config.DEPLOYMENT_EDITION = DeploymentEdition.COMMUNITY
mock_global_dify_config.APP_MAX_ACTIVE_REQUESTS = 100
mock_global_dify_config.APP_DAILY_RATE_LIMIT = 1000
mock_global_dify_config.HOSTED_POOL_CREDITS = 1000
yield {
"billing_service": mock_billing_service,
"workflow_service": mock_workflow_service,
"rate_limit": mock_rate_limit,
"completion_generator": mock_completion_generator,
"chat_generator": mock_chat_generator,
"agent_chat_generator": mock_agent_chat_generator,
"advanced_chat_generator": mock_advanced_chat_generator,
"workflow_generator": mock_workflow_generator,
"message_based_generator": mock_message_based_generator,
"account_feature_service": mock_account_feature_service,
"dify_config": mock_dify_config,
"quota_dify_config": mock_quota_dify_config,
"global_dify_config": mock_global_dify_config,
}
def _create_test_app_and_account(
self,
db_session_with_containers: Session,
mock_external_service_dependencies,
mode: Literal["chat", "agent-chat", "advanced-chat", "workflow", "completion"] = "chat",
):
"""
Helper method to create a test app and account for testing.
Args:
db_session_with_containers: Database session from testcontainers infrastructure
mock_external_service_dependencies: Mock dependencies
mode: App mode to create
Returns:
tuple: (app, account) - Created app and account instances
"""
fake = Faker()
# Setup mocks for account creation
mock_external_service_dependencies["account_feature_service"].is_registration_allowed.return_value = True
# Create account and tenant
from tests.e2e_tests.containers.helpers import accounts as account_fixtures
account = account_fixtures.create_account(
email=fake.email(),
name=fake.name(),
interface_language="en-US",
password=generate_valid_password(fake),
session=db_session_with_containers,
)
account_fixtures.create_owner_workspace(account, name=fake.company(), session=db_session_with_containers)
tenant = account.current_tenant
from services.app_service import AppService, CreateAppParams
# Create app with realistic data
app_args = CreateAppParams(
name=fake.company(),
description=fake.text(max_nb_chars=100),
mode=mode,
icon_type="emoji",
icon="🤖",
icon_background="#FF6B6B",
api_rph=100,
api_rpm=10,
max_active_requests=5,
)
app_service = AppService()
app = app_service.create_app(tenant.id, app_args, account, session=db_session_with_containers)
return app, account
def _create_test_workflow(self, db_session_with_containers: Session, app: App):
"""
Helper method to create a test workflow for testing.
Args:
db_session_with_containers: Database session from testcontainers infrastructure
app: App instance
Returns:
Workflow: Created workflow instance
"""
fake = Faker()
workflow = Workflow(
id=str(uuid.uuid4()),
app_id=app.id,
tenant_id=app.tenant_id,
marked_name=fake.company(),
marked_comment=fake.text(max_nb_chars=100),
type=ModelWorkflowType.WORKFLOW,
version="published",
graph='{"nodes": [], "edges": []}',
_features="{}",
created_by=app.created_by,
)
db_session_with_containers.add(workflow)
db_session_with_containers.commit()
return workflow
def test_generate_completion_mode_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful generation for completion mode app.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify rate limiting was called
mock_external_service_dependencies["rate_limit"].return_value.enter.assert_called_once()
mock_external_service_dependencies["rate_limit"].return_value.generate.assert_called_once()
# Verify completion generator was called
mock_external_service_dependencies["completion_generator"].return_value.generate.assert_called_once()
mock_external_service_dependencies["completion_generator"].convert_to_event_stream.assert_called_once()
def test_generate_chat_mode_success(self, db_session_with_containers: Session, mock_external_service_dependencies):
"""
Test successful generation for chat mode app.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="chat"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify chat generator was called
mock_external_service_dependencies["chat_generator"].return_value.generate.assert_called_once()
mock_external_service_dependencies["chat_generator"].convert_to_event_stream.assert_called_once()
def test_generate_agent_chat_mode_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful generation for agent chat mode app.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="agent-chat"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify agent chat generator was called
mock_external_service_dependencies["agent_chat_generator"].return_value.generate.assert_called_once()
mock_external_service_dependencies["agent_chat_generator"].convert_to_event_stream.assert_called_once()
def test_generate_advanced_chat_mode_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful generation for advanced chat mode app.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify advanced chat generator was called
mock_external_service_dependencies["advanced_chat_generator"].retrieve_events.assert_called_once()
mock_external_service_dependencies["advanced_chat_generator"].convert_to_event_stream.assert_called_once()
def test_generate_workflow_mode_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful generation for workflow mode app.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="workflow"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify workflow generator was called
mock_external_service_dependencies["message_based_generator"].retrieve_events.assert_called_once()
mock_external_service_dependencies["workflow_generator"].convert_to_event_stream.assert_called_once()
def test_generate_with_specific_workflow_id(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with a specific workflow ID.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
workflow_id = str(uuid.uuid4())
# Setup test arguments
args = {
"inputs": {"query": fake.text(max_nb_chars=50)},
"workflow_id": workflow_id,
"response_mode": "streaming",
}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify workflow service was called with specific workflow ID
mock_external_service_dependencies[
"workflow_service"
].return_value.get_published_workflow_by_id.assert_called_once()
def test_generate_with_debugger_invoke_from(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with debugger invoke from.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.DEBUGGER,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify draft workflow was fetched for debugger
mock_external_service_dependencies["workflow_service"].return_value.get_draft_workflow.assert_called_once()
def test_generate_with_non_streaming_mode(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with non-streaming mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "blocking"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=False,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify rate limit exit was called for non-streaming mode
mock_external_service_dependencies["rate_limit"].return_value.exit.assert_called_once()
def test_generate_with_end_user(self, db_session_with_containers: Session, mock_external_service_dependencies):
"""
Test generation with EndUser instead of Account.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Create end user
end_user = EndUser(
tenant_id=account.current_tenant.id,
app_id=app.id,
type=EndUserType.BROWSER,
external_user_id=fake.uuid4(),
name=fake.name(),
_is_anonymous=False,
session_id=fake.uuid4(),
)
db_session_with_containers.add(end_user)
db_session_with_containers.commit()
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=end_user,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
def test_generate_in_cloud_sandbox_plan(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation in the Cloud edition with a sandbox plan.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Billing services are available in the Cloud deployment edition.
mock_external_service_dependencies["dify_config"].DEPLOYMENT_EDITION = DeploymentEdition.CLOUD
mock_external_service_dependencies["quota_dify_config"].DEPLOYMENT_EDITION = DeploymentEdition.CLOUD
mock_external_service_dependencies["global_dify_config"].DEPLOYMENT_EDITION = DeploymentEdition.CLOUD
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify billing two-phase quota (reserve + commit)
billing = mock_external_service_dependencies["billing_service"]
billing.quota_reserve.assert_called_once()
billing.quota_commit.assert_called_once()
def test_generate_with_invalid_app_mode(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with invalid app mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="chat"
)
# Manually set invalid mode after creation
# With EnumText, invalid values are rejected at the DB level during flush,
# raising StatementError wrapping ValueError
app.mode = "invalid_mode"
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test and expect either ValueError (direct) or
# StatementError (from EnumText validation during autoflush)
with pytest.raises((ValueError, sa.exc.StatementError)):
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
def test_generate_with_workflow_id_format_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with invalid workflow ID format.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Setup test arguments with invalid workflow ID
args = {
"inputs": {"query": fake.text(max_nb_chars=50)},
"workflow_id": "invalid_uuid",
"response_mode": "streaming",
}
# Execute the method under test and expect WorkflowIdFormatError
with pytest.raises(WorkflowIdFormatError) as exc_info:
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert "Invalid workflow_id format" in str(exc_info.value)
def test_generate_with_workflow_not_found_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation when workflow is not found.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
workflow_id = str(uuid.uuid4())
# Setup workflow service to return None (workflow not found)
mock_external_service_dependencies[
"workflow_service"
].return_value.get_published_workflow_by_id.return_value = None
# Setup test arguments
args = {
"inputs": {"query": fake.text(max_nb_chars=50)},
"workflow_id": workflow_id,
"response_mode": "streaming",
}
# Execute the method under test and expect WorkflowNotFoundError
with pytest.raises(WorkflowNotFoundError) as exc_info:
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert f"Workflow not found with id: {workflow_id}" in str(exc_info.value)
def test_generate_with_workflow_not_initialized_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation when workflow is not initialized for debugger.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Setup workflow service to return None (workflow not initialized)
mock_external_service_dependencies["workflow_service"].return_value.get_draft_workflow.return_value = None
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test and expect ValueError
with pytest.raises(ValueError, match="Workflow not initialized") as exc_info:
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.DEBUGGER,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert "Workflow not initialized" in str(exc_info.value)
def test_generate_with_workflow_not_published_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation when workflow is not published for non-debugger.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Setup workflow service to return None (workflow not published)
mock_external_service_dependencies["workflow_service"].return_value.get_published_workflow.return_value = None
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test and expect ValueError
with pytest.raises(ValueError, match="Workflow not published") as exc_info:
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert "Workflow not published" in str(exc_info.value)
def test_generate_single_iteration_advanced_chat_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful single iteration generation for advanced chat mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test
result = AppGenerateService.generate_single_iteration(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["advanced_chat_stream"]
# Verify advanced chat generator was called
mock_external_service_dependencies[
"advanced_chat_generator"
].return_value.single_iteration_generate.assert_called_once()
def test_generate_single_iteration_workflow_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful single iteration generation for workflow mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="workflow"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test
result = AppGenerateService.generate_single_iteration(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["advanced_chat_stream"]
# Verify workflow generator was called
mock_external_service_dependencies[
"workflow_generator"
].return_value.single_iteration_generate.assert_called_once()
def test_generate_single_iteration_invalid_mode(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test single iteration generation with invalid app mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test and expect ValueError
with pytest.raises(ValueError, match="Invalid app mode") as exc_info:
AppGenerateService.generate_single_iteration(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert "Invalid app mode" in str(exc_info.value)
def test_generate_single_loop_advanced_chat_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful single loop generation for advanced chat mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test
result = AppGenerateService.generate_single_loop(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["advanced_chat_stream"]
# Verify advanced chat generator was called
mock_external_service_dependencies[
"advanced_chat_generator"
].return_value.single_loop_generate.assert_called_once()
def test_generate_single_loop_workflow_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test successful single loop generation for workflow mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="workflow"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test
result = AppGenerateService.generate_single_loop(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["advanced_chat_stream"]
# Verify workflow generator was called
mock_external_service_dependencies["workflow_generator"].return_value.single_loop_generate.assert_called_once()
def test_generate_single_loop_invalid_mode(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test single loop generation with invalid app mode.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
node_id = fake.uuid4()
args = {"inputs": {"query": fake.text(max_nb_chars=50)}}
# Execute the method under test and expect ValueError
with pytest.raises(ValueError, match="Invalid app mode") as exc_info:
AppGenerateService.generate_single_loop(
app_model=app,
user=account,
node_id=node_id,
args=args,
streaming=True,
session=db_session_with_containers,
)
# Verify error message
assert "Invalid app mode" in str(exc_info.value)
def test_get_max_active_requests_with_app_limit(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test getting max active requests with app-specific limit.
"""
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Set app-specific limit
app.max_active_requests = 10
# Execute the method under test
result = AppGenerateService._get_max_active_requests(app)
# Verify the result (should return the smaller value between app limit and config limit)
assert result == 10
def test_get_max_active_requests_with_config_limit(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test getting max active requests with config limit being smaller.
"""
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Set app-specific limit higher than config
app.max_active_requests = 100
# Execute the method under test
result = AppGenerateService._get_max_active_requests(app)
# Verify the result (should return the smaller value)
# Assuming config limit is smaller than 100
assert result <= 100
def test_get_max_active_requests_with_zero_limits(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test getting max active requests with zero limits (infinite).
"""
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Set app-specific limit to 0 (infinite)
app.max_active_requests = 0
# Execute the method under test
result = AppGenerateService._get_max_active_requests(app)
# Verify the result (should return config limit when app limit is 0)
assert result == 100 # dify_config.APP_MAX_ACTIVE_REQUESTS
def test_generate_with_exception_cleanup(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test that rate limit exit is called when an exception occurs.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="completion"
)
# Setup completion generator to raise an exception
mock_external_service_dependencies["completion_generator"].return_value.generate.side_effect = Exception(
"Test exception"
)
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test and expect exception
with pytest.raises(Exception, match="Test exception") as exc_info:
AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify exception message
assert "Test exception" in str(exc_info.value)
# Verify rate limit exit was called for cleanup
mock_external_service_dependencies["rate_limit"].return_value.exit.assert_called_once()
def test_generate_with_agent_mode_detection(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with agent mode detection based on app configuration.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="chat"
)
# Mock app to have agent mode enabled by setting the mode directly
app.mode = "agent-chat"
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify agent chat generator was called instead of regular chat generator
mock_external_service_dependencies["agent_chat_generator"].return_value.generate.assert_called_once()
mock_external_service_dependencies["agent_chat_generator"].convert_to_event_stream.assert_called_once()
def test_generate_with_different_invoke_from_values(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
"""
Test generation with different invoke from values.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="advanced-chat"
)
# Test different invoke from values
invoke_from_values = [
InvokeFrom.SERVICE_API,
InvokeFrom.WEB_APP,
InvokeFrom.EXPLORE,
InvokeFrom.DEBUGGER,
]
for invoke_from in invoke_from_values:
# Setup test arguments
args = {"inputs": {"query": fake.text(max_nb_chars=50)}, "response_mode": "streaming"}
# Execute the method under test
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=invoke_from,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
def test_generate_with_complex_args(self, db_session_with_containers: Session, mock_external_service_dependencies):
"""
Test generation with complex arguments including files and external trace ID.
"""
fake = Faker()
app, account = self._create_test_app_and_account(
db_session_with_containers, mock_external_service_dependencies, mode="workflow"
)
# Setup complex test arguments
args = {
"inputs": {
"query": fake.text(max_nb_chars=50),
"context": fake.text(max_nb_chars=100),
"parameters": {"temperature": 0.7, "max_tokens": 1000},
},
"files": [
{"id": fake.uuid4(), "name": "test_file.txt", "size": 1024},
{"id": fake.uuid4(), "name": "test_image.jpg", "size": 2048},
],
"external_trace_id": fake.uuid4(),
"response_mode": "streaming",
}
# Execute the method under test
with patch("services.app_generate_service.AppExecutionParams", autospec=True) as mock_exec_params:
mock_payload = MagicMock()
mock_payload.workflow_run_id = fake.uuid4()
mock_payload.model_dump_json.return_value = "{}"
mock_exec_params.new.return_value = mock_payload
result = AppGenerateService.generate(
app_model=app,
user=account,
args=args,
invoke_from=InvokeFrom.SERVICE_API,
streaming=True,
session=db_session_with_containers,
)
# Verify the result
assert result == ["test_response"]
# Verify payload was built with complex args
mock_exec_params.new.assert_called_once()
call_kwargs = mock_exec_params.new.call_args.kwargs
assert call_kwargs["args"] == args
# Verify workflow streaming event retrieval was used
mock_external_service_dependencies["message_based_generator"].retrieve_events.assert_called_once_with(
ANY,
mock_payload.workflow_run_id,
on_subscribe=ANY,
)