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.

46.9 KB
Raw Blame
from __future__ import annotations

import json
from collections.abc import Callable
from copy import deepcopy
from datetime import datetime
from types import SimpleNamespace
from typing import NoReturn
from unittest.mock import MagicMock, patch
from uuid import uuid4

import pytest
from sqlalchemy import event, select
from sqlalchemy.orm import Session, sessionmaker

from constants.model_template import default_app_templates
from core.errors.error import ProviderTokenNotInitError
from enums import DeploymentEdition
from graphon.model_runtime.entities.model_entities import ModelType
from models import Account, Tenant
from models.account import TenantAccountJoin, TenantAccountRole
from models.agent import (
    Agent,
    AgentConfigSnapshot,
    AgentIconType,
    AgentScope,
    AgentSource,
    AgentStatus,
    WorkflowAgentBindingType,
    WorkflowAgentNodeBinding,
)
from models.agent_config_entities import AgentSoulConfig
from models.model import App, AppMode, AppModelConfig, IconType
from models.provider import TenantDefaultModel
from models.workflow import Workflow, WorkflowType
from repositories.app.console_repository import ConsoleAppRepository
from services.agent.errors import AgentAccessNotReadyError, AgentNameConflictError
from services.app_service import AppListParams, AppResponseView, AppService, CreateAppParams
from services.rbac import contracts as rbac_contracts


def _persist_account(session: Session) -> Account:
    tenant = Tenant(name="App Service Workspace")
    account = Account(name="Test Account", email=f"app-service-{uuid4()}@example.com")
    membership = TenantAccountJoin(
        tenant_id=tenant.id,
        account_id=account.id,
        current=True,
        role=TenantAccountRole.OWNER,
    )
    account._current_tenant = tenant
    session.add_all([tenant, account, membership])
    session.commit()
    return account


def _account_identity(account_id: str) -> Account:
    account = Account(name="Current User", email=f"{account_id}@example.com")
    account.id = account_id
    return account


def _persist_app(session: Session, *, tenant_id: str, name: str = "Visible App") -> App:
    app = App(
        id=str(uuid4()),
        tenant_id=tenant_id,
        name=name,
        mode=AppMode.CHAT,
        icon_type=IconType.EMOJI,
        icon="chat",
        icon_background="#FFFFFF",
        enable_site=False,
        enable_api=False,
    )
    session.add(app)
    session.commit()
    return app


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_get_app_in_workspace_enforces_ownership(sqlite_session: Session) -> None:
    tenant_id = str(uuid4())
    app = _persist_app(sqlite_session, tenant_id=tenant_id)

    assert AppService.get_app_in_workspace(tenant_id=tenant_id, app_id=app.id, session=sqlite_session) is app
    assert AppService.get_app_in_workspace(tenant_id=str(uuid4()), app_id=app.id, session=sqlite_session) is None
    assert AppService.get_app_in_workspace(tenant_id=tenant_id, app_id=str(uuid4()), session=sqlite_session) is None


def _persist_agent_app(
    session: Session,
    *,
    app_name: str = "Old",
    agent_name: str = "Old",
    tenant_id: str | None = None,
    creator_id: str | None = None,
    active_config_snapshot_id: str | None = None,
    active_config_is_published: bool = False,
) -> tuple[App, Agent]:
    tenant_id = tenant_id or str(uuid4())
    creator_id = creator_id or str(uuid4())
    app = App(
        id=str(uuid4()),
        tenant_id=tenant_id,
        name=app_name,
        description="old",
        mode=AppMode.AGENT,
        icon_type=IconType.EMOJI,
        icon="robot",
        icon_background="#fff",
        enable_site=False,
        enable_api=False,
        created_by=creator_id,
    )
    agent = Agent(
        tenant_id=tenant_id,
        name=agent_name,
        description="old",
        role="research assistant",
        scope=AgentScope.ROSTER,
        source=AgentSource.AGENT_APP,
        status=AgentStatus.ACTIVE,
        icon_type=AgentIconType.EMOJI,
        icon="robot",
        icon_background="#fff",
        app_id=app.id,
        active_config_snapshot_id=active_config_snapshot_id,
        active_config_is_published=active_config_is_published,
        created_by=creator_id,
    )
    session.add_all([app, agent])
    session.commit()
    return app, agent


