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
from __future__ import annotations
import base64
import json
from types import SimpleNamespace
from typing import Any
from unittest.mock import MagicMock, patch
from uuid import uuid4
import pytest
import yaml
from faker import Faker
from flask import Flask
from sqlalchemy import func, select
from sqlalchemy.orm import Session
from core.trigger.constants import (
TRIGGER_PLUGIN_NODE_TYPE,
TRIGGER_SCHEDULE_NODE_TYPE,
TRIGGER_WEBHOOK_NODE_TYPE,
)
from extensions.ext_redis import redis_client
from graphon.enums import BuiltinNodeTypes
from models import Account, App, AppMode
from models.account import Tenant
from models.agent import (
Agent,
AgentConfigDraft,
AgentConfigDraftType,
AgentConfigSnapshot,
AgentScope,
AgentSource,
AgentStatus,
WorkflowAgentBindingType,
WorkflowAgentNodeBinding,
)
from models.agent_config_entities import AgentSoulConfig
from models.model import AppModelConfig, IconType
from models.workflow import Workflow, WorkflowType
from services import app_dsl_service
from services.agent.dsl_entities import AGENT_PACKAGE_REF_KEY, make_portable_agent_package
from services.agent.dsl_service import AgentDslService
from services.app_creation_records import create_site_record
from services.app_dsl_service import (
CHECK_DEPENDENCIES_REDIS_KEY_PREFIX,
CURRENT_DSL_VERSION,
DSL_MAX_SIZE,
IMPORT_INFO_REDIS_EXPIRY,
IMPORT_INFO_REDIS_KEY_PREFIX,
AppDslService,
CheckDependenciesPendingData,
ImportMode,
ImportStatus,
PendingData,
)
from services.app_service import AppService, CreateAppParams
from services.dsl_version import check_version_compatibility
from services.errors.app import WorkflowNotFoundError
from tests.e2e_tests.containers.helpers import accounts as account_fixtures
from tests.e2e_tests.containers.helpers import generate_valid_password
_DEFAULT_TENANT_ID = "00000000-0000-0000-0000-000000000001"
_DEFAULT_ACCOUNT_ID = "00000000-0000-0000-0000-000000000002"
def _account(*, tenant_id: str = _DEFAULT_TENANT_ID, account_id: str = _DEFAULT_ACCOUNT_ID) -> Account:
account = Account(name="DSL test account", email="[email protected]")
account.id = account_id
tenant = Tenant(name="DSL test workspace")
tenant.id = tenant_id
account._current_tenant = tenant
return account
def _yaml_dump(data: dict) -> str:
return yaml.safe_dump(data, allow_unicode=True)
def _workflow_yaml(*, version: str = CURRENT_DSL_VERSION) -> str:
return _yaml_dump(
{
"version": version,
"kind": "app",
"app": {"name": "My App", "mode": AppMode.WORKFLOW.value},
"workflow": {"graph": {"nodes": []}, "features": {}},
}
)
def _pending_yaml_content(version: str = "99.0.0") -> bytes:
return (f'version: "{version}"\nkind: app\napp:\n name: Loop Test\n mode: workflow\n').encode()
def _app_record(**overrides: Any) -> App:
"""Create a transient App with real mapped attributes and session helpers."""
defaults = {
"id": str(uuid4()),
"tenant_id": _DEFAULT_TENANT_ID,
"mode": AppMode.WORKFLOW,
"name": "n",
"description": "d",
"icon_type": IconType.EMOJI,
"icon": "i",
"icon_background": "#fff",
"use_icon_as_answer_icon": False,
}
attributes = defaults | overrides
timestamps = {name: attributes.pop(name) for name in ("created_at", "updated_at") if name in attributes}
app = App(**attributes)
for name, value in timestamps.items():
setattr(app, name, value)
return app
class TestAppDslService:
"""Integration tests for AppDslService using testcontainers."""
@pytest.fixture
def app(self, flask_app_with_containers: Flask):
return flask_app_with_containers
@pytest.fixture
def mock_external_service_dependencies(self):
"""Mock setup for external service dependencies."""
with (
patch("services.app_dsl_service.WorkflowService") as mock_workflow_service,
patch("services.app_dsl_service.DependenciesAnalysisService") as mock_dependencies_service,
patch("services.app_dsl_service.app_was_created") as mock_app_was_created,
patch("services.app_service.ModelManager.for_tenant") as mock_model_manager,
patch("services.app_service.SystemFeatureService") as mock_feature_service,
patch("services.app_service.EnterpriseService") as mock_enterprise_service,
):
mock_workflow_service.get_draft_workflow.return_value = None
mock_workflow_service.get_published_workflow_by_id.return_value = None
mock_workflow_service.return_value.get_draft_workflow.return_value = None
mock_workflow_service.return_value.sync_draft_workflow.return_value = MagicMock()
mock_dependencies_service.generate_latest_dependencies.return_value = []
mock_dependencies_service.get_leaked_dependencies.return_value = []
mock_dependencies_service.generate_dependencies.return_value = []
mock_app_was_created.send.return_value = None
mock_model_instance = mock_model_manager.return_value
mock_model_instance.get_default_model_instance.return_value = None
mock_model_instance.get_default_provider_model_name.return_value = (
"openai",
"gpt-3.5-turbo",
)
mock_feature_service.is_webapp_auth_enabled.return_value = False
mock_enterprise_service.WebAppAuth.update_app_access_mode.return_value = None
mock_enterprise_service.WebAppAuth.cleanup_webapp.return_value = None
yield {
"workflow_service": mock_workflow_service,
"dependencies_service": mock_dependencies_service,
"app_was_created": mock_app_was_created,
"model_manager": mock_model_manager,
"feature_service": mock_feature_service,
"enterprise_service": mock_enterprise_service,
}
def _create_test_app_and_account(self, db_session_with_containers: Session, mock_external_service_dependencies):
fake = Faker()
with patch("services.account.login_adapters.SystemFeatureService") as mock_account_feature_service:
mock_account_feature_service.is_registration_allowed.return_value = True
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
app_args = CreateAppParams(
name=fake.company(),
description=fake.text(max_nb_chars=100),
mode="chat",
icon_type="emoji",
icon="🤖",
icon_background="#FF6B6B",
api_rph=100,
api_rpm=10,
)
app_service = AppService()
app = app_service.create_app(tenant.id, app_args, account, session=db_session_with_containers)
return app, account
def _create_simple_yaml_content(self, app_name: str = "Test App", app_mode: str = "chat") -> str:
yaml_data = {
"version": "0.3.0",
"kind": "app",
"app": {
"name": app_name,
"mode": app_mode,
"icon": "🤖",
"icon_background": "#FFEAD5",
"description": "Test app description",
"use_icon_as_answer_icon": False,
},
"model_config": {
"model": {
"provider": "openai",
"name": "gpt-3.5-turbo",
"mode": "chat",
"completion_params": {
"max_tokens": 1000,
"temperature": 0.7,
"top_p": 1.0,
},
},
"pre_prompt": "You are a helpful assistant.",
"prompt_type": "simple",
},
}
return yaml.dump(yaml_data, allow_unicode=True)
# ── Version Compatibility ─────────────────────────────────────────
def test_check_version_compatibility_invalid_version_returns_failed(self):
assert check_version_compatibility("not-a-version", app_dsl_service.CURRENT_DSL_VERSION) == ImportStatus.FAILED
def test_check_version_compatibility_newer_version_returns_pending(self):
assert check_version_compatibility("99.0.0", app_dsl_service.CURRENT_DSL_VERSION) == ImportStatus.PENDING
def test_check_version_compatibility_major_older_returns_pending(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(app_dsl_service, "CURRENT_DSL_VERSION", "1.0.0")
assert check_version_compatibility("0.9.9", app_dsl_service.CURRENT_DSL_VERSION) == ImportStatus.PENDING
def test_check_version_compatibility_minor_older_returns_completed_with_warnings(
self,
):
assert (
check_version_compatibility("0.5.0", app_dsl_service.CURRENT_DSL_VERSION)
== ImportStatus.COMPLETED_WITH_WARNINGS
)
def test_check_version_compatibility_equal_returns_completed(self):
assert check_version_compatibility(CURRENT_DSL_VERSION, CURRENT_DSL_VERSION) == ImportStatus.COMPLETED
# ── Import: Validation ────────────────────────────────────────────
def test_import_app_invalid_import_mode_raises_value_error(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="Invalid import_mode"):
service.import_app(
account=_account(),
import_mode="invalid-mode",
yaml_content="version: '0.1.0'",
)
def test_import_app_missing_yaml_content(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=None,
)
assert result.status == ImportStatus.FAILED
assert "yaml_content is required" in result.error
def test_import_app_missing_yaml_url(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url=None,
)
assert result.status == ImportStatus.FAILED
assert "yaml_url is required" in result.error
def test_import_app_yaml_not_mapping_returns_failed(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content="[]",
)
assert result.status == ImportStatus.FAILED
assert "content must be a mapping" in result.error
def test_import_app_version_not_str_returns_failed(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
yaml_content = _yaml_dump({"version": 1, "kind": "app", "app": {"name": "x", "mode": "workflow"}})
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=yaml_content,
)
assert result.status == ImportStatus.FAILED
assert "Invalid version type" in result.error
def test_import_app_missing_app_data_returns_failed(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_yaml_dump({"version": "0.6.0", "kind": "app"}),
)
assert result.status == ImportStatus.FAILED
assert "Missing app data" in result.error
def test_import_app_yaml_error_returns_failed(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
def bad_safe_load(_content: str):
raise yaml.YAMLError("bad")
monkeypatch.setattr(app_dsl_service.yaml, "safe_load", bad_safe_load)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content="x: y",
)
assert result.status == ImportStatus.FAILED
assert result.error.startswith("Invalid YAML format:")
def test_import_app_unexpected_error_returns_failed(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
monkeypatch.setattr(
AppDslService,
"_create_or_update_app",
lambda *_args, **_kwargs: (_ for _ in ()).throw(ValueError("oops")),
)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_workflow_yaml(),
)
assert result.status == ImportStatus.FAILED
assert result.error == "oops"
# ── Import: YAML URL ──────────────────────────────────────────────
def test_import_app_yaml_url_fetch_error_returns_failed(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
monkeypatch.setattr(
app_dsl_service.remote_fetcher,
"make_request",
lambda _method, _url, **_kw: (_ for _ in ()).throw(RuntimeError("boom")),
)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url="https://example.com/a.yml",
)
assert result.status == ImportStatus.FAILED
assert "Error fetching YAML from URL: boom" in result.error
def test_import_app_yaml_url_empty_content_returns_failed(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
response = MagicMock()
response.content = b""
response.raise_for_status.return_value = None
monkeypatch.setattr(app_dsl_service.remote_fetcher, "make_request", lambda _method, _url, **_kw: response)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url="https://example.com/a.yml",
)
assert result.status == ImportStatus.FAILED
assert "Empty content" in result.error
def test_import_app_yaml_url_file_too_large_returns_failed(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
response = MagicMock()
response.content = b"x" * (DSL_MAX_SIZE + 1)
response.raise_for_status.return_value = None
monkeypatch.setattr(app_dsl_service.remote_fetcher, "make_request", lambda _method, _url, **_kw: response)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url="https://example.com/a.yml",
)
assert result.status == ImportStatus.FAILED
assert "File size exceeds" in result.error
def test_import_app_yaml_url_user_attachments_keeps_original_url(
self, db_session_with_containers: Session, monkeypatch
):
yaml_url = "https://github.com/user-attachments/files/24290802/loop-test.yml"
yaml_bytes = _pending_yaml_content()
requested_urls: list[str] = []
def fake_make_request(method: str, url: str, **kwargs):
assert method == "GET"
requested_urls.append(url)
response = MagicMock()
response.content = yaml_bytes
response.raise_for_status.return_value = None
return response
monkeypatch.setattr(app_dsl_service.remote_fetcher, "make_request", fake_make_request)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url=yaml_url,
)
assert result.status == ImportStatus.PENDING
assert result.imported_dsl_version == "99.0.0"
assert requested_urls == [yaml_url]
def test_import_app_yaml_url_github_blob_rewrites_to_raw(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
yaml_url = "https://github.com/acme/repo/blob/main/app.yml"
raw_url = "https://raw.githubusercontent.com/acme/repo/main/app.yml"
yaml_bytes = _pending_yaml_content()
requested_urls: list[str] = []
def fake_make_request(method: str, url: str, **kwargs):
assert method == "GET"
requested_urls.append(url)
assert url == raw_url
response = MagicMock()
response.content = yaml_bytes
response.raise_for_status.return_value = None
return response
monkeypatch.setattr(app_dsl_service.remote_fetcher, "make_request", fake_make_request)
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_URL,
yaml_url=yaml_url,
)
assert result.status == ImportStatus.PENDING
assert requested_urls == [raw_url]
# ── Import: App ID checks ────────────────────────────────────────
def test_import_app_app_id_not_found_returns_failed(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_workflow_yaml(),
app_id=str(uuid4()),
)
assert result.status == ImportStatus.FAILED
assert result.error == "App not found"
def test_import_app_overwrite_only_allows_workflow_and_advanced_chat(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
assert app.mode == "chat"
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=account,
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_workflow_yaml(),
app_id=app.id,
)
assert result.status == ImportStatus.FAILED
assert "Only workflow or advanced chat apps" in result.error
# ── Import: Flow ──────────────────────────────────────────────────
def test_import_app_pending_stores_import_info_in_redis(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_workflow_yaml(version="99.0.0"),
name="n",
description="d",
icon_type="emoji",
icon="i",
icon_background="#000000",
)
assert result.status == ImportStatus.PENDING
assert result.imported_dsl_version == "99.0.0"
redis_key = f"{IMPORT_INFO_REDIS_KEY_PREFIX}{result.id}"
stored = redis_client.get(redis_key)
assert stored is not None
pending = PendingData.model_validate_json(stored)
assert pending.tenant_id == _DEFAULT_TENANT_ID
assert pending.account_id == _DEFAULT_ACCOUNT_ID
def test_import_app_completed_uses_declared_dependencies(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
_, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
dependencies_payload = [
{
"type": "package",
"value": {
"plugin_unique_identifier": "langgenius/google",
"version": "1.0.0",
},
}
]
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=account,
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_yaml_dump(
{
"version": CURRENT_DSL_VERSION,
"kind": "app",
"app": {"name": "My App", "mode": AppMode.WORKFLOW.value},
"workflow": {"graph": {"nodes": []}, "features": {}},
"dependencies": dependencies_payload,
}
),
)
assert result.status == ImportStatus.COMPLETED
assert result.app_id is not None
@pytest.mark.parametrize("has_workflow", [True, False])
def test_import_app_legacy_versions_extract_dependencies(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch, has_workflow: bool
):
monkeypatch.setattr(
AppDslService,
"_extract_dependencies_from_workflow_graph",
lambda *_args, **_kwargs: ["from-workflow"],
)
monkeypatch.setattr(
AppDslService,
"_extract_dependencies_from_model_config",
lambda *_args, **_kwargs: ["from-model-config"],
)
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"generate_latest_dependencies",
lambda deps: [SimpleNamespace(model_dump=lambda: {"dep": deps[0]})],
)
created_app = SimpleNamespace(
id=str(uuid4()),
mode=AppMode.WORKFLOW,
tenant_id=_DEFAULT_TENANT_ID,
)
monkeypatch.setattr(
AppDslService,
"_create_or_update_app",
lambda *_args, **_kwargs: created_app,
)
draft_var_service = MagicMock()
monkeypatch.setattr(
app_dsl_service,
"WorkflowDraftVariableService",
lambda *args, **kwargs: draft_var_service,
)
data: dict = {
"version": "0.1.5",
"kind": "app",
"app": {"name": "Legacy", "mode": AppMode.WORKFLOW.value},
}
if has_workflow:
data["workflow"] = {"graph": {"nodes": []}, "features": {}}
else:
data["model_config"] = {"model": {"provider": "openai"}}
service = AppDslService(db_session_with_containers)
result = service.import_app(
account=_account(),
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_yaml_dump(data),
)
assert result.status == ImportStatus.COMPLETED_WITH_WARNINGS
draft_var_service.delete_app_workflow_variables.assert_called_once_with(app_id=created_app.id)
# ── Confirm Import ────────────────────────────────────────────────
def test_confirm_import_expired_returns_failed(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
result = service.confirm_import(import_id=str(uuid4()), account=_account())
assert result.status == ImportStatus.FAILED
assert "expired" in result.error
def test_confirm_import_success_deletes_redis_key(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
import_id = str(uuid4())
redis_key = f"{IMPORT_INFO_REDIS_KEY_PREFIX}{import_id}"
pending = PendingData(
tenant_id=_DEFAULT_TENANT_ID,
account_id=_DEFAULT_ACCOUNT_ID,
import_mode=ImportMode.YAML_CONTENT,
yaml_content=_workflow_yaml(),
name="name",
description="desc",
icon_type="emoji",
icon="🤖",
icon_background="#fff",
app_id=None,
)
redis_client.setex(redis_key, IMPORT_INFO_REDIS_EXPIRY, pending.model_dump_json())
created_app = SimpleNamespace(
id=str(uuid4()),
mode=AppMode.WORKFLOW.value,
tenant_id=_DEFAULT_TENANT_ID,
)
monkeypatch.setattr(
AppDslService,
"_create_or_update_app",
lambda *_args, **_kwargs: created_app,
)
service = AppDslService(db_session_with_containers)
result = service.confirm_import(import_id=import_id, account=_account())
assert result.status == ImportStatus.COMPLETED
assert result.app_id == created_app.id
assert redis_client.get(redis_key) is None
def test_confirm_import_invalid_pending_data_type_returns_failed(self, db_session_with_containers: Session):
import_id = str(uuid4())
redis_key = f"{IMPORT_INFO_REDIS_KEY_PREFIX}{import_id}"
redis_client.setex(redis_key, IMPORT_INFO_REDIS_EXPIRY, "123")
service = AppDslService(db_session_with_containers)
result = service.confirm_import(import_id=import_id, account=_account())
assert result.status == ImportStatus.FAILED
assert "validation error" in result.error
def test_confirm_import_exception_returns_failed(self, db_session_with_containers: Session):
import_id = str(uuid4())
redis_key = f"{IMPORT_INFO_REDIS_KEY_PREFIX}{import_id}"
redis_client.setex(redis_key, IMPORT_INFO_REDIS_EXPIRY, "not-valid-json")
service = AppDslService(db_session_with_containers)
result = service.confirm_import(import_id=import_id, account=_account())
assert result.status == ImportStatus.FAILED
# ── Check Dependencies ────────────────────────────────────────────
def test_check_dependencies_returns_empty_when_no_redis_data(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
app_model = _app_record()
result = service.check_dependencies(app_model=app_model)
assert result.leaked_dependencies == []
def test_check_dependencies_calls_analysis_service(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
app_id = str(uuid4())
pending = CheckDependenciesPendingData(dependencies=[], app_id=app_id)
redis_client.setex(
f"{CHECK_DEPENDENCIES_REDIS_KEY_PREFIX}{app_id}",
IMPORT_INFO_REDIS_EXPIRY,
pending.model_dump_json(),
)
dep = app_dsl_service.PluginDependency.model_validate(
{
"type": "package",
"value": {
"plugin_unique_identifier": "acme/foo",
"version": "1.0.0",
},
}
)
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"get_leaked_dependencies",
lambda *, tenant_id, dependencies: [dep],
)
service = AppDslService(db_session_with_containers)
result = service.check_dependencies(app_model=_app_record(id=app_id))
assert len(result.leaked_dependencies) == 1
def test_check_dependencies_with_real_app(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
mock_dependencies_json = '{"app_id": "' + app.id + '", "dependencies": []}'
redis_client.setex(
f"{CHECK_DEPENDENCIES_REDIS_KEY_PREFIX}{app.id}",
IMPORT_INFO_REDIS_EXPIRY,
mock_dependencies_json,
)
dsl_service = AppDslService(db_session_with_containers)
result = dsl_service.check_dependencies(app_model=app)
assert result.leaked_dependencies == []
# ── Create/Update App ─────────────────────────────────────────────
def test_create_or_update_app_missing_mode_raises(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="loss app mode"):
service._create_or_update_app(app=None, data={"app": {}}, account=_account())
def test_create_or_update_app_existing_app_updates_fields(
self, db_session_with_containers: Session, monkeypatch: pytest.MonkeyPatch
):
fixed_now = object()
monkeypatch.setattr(app_dsl_service, "naive_utc_now", lambda: fixed_now)
workflow_service = MagicMock()
workflow_service.get_draft_workflow.return_value = None
monkeypatch.setattr(app_dsl_service, "WorkflowService", lambda: workflow_service)
monkeypatch.setattr(
app_dsl_service.variable_factory,
"build_environment_variable_from_mapping",
lambda _m: SimpleNamespace(kind="env"),
)
monkeypatch.setattr(
app_dsl_service.variable_factory,
"build_conversation_variable_from_mapping",
lambda _m: SimpleNamespace(kind="conv"),
)
app = _app_record(
mode=AppMode.WORKFLOW,
name="old",
description="old-desc",
icon_type=IconType.EMOJI,
icon="old-icon",
icon_background="#111111",
updated_by=None,
updated_at=None,
)
service = AppDslService(db_session_with_containers)
updated = service._create_or_update_app(
app=app,
data={
"app": {
"mode": AppMode.WORKFLOW,
"name": "yaml-name",
"icon_type": IconType.IMAGE,
"icon": "X",
},
"workflow": {"graph": {"nodes": []}, "features": {}},
},
account=_account(),
name="override-name",
description=None,
icon_background="#222222",
)
assert updated is app
assert app.name == "override-name"
assert app.icon_type == app_dsl_service.DEFAULT_ICON_TYPE
assert app.icon == app_dsl_service.DEFAULT_ICON
assert app.icon_background == "#222222"
assert app.updated_at is fixed_now
def test_create_or_update_app_new_app_requires_tenant(self, db_session_with_containers: Session):
account = _account()
account._current_tenant = None
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="Current tenant is not set"):
service._create_or_update_app(
app=None,
data={"app": {"mode": AppMode.WORKFLOW, "name": "n"}},
account=account,
)
def test_create_or_update_app_creates_workflow_app_and_saves_dependencies(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
_, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
mock_wf_svc = mock_external_service_dependencies["workflow_service"]
mock_wf_svc.return_value.get_draft_workflow.return_value = MagicMock(unique_hash="uh")
service = AppDslService(db_session_with_containers)
deps = [
app_dsl_service.PluginDependency.model_validate(
{
"type": "package",
"value": {
"plugin_unique_identifier": "acme/foo",
"version": "1.0.0",
},
}
)
]
data = {
"app": {"mode": AppMode.WORKFLOW, "name": "n"},
"workflow": {
"graph": {"nodes": []},
"features": {},
},
}
app = service._create_or_update_app(app=None, data=data, account=account, dependencies=deps)
assert app.tenant_id == account.current_tenant_id
mock_external_service_dependencies["app_was_created"].send.assert_called_once()
mock_wf_svc.return_value.sync_draft_workflow.assert_called_once()
stored = redis_client.get(f"{CHECK_DEPENDENCIES_REDIS_KEY_PREFIX}{app.id}")
assert stored is not None
def test_create_or_update_app_workflow_missing_workflow_data_raises(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="Missing workflow data"):
service._create_or_update_app(
app=_app_record(mode=AppMode.WORKFLOW),
data={"app": {"mode": AppMode.WORKFLOW}},
account=_account(),
)
def test_create_or_update_app_chat_requires_model_config(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="Missing model_config"):
service._create_or_update_app(
app=_app_record(mode=AppMode.CHAT),
data={"app": {"mode": AppMode.CHAT}},
account=_account(),
)
def test_create_or_update_app_chat_creates_model_config_and_sends_event(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
app.app_model_config_id = None
db_session_with_containers.commit()
service = AppDslService(db_session_with_containers)
with patch("services.app_dsl_service.app_model_config_was_updated") as signal:
service._create_or_update_app(
app=app,
data={
"app": {"mode": AppMode.CHAT},
"model_config": {"model": {"provider": "openai"}},
},
account=account,
)
db_session_with_containers.expire_all()
assert app.app_model_config_id is not None
assert signal.send.call_args.kwargs["session"] is db_session_with_containers
def test_create_or_update_app_invalid_mode_raises(self, db_session_with_containers: Session):
service = AppDslService(db_session_with_containers)
with pytest.raises(ValueError, match="Invalid app mode"):
service._create_or_update_app(
app=_app_record(mode=AppMode.RAG_PIPELINE),
data={"app": {"mode": AppMode.RAG_PIPELINE}},
account=_account(),
)
# ── Export ─────────────────────────────────────────────────────────
def test_export_dsl_delegates_by_mode(
self,
monkeypatch: pytest.MonkeyPatch,
db_session_with_containers: Session,
mock_external_service_dependencies,
):
workflow_calls: list[bool] = []
model_calls: list[bool] = []
def append_workflow(**_kwargs: Any) -> list[str]:
workflow_calls.append(True)
return []
def append_model(*_args: Any, **_kwargs: Any) -> list[str]:
model_calls.append(True)
return []
monkeypatch.setattr(
AppDslService,
"_append_workflow_export_data",
append_workflow,
)
monkeypatch.setattr(
AppDslService,
"_append_model_config_export_data",
append_model,
)
workflow_app = _app_record(
mode=AppMode.WORKFLOW,
icon_type="emoji",
)
AppDslService.export_dsl(workflow_app, session=db_session_with_containers)
assert workflow_calls == [True]
chat_app = _app_record(
mode=AppMode.CHAT,
icon_type="emoji",
)
AppDslService.export_dsl(chat_app, session=db_session_with_containers)
assert model_calls == [True]
def test_export_dsl_preserves_icon_and_icon_type(
self,
monkeypatch: pytest.MonkeyPatch,
db_session_with_containers: Session,
mock_external_service_dependencies,
):
monkeypatch.setattr(
AppDslService,
"_append_workflow_export_data",
lambda **_kwargs: [],
)
emoji_app = _app_record(
mode=AppMode.WORKFLOW,
name="Emoji App",
icon="🎨",
icon_type=IconType.EMOJI,
icon_background="#FF5733",
description="App with emoji icon",
use_icon_as_answer_icon=True,
)
yaml_output = AppDslService.export_dsl(emoji_app, session=db_session_with_containers)
data = yaml.safe_load(yaml_output)
assert data["app"]["icon"] == "🎨"
assert data["app"]["icon_type"] == "emoji"
assert data["app"]["icon_background"] == "#FF5733"
image_app = _app_record(
mode=AppMode.WORKFLOW,
name="Image App",
icon="https://example.com/icon.png",
icon_type=IconType.IMAGE,
icon_background="#FFEAD5",
description="App with image icon",
use_icon_as_answer_icon=False,
)
yaml_output = AppDslService.export_dsl(image_app, session=db_session_with_containers)
data = yaml.safe_load(yaml_output)
assert data["app"]["icon"] == "https://example.com/icon.png"
assert data["app"]["icon_type"] == "image"
assert data["app"]["icon_background"] == "#FFEAD5"
def test_export_dsl_chat_app_success(self, db_session_with_containers: Session, mock_external_service_dependencies):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
model_config = AppModelConfig(
app_id=app.id,
provider="openai",
model_id="gpt-3.5-turbo",
model=json.dumps(
{
"provider": "openai",
"name": "gpt-3.5-turbo",
"mode": "chat",
"completion_params": {
"max_tokens": 1000,
"temperature": 0.7,
},
}
),
pre_prompt="You are a helpful assistant.",
prompt_type="simple",
created_by=account.id,
updated_by=account.id,
)
model_config.id = str(uuid4())
app.app_model_config_id = model_config.id
db_session_with_containers.add(model_config)
db_session_with_containers.commit()
exported_dsl = AppDslService.export_dsl(app, include_secret=False, session=db_session_with_containers)
exported_data = yaml.safe_load(exported_dsl)
assert exported_data["kind"] == "app"
assert exported_data["app"]["name"] == app.name
assert exported_data["app"]["mode"] == app.mode
assert "model_config" in exported_data
assert "dependencies" in exported_data
def test_workflow_package_import_materializes_all_agent_bindings_as_inline(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
app.mode = AppMode.WORKFLOW
workflow = Workflow.new(
tenant_id=app.tenant_id,
app_id=app.id,
type=WorkflowType.WORKFLOW.value,
version=Workflow.VERSION_DRAFT,
graph=json.dumps({"nodes": [], "edges": []}),
features=json.dumps({}),
created_by=account.id,
environment_variables=[],
conversation_variables=[],
rag_pipeline_variables=[],
)
db_session_with_containers.add(workflow)
db_session_with_containers.flush()
source_agent = Agent(
tenant_id=app.tenant_id,
name="Portable Agent",
description="Imported into each node",
role="researcher",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
status=AgentStatus.ACTIVE,
created_by=account.id,
updated_by=account.id,
)
package = make_portable_agent_package(source_agent, AgentSoulConfig(config_note="portable"))
graph = {
"nodes": [
{
"id": "roster-node",
"data": {
"type": BuiltinNodeTypes.AGENT,
"version": "2",
"agent_node_kind": "dify_agent",
"agent_binding": {
"binding_type": WorkflowAgentBindingType.ROSTER_AGENT.value,
AGENT_PACKAGE_REF_KEY: "agent_1",
},
},
},
{
"id": "inline-node",
"data": {
"type": BuiltinNodeTypes.AGENT,
"version": "2",
"agent_node_kind": "dify_agent",
"agent_binding": {
"binding_type": WorkflowAgentBindingType.INLINE_AGENT.value,
AGENT_PACKAGE_REF_KEY: "agent_1",
},
},
},
],
"edges": [],
}
imported_roster_count_before = db_session_with_containers.scalar(
select(func.count())
.select_from(Agent)
.where(
Agent.tenant_id == app.tenant_id,
Agent.scope == AgentScope.ROSTER,
Agent.source == AgentSource.IMPORTED,
)
)
imported_graph, warnings, retirement_candidates = AgentDslService(
db_session_with_containers
).import_workflow_packages(
workflow=workflow,
portable_graph=graph,
raw_packages={"agent_1": package.model_dump(mode="json")},
account=account,
)
db_session_with_containers.commit()
assert warnings == []
assert retirement_candidates == set()
graph_bindings = [node["data"]["agent_binding"] for node in imported_graph["nodes"]]
assert all(binding["binding_type"] == WorkflowAgentBindingType.INLINE_AGENT.value for binding in graph_bindings)
assert len({binding["agent_id"] for binding in graph_bindings}) == 2
bindings = db_session_with_containers.scalars(
select(WorkflowAgentNodeBinding).where(
WorkflowAgentNodeBinding.tenant_id == app.tenant_id,
WorkflowAgentNodeBinding.workflow_id == workflow.id,
WorkflowAgentNodeBinding.workflow_version == Workflow.VERSION_DRAFT,
)
).all()
assert len(bindings) == 2
assert all(binding.binding_type == WorkflowAgentBindingType.INLINE_AGENT for binding in bindings)
imported_agents = db_session_with_containers.scalars(
select(Agent).where(Agent.id.in_({binding.agent_id for binding in bindings if binding.agent_id}))
).all()
assert len(imported_agents) == 2
assert all(agent.scope == AgentScope.WORKFLOW_ONLY for agent in imported_agents)
assert all(agent.source == AgentSource.IMPORTED for agent in imported_agents)
assert all(agent.app_id == app.id and agent.workflow_id == workflow.id for agent in imported_agents)
assert {agent.workflow_node_id for agent in imported_agents} == {"roster-node", "inline-node"}
assert all(agent.backing_app_id for agent in imported_agents)
backing_apps = db_session_with_containers.scalars(
select(App).where(App.id.in_({agent.backing_app_id for agent in imported_agents if agent.backing_app_id}))
).all()
assert len(backing_apps) == 2
assert all(backing_app.mode == AppMode.AGENT for backing_app in backing_apps)
assert all(backing_app.enable_site is False and backing_app.enable_api is False for backing_app in backing_apps)
imported_roster_count_after = db_session_with_containers.scalar(
select(func.count())
.select_from(Agent)
.where(
Agent.tenant_id == app.tenant_id,
Agent.scope == AgentScope.ROSTER,
Agent.source == AgentSource.IMPORTED,
)
)
assert imported_roster_count_after == imported_roster_count_before
def test_agent_app_dsl_round_trip_creates_unpublished_imported_agent(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
_, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
source_app = AppService().create_app(
account.current_tenant_id,
CreateAppParams(
name="Portable Agent",
description="Agent DSL integration test",
mode="agent",
agent_role="researcher",
icon_type="emoji",
icon="R",
icon_background="#FFFFFF",
),
account,
session=db_session_with_containers,
)
source_agent = db_session_with_containers.scalar(
select(Agent).where(
Agent.tenant_id == account.current_tenant_id,
Agent.app_id == source_app.id,
Agent.scope == AgentScope.ROSTER,
)
)
assert source_agent is not None
source_snapshot = db_session_with_containers.scalar(
select(AgentConfigSnapshot).where(
AgentConfigSnapshot.agent_id == source_agent.id,
AgentConfigSnapshot.id == source_agent.active_config_snapshot_id,
)
)
assert source_snapshot is not None
source_snapshot.config_snapshot = AgentSoulConfig.model_validate(
{
"config_skills": [
{
"name": "research",
"description": "Research source material.",
"file_id": "source-skill-file-id",
"size": 123,
}
],
"config_files": [
{
"name": "guide.md",
"file_kind": "upload_file",
"file_id": "source-config-file-id",
"size": 456,
"mime_type": "text/markdown",
}
],
}
)
db_session_with_containers.commit()
yaml_content = AppDslService.export_dsl(
source_app,
include_secret=False,
session=db_session_with_containers,
)
exported_data = yaml.safe_load(yaml_content)
serialized_package = exported_data["agent_packages"][exported_data["agent"]["package_ref"]]
assert exported_data["app"]["mode"] == AppMode.AGENT.value
assert "agent_id" not in json.dumps(serialized_package)
assert serialized_package["soul"]["config_skills"] == [
{
"name": "research",
"description": "Research source material.",
"file_kind": "tool_file",
"file_id": "",
"is_missing": True,
"size": 123,
"hash": None,
"mime_type": "application/zip",
}
]
assert serialized_package["soul"]["config_files"] == [
{
"name": "guide.md",
"file_kind": "upload_file",
"file_id": "",
"is_missing": True,
"size": 456,
"hash": None,
"mime_type": "text/markdown",
}
]
assert "source-skill-file-id" not in yaml_content
assert "source-config-file-id" not in yaml_content
mock_external_service_dependencies["app_was_created"].send.side_effect = (
lambda app, *, account, session, **_kwargs: create_site_record(app=app, account=account, session=session)
)
result = AppDslService(db_session_with_containers).import_app(
account=account,
import_mode=ImportMode.YAML_CONTENT,
yaml_content=yaml_content,
)
assert result.status == ImportStatus.COMPLETED_WITH_WARNINGS
assert {warning.code for warning in result.warnings} == {
"agent_file_omitted",
"agent_skill_omitted",
}
assert result.app_id is not None
db_session_with_containers.commit()
imported_agent = db_session_with_containers.scalar(
select(Agent).where(
Agent.tenant_id == account.current_tenant_id,
Agent.app_id == result.app_id,
Agent.scope == AgentScope.ROSTER,
Agent.source == AgentSource.IMPORTED,
)
)
assert imported_agent is not None
assert imported_agent.active_config_is_published is False
imported_app = db_session_with_containers.get(App, result.app_id)
assert imported_app is not None
assert imported_app.enable_site is False
assert imported_app.enable_api is False
imported_site = imported_app.site_with_session(session=db_session_with_containers)
assert imported_site is not None
assert imported_site.title == exported_data["site"]["title"]
draft = db_session_with_containers.scalar(
select(AgentConfigDraft).where(
AgentConfigDraft.agent_id == imported_agent.id,
AgentConfigDraft.draft_type == AgentConfigDraftType.DRAFT,
AgentConfigDraft.draft_owner_key == "",
)
)
assert draft is not None
assert draft.base_snapshot_id == imported_agent.active_config_snapshot_id
imported_soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)
assert imported_soul.config_skills[0].name == "research"
assert imported_soul.config_skills[0].file_id == ""
assert imported_soul.config_skills[0].is_missing is True
assert imported_soul.config_files[0].name == "guide.md"
assert imported_soul.config_files[0].file_id == ""
assert imported_soul.config_files[0].is_missing is True
def test_export_dsl_workflow_app_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
app.mode = "workflow"
db_session_with_containers.commit()
mock_workflow = MagicMock()
mock_workflow.to_dict.return_value = {
"graph": {
"nodes": [
{
"id": "start",
"type": "start",
"data": {"type": "start"},
}
],
"edges": [],
},
"features": {},
"environment_variables": [],
"conversation_variables": [],
}
mock_external_service_dependencies["workflow_service"].get_draft_workflow.return_value = mock_workflow
exported_dsl = AppDslService.export_dsl(app, include_secret=False, session=db_session_with_containers)
exported_data = yaml.safe_load(exported_dsl)
assert exported_data["kind"] == "app"
assert exported_data["app"]["mode"] == "workflow"
assert "workflow" in exported_data
assert "dependencies" in exported_data
def test_export_dsl_with_workflow_id_success(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
app.mode = "workflow"
db_session_with_containers.commit()
mock_workflow = MagicMock()
mock_workflow.to_dict.return_value = {
"graph": {
"nodes": [
{
"id": "start",
"type": "start",
"data": {"type": "start"},
}
],
"edges": [],
},
"features": {},
"environment_variables": [],
"conversation_variables": [],
}
workflow_id = str(uuid4())
workflow_service = mock_external_service_dependencies["workflow_service"]
workflow_service.get_published_workflow_by_id.return_value = mock_workflow
exported_dsl = AppDslService.export_dsl(
app, include_secret=False, workflow_id=workflow_id, session=db_session_with_containers
)
exported_data = yaml.safe_load(exported_dsl)
workflow_service.get_published_workflow_by_id.assert_called_once_with(
app, workflow_id, session=db_session_with_containers
)
assert exported_data["kind"] == "app"
assert "workflow" in exported_data
def test_export_dsl_with_invalid_workflow_id_raises_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
app.mode = "workflow"
db_session_with_containers.commit()
mock_external_service_dependencies["workflow_service"].get_published_workflow_by_id.return_value = None
with pytest.raises(
WorkflowNotFoundError,
match="Workflow version not found. Workflow ID:",
):
AppDslService.export_dsl(
app, include_secret=False, workflow_id=str(uuid4()), session=db_session_with_containers
)
# ── Workflow Export Data ───────────────────────────────────────────
def test_append_workflow_export_data_filters_and_overrides(
self, monkeypatch: pytest.MonkeyPatch, db_session_with_containers: Session
):
workflow_dict = {
"graph": {
"nodes": [
{
"data": {
"type": BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL,
"dataset_ids": ["d1", "d2"],
}
},
{
"data": {
"type": BuiltinNodeTypes.TOOL,
"credential_id": "secret",
}
},
{
"data": {
"type": BuiltinNodeTypes.AGENT,
"agent_parameters": {"tools": {"value": [{"credential_id": "secret"}]}},
}
},
{
"data": {
"type": TRIGGER_SCHEDULE_NODE_TYPE,
"config": {"x": 1},
}
},
{
"data": {
"type": TRIGGER_WEBHOOK_NODE_TYPE,
"webhook_url": "x",
"webhook_debug_url": "y",
}
},
{
"data": {
"type": TRIGGER_PLUGIN_NODE_TYPE,
"subscription_id": "s",
}
},
]
}
}
workflow = SimpleNamespace(to_dict=lambda *, include_secret: workflow_dict)
monkeypatch.setattr(app_dsl_service.WorkflowService, "get_draft_workflow", MagicMock(return_value=workflow))
monkeypatch.setattr(
AppDslService,
"encrypt_dataset_id",
lambda *, dataset_id, tenant_id: f"enc:{tenant_id}:{dataset_id}",
)
monkeypatch.setattr(
app_dsl_service.TriggerScheduleNode,
"get_default_config",
lambda: {"config": {"default": True}},
)
monkeypatch.setattr(
AppDslService,
"_extract_dependencies_from_workflow",
lambda *_args, **_kwargs: ["dep-1"],
)
export_data: dict = {}
dependencies = AppDslService._append_workflow_export_data(
export_data=export_data,
app_model=_app_record(),
include_secret=False,
workflow_id=None,
session=db_session_with_containers,
)
nodes = export_data["workflow"]["graph"]["nodes"]
assert nodes[0]["data"]["dataset_ids"] == [
f"enc:{_DEFAULT_TENANT_ID}:d1",
f"enc:{_DEFAULT_TENANT_ID}:d2",
]
assert "credential_id" not in nodes[1]["data"]
assert "credential_id" not in nodes[2]["data"]["agent_parameters"]["tools"]["value"][0]
assert nodes[3]["data"]["config"] == {"default": True}
assert nodes[4]["data"]["webhook_url"] == ""
assert nodes[4]["data"]["webhook_debug_url"] == ""
assert nodes[5]["data"]["subscription_id"] == ""
assert dependencies == ["dep-1"]
def test_append_workflow_export_data_missing_workflow_raises(self, db_session_with_containers: Session):
with pytest.raises(WorkflowNotFoundError, match="Missing draft workflow configuration"):
AppDslService._append_workflow_export_data(
export_data={},
app_model=_app_record(),
include_secret=False,
workflow_id=None,
session=db_session_with_containers,
)
# ── Model Config Export Data ──────────────────────────────────────
def test_append_model_config_export_data_filters_credential_id(
self, monkeypatch: pytest.MonkeyPatch, db_session_with_containers: Session
):
monkeypatch.setattr(
AppDslService,
"_extract_dependencies_from_model_config",
lambda *_args, **_kwargs: ["dep-1"],
)
app_model = _app_record()
app_model_config = AppModelConfig(
app_id=app_model.id,
agent_mode=json.dumps({"enabled": True, "tools": [{"credential_id": "secret"}]}),
)
app_model.app_model_config_id = app_model_config.id
db_session_with_containers.add(app_model_config)
db_session_with_containers.flush()
db_session_with_containers.expire_all()
annotation_reply = {"enabled": False}
monkeypatch.setattr(app_dsl_service, "load_annotation_reply_config", lambda *_args: annotation_reply)
export_data: dict = {}
dependencies = AppDslService._append_model_config_export_data(
export_data, app_model, session=db_session_with_containers
)
assert export_data["model_config"]["agent_mode"]["tools"] == [{}]
assert dependencies == ["dep-1"]
assert export_data["model_config"]["annotation_reply"] == annotation_reply
assert app_model_config.agent_mode_dict["tools"] == [{"credential_id": "secret"}]
def test_append_model_config_export_data_requires_app_config(self, db_session_with_containers: Session):
with pytest.raises(ValueError, match="Missing app configuration"):
AppDslService._append_model_config_export_data(
{}, _app_record(app_model_config_id=str(uuid4())), session=db_session_with_containers
)
# ── Dependency Extraction ─────────────────────────────────────────
def test_extract_dependencies_from_workflow_graph_covers_all_node_types(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"analyze_tool_dependency",
lambda provider_id: f"tool:{provider_id}",
)
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"analyze_model_provider_dependency",
lambda provider: f"model:{provider}",
)
monkeypatch.setattr(
app_dsl_service.LLMNodeData,
"model_validate",
lambda _d: SimpleNamespace(model=SimpleNamespace(provider="m1")),
)
monkeypatch.setattr(
app_dsl_service.QuestionClassifierNodeData,
"model_validate",
lambda _d: SimpleNamespace(model=SimpleNamespace(provider="m2")),
)
monkeypatch.setattr(
app_dsl_service.ParameterExtractorNodeData,
"model_validate",
lambda _d: SimpleNamespace(model=SimpleNamespace(provider="m3")),
)
def kr_validate(_d):
return SimpleNamespace(
retrieval_mode="multiple",
multiple_retrieval_config=SimpleNamespace(
reranking_mode="weighted_score",
weights=SimpleNamespace(vector_setting=SimpleNamespace(embedding_provider_name="m4")),
reranking_model=None,
),
single_retrieval_config=None,
)
monkeypatch.setattr(
app_dsl_service.KnowledgeRetrievalNodeData,
"model_validate",
kr_validate,
)
graph = {
"nodes": [
{
"data": {
"type": BuiltinNodeTypes.TOOL,
"title": "Tool",
"provider_id": "p1",
"provider_type": "builtin",
"provider_name": "p1",
"tool_name": "run",
"tool_label": "Run",
"tool_configurations": {},
"tool_parameters": {},
}
},
{"data": {"type": BuiltinNodeTypes.LLM}},
{"data": {"type": BuiltinNodeTypes.QUESTION_CLASSIFIER}},
{"data": {"type": BuiltinNodeTypes.PARAMETER_EXTRACTOR}},
{"data": {"type": BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL}},
{"data": {"type": "unknown"}},
]
}
deps = AppDslService._extract_dependencies_from_workflow_graph(graph)
assert deps == [
"tool:p1",
"model:m1",
"model:m2",
"model:m3",
"model:m4",
]
def test_extract_dependencies_from_workflow_graph_handles_exceptions(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.ToolNodeData,
"model_validate",
lambda _d: (_ for _ in ()).throw(ValueError("bad")),
)
deps = AppDslService._extract_dependencies_from_workflow_graph(
{"nodes": [{"data": {"type": BuiltinNodeTypes.TOOL}}]}
)
assert deps == []
def test_extract_dependencies_from_model_config_parses_providers(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"analyze_model_provider_dependency",
lambda provider: f"model:{provider}",
)
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"analyze_tool_dependency",
lambda provider_id: f"tool:{provider_id}",
)
deps = AppDslService._extract_dependencies_from_model_config(
{
"model": {"provider": "p1"},
"dataset_configs": {
"datasets": {"datasets": [{"reranking_model": {"reranking_provider_name": {"provider": "p2"}}}]}
},
"agent_mode": {"tools": [{"provider_type": "builtin", "provider_id": "t1"}]},
}
)
assert deps == ["model:p1", "model:p2", "tool:t1"]
def test_extract_dependencies_from_model_config_handles_exceptions(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"analyze_model_provider_dependency",
lambda _p: (_ for _ in ()).throw(ValueError("bad")),
)
deps = AppDslService._extract_dependencies_from_model_config({"model": {"provider": "p1"}})
assert deps == []
# ── Leaked Dependencies ───────────────────────────────────────────
def test_get_leaked_dependencies_empty_returns_empty(self):
assert AppDslService.get_leaked_dependencies(_DEFAULT_TENANT_ID, []) == []
def test_get_leaked_dependencies_delegates(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.DependenciesAnalysisService,
"get_leaked_dependencies",
lambda *, tenant_id, dependencies: [SimpleNamespace(tenant_id=tenant_id, deps=dependencies)],
)
res = AppDslService.get_leaked_dependencies(_DEFAULT_TENANT_ID, [SimpleNamespace(id="x")])
assert len(res) == 1
# ── Encryption/Decryption ─────────────────────────────────────────
def test_encrypt_decrypt_dataset_id_respects_config(self, monkeypatch: pytest.MonkeyPatch):
tenant_id = _DEFAULT_TENANT_ID
dataset_uuid = "00000000-0000-0000-0000-000000000000"
monkeypatch.setattr(
app_dsl_service.dify_config,
"DSL_EXPORT_ENCRYPT_DATASET_ID",
False,
)
assert AppDslService.encrypt_dataset_id(dataset_id=dataset_uuid, tenant_id=tenant_id) == dataset_uuid
monkeypatch.setattr(
app_dsl_service.dify_config,
"DSL_EXPORT_ENCRYPT_DATASET_ID",
True,
)
encrypted = AppDslService.encrypt_dataset_id(dataset_id=dataset_uuid, tenant_id=tenant_id)
assert encrypted != dataset_uuid
assert base64.b64decode(encrypted.encode())
assert AppDslService.decrypt_dataset_id(encrypted_data=encrypted, tenant_id=tenant_id) == dataset_uuid
def test_decrypt_dataset_id_returns_plain_uuid_unchanged(self):
value = "00000000-0000-0000-0000-000000000000"
assert AppDslService.decrypt_dataset_id(encrypted_data=value, tenant_id=_DEFAULT_TENANT_ID) == value
def test_decrypt_dataset_id_returns_none_on_invalid_data(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.dify_config,
"DSL_EXPORT_ENCRYPT_DATASET_ID",
True,
)
assert AppDslService.decrypt_dataset_id(encrypted_data="not-base64", tenant_id=_DEFAULT_TENANT_ID) is None
def test_decrypt_dataset_id_returns_none_when_decrypted_is_not_uuid(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setattr(
app_dsl_service.dify_config,
"DSL_EXPORT_ENCRYPT_DATASET_ID",
True,
)
encrypted = AppDslService.encrypt_dataset_id(dataset_id="not-a-uuid", tenant_id=_DEFAULT_TENANT_ID)
assert AppDslService.decrypt_dataset_id(encrypted_data=encrypted, tenant_id=_DEFAULT_TENANT_ID) is None
# ── Utility ───────────────────────────────────────────────────────
def test_is_valid_uuid_handles_bad_inputs(self):
assert AppDslService._is_valid_uuid("00000000-0000-0000-0000-000000000000") is True
assert AppDslService._is_valid_uuid("nope") is False