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 collections.abc import Callable
from dataclasses import dataclass, field
from io import BytesIO
from types import SimpleNamespace
from typing import cast
from unittest.mock import Mock
from uuid import uuid4
import pytest
import yaml
from pydantic import ValidationError
from sqlalchemy import event, select
from sqlalchemy.orm import Session, sessionmaker
from constants.dsl_version import CURRENT_APP_DSL_VERSION
from core.plugin.entities.plugin import PluginDependency, PluginDependencyType
from core.rbac import RBACPermission, RBACResourceScope
from core.workflow.llm_environment_variable import LLMEnvironmentVariable
from enums import DeploymentEdition
from models import Account, App, AppMode
from models.enums import CustomizeTokenStrategy
from models.model import AppModelConfig, AppModelConfigDict, IconType, Site
from models.workflow import Workflow
from services.agent.dsl_entities import AgentPackage
from services.agent.roster_package_entities import PackageIcon
from services.app_dsl_service import AppDslService, PendingData
from services.app_package_service import PreparedAppPackage
from services.entities.dsl_entities import ImportStatus
from services.entities.feature_entities import FeatureModel, LimitationModel
from services.entities.site_dsl import SiteDsl
from services.errors.app import DraftChangedError, WorkflowNotFoundError
from services.errors.base import NoPermissionError
from services.workflow.graph_diff import draft_token
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account, make_app, make_tenant, make_workflow
_OVERWRITE_APP_ID = "11111111-1111-4111-8111-111111111111"
_TENANT_ID = "22222222-2222-4222-8222-222222222222"
_CALLER_ID = "33333333-3333-4333-8333-333333333333"
_OTHER_ACCOUNT_ID = "44444444-4444-4444-8444-444444444444"
_WORKFLOW_TOOL_PROVIDER_ID = "77777777-7777-4777-8777-000000000000"
_API_TOOL_PROVIDER_ID = "88888888-8888-4888-8888-000000000000"
_PENDING_WORKFLOW_DSL = "version: 99.0.0\nkind: app\napp: {name: Test, mode: workflow}\n"
_PENDING_DATA_JSON = PendingData(
tenant_id=_TENANT_ID,
account_id=_CALLER_ID,
import_mode="yaml-content",
yaml_content=_PENDING_WORKFLOW_DSL,
app_id=_OVERWRITE_APP_ID,
).model_dump_json()
def _persist_overwrite_target(session: Session, *, maintainer: str = _OTHER_ACCOUNT_ID) -> App:
app = App(
id=_OVERWRITE_APP_ID,
tenant_id=_TENANT_ID,
name="Target",
description="",
mode=AppMode.WORKFLOW,
icon_type=IconType.EMOJI,
icon="robot",
icon_background="#FFFFFF",
enable_site=True,
enable_api=True,
created_by=maintainer,
maintainer=maintainer,
updated_by=maintainer,
)
session.add(app)
session.commit()
return app
def _account(*, account_id: str = "account-1", tenant_id: str = "tenant-1") -> Account:
return make_account(
account_id=account_id,
name="DSL author",
email=f"{account_id}@example.com",
tenant=make_tenant(tenant_id=tenant_id, name="DSL workspace"),
)
def _app(
*,
app_id: str = "11111111-1111-1111-1111-111111111111",
tenant_id: str = "33333333-3333-3333-3333-333333333333",
mode: AppMode = AppMode.CHAT,
app_model_config_id: str | None = None,
) -> App:
return make_app(
app_id=app_id,
tenant_id=tenant_id,
app_model_config_id=app_model_config_id,
name="Existing app",
mode=mode,
max_active_requests=0,
)
def _workflow(
*, graph: dict[str, object], environment_variables: list[LLMEnvironmentVariable] | None = None
) -> Workflow:
return make_workflow(workflow_id="workflow-1", graph=graph, environment_variables=environment_variables or [])
@pytest.mark.parametrize("version", [CURRENT_APP_DSL_VERSION, "99.0.0"])
@pytest.mark.parametrize("size", [5, 6])
def test_import_rejects_cloud_app_quota_before_side_effects(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session, version: str, size: int
) -> None:
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
feature_calls: list[tuple[str, bool]] = []
def features(tenant_id: str, *, exclude_vector_space: bool) -> FeatureModel:
feature_calls.append((tenant_id, exclude_vector_space))
return FeatureModel(apps=LimitationModel(size=size, limit=5))
def unexpected_side_effect(*_args: object, **_kwargs: object) -> None:
pytest.fail("Quota rejection must precede import side effects")
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", features)
monkeypatch.setattr("services.app_dsl_service.redis_client.setex", unexpected_side_effect)
service = AppDslService(unbound_session)
monkeypatch.setattr(service, "_create_or_update_app", unexpected_side_effect)
package = PreparedAppPackage(
archive=BytesIO(),
members={},
dsl="",
agents={},
agent_resources={},
workflow_tools=[],
icons=[PackageIcon(id="i_000001", path="i_000001.png", size=0, sha256="0" * 64)],
)
monkeypatch.setattr(package, "materialize_icons", unexpected_side_effect)
monkeypatch.setattr(package, "materialize_agents", unexpected_side_effect)
with (
package,
pytest.raises(NoPermissionError, match="The number of apps has reached the limit of your subscription"),
):
service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content=yaml.safe_dump({"version": version, "app": {"name": "Imported", "mode": "workflow"}}),
package=package,
)
assert feature_calls == [("tenant-1", True)]
@pytest.mark.parametrize("confirmed", [False, True])
@pytest.mark.parametrize(
("edition", "size", "limit", "overwrite"),
[
(DeploymentEdition.COMMUNITY, 5, 5, False),
(DeploymentEdition.ENTERPRISE, 5, 5, False),
(DeploymentEdition.CLOUD, 4, 5, False),
(DeploymentEdition.CLOUD, 5, 0, False),
(DeploymentEdition.CLOUD, 5, 5, True),
],
)
def test_import_app_quota_allows_other_editions_available_capacity_and_overwrites(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
confirmed: bool,
edition: DeploymentEdition,
size: int,
limit: int,
overwrite: bool,
) -> None:
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=edition)
feature_calls: list[tuple[str, bool]] = []
def features(tenant_id: str, *, exclude_vector_space: bool) -> FeatureModel:
feature_calls.append((tenant_id, exclude_vector_space))
return FeatureModel(apps=LimitationModel(size=size, limit=limit))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", features)
monkeypatch.setattr(
"services.app_dsl_service.WorkflowDraftVariableService.delete_app_workflow_variables",
lambda *_args, **_kwargs: None,
)
service = AppDslService(sqlite_session)
app = _app(mode=AppMode.WORKFLOW)
imported: list[App] = []
def create_or_update(**_kwargs: object) -> App:
imported.append(app)
return app
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
monkeypatch.setattr(service, "_load_app_for_overwrite", lambda *_args: app)
pending = PendingData(
tenant_id="tenant-1",
account_id="account-1",
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{"version": CURRENT_APP_DSL_VERSION, "app": {"name": "Imported", "mode": "workflow"}}
),
app_id=app.id if overwrite else None,
)
if confirmed:
monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _: pending.model_dump_json())
result = service.confirm_import(import_id="pending", account=_account())
else:
result = service.import_app(
account=_account(),
import_mode=pending.import_mode,
yaml_content=pending.yaml_content,
app_id=pending.app_id,
)
assert result.status == ImportStatus.COMPLETED, result.error
assert imported == [app]
assert feature_calls == ([("tenant-1", True)] if edition == DeploymentEdition.CLOUD and not overwrite else [])
def test_confirm_import_rechecks_cloud_app_quota_and_preserves_pending_on_rejection(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
features = FeatureModel(apps=LimitationModel(size=4, limit=5))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_args, **_kwargs: features)
pending_imports: dict[str, str] = {}
monkeypatch.setattr(
"services.app_dsl_service.redis_client.setex",
lambda key, _expiry, value: pending_imports.__setitem__(key, value),
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", pending_imports.get)
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", pending_imports.pop)
service = AppDslService(unbound_session)
imported: list[App] = []
def create_or_update(**_kwargs: object) -> App:
app = _app(mode=AppMode.WORKFLOW)
imported.append(app)
return app
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
pending = service.import_app(account=_account(), import_mode="yaml-content", yaml_content=_PENDING_WORKFLOW_DSL)
assert pending.status == ImportStatus.PENDING
features.apps.size = 5
with pytest.raises(NoPermissionError, match="The number of apps has reached the limit of your subscription"):
service.confirm_import(import_id=pending.id, account=_account())
assert not imported
assert f"app_import_info:{pending.id}" in pending_imports
features.apps.size = 4
assert service.confirm_import(import_id=pending.id, account=_account()).status == ImportStatus.COMPLETED
assert len(imported) == 1
assert f"app_import_info:{pending.id}" not in pending_imports
def _tool_node_data(*, provider_type: str, provider_id: str, **extra: str) -> dict[str, object]:
return {
"type": "tool",
"title": "Tool",
"provider_id": provider_id,
"provider_type": provider_type,
"provider_name": provider_id,
"tool_name": "run",
"tool_label": "Run",
"tool_configurations": {},
"tool_parameters": {},
**extra,
}
def test_extract_workflow_dependencies_includes_plugin_nodes() -> None:
graph = {
"nodes": [
{"data": _tool_node_data(provider_type="plugin", provider_id="acme/tool/provider", plugin_id="acme/tool")},
{"data": {"type": "trigger-plugin", "plugin_id": "acme/trigger"}},
{"data": {"type": "datasource", "provider_type": "online_document", "plugin_id": "acme/drive"}},
{"data": {"type": "datasource", "provider_type": "local_file", "plugin_id": "langgenius/file"}},
{"data": {"type": "agent", "agent_strategy_provider_name": "acme/strategy/provider"}},
]
}
assert AppDslService._extract_dependencies_from_workflow_graph(graph) == [
"acme/tool",
"acme/trigger",
"acme/drive",
"acme/strategy",
]
def test_extract_workflow_dependencies_uses_llm_environment_variable_provider(monkeypatch: pytest.MonkeyPatch) -> None:
workflow = _workflow(
graph={
"nodes": [
{
"id": "llm-node",
"data": {
"type": "llm",
"title": "LLM",
"model": {"provider": "old-provider", "name": "old-model", "mode": "chat"},
"model_selector": ["env", "shared_model"],
"prompt_template": [{"role": "system", "text": "x"}],
"context": {"enabled": False, "variable_selector": []},
"vision": {"enabled": False},
},
}
]
},
environment_variables=[
LLMEnvironmentVariable(
name="shared_model",
value={"provider": "new-provider", "name": "new-model", "mode": "chat"},
)
],
)
analyze_dependency = Mock(side_effect=lambda provider: provider)
monkeypatch.setattr(
"services.app_dsl_service.DependenciesAnalysisService.analyze_model_provider_dependency",
analyze_dependency,
)
result = AppDslService._extract_dependencies_from_workflow(workflow)
assert result == ["new-provider"]
analyze_dependency.assert_called_once_with("new-provider")
@pytest.mark.parametrize("model_selector", [[], ["env", "missing_model"]])
def test_extract_workflow_dependencies_tolerates_unresolved_llm_environment_reference(
monkeypatch: pytest.MonkeyPatch, model_selector: list[str]
) -> None:
workflow = _workflow(
graph={
"nodes": [
{
"id": "llm-node",
"data": {
"type": "llm",
"title": "LLM",
"model": {"provider": "old-provider", "name": "old-model", "mode": "chat"},
"model_selector": model_selector,
"prompt_template": [{"role": "system", "text": "x"}],
"context": {"enabled": False, "variable_selector": []},
"vision": {"enabled": False},
},
}
]
},
)
analyze_dependency = Mock(side_effect=lambda provider: provider)
monkeypatch.setattr(
"services.app_dsl_service.DependenciesAnalysisService.analyze_model_provider_dependency",
analyze_dependency,
)
result = AppDslService._extract_dependencies_from_workflow(workflow)
assert result == ["old-provider"]
analyze_dependency.assert_called_once_with("old-provider")
def test_extract_workflow_dependencies_skips_workspace_tool_providers() -> None:
graph = {
"nodes": [
{"data": _tool_node_data(provider_type="builtin", provider_id="time")},
{"data": _tool_node_data(provider_type="workflow", provider_id=_WORKFLOW_TOOL_PROVIDER_ID)},
{"data": _tool_node_data(provider_type="api", provider_id=_API_TOOL_PROVIDER_ID)},
]
}
assert AppDslService._extract_dependencies_from_workflow_graph(graph) == ["langgenius/time"]
def test_extract_model_config_dependencies_skips_workspace_tool_providers() -> None:
model_config = {
"agent_mode": {
"tools": [
{"dataset": {"enabled": True, "id": "dataset-1"}},
{"provider_type": "workflow", "provider_id": _WORKFLOW_TOOL_PROVIDER_ID, "tool_name": "summarize"},
{"provider_type": "builtin", "provider_id": "time", "tool_name": "current_time"},
]
}
}
assert AppDslService._extract_dependencies_from_model_config(model_config) == ["langgenius/time"]
def test_import_app_rejects_oversized_yaml_content_before_parsing(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
monkeypatch.setattr("services.app_dsl_service.DSL_MAX_SIZE", 3)
service = AppDslService(session=unbound_session)
account = _account()
result = service.import_app(account=account, import_mode="yaml-content", yaml_content="你你")
assert result.status == ImportStatus.FAILED
assert result.error == "File size exceeds the limit of 10MB"
assert not unbound_session.in_transaction()
def test_import_app_rejects_oversized_yaml_url_bytes_before_decode(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
monkeypatch.setattr("services.app_dsl_service.DSL_MAX_SIZE", 1)
response = Mock()
response.raise_for_status.return_value = None
response.content = b"\xff\xff"
monkeypatch.setattr("services.app_dsl_service.remote_fetcher.make_request", Mock(return_value=response))
service = AppDslService(session=unbound_session)
result = service.import_app(
account=_account(),
import_mode="yaml-url",
yaml_url="https://example.com/app.yaml",
)
assert result.status == ImportStatus.FAILED
assert result.error == "File size exceeds the limit of 10MB"
assert not unbound_session.in_transaction()
def test_import_app_returns_decode_error_for_invalid_yaml_url_bytes(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
response = Mock()
response.raise_for_status.return_value = None
response.content = b"\xff"
monkeypatch.setattr("services.app_dsl_service.remote_fetcher.make_request", Mock(return_value=response))
service = AppDslService(session=unbound_session)
result = service.import_app(
account=_account(),
import_mode="yaml-url",
yaml_url="https://example.com/app.yaml",
)
assert result.status == ImportStatus.FAILED
assert "utf-8" in result.error
assert not unbound_session.in_transaction()
def test_import_app_checks_overwrite_rbac_before_database_access(
monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_persist_overwrite_target(sqlite_session)
account = Mock(id=_CALLER_ID, current_tenant_id=_TENANT_ID)
def deny_before_transaction(*_args: object, **_kwargs: object) -> bool:
assert not sqlite_session.in_transaction()
return False
check = Mock(side_effect=deny_before_transaction)
setex = Mock()
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", check)
monkeypatch.setattr("services.app_dsl_service.redis_client.setex", setex)
with pytest.raises(NoPermissionError, match="permission to overwrite"):
AppDslService(sqlite_session).import_app(
account=account,
import_mode="yaml-content",
yaml_content=_PENDING_WORKFLOW_DSL,
app_id=_OVERWRITE_APP_ID,
)
check.assert_called_once_with(
_TENANT_ID,
_CALLER_ID,
scene=RBACPermission.APP_IMPORT_EXPORT_DSL,
resource_type=RBACResourceScope.APP,
resource_id=_OVERWRITE_APP_ID,
)
setex.assert_not_called()
def test_confirm_import_rechecks_overwrite_rbac_before_database_access(
monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_persist_overwrite_target(sqlite_session)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", Mock(return_value=_PENDING_DATA_JSON))
redis_delete = Mock()
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", redis_delete)
create_or_update = Mock()
service = AppDslService(sqlite_session)
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
def deny_before_transaction(*_args: object, **_kwargs: object) -> bool:
assert not sqlite_session.in_transaction()
return False
check = Mock(side_effect=deny_before_transaction)
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", check)
with pytest.raises(NoPermissionError, match="permission to overwrite"):
service.confirm_import(
import_id="import-1",
account=Mock(id=_CALLER_ID, current_tenant_id=_TENANT_ID),
)
check.assert_called_once_with(
_TENANT_ID,
_CALLER_ID,
scene=RBACPermission.APP_IMPORT_EXPORT_DSL,
resource_type=RBACResourceScope.APP,
resource_id=_OVERWRITE_APP_ID,
)
create_or_update.assert_not_called()
redis_delete.assert_not_called()
def test_confirm_import_does_not_create_when_overwrite_target_disappeared(
monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
monkeypatch.setattr("services.app_dsl_service.redis_client.get", Mock(return_value=_PENDING_DATA_JSON))
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", Mock(return_value=True))
redis_delete = Mock()
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", redis_delete)
service = AppDslService(sqlite_session)
create_or_update = Mock()
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
result = service.confirm_import(
import_id="import-1",
account=Mock(id=_CALLER_ID, current_tenant_id=_TENANT_ID),
)
assert result.status == ImportStatus.FAILED
assert result.error == "App not found"
create_or_update.assert_not_called()
redis_delete.assert_not_called()
def test_pending_import_is_scoped_to_its_owner(monkeypatch: pytest.MonkeyPatch, unbound_session: Session) -> None:
pending_imports: dict[str, str] = {}
monkeypatch.setattr(
"services.app_dsl_service.redis_client.setex",
lambda key, _expiry, value: pending_imports.__setitem__(key, value),
)
service = AppDslService(session=unbound_session)
creator = _account()
pending = service.import_app(
account=creator,
import_mode="yaml-content",
yaml_content="version: 99.0.0\nkind: app\napp: {name: Test, mode: workflow}\n",
)
redis_key = f"app_import_info:{pending.id}"
assert pending.status == ImportStatus.PENDING
assert redis_key in pending_imports
pending_data = PendingData.model_validate_json(pending_imports[redis_key])
assert pending_data.tenant_id == "tenant-1"
assert pending_data.account_id == "account-1"
monkeypatch.setattr("services.app_dsl_service.redis_client.get", pending_imports.get)
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", pending_imports.pop)
create_or_update = Mock(return_value=_app(app_id="app-1", mode=AppMode.WORKFLOW))
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
load = Mock(wraps=yaml.safe_load)
monkeypatch.setattr("services.app_dsl_service.yaml.safe_load", load)
pending_imports[redis_key] = pending_data.model_dump_json(exclude={"tenant_id", "account_id"})
assert service.confirm_import(import_id=pending.id, account=creator).status == ImportStatus.FAILED
load.assert_not_called()
create_or_update.assert_not_called()
assert redis_key in pending_imports
pending_imports[redis_key] = pending_data.model_dump_json()
for other_account in (
_account(tenant_id="tenant-2"),
_account(account_id="account-2"),
):
assert service.confirm_import(import_id=pending.id, account=other_account).status == ImportStatus.FAILED
assert service.confirm_import(import_id=pending.id, account=creator).status == ImportStatus.COMPLETED
assert redis_key not in pending_imports
@pytest.mark.parametrize("edition", [DeploymentEdition.COMMUNITY, DeploymentEdition.CLOUD])
def test_pending_import_requires_current_tenant(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session, edition: DeploymentEdition
) -> None:
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=edition)
setex = Mock()
monkeypatch.setattr("services.app_dsl_service.redis_client.setex", setex)
account = _account()
account._current_tenant = None
result = AppDslService(session=unbound_session).import_app(
account=account,
import_mode="yaml-content",
yaml_content="version: 99.0.0\nkind: app\napp: {name: Test, mode: workflow}\n",
)
assert result.status == ImportStatus.FAILED
assert result.error == "Current tenant is not set"
setex.assert_not_called()
@pytest.mark.parametrize(
("caller_tenant_id", "caller_account_id", "expected"),
[
("tenant-1", "account-1", True),
(None, "account-1", False),
("tenant-2", "account-1", False),
("tenant-1", "account-2", False),
],
)
def test_pending_import_owner_access(
caller_tenant_id: str | None,
caller_account_id: str,
expected: bool,
) -> None:
pending = PendingData(
tenant_id="tenant-1",
account_id="account-1",
import_mode="yaml-content",
yaml_content="",
)
assert pending.is_accessible_by(tenant_id=caller_tenant_id, account_id=caller_account_id) is expected
@pytest.mark.parametrize(
"payload",
[
'{"import_mode":"yaml-content","yaml_content":"secret-token-123"}',
'{"tenant_id":"tenant-1","import_mode":"yaml-content","yaml_content":"secret-token-123"}',
'{"account_id":"account-1","import_mode":"yaml-content","yaml_content":"secret-token-123"}',
],
)
def test_pending_import_owner_is_required(payload: str) -> None:
with pytest.raises(
ValueError,
match=(
"(?:1 validation error for PendingData\\\naccount_id|1 validation "
"error for PendingData\\\ntenant_id|2 validation errors for "
"PendingData\\\ntenant_id)"
),
) as exc_info:
PendingData.model_validate_json(payload)
assert "secret-token-123" not in str(exc_info.value)
def test_create_or_update_app_loads_existing_model_config_with_service_session(
sqlite_session_factory: sessionmaker[Session],
) -> None:
with sqlite_session_factory() as arrange_session:
app_model_config = AppModelConfig(
app_id="11111111-1111-1111-1111-111111111111",
created_by="22222222-2222-2222-2222-222222222222",
updated_by="22222222-2222-2222-2222-222222222222",
)
arrange_session.add(app_model_config)
arrange_session.commit()
app_model_config_id = app_model_config.id
app = _app(app_model_config_id=app_model_config_id)
with sqlite_session_factory() as service_session:
result = AppDslService(session=service_session)._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.CHAT}, "model_config": {"model": {}}},
account=_account(),
)
assert result is app
assert app.app_model_config_id == app_model_config_id
configs = list(service_session.scalars(select(AppModelConfig)))
assert [config.id for config in configs] == [app_model_config_id]
def test_create_or_update_app_silently_discards_invalid_image_icon(sqlite_session: Session) -> None:
app = _app(tenant_id=_TENANT_ID)
service = AppDslService(session=sqlite_session)
result = service._create_or_update_app(
app=app,
data={
"app": {
"mode": AppMode.CHAT.value,
"icon_type": IconType.IMAGE.value,
"icon": "55555555-5555-4555-8555-555555555555",
},
"model_config": {"model": {}},
},
account=_account(tenant_id=_TENANT_ID),
)
assert result.icon_type == IconType.EMOJI
assert result.icon == "🤖"
assert service._warnings == []
@pytest.mark.parametrize("allow_premium_site_settings", [False, True])
def test_create_or_update_app_applies_site_settings_without_changing_access(
sqlite_session: Session, allow_premium_site_settings: bool
) -> None:
app = _app(tenant_id=_TENANT_ID)
site = Site(
app_id=app.id,
title="Original Site",
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.NOT_ALLOW,
code="destination-code",
copyright="Existing copyright",
input_placeholder="Existing placeholder",
)
sqlite_session.add_all([app, site])
sqlite_session.flush()
service = AppDslService(session=sqlite_session)
service._create_or_update_app(
app=app,
data={
"app": {"mode": AppMode.CHAT.value, "icon_type": "emoji", "icon": "robot"},
"site": {
"title": "Imported Site",
"icon_type": "image",
"icon": "55555555-5555-4555-8555-555555555555",
"use_icon_as_answer_icon": True,
"copyright": "Imported copyright",
"input_placeholder": "Imported placeholder",
},
"model_config": {"model": {}},
},
account=_account(tenant_id=_TENANT_ID),
allow_premium_site_settings=allow_premium_site_settings,
)
assert site.title == "Imported Site"
assert site.use_icon_as_answer_icon is True
assert site.icon_type == app.icon_type
assert site.icon == app.icon
assert service._warnings == []
assert site.code == "destination-code"
assert site.customize_token_strategy == CustomizeTokenStrategy.NOT_ALLOW
assert site.copyright == ("Imported copyright" if allow_premium_site_settings else "Existing copyright")
assert site.input_placeholder == ("Imported placeholder" if allow_premium_site_settings else "Existing placeholder")
def test_create_or_update_app_rejects_null_required_site_setting_before_mutation(unbound_session: Session) -> None:
app = _app()
with pytest.raises(ValueError, match="Required Site settings cannot be null"):
AppDslService(unbound_session)._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.CHAT.value}, "site": {"title": None}},
account=_account(),
)
assert app.name == "Existing app"
def test_import_app_resolves_site_entitlement_before_database_writes(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
service = AppDslService(unbound_session)
create_or_update = Mock(return_value=_app())
entitlement = Mock(return_value=False)
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
monkeypatch.setattr("services.app_dsl_service.FeatureService.can_import_premium_site_settings", entitlement)
monkeypatch.setattr("services.app_dsl_service.WorkflowDraftVariableService", Mock())
result = service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{
"version": CURRENT_APP_DSL_VERSION,
"kind": "app",
"app": {"name": "Imported", "mode": "chat"},
"site": {"copyright": "Source copyright"},
}
),
)
assert result.status == ImportStatus.COMPLETED
entitlement.assert_called_once_with("tenant-1")
assert create_or_update.call_args.kwargs["allow_premium_site_settings"] is False
entitlement.reset_mock()
result = service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{"version": CURRENT_APP_DSL_VERSION, "kind": "app", "app": {"name": "Legacy", "mode": "chat"}}
),
)
assert result.status == ImportStatus.COMPLETED
entitlement.assert_not_called()
def test_confirm_import_rechecks_site_entitlement(monkeypatch: pytest.MonkeyPatch, unbound_session: Session) -> None:
pending = PendingData(
tenant_id="tenant-1",
account_id="account-1",
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{
"version": CURRENT_APP_DSL_VERSION,
"kind": "app",
"app": {"name": "Imported", "mode": "chat"},
"site": {"input_placeholder": "Source placeholder"},
}
),
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", Mock(return_value=pending.model_dump_json()))
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", Mock())
entitlement = Mock(return_value=False)
monkeypatch.setattr("services.app_dsl_service.FeatureService.can_import_premium_site_settings", entitlement)
service = AppDslService(unbound_session)
create_or_update = Mock(return_value=_app())
monkeypatch.setattr(service, "_create_or_update_app", create_or_update)
result = service.confirm_import(import_id="pending-import", account=_account())
assert result.status == ImportStatus.COMPLETED
entitlement.assert_called_once_with("tenant-1")
assert create_or_update.call_args.kwargs["allow_premium_site_settings"] is False
@pytest.mark.parametrize(
("title", "language", "expected_language"),
[("Exported Site", "en-US", "en-US"), ("", "en", "en-US")],
)
def test_load_export_data_includes_site_presentation_settings(
sqlite_session: Session,
monkeypatch: pytest.MonkeyPatch,
title: str,
language: str,
expected_language: str,
) -> None:
app = _app()
site = Site(
app_id=app.id,
title=title,
default_language=language,
customize_token_strategy=CustomizeTokenStrategy.NOT_ALLOW,
icon_type=IconType.EMOJI,
icon="🌱",
use_icon_as_answer_icon=True,
code="private-code",
)
sqlite_session.add_all([app, site])
sqlite_session.flush()
monkeypatch.setattr(AppDslService, "_append_model_config_export_data", Mock(return_value=[]))
data = AppDslService.load_export_data(app, session=sqlite_session).data
assert data["site"]["title"] == title
assert data["site"]["default_language"] == expected_language
assert SiteDsl.model_validate(data["site"]).title == title
assert data["site"]["icon"] == "🌱"
assert data["site"]["use_icon_as_answer_icon"] is True
assert (
not {
"id",
"app_id",
"code",
"customize_domain",
"customize_token_strategy",
"prompt_public",
"status",
}
& data["site"].keys()
)
def test_site_dsl_import_rejects_unsupported_language() -> None:
with pytest.raises(ValidationError, match="en is not a valid language"):
SiteDsl.model_validate({"default_language": "en"})
def test_create_or_update_app_flushes_new_model_config_before_signal(
monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
events: list[str] = []
def record_flush(_session: Session, _flush_context: object) -> None:
events.append("flush")
def record_signal(*_args: object, **_kwargs: object) -> None:
events.append("signal")
event.listen(sqlite_session, "after_flush", record_flush)
signal = Mock()
signal.send.side_effect = record_signal
monkeypatch.setattr("services.app_dsl_service.app_model_config_was_updated", signal)
app = _app()
try:
AppDslService(session=sqlite_session)._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.CHAT}, "model_config": {"model": {}}},
account=_account(account_id="22222222-2222-2222-2222-222222222222"),
)
finally:
event.remove(sqlite_session, "after_flush", record_flush)
assert events == ["flush", "signal"]
assert signal.send.call_args.kwargs["session"] is sqlite_session
assert app.app_model_config_id is not None
assert sqlite_session.get(AppModelConfig, app.app_model_config_id) is not None
assert sqlite_session.in_transaction()
@pytest.mark.parametrize(
("feature", "field", "value"),
[
("suggested_questions_after_answer", "prompt", None),
("suggested_questions_after_answer", "prompt", 123),
("text_to_speech", "voice", None),
("text_to_speech", "language", 123),
("text_to_speech", "autoPlay", "auto"),
],
)
def test_chat_dsl_import_rejects_invalid_feature_fields(
sqlite_session: Session, feature: str, field: str, value: object
) -> None:
app = _app()
with pytest.raises(ValueError, match=field):
AppDslService(session=sqlite_session)._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.CHAT}, "model_config": {feature: {"enabled": True, field: value}}},
account=_account(),
)
assert app.app_model_config_id is None
assert list(sqlite_session.scalars(select(AppModelConfig))) == []
def test_chat_dsl_import_preserves_valid_feature_fields(sqlite_session: Session) -> None:
app = _app()
model_config = {
"suggested_questions_after_answer": {"enabled": True, "prompt": "Follow up"},
"text_to_speech": {"enabled": True, "voice": "alloy", "language": "en", "autoPlay": "disabled"},
}
AppDslService(session=sqlite_session)._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.CHAT}, "model_config": model_config},
account=_account(),
)
assert app.app_model_config_id is not None
persisted = sqlite_session.get(AppModelConfig, app.app_model_config_id)
assert persisted is not None
assert persisted.suggested_questions_after_answer_dict == model_config["suggested_questions_after_answer"]
assert persisted.text_to_speech_dict == model_config["text_to_speech"]
def test_create_or_update_app_removes_imported_workflow_viewport(monkeypatch: pytest.MonkeyPatch) -> None:
session = cast(Session, SimpleNamespace(add=Mock(), flush=Mock(), get=Mock()))
service = AppDslService(session=session)
app = SimpleNamespace(
id="app-1",
tenant_id="tenant-1",
name="Workflow",
description="",
icon_type=IconType.EMOJI,
icon="robot",
icon_background="#FFFFFF",
)
workflow_service = SimpleNamespace(
get_draft_workflow=Mock(return_value=None),
sync_draft_workflow=Mock(return_value=SimpleNamespace(id="workflow-1")),
)
monkeypatch.setattr("services.app_dsl_service.WorkflowService", Mock(return_value=workflow_service))
imported_graph: dict[str, object] = {
"nodes": [],
"edges": [],
"viewport": {"x": 100, "y": 200, "zoom": 1.5},
}
service._create_or_update_app(
app=cast(App, app),
data={
"app": {"mode": AppMode.WORKFLOW.value},
"workflow": {"graph": imported_graph},
},
account=Mock(id="account-1"),
)
assert workflow_service.sync_draft_workflow.call_args.kwargs["graph"] == {
"nodes": [],
"edges": [],
}
assert imported_graph["viewport"] == {"x": 100, "y": 200, "zoom": 1.5}
def test_create_or_update_app_forwards_imported_agent_purge_ids(monkeypatch: pytest.MonkeyPatch) -> None:
session = cast(Session, SimpleNamespace(add=Mock(), flush=Mock(), commit=Mock(), get=Mock()))
service = AppDslService(session=session)
app = SimpleNamespace(
id="app-1",
tenant_id="tenant-1",
name="Workflow",
description="",
icon_type=IconType.EMOJI,
icon="robot",
icon_background="#FFFFFF",
)
workflow = SimpleNamespace(id="workflow-1")
workflow_service = SimpleNamespace(
get_draft_workflow=Mock(return_value=None),
sync_draft_workflow=Mock(return_value=workflow),
)
monkeypatch.setattr("services.app_dsl_service.WorkflowService", Mock(return_value=workflow_service))
monkeypatch.setattr(
"services.app_dsl_service.AgentDslService.graph_without_package_bindings",
Mock(return_value={"nodes": [], "edges": []}),
)
monkeypatch.setattr(
"services.app_dsl_service.AgentDslService.import_workflow_packages",
Mock(return_value=(workflow, [], {"retired-agent"})),
)
monkeypatch.setattr(
"services.app_dsl_service.WorkflowAgentPublishService.validate_agent_nodes_for_draft_sync",
Mock(),
)
retire_unowned = Mock()
monkeypatch.setattr(
"services.app_dsl_service.WorkflowAgentRetirementService.retire_unowned",
retire_unowned,
)
service._create_or_update_app(
app=cast(App, app),
data={
"app": {"mode": AppMode.WORKFLOW.value},
"workflow": {"graph": {"nodes": [], "edges": []}},
"agent_packages": {"package-1": {}},
},
account=Mock(id="account-1"),
)
retire_unowned.assert_called_once_with(
tenant_id="tenant-1",
agent_ids={"retired-agent"},
account_id="account-1",
)
def test_export_dsl_loads_model_config_and_annotation_reply_with_request_session(
monkeypatch: pytest.MonkeyPatch,
sqlite_session_factory: sessionmaker[Session],
) -> None:
model_config = cast(AppModelConfigDict, {"model": {}, "agent_mode": {"tools": []}})
with sqlite_session_factory() as arrange_session:
app_model_config = AppModelConfig(
app_id="11111111-1111-1111-1111-111111111111",
created_by="22222222-2222-2222-2222-222222222222",
updated_by="22222222-2222-2222-2222-222222222222",
).from_model_config_dict(model_config)
arrange_session.add(app_model_config)
arrange_session.commit()
app_model_config_id = app_model_config.id
app_id = app_model_config.app_id
annotation_reply = {"enabled": False}
load_annotation_reply_config = Mock(return_value=annotation_reply)
monkeypatch.setattr("services.app_dsl_service.load_annotation_reply_config", load_annotation_reply_config)
monkeypatch.setattr(
"services.app_dsl_service.DependenciesAnalysisService.generate_dependencies",
Mock(return_value=[]),
)
app = _app(app_model_config_id=app_model_config_id)
with sqlite_session_factory() as service_session:
exported = AppDslService.export_dsl(app, session=service_session)
export_data = yaml.safe_load(exported)
assert export_data["model_config"]["model"] == {}
assert export_data["model_config"]["annotation_reply"] == annotation_reply
load_annotation_reply_config.assert_called_once_with(service_session, app_id)
def test_agent_import_of_new_agent_checks_function_scope(
monkeypatch: pytest.MonkeyPatch,
unbound_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(RBAC_ENABLED=True)
check = Mock(return_value=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", check)
account = _account()
AppDslService(session=unbound_session)._ensure_agent_import_permission(account, app=None)
check.assert_called_once_with(
account.current_tenant_id,
account.id,
scene=RBACPermission.AGENT_IMPORT_EXPORT_DSL,
resource_type=None,
resource_id=None,
)
def test_create_or_update_app_gates_agent_mode_before_creation(
monkeypatch: pytest.MonkeyPatch,
unbound_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", Mock(return_value=False))
service = AppDslService(session=unbound_session)
with pytest.raises(NoPermissionError):
service._create_or_update_app(
app=None,
data={"app": {"mode": "agent", "name": "Gated agent"}},
account=_account(),
)
assert not unbound_session.in_transaction()
def test_import_app_reraises_permission_denial_instead_of_failed_result(
monkeypatch: pytest.MonkeyPatch,
unbound_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr("services.app_dsl_service.RBACService.CheckAccess.check", Mock(return_value=False))
service = AppDslService(session=unbound_session)
with pytest.raises(NoPermissionError):
service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content="app:\n mode: agent\n name: Denied agent\n",
)
assert not unbound_session.in_transaction()
def test_append_workflow_export_data_reports_missing_selected_workflow(
sqlite_session: Session,
) -> None:
workflow_id = "11111111-1111-4111-8111-111111111111"
app = _app(app_id="app-1", tenant_id="tenant-1")
with pytest.raises(WorkflowNotFoundError, match=f"Workflow version not found. Workflow ID: {workflow_id}"):
AppDslService._append_workflow_export_data(
export_data={},
app_model=app,
include_secret=False,
session=sqlite_session,
workflow_id=workflow_id,
)
@pytest.mark.parametrize(
"mode",
[AppMode.AGENT, AppMode.WORKFLOW, AppMode.ADVANCED_CHAT, AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION],
)
def test_export_dsl_preserves_envelope_and_mode_specific_content(
mode: AppMode, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
app = _app(mode=mode)
package = AgentPackage.model_validate({"metadata": {"name": app.name}, "soul": {}})
monkeypatch.setattr(
"services.app_dsl_service.AgentDslService.export_agent_app",
Mock(return_value=("agent_1", {"agent_1": package})),
)
monkeypatch.setattr(
"services.app_dsl_service.DependenciesAnalysisService.generate_dependencies", Mock(return_value=[])
)
def append_workflow(*, export_data: dict[str, object], **_kwargs: object) -> list[str]:
export_data["workflow"] = {"fixture": "workflow"}
return []
def append_model(export_data: dict[str, object], *_args: object, **_kwargs: object) -> list[str]:
export_data["model_config"] = {"fixture": "model"}
return []
monkeypatch.setattr(AppDslService, "_append_workflow_export_data", Mock(side_effect=append_workflow))
monkeypatch.setattr(AppDslService, "_append_model_config_export_data", Mock(side_effect=append_model))
monkeypatch.setattr(App, "site_with_session", Mock(return_value=None))
data = yaml.safe_load(AppDslService.export_dsl(app, session=unbound_session))
assert data["version"] == CURRENT_APP_DSL_VERSION
assert data["kind"] == "app"
assert data["app"] == {
"name": "Existing app",
"description": "",
"mode": mode.value,
"icon_type": "emoji",
"icon": "robot",
"icon_background": "#FFFFFF",
"use_icon_as_answer_icon": False,
}
if mode == AppMode.AGENT:
assert data["agent"] == {"package_ref": "agent_1"}
assert AgentPackage.model_validate(data["agent_packages"]["agent_1"]) == package
assert data["dependencies"] == []
assert "workflow" not in data
assert "model_config" not in data
elif mode in {AppMode.WORKFLOW, AppMode.ADVANCED_CHAT}:
assert data["workflow"] == {"fixture": "workflow"}
assert "agent" not in data
assert "model_config" not in data
else:
assert data["model_config"] == {"fixture": "model"}
assert "agent" not in data
assert "workflow" not in data
@pytest.mark.parametrize(
("mode", "node_type"),
[
(AppMode.WORKFLOW, "answer"),
(AppMode.ADVANCED_CHAT, "end"),
(AppMode.ADVANCED_CHAT, "trigger-webhook"),
(AppMode.ADVANCED_CHAT, "trigger-schedule"),
(AppMode.ADVANCED_CHAT, "trigger-plugin"),
],
)
def test_overwrite_rejects_incompatible_nodes_before_mutation(
monkeypatch: pytest.MonkeyPatch, sqlite_session: Session, mode: AppMode, node_type: str
) -> None:
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
target = _app(tenant_id="tenant-1", mode=mode)
target.name = "Original"
sqlite_session.add(target)
sqlite_session.commit()
service = AppDslService(sqlite_session)
result = service.import_app(
account=_account(),
import_mode="yaml-content",
app_id=target.id,
yaml_content=yaml.safe_dump(
{
"version": CURRENT_APP_DSL_VERSION,
"kind": "app",
"app": {"mode": mode.value, "name": "Changed"},
"workflow": {"graph": {"nodes": [{"data": {"type": node_type}}]}},
}
),
)
assert result.status == ImportStatus.FAILED
assert result.error is not None
assert "incompatible" in result.error
sqlite_session.refresh(target)
assert target.name == "Original"
assert not sqlite_session.new
assert not sqlite_session.deleted
@pytest.mark.parametrize(
("content", "found"),
[
({"meta": {}, "nodes": [], "edges": []}, "meta, nodes, edges"),
({"app": None}, "none"),
({"x" * 81: {}}, "x" * 80 + "…"),
],
ids=["original-keys", "empty-app", "bounded-key-list"],
)
def test_missing_app_section_names_the_keys_that_were_present(
unbound_session: Session, content: dict[str, object], found: str
) -> None:
result = AppDslService(session=unbound_session).import_app(
account=_account(), import_mode="yaml-content", yaml_content=yaml.safe_dump(content, sort_keys=False)
)
assert result.status == ImportStatus.FAILED
assert result.error is not None
assert result.error.startswith("Missing app data in YAML content.")
assert result.error.endswith(f"(found: {found}).")
assert not unbound_session.in_transaction()
@dataclass
class _DraftWorkflowService:
draft: Workflow | None
lookups: list[str] = field(default_factory=list)
synced_hashes: list[str | None] = field(default_factory=list)
def _draft_of(self, app_model: App) -> Workflow | None:
return self.draft if self.draft is not None and self.draft.app_id == app_model.id else None
def get_draft_workflow(self, app_model: App, **_: object) -> Workflow | None:
self.lookups.append("read")
return self._draft_of(app_model)
def get_draft_workflow_for_update(self, app_model: App, **_: object) -> Workflow | None:
self.lookups.append("locked")
return self._draft_of(app_model)
def sync_draft_workflow(self, *, graph: dict[str, object], unique_hash: str | None, **_: object) -> Workflow:
self.synced_hashes.append(unique_hash)
return _workflow(graph=graph)
def _workflow_draft(app: App) -> Workflow:
return make_workflow(tenant_id=app.tenant_id, app_id=app.id, graph={"nodes": [], "edges": []})
def _guarded_overwrite(
monkeypatch: pytest.MonkeyPatch, session: Session, *, draft: Workflow | None
) -> tuple[AppDslService, _DraftWorkflowService, Callable[[str], App]]:
service = AppDslService(session=session)
workflow_service = _DraftWorkflowService(draft=draft)
monkeypatch.setattr("services.app_dsl_service.WorkflowService", lambda: workflow_service)
app = _app(mode=AppMode.WORKFLOW)
def overwrite(draft_hash: str) -> App:
return service._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.WORKFLOW.value}, "workflow": {"graph": {"nodes": [], "edges": []}}},
account=_account(),
draft_hash=draft_hash,
)
return service, workflow_service, overwrite
def test_guarded_overwrite_saves_against_the_locked_draft_it_matched(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
draft = _workflow_draft(_app(mode=AppMode.WORKFLOW))
_, workflow_service, overwrite = _guarded_overwrite(monkeypatch, unbound_session, draft=draft)
overwrite(draft_token(draft))
assert workflow_service.lookups == ["locked"]
assert workflow_service.synced_hashes == [draft.unique_hash]
@pytest.mark.parametrize("draft_exists", [True, False], ids=["draft-changed", "draft-gone"])
def test_guarded_overwrite_refuses_a_draft_that_no_longer_matches(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session, draft_exists: bool
) -> None:
draft = _workflow_draft(_app(mode=AppMode.WORKFLOW)) if draft_exists else None
_, workflow_service, overwrite = _guarded_overwrite(monkeypatch, unbound_session, draft=draft)
with pytest.raises(DraftChangedError):
overwrite("exported")
assert workflow_service.synced_hashes == []
def test_refused_overwrite_leaves_the_app_and_cached_dependencies_alone(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
app = _app(mode=AppMode.WORKFLOW)
service, workflow_service, _ = _guarded_overwrite(monkeypatch, unbound_session, draft=_workflow_draft(app))
cached: list[str] = []
monkeypatch.setattr("services.app_dsl_service.redis_client.setex", lambda key, _expiry, _value: cached.append(key))
dependency = PluginDependency(
type=PluginDependencyType.Package,
value=PluginDependency.Package(plugin_unique_identifier="langgenius/openai:1.0.0@abc"),
)
with pytest.raises(DraftChangedError):
service._create_or_update_app(
app=app,
data={"app": {"mode": AppMode.WORKFLOW.value, "name": "After"}, "workflow": {"graph": {}}},
account=_account(),
dependencies=[dependency],
draft_hash="exported",
)
assert cached == []
assert app.name == "Existing app"
assert workflow_service.synced_hashes == []
def _refuse_changed_draft(forwarded: list[str | None]) -> Callable[..., App]:
def create_or_update_app(*, draft_hash: str | None = None, **_: object) -> App:
forwarded.append(draft_hash)
raise DraftChangedError()
return create_or_update_app
def test_import_app_reraises_a_changed_draft_and_keeps_the_hash_for_the_confirm(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
pending_imports: dict[str, str] = {}
monkeypatch.setattr(
"services.app_dsl_service.redis_client.setex",
lambda key, _expiry, value: pending_imports.__setitem__(key, value),
)
service = AppDslService(session=unbound_session)
forwarded: list[str | None] = []
monkeypatch.setattr(service, "_create_or_update_app", _refuse_changed_draft(forwarded))
with pytest.raises(DraftChangedError):
service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{"version": CURRENT_APP_DSL_VERSION, "kind": "app", "app": {"name": "Imported", "mode": "chat"}}
),
draft_hash="exported",
)
assert forwarded == ["exported"]
pending = service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content="version: 99.0.0\nkind: app\napp: {name: Test, mode: workflow}\n",
draft_hash="exported",
)
assert pending.status == ImportStatus.PENDING
stored = PendingData.model_validate_json(pending_imports[f"app_import_info:{pending.id}"])
assert stored.draft_hash == "exported"
def test_confirm_import_checks_the_pending_draft_hash(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
pending = PendingData(
tenant_id="tenant-1",
account_id="account-1",
import_mode="yaml-content",
yaml_content=yaml.safe_dump(
{"version": CURRENT_APP_DSL_VERSION, "kind": "app", "app": {"name": "Imported", "mode": "chat"}}
),
draft_hash="exported",
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _key: pending.model_dump_json())
deleted: list[str] = []
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", deleted.append)
service = AppDslService(unbound_session)
forwarded: list[str | None] = []
monkeypatch.setattr(service, "_create_or_update_app", _refuse_changed_draft(forwarded))
with pytest.raises(DraftChangedError):
service.confirm_import(import_id="pending-import", account=_account())
assert forwarded == ["exported"]
assert deleted == []
def test_pending_data_without_a_draft_hash_still_reads() -> None:
older = PendingData.model_validate_json(_PENDING_DATA_JSON).model_dump_json(exclude={"draft_hash"})
assert PendingData.model_validate_json(older).draft_hash is None
@pytest.mark.parametrize("confirmed", [False, True])
@pytest.mark.parametrize("overwrite", [False, True])
def test_import_creation_marker_tracks_persisted_app(
sqlite_session: Session, monkeypatch: pytest.MonkeyPatch, confirmed: bool, overwrite: bool
) -> None:
account = _account(account_id=_CALLER_ID, tenant_id=_TENANT_ID)
_persist_overwrite_target(sqlite_session) if overwrite else None
data = yaml.safe_dump(
{
"version": CURRENT_APP_DSL_VERSION,
"kind": "app",
"app": {"name": "Imported", "mode": "workflow"},
"workflow": {"graph": {"nodes": [], "edges": []}, "features": {}},
}
)
monkeypatch.setattr("services.app_dsl_service.WorkflowService", Mock())
service = AppDslService(sqlite_session)
if confirmed:
pending = PendingData(
tenant_id=_TENANT_ID,
account_id=_CALLER_ID,
import_mode="yaml-content",
yaml_content=data,
app_id=_OVERWRITE_APP_ID if overwrite else None,
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _: pending.model_dump_json())
result = service.confirm_import(import_id="pending", account=account)
else:
result = service.import_app(
account=account,
import_mode="yaml-content",
yaml_content=data,
app_id=_OVERWRITE_APP_ID if overwrite else None,
)
assert result.status == ImportStatus.COMPLETED, result.error
assert result.app_created is (not overwrite)
assert sqlite_session.get(App, result.app_id) is not None
assert "app_created" not in result.model_dump()
assert "app_created" not in result.model_json_schema(mode="serialization")["properties"]
@pytest.mark.parametrize("mode", list(AppMode) + [None])
def test_import_creator_access_only_initializes_ordinary_apps(
mode: AppMode | None, monkeypatch: pytest.MonkeyPatch
) -> None:
from services.app_dsl_service import initialize_imported_app_creator_access
from services.entities.dsl_entities import Import
sync = Mock()
monkeypatch.setattr("services.enterprise.rbac_service.try_sync_creator_access_policy_member_bindings", sync)
result = Import(id="import", status=ImportStatus.COMPLETED, app_id="app", app_mode=mode, app_created=True)
initialize_imported_app_creator_access(result, tenant_id="tenant", account_id="creator")
assert sync.call_count == (
1
if mode in {AppMode.CHAT, AppMode.COMPLETION, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}
else 0
)
@pytest.mark.parametrize("confirmed", [False, True])
def test_failed_import_does_not_report_creation(
sqlite_session: Session, monkeypatch: pytest.MonkeyPatch, confirmed: bool
) -> None:
data = "version: " + CURRENT_APP_DSL_VERSION + "\nkind: app\napp: {name: Broken, mode: chat}\n"
service = AppDslService(sqlite_session)
if confirmed:
pending = PendingData(
tenant_id="tenant-1", account_id="account-1", import_mode="yaml-content", yaml_content=data
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _: pending.model_dump_json())
result = service.confirm_import(import_id="pending", account=_account())
else:
result = service.import_app(account=_account(), import_mode="yaml-content", yaml_content=data)
assert result.status == ImportStatus.FAILED
assert not result.app_created
def test_pending_import_does_not_report_creation_or_cache_marker(
unbound_session: Session, monkeypatch: pytest.MonkeyPatch
) -> None:
cache = Mock()
monkeypatch.setattr("services.app_dsl_service.redis_client.setex", cache)
result = AppDslService(unbound_session).import_app(
account=_account(), import_mode="yaml-content", yaml_content=_PENDING_WORKFLOW_DSL
)
assert result.status == ImportStatus.PENDING
assert not result.app_created
assert "app_created" not in cache.call_args.args[2]
@pytest.mark.parametrize("overwrite", [False, True])
def test_confirmed_import_reports_creation_only_for_new_apps(
unbound_session: Session, monkeypatch: pytest.MonkeyPatch, overwrite: bool
) -> None:
pending_imports: dict[str, str] = {}
monkeypatch.setattr(
"services.app_dsl_service.redis_client.setex",
lambda key, _expiry, value: pending_imports.__setitem__(key, value),
)
monkeypatch.setattr("services.app_dsl_service.redis_client.get", pending_imports.get)
monkeypatch.setattr("services.app_dsl_service.redis_client.delete", pending_imports.pop)
existing = _app(mode=AppMode.WORKFLOW)
service = AppDslService(unbound_session)
monkeypatch.setattr(service, "_load_app_for_overwrite", lambda _account, _app_id: existing)
monkeypatch.setattr(service, "_validate_workflow_overwrite", lambda _app, _data: None)
monkeypatch.setattr(service, "_create_or_update_app", lambda *, app, **_kwargs: app or _app(app_id=str(uuid4())))
pending = service.import_app(
account=_account(),
import_mode="yaml-content",
yaml_content=_PENDING_WORKFLOW_DSL,
app_id=existing.id if overwrite else None,
)
assert pending.status == ImportStatus.PENDING
result = service.confirm_import(import_id=pending.id, account=_account())
assert result.status == ImportStatus.COMPLETED
assert result.app_created is not overwrite
assert (result.app_id == existing.id) is overwrite