class TestCreateAppTransactionBoundary:
    def test_agent_app_seeds_workspace_default_model_in_initial_snapshot(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        account = _persist_account(sqlite_session)
        tenant_id = account.current_tenant_id or ""
        sqlite_session.add(
            TenantDefaultModel(
                tenant_id=tenant_id,
                model_type=ModelType.LLM,
                provider_name="langgenius/openai/openai",
                model_name="gpt-4o",
            )
        )
        sqlite_session.commit()

        with (
            patch("services.app_service.app_was_created.send"),
            patch("services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"),
            patch("services.app_service.SystemFeatureService.is_webapp_auth_enabled", return_value=False),
        ):
            app = AppService().create_app(
                tenant_id,
                CreateAppParams(name="Agent with default model", mode=AppMode.AGENT.value),
                account,
                session=sqlite_session,
            )

        agent = sqlite_session.scalar(select(Agent).where(Agent.app_id == app.id))
        assert agent is not None
        snapshot = sqlite_session.get(AgentConfigSnapshot, agent.active_config_snapshot_id)
        assert snapshot is not None
        model = AgentSoulConfig.model_validate(snapshot.config_snapshot_dict).model
        assert model is not None
        assert model.plugin_id == "langgenius/openai"
        assert model.model_provider == "langgenius/openai/openai"
        assert model.model == "gpt-4o"
        assert agent.active_config_has_model is True

    def test_agent_app_without_available_default_keeps_initial_model_empty(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        account = _persist_account(sqlite_session)
        tenant_id = account.current_tenant_id or ""

        with (
            patch("services.app_service.ModelProviderService.get_default_model_selection", return_value=None),
            patch("services.app_service.app_was_created.send"),
            patch("services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"),
            patch("services.app_service.SystemFeatureService.is_webapp_auth_enabled", return_value=False),
        ):
            app = AppService().create_app(
                tenant_id,
                CreateAppParams(name="Agent without default model", mode=AppMode.AGENT.value),
                account,
                session=sqlite_session,
            )

        agent = sqlite_session.scalar(select(Agent).where(Agent.app_id == app.id))
        assert agent is not None
        snapshot = sqlite_session.get(AgentConfigSnapshot, agent.active_config_snapshot_id)
        assert snapshot is not None
        assert AgentSoulConfig.model_validate(snapshot.config_snapshot_dict).model is None
        assert agent.active_config_has_model is False

    def test_agent_app_with_invalid_default_provider_still_creates_empty_snapshot(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        account = _persist_account(sqlite_session)
        tenant_id = account.current_tenant_id or ""
        sqlite_session.add(
            TenantDefaultModel(
                tenant_id=tenant_id,
                model_type=ModelType.LLM,
                provider_name="invalid/provider",
                model_name="gpt-4o",
            )
        )
        sqlite_session.commit()

        with (
            patch("services.app_service.app_was_created.send"),
            patch("services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"),
            patch("services.app_service.SystemFeatureService.is_webapp_auth_enabled", return_value=False),
        ):
            app = AppService().create_app(
                tenant_id,
                CreateAppParams(name="Agent with invalid default", mode=AppMode.AGENT.value),
                account,
                session=sqlite_session,
            )

        agent = sqlite_session.scalar(select(Agent).where(Agent.app_id == app.id))
        assert agent is not None
        snapshot = sqlite_session.get(AgentConfigSnapshot, agent.active_config_snapshot_id)
        assert snapshot is not None
        assert AgentSoulConfig.model_validate(snapshot.config_snapshot_dict).model is None
        assert agent.active_config_has_model is False

    def test_commits_database_state_before_external_side_effects(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        account = _persist_account(sqlite_session)
        phase_events: list[str] = []
        event.listen(sqlite_session, "after_commit", lambda _session: phase_events.append("commit"))

        with (
            patch(
                "services.app_service.app_was_created.send",
                side_effect=lambda *_args, **_kwargs: phase_events.append("signal"),
            ),
            patch(
                "services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings",
                side_effect=lambda *_args: phase_events.append("external"),
            ),
            patch(
                "services.app_service.SystemFeatureService.is_webapp_auth_enabled",
                return_value=False,
            ),
        ):
            app = AppService().create_app(
                account.current_tenant_id,
                CreateAppParams(name="Workflow", mode=AppMode.WORKFLOW.value),
                account,
                session=sqlite_session,
            )

        assert phase_events == ["commit", "signal", "commit", "external"]
        assert sqlite_session.get(App, app.id) is app

    def test_duplicate_agent_name_rolls_back_and_raises_conflict(self, sqlite_session: Session) -> None:
        account = _persist_account(sqlite_session)
        tenant_id = account.current_tenant_id or ""
        existing_agent = Agent(
            tenant_id=tenant_id,
            name="Existing Agent",
            description="existing",
            role="",
            scope=AgentScope.ROSTER,
            source=AgentSource.ROSTER,
            status=AgentStatus.ACTIVE,
        )
        sqlite_session.add(existing_agent)
        sqlite_session.commit()
        rollback_events: list[str] = []
        event.listen(sqlite_session, "after_rollback", lambda _session: rollback_events.append("rollback"))

        with pytest.raises(AgentNameConflictError):
            AppService().create_app(
                tenant_id,
                CreateAppParams(name="Existing Agent", mode=AppMode.AGENT.value),
                account,
                session=sqlite_session,
            )

        assert rollback_events == ["rollback"]
        assert sqlite_session.scalars(select(App).where(App.tenant_id == tenant_id)).all() == []
        assert sqlite_session.scalars(select(AppModelConfig)).all() == []
        assert sqlite_session.get(Agent, existing_agent.id) is existing_agent

    def test_falls_back_when_default_model_schema_is_unavailable(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        account = _persist_account(sqlite_session)
        model_type_instance = MagicMock()
        model_type_instance.get_model_schema.side_effect = ValueError("Base model unknown-model not found")
        model_instance = SimpleNamespace(
            model_name="unknown-model",
            provider="langgenius/openai/openai",
            credentials={},
            model_type_instance=model_type_instance,
        )
        model_manager = MagicMock()
        model_manager.get_default_model_instance.return_value = model_instance
        model_manager.get_default_provider_model_name.return_value = ("openai", "gpt-4o")
        with (
            patch("services.app_service.ModelManager.for_tenant", return_value=model_manager),
            patch("services.app_service.app_was_created.send"),
            patch("services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"),
            patch(
                "services.app_service.SystemFeatureService.is_webapp_auth_enabled",
                return_value=False,
            ),
        ):
            app = AppService().create_app(
                account.current_tenant_id,
                CreateAppParams(name="Chat", mode=AppMode.CHAT.value),
                account,
                session=sqlite_session,
            )

        app_model_config = sqlite_session.get(AppModelConfig, app.app_model_config_id)
        assert app_model_config is not None
        assert app.mode == AppMode.CHAT
        assert app_model_config.model_dict == {
            "provider": "openai",
            "name": "gpt-4o",
            "mode": "chat",
            "completion_params": {},
        }
        model_manager.get_default_provider_model_name.assert_called_once_with(
            tenant_id=account.current_tenant_id, model_type=ModelType.LLM
        )


class TestCreateAppRBACAccessInitialization:
    """`create_app` bootstraps RBAC access per app mode: agents get the agent flavour."""

    @staticmethod
    def _create(session: Session, account: Account, mode: AppMode) -> App:
        with (
            patch("services.app_service.app_was_created.send"),
            patch(
                "services.app_service.SystemFeatureService.is_webapp_auth_enabled",
                return_value=False,
            ),
        ):
            return AppService().create_app(
                account.current_tenant_id,
                CreateAppParams(name=f"RBAC {mode.value}", mode=mode.value),
                account,
                session=session,
            )

    def test_agent_app_initializes_agent_access_and_skips_the_app_creator_sync(
        self, sqlite_session: Session, config_overrides: Callable[..., None]
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, RBAC_ENABLED=True)
        account = _persist_account(sqlite_session)

        with (
            patch(
                "services.rbac_agent_access_service.enterprise_rbac_service.RBACService.AgentAccess.replace_whitelist"
            ) as replace_whitelist,
            patch("services.rbac_agent_access_service.initialize_created_app_rbac_access_task.delay") as seed_task,
            patch(
                "services.rbac_agent_access_service.enterprise_rbac_service.RBACService.AccessPolicies"
                ".sync_creator_access_policy_member_bindings"
            ) as creator_sync,
            patch(
                "services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"
            ) as app_creator_sync,
        ):
            app = self._create(sqlite_session, account, AppMode.AGENT)

        agent = sqlite_session.scalars(select(Agent).where(Agent.app_id == app.id)).one()
        replace_whitelist.assert_called_once_with(
            account.current_tenant_id,
            account.id,
            agent.id,
            rbac_contracts.ReplaceMemberBindings(automatic_include_workspace_members=True),
        )
        seed_task.assert_called_once_with(account.current_tenant_id, account.id, agent_id=agent.id)
        creator_sync.assert_called_once_with(
            account.current_tenant_id,
            account.id,
            resource_type=rbac_contracts.RBACResourceType.AGENT,
            resource_id=agent.id,
        )
        app_creator_sync.assert_not_called()


@pytest.mark.parametrize(
    "update_status",
    [AppService.update_app_api_status],
)
def test_app_status_updates_commit_before_signal(update_status: Callable[..., App], sqlite_session: Session) -> None:
    account = _persist_account(sqlite_session)
    app = _persist_app(sqlite_session, tenant_id=account.current_tenant_id or "")
    phase_events: list[str] = []
    event.listen(sqlite_session, "after_commit", lambda _session: phase_events.append("commit"))

    with (
        patch("services.app_service.current_user", account),
        patch("services.app_service.app_was_updated.send", side_effect=lambda *_args: phase_events.append("signal")),
    ):
        update_status(AppService(), app, True, session=sqlite_session)

    assert phase_events == ["commit", "signal"]


@pytest.mark.parametrize(
    "update_status",
    [
        AppService.update_app_api_status,
    ],
)
def test_unpublished_agent_app_access_cannot_be_enabled(
    update_status: Callable[..., App], sqlite_session: Session
) -> None:
    app, _ = _persist_agent_app(sqlite_session)
    commits: list[str] = []
    event.listen(sqlite_session, "after_commit", lambda _session: commits.append("commit"))

    with pytest.raises(AgentAccessNotReadyError):
        update_status(AppService(), app, True, session=sqlite_session)

    assert app.enable_site is False
    assert app.enable_api is False
    assert commits == []


class TestAppLookup:
    """The auth pipeline's app lookup preserves status and API enablement signals."""

    def test_get_app_by_id_is_plain_session_get(self, sqlite_session: Session):
        """``get_app_by_id`` must NOT apply status / visibility filters
        — callers (e.g. the openapi auth pipeline) need to differentiate
        404 (missing) from 403 (``enable_api`` off) and would lose that
        signal if the helper coalesced both into ``None``.
        """
        sentinel_app = _persist_app(sqlite_session, tenant_id=str(uuid4()))
        sentinel_app.status = "archived"  # type: ignore[assignment]

        assert AppService.get_app_by_id(sentinel_app.id, sqlite_session) is sentinel_app

    def test_get_app_by_id_returns_none_when_missing(self, sqlite_session: Session):
        assert AppService.get_app_by_id(str(uuid4()), sqlite_session) is None


def test_get_recent_apps_uses_one_tenant_scoped_projection_query(sqlite_session: Session) -> None:
    tenant_id = str(uuid4())
    other_tenant_id = str(uuid4())
    account = Account(name="Recent Apps Author", email="[email protected]")
    sqlite_session.add(account)
    sqlite_session.flush()

    def create_app(*, name: str, tenant_id: str, updated_at: datetime, mode: AppMode = AppMode.CHAT) -> App:
        app = App(
            id=str(uuid4()),
            tenant_id=tenant_id,
            name=name,
            description="",
            mode=mode,
            icon_type=IconType.EMOJI,
            icon="🚀",
            icon_background="#FFFFFF",
            enable_site=False,
            enable_api=False,
            created_by=account.id,
            maintainer=account.id,
            use_icon_as_answer_icon=False,
        )
        app.created_at = updated_at
        app.updated_at = updated_at
        return app

    newest = create_app(name="Newest", tenant_id=tenant_id, updated_at=datetime(2026, 7, 3))
    legacy_agent = AppModelConfig(
        app_id=newest.id,
        agent_mode='{"enabled": true, "strategy": "react"}',
    )
    newest.app_model_config_id = legacy_agent.id
    second = create_app(
        name="Second",
        tenant_id=tenant_id,
        updated_at=datetime(2026, 7, 2),
        mode=AppMode.WORKFLOW,
    )
    second.icon_type = None
    second.icon = None
    second.icon_background = None
    second.created_by = None
    second.maintainer = None
    channel = create_app(
        name="Channel",
        tenant_id=tenant_id,
        updated_at=datetime(2026, 7, 5),
        mode=AppMode.CHANNEL,
    )
    rag_pipeline = create_app(
        name="RAG Pipeline",
        tenant_id=tenant_id,
        updated_at=datetime(2026, 7, 4),
        mode=AppMode.RAG_PIPELINE,
    )
    oldest = create_app(name="Oldest", tenant_id=tenant_id, updated_at=datetime(2026, 7, 1))
    foreign = create_app(name="Foreign", tenant_id=other_tenant_id, updated_at=datetime(2026, 7, 4))
    sqlite_session.add_all([newest, legacy_agent, second, channel, rag_pipeline, oldest, foreign])
    sqlite_session.commit()

    statements: list[str] = []
    bind = sqlite_session.get_bind()

    def record_sql(_conn, _cursor, statement, _parameters, _context, _executemany) -> None:
        statements.append(statement)

    event.listen(bind, "before_cursor_execute", record_sql)
    try:
        recent_apps = ConsoleAppRepository.get_recent_apps(
            account.id,
            tenant_id,
            AppListParams(limit=2),
            sqlite_session,
        )
    finally:
        event.remove(bind, "before_cursor_execute", record_sql)

    assert [(app.name, app.mode, app.icon_type, app.author_name, app.maintainer) for app in recent_apps] == [
        ("Newest", AppMode.CHAT, IconType.EMOJI, "Recent Apps Author", account.id),
        ("Second", AppMode.WORKFLOW, None, None, None),
    ]
    select_statements = [statement for statement in statements if statement.lstrip().upper().startswith("SELECT")]
    assert len(select_statements) == 1
    assert "count(" not in select_statements[0].lower()
    assert "app_model_configs" not in select_statements[0].lower()


class TestAppResponseViewAgentConfig:
    def test_masking_persistent_agent_config_does_not_change_database(
        self, sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]
    ):
        tenant_id = str(uuid4())
        app = _persist_app(sqlite_session, tenant_id=tenant_id)
        app.mode = AppMode.AGENT_CHAT
        original_agent_mode = {"enabled": True, "tools": [{"parameters": {"secret": "encrypted-value"}}]}
        config = AppModelConfig(app_id=app.id, agent_mode=json.dumps(original_agent_mode))
        sqlite_session.add(config)
        sqlite_session.flush()
        app.app_model_config_id = config.id
        sqlite_session.commit()

        account = Account(name="Test Account", email="[email protected]")
        account._current_tenant = Tenant(name="Test Tenant")
        account._current_tenant.id = tenant_id
        masked_agent_mode = {"enabled": True, "tools": [{"parameters": {"secret": "[masked]"}}]}

        with (
            patch("services.app_service.mask_agent_tool_parameters", return_value=masked_agent_mode),
            patch.object(sqlite_session, "refresh", side_effect=AssertionError("App refresh is unnecessary")),
        ):
            response_config = AppResponseView(app, session=sqlite_session, account=account).app_model_config
            assert response_config is not None
            assert response_config.agent_mode_dict == masked_agent_mode
            assert config.agent_mode_dict == original_agent_mode
            assert not sqlite_session.is_modified(config)
            sqlite_session.commit()

        with sqlite_session_factory() as read_session:
            saved_config = read_session.get(AppModelConfig, config.id)
            assert saved_config is not None
            assert saved_config.agent_mode_dict == original_agent_mode


class TestAgentAppType:
    """S1: new ``AppMode.AGENT`` app type wiring."""

    def test_agent_mode_enum_and_template_exist(self):
        from constants.model_template import default_app_templates
        from models.model import AppMode

        assert AppMode.AGENT.value == "agent"
        assert AppMode.AGENT in default_app_templates
        # Runtime config comes from the Agent Soul, so no model_config is seeded.
        assert "model_config" not in default_app_templates[AppMode.AGENT]
        assert default_app_templates[AppMode.AGENT]["app"]["mode"] == AppMode.AGENT
        assert default_app_templates[AppMode.AGENT]["app"]["enable_site"] is False
        assert default_app_templates[AppMode.AGENT]["app"]["enable_api"] is False

    def test_create_app_params_accepts_agent_mode(self):
        from services.app_service import CreateAppParams

        params = CreateAppParams(name="Iris", mode="agent")
        assert params.mode == "agent"

    def test_list_filter_and_counts_use_server_owned_publication_state(self, sqlite_session: Session):
        tenant_id = str(uuid4())
        creator_id = str(uuid4())
        published_app, _ = _persist_agent_app(
            sqlite_session,
            app_name="Published",
            agent_name="Published Agent",
            tenant_id=tenant_id,
            creator_id=creator_id,
            active_config_snapshot_id=str(uuid4()),
            active_config_is_published=True,
        )
        draft_app, _ = _persist_agent_app(
            sqlite_session,
            app_name="Draft",
            agent_name="Draft Agent",
            tenant_id=tenant_id,
            creator_id=creator_id,
            active_config_snapshot_id=str(uuid4()),
        )
        unpublished_app, _ = _persist_agent_app(
            sqlite_session,
            app_name="Unpublished",
            agent_name="Unpublished Agent",
            tenant_id=tenant_id,
            creator_id=creator_id,
        )
        _persist_agent_app(
            sqlite_session,
            app_name="Other tenant",
            agent_name="Other Agent",
            active_config_snapshot_id=str(uuid4()),
            active_config_is_published=True,
        )

        service = AppService()
        published_page = service.get_paginate_apps(
            creator_id,
            tenant_id,
            AppListParams(mode="agent", status="normal", agent_is_published=True),
            sqlite_session,
        )
        draft_page = service.get_paginate_apps(
            creator_id,
            tenant_id,
            AppListParams(mode="agent", status="normal", agent_is_published=False),
            sqlite_session,
        )
        counts = service.get_agent_publication_counts(
            creator_id,
            tenant_id,
            AppListParams(mode="agent", status="normal", agent_is_published=True),
            sqlite_session,
        )
        searched_counts = service.get_agent_publication_counts(
            creator_id,
            tenant_id,
            AppListParams(mode="agent", status="normal", name="Draft", agent_is_published=True),
            sqlite_session,
        )

        assert published_page is not None
        assert {app.id for app in published_page.items} == {published_app.id}
        assert published_page.total == 1
        assert draft_page is not None
        assert {app.id for app in draft_page.items} == {draft_app.id, unpublished_app.id}
        assert draft_page.total == 2
        assert counts.published == 1
        assert counts.drafts == 2
        assert searched_counts.published == 0
        assert searched_counts.drafts == 1

    def test_bound_agent_id_is_none_for_non_agent_app(self):
        """Non-agent apps short-circuit before the session is used."""
        from models.model import App, AppMode

        app = App(
            mode=AppMode.CHAT,
        )
        # `agent_app_binding_with_session` returns before touching the session
        # for a non-agent app, so passing None still exercises that path.
        assert app.bound_agent_id_with_session(session=None) is None  # type: ignore[arg-type]

    def test_update_agent_app_syncs_backing_agent_identity(self, sqlite_session: Session):
        app, backing_agent = _persist_agent_app(sqlite_session)
        account_id = str(uuid4())

        with (
            patch("services.app_service.current_user", _account_identity(account_id)),
            patch("services.app_service.app_was_updated.send"),
        ):
            updated_app = AppService().update_app(
                app,
                {
                    "name": "Iris",
                    "description": "agent app",
                    "role": "research assistant",
                    "icon_type": "image",
                    "icon": "file-id",
                    "icon_background": "#123456",
                    "use_icon_as_answer_icon": False,
                    "max_active_requests": 0,
                },
                session=sqlite_session,
            )

        assert updated_app.name == "Iris"
        assert backing_agent.name == "Iris"
        assert backing_agent.description == "agent app"
        assert backing_agent.role == "research assistant"
        assert backing_agent.icon_type == AgentIconType.IMAGE
        assert backing_agent.icon == "file-id"
        assert backing_agent.icon_background == "#123456"
        assert backing_agent.updated_by == account_id
        assert backing_agent.updated_at == updated_app.updated_at

    def test_update_agent_app_preserves_role_when_args_omit_it(self, sqlite_session: Session):
        app, backing_agent = _persist_agent_app(sqlite_session)

        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_updated.send"),
        ):
            AppService().update_app(
                app,
                {
                    "name": "Iris",
                    "description": "agent app",
                    "icon_type": "image",
                    "icon": "file-id",
                    "icon_background": "#123456",
                    "use_icon_as_answer_icon": False,
                    "max_active_requests": 0,
                },
                session=sqlite_session,
            )

        assert backing_agent.role == "research assistant"

    def test_update_agent_app_clears_role_when_args_set_empty_string(self, sqlite_session: Session):
        app, backing_agent = _persist_agent_app(sqlite_session)

        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_updated.send"),
        ):
            AppService().update_app(
                app,
                {
                    "name": "Iris",
                    "description": "agent app",
                    "role": "",
                    "icon_type": "image",
                    "icon": "file-id",
                    "icon_background": "#123456",
                    "use_icon_as_answer_icon": False,
                    "max_active_requests": 0,
                },
                session=sqlite_session,
            )

        assert backing_agent.role == ""

    def test_update_agent_app_duplicate_name_rolls_back_and_raises_conflict(self, sqlite_session: Session):
        app, backing_agent = _persist_agent_app(sqlite_session)
        existing = Agent(
            tenant_id=app.tenant_id,
            name="Existing Agent",
            description="existing",
            role="",
            scope=AgentScope.ROSTER,
            source=AgentSource.ROSTER,
            status=AgentStatus.ACTIVE,
        )
        sqlite_session.add(existing)
        sqlite_session.commit()
        rollback_events: list[str] = []
        event.listen(sqlite_session, "after_rollback", lambda _session: rollback_events.append("rollback"))

        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_updated.send"),
        ):
            with pytest.raises(AgentNameConflictError):
                AppService().update_app(
                    app,
                    {
                        "name": "Existing Agent",
                        "description": "agent app",
                        "role": "research assistant",
                        "icon_type": "emoji",
                        "icon": "robot",
                        "icon_background": "#fff",
                        "use_icon_as_answer_icon": False,
                        "max_active_requests": 0,
                    },
                    session=sqlite_session,
                )

        assert rollback_events == ["rollback"]
        sqlite_session.expire_all()
        assert sqlite_session.get(Agent, backing_agent.id).name == "Old"  # type: ignore[union-attr]

    def test_delete_agent_app_archives_backing_agent(self, sqlite_session: Session):
        app, backing_agent = _persist_agent_app(sqlite_session)
        workflow_app = _persist_app(sqlite_session, tenant_id=app.tenant_id, name="Workflow")
        workflow_app.mode = AppMode.WORKFLOW
        referencing_workflow = Workflow.new(
            tenant_id=app.tenant_id,
            app_id=workflow_app.id,
            type=WorkflowType.WORKFLOW.value,
            version=Workflow.VERSION_DRAFT,
            graph="{}",
            features="{}",
            created_by="account-1",
            environment_variables=[],
            conversation_variables=[],
            rag_pipeline_variables=[],
        )
        workflow_binding = WorkflowAgentNodeBinding(
            tenant_id=app.tenant_id,
            app_id=workflow_app.id,
            workflow_id=referencing_workflow.id,
            workflow_version=referencing_workflow.version,
            node_id="agent-node",
            binding_type=WorkflowAgentBindingType.ROSTER_AGENT,
            agent_id=backing_agent.id,
            current_snapshot_id="snapshot-1",
            node_job_config={},
        )
        workflow_agents = [
            Agent(
                tenant_id=app.tenant_id,
                name=f"Workflow Agent {index}",
                description="",
                role="",
                scope=AgentScope.WORKFLOW_ONLY,
                source=AgentSource.WORKFLOW,
                status=AgentStatus.ACTIVE,
                app_id=app.id,
                workflow_id=str(uuid4()),
                workflow_node_id=f"node-{index}",
            )
            for index in range(2)
        ]
        sqlite_session.add_all([referencing_workflow, workflow_binding, *workflow_agents])
        sqlite_session.commit()
        account_id = str(uuid4())
        events: list[str] = []
        event.listen(sqlite_session, "after_commit", lambda _session: events.append("commit"))

        with (
            patch("services.app_service.current_user", _account_identity(account_id)),
            patch("services.app_service.app_was_deleted.send"),
            patch("services.app_service.BillingService"),
            patch("services.app_service.EnterpriseService"),
            patch("services.app_service.SystemFeatureService"),
            patch(
                "services.app_service.remove_app_and_related_data_task.delay",
                side_effect=lambda **_kwargs: events.append("enqueue-app-cleanup"),
            ),
            patch(
                "services.app_service.AgentHomeSnapshotService.retire_all_for_agent",
                return_value=["home-1"],
            ) as mock_retire_homes,
            patch(
                "services.app_service.AgentWorkspaceService.retire_all_for_app",
                side_effect=lambda **_kwargs: events.append("retire-app-workspaces") or ["workspace-1"],
            ) as mock_retire_workspaces,
            patch(
                "services.app_service.WorkflowAgentRetirementService.retire_unowned",
                side_effect=lambda **_kwargs: events.append("retire-workflow-agents"),
            ) as mock_workflow_retirement,
            patch(
                "services.app_service.enqueue_agent_resource_collection",
                side_effect=lambda **_kwargs: events.append("enqueue"),
            ) as mock_enqueue_collection,
        ):
            AppService().delete_app(app, session=sqlite_session)

        assert events == [
            "retire-app-workspaces",
            "commit",
            "enqueue-app-cleanup",
            "retire-workflow-agents",
            "enqueue",
        ]
        sqlite_session.expire_all()
        persisted_agent = sqlite_session.get(Agent, backing_agent.id)
        assert persisted_agent is not None
        assert sqlite_session.get(App, app.id) is None
        assert persisted_agent.status == AgentStatus.ARCHIVED
        assert persisted_agent.archived_by == account_id
        assert persisted_agent.archived_at is not None
        persisted_workflow_binding = sqlite_session.get(WorkflowAgentNodeBinding, workflow_binding.id)
        assert persisted_workflow_binding is not None
        assert persisted_workflow_binding.agent_id == backing_agent.id
        mock_workflow_retirement.assert_called_once_with(
            tenant_id=app.tenant_id,
            agent_ids={agent.id for agent in workflow_agents},
            account_id=account_id,
        )
        mock_retire_workspaces.assert_called_once_with(
            session=sqlite_session,
            tenant_id=app.tenant_id,
            app_id=app.id,
        )
        mock_retire_homes.assert_called_once_with(
            session=sqlite_session,
            tenant_id=app.tenant_id,
            agent_id=backing_agent.id,
        )
        mock_enqueue_collection.assert_called_once_with(
            tenant_id=app.tenant_id,
            workspace_ids=["workspace-1"],
            binding_ids=[],
            home_snapshot_ids=["home-1"],
            purge_agent_ids=[backing_agent.id],
        )

    def test_delete_app_commit_failure_does_not_retire_workflow_agents_or_enqueue(self, sqlite_session: Session):
        app = _persist_app(sqlite_session, tenant_id=str(uuid4()))
        app.mode = AppMode.WORKFLOW
        workflow_agent = Agent(
            tenant_id=app.tenant_id,
            name="Workflow Agent",
            description="",
            role="",
            scope=AgentScope.WORKFLOW_ONLY,
            source=AgentSource.WORKFLOW,
            status=AgentStatus.ACTIVE,
            app_id=app.id,
            workflow_id=str(uuid4()),
            workflow_node_id="node-1",
        )
        sqlite_session.add(workflow_agent)
        sqlite_session.commit()

        def fail_commit(_session: Session) -> None:
            raise RuntimeError("commit failed")

        event.listen(sqlite_session, "before_commit", fail_commit, once=True)
        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_deleted.send"),
            patch("services.app_service.AgentWorkspaceService.retire_all_for_app", return_value=["workspace-1"]),
            patch("services.app_service.WorkflowAgentRetirementService.retire_unowned") as retire_unowned,
            patch("services.app_service.enqueue_agent_resource_collection") as enqueue_collection,
            patch("services.app_service.remove_app_and_related_data_task.delay") as enqueue_app_cleanup,
        ):
            with pytest.raises(RuntimeError, match="commit failed"):
                AppService().delete_app(app, session=sqlite_session)

        retire_unowned.assert_not_called()
        enqueue_collection.assert_not_called()
        enqueue_app_cleanup.assert_not_called()

    def test_delete_workflow_app_releases_all_bindings_before_retirement(self, sqlite_session: Session):
        app = _persist_app(sqlite_session, tenant_id=str(uuid4()))
        app.mode = AppMode.WORKFLOW
        workflow = Workflow.new(
            tenant_id=app.tenant_id,
            app_id=app.id,
            type=WorkflowType.WORKFLOW.value,
            version="historical-version",
            graph="{}",
            features="{}",
            created_by="account-1",
            environment_variables=[],
            conversation_variables=[],
            rag_pipeline_variables=[],
        )
        inline_binding = WorkflowAgentNodeBinding(
            tenant_id=app.tenant_id,
            app_id=app.id,
            workflow_id=workflow.id,
            workflow_version=workflow.version,
            node_id="inline-node",
            binding_type=WorkflowAgentBindingType.INLINE_AGENT,
            agent_id="inline-agent",
            current_snapshot_id="snapshot-1",
            node_job_config={},
        )
        roster_binding = WorkflowAgentNodeBinding(
            tenant_id=app.tenant_id,
            app_id=app.id,
            workflow_id=workflow.id,
            workflow_version=workflow.version,
            node_id="roster-node",
            binding_type=WorkflowAgentBindingType.ROSTER_AGENT,
            agent_id="roster-agent",
            current_snapshot_id="snapshot-2",
            node_job_config={},
        )
        sqlite_session.add_all([workflow, inline_binding, roster_binding])
        sqlite_session.commit()
        events: list[str] = []

        def retire_unowned(**kwargs):
            events.append("retire")
            assert sqlite_session.get(WorkflowAgentNodeBinding, inline_binding.id) is None
            assert sqlite_session.get(WorkflowAgentNodeBinding, roster_binding.id) is None
            assert kwargs["agent_ids"] == {"inline-agent"}

        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_deleted.send"),
            patch("services.app_service.SystemFeatureService"),
            patch("services.app_service.BillingService"),
            patch("services.app_service.EnterpriseService"),
            patch("services.app_service.AgentWorkspaceService.retire_all_for_app", return_value=[]),
            patch(
                "services.app_service.remove_app_and_related_data_task.delay",
                side_effect=lambda **_kwargs: events.append("enqueue-app-cleanup"),
            ),
            patch(
                "services.app_service.WorkflowAgentRetirementService.retire_unowned",
                side_effect=retire_unowned,
            ),
            patch("services.app_service.enqueue_agent_resource_collection"),
        ):
            AppService().delete_app(app, session=sqlite_session)

        assert events == ["enqueue-app-cleanup", "retire"]
        assert sqlite_session.get(WorkflowAgentNodeBinding, inline_binding.id) is None
        assert sqlite_session.get(WorkflowAgentNodeBinding, roster_binding.id) is None

    def test_delete_app_cleanup_enqueue_failure_propagates_before_retirement(self, sqlite_session: Session):
        app = _persist_app(sqlite_session, tenant_id=str(uuid4()))
        error = RuntimeError("broker unavailable")

        with (
            patch("services.app_service.current_user", _account_identity(str(uuid4()))),
            patch("services.app_service.app_was_deleted.send"),
            patch("services.app_service.AgentWorkspaceService.retire_all_for_app", return_value=[]),
            patch("services.app_service.remove_app_and_related_data_task.delay", side_effect=error),
            patch("services.app_service.WorkflowAgentRetirementService.retire_unowned") as retire_unowned,
            patch("services.app_service.enqueue_agent_resource_collection") as enqueue_collection,
        ):
            with pytest.raises(RuntimeError) as exc_info:
                AppService().delete_app(app, session=sqlite_session)

        assert exc_info.value is error
        retire_unowned.assert_not_called()
        enqueue_collection.assert_not_called()


