Skip to content

armgit / dify

Public Imported from GitHub
0

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.

59.9 KB
Raw Blame
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