class _TenantDefaultModelManager:
    """Tenant model manager the fallback branch needs, built without a mock.

    Contract: `get_default_model_instance` always raises `ProviderTokenNotInitError`
    and `get_default_provider_model_name` returns the tenant-scoped provider/model pair.
    Those are the only two calls `AppService` makes on a tenant manager while it reads
    `default_app_templates`, so the fallback path is exercised against real code.
    """

    def __init__(self, provider: str, model: str) -> None:
        self._provider = provider
        self._model = model

    def get_default_model_instance(self, *, tenant_id: str, model_type: ModelType) -> NoReturn:
        raise ProviderTokenNotInitError(f"no default {model_type} model instance for tenant {tenant_id}")

    def get_default_provider_model_name(self, *, tenant_id: str, model_type: ModelType) -> tuple[str, str]:
        if not tenant_id or model_type is not ModelType.LLM:
            raise AssertionError(f"unexpected default model lookup: {tenant_id!r} ({model_type})")
        return self._provider, self._model


class TestSharedAppTemplateIsolation:
    """`default_app_templates` is imported once per process, so app creation must read it without writing to it.

    Precondition: the tenant's default model instance is unavailable while a tenant-scoped default
    provider/model exists. Postcondition: the new app uses the tenant's model and the shipped template
    keeps its own provider and model for every later request and tenant.
    """

    @staticmethod
    def _tenant_default_model_manager() -> _TenantDefaultModelManager:
        return _TenantDefaultModelManager("langgenius/anthropic/anthropic", "claude-3-5-sonnet")

    @staticmethod
    def _use_clean_template_model(monkeypatch: pytest.MonkeyPatch, mode: AppMode) -> dict[str, object]:
        baseline: dict[str, object] = {"provider": "openai", "name": "gpt-4o", "mode": "chat", "completion_params": {}}
        monkeypatch.setitem(default_app_templates[mode]["model_config"], "model", deepcopy(baseline))
        return baseline

    def test_create_app_does_not_rewrite_the_shared_template(
        self,
        sqlite_session: Session,
        config_overrides: Callable[..., None],
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
        baseline = self._use_clean_template_model(monkeypatch, AppMode.CHAT)
        account = _persist_account(sqlite_session)
        model_manager = self._tenant_default_model_manager()

        with (
            patch("services.app_service.ModelManager.for_tenant", return_value=model_manager),
            patch("services.app_service.app_was_created.send"),
            patch("services.app_service.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"),
            patch("services.app_service.SystemFeatureService.is_webapp_auth_enabled", return_value=False),
        ):
            app = AppService().create_app(
                account.current_tenant_id,
                CreateAppParams(name="Chat", mode=AppMode.CHAT.value),
                account,
                session=sqlite_session,
            )

        app_model_config = sqlite_session.get(AppModelConfig, app.app_model_config_id)
        assert app_model_config is not None
        assert app_model_config.model_dict == {
            "provider": "langgenius/anthropic/anthropic",
            "name": "claude-3-5-sonnet",
            "mode": "chat",
            "completion_params": {},
        }
        assert default_app_templates[AppMode.CHAT]["model_config"]["model"] == baseline

    def test_prepare_creation_does_not_rewrite_the_shared_template(self, monkeypatch: pytest.MonkeyPatch) -> None:
        baseline = self._use_clean_template_model(monkeypatch, AppMode.COMPLETION)
        model_manager = self._tenant_default_model_manager()

        with patch("services.app_service.ModelManager.for_tenant", return_value=model_manager):
            settings = AppService.prepare_creation(
                "tenant-a",
                CreateAppParams(name="Completion", mode=AppMode.COMPLETION.value),
            )

        assert settings.model_config is not None
        assert json.loads(settings.model_config["model"])["provider"] == "langgenius/anthropic/anthropic"
        assert default_app_templates[AppMode.COMPLETION]["model_config"]["model"] == baseline