chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

Whitespace-only changes.
@@ -0,0 +1,32 @@
import pytest
from controllers.console.app.advanced_prompt_template import AdvancedPromptTemplateResponse
from core.prompt.prompt_templates.advanced_prompt_templates import (
CHAT_APP_CHAT_PROMPT_CONFIG,
CHAT_APP_COMPLETION_PROMPT_CONFIG,
COMPLETION_APP_CHAT_PROMPT_CONFIG,
COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
)
@pytest.mark.parametrize(
"template",
[
CHAT_APP_CHAT_PROMPT_CONFIG,
CHAT_APP_COMPLETION_PROMPT_CONFIG,
COMPLETION_APP_CHAT_PROMPT_CONFIG,
COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
],
)
def test_prompt_templates_keep_their_shape(template: dict[str, object]) -> None:
dumped = AdvancedPromptTemplateResponse.model_validate(template).model_dump(mode="json", exclude_unset=True)
assert dumped == template
def test_completion_templates_keep_their_stop_words() -> None:
dumped = AdvancedPromptTemplateResponse.model_validate(CHAT_APP_COMPLETION_PROMPT_CONFIG).model_dump(
mode="json", exclude_unset=True
)
assert dumped["stop"] == ["Human:"]
@@ -0,0 +1,143 @@
"""Console admission and transport contracts for Agent App features and references."""
from dataclasses import dataclass, field
from inspect import unwrap
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden
from controllers.console import flask_admission
from controllers.console.app import advanced_prompt_template, agent_app_access, agent_app_feature
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.agent.errors import AgentNotFoundError
from services.app.advanced_prompt_template_service import AdvancedPromptTemplateService
from services.app.agent_app_contracts import AgentAppNotFoundError, AgentReferencingWorkflow
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
from tests.helpers.unit.model_factories import make_account
CONTEXT = RequestContext("request", None, "actor", "tenant")
AGENT_ID = UUID("11111111-1111-1111-1111-111111111111")
@dataclass
class FeatureService:
calls: list[tuple[RequestContext, str, dict[str, object]]] = field(default_factory=list)
def update_features(self, context: RequestContext, agent_id: str, config: dict[str, object]) -> None:
self.calls.append((context, agent_id, config))
@dataclass
class AccessService:
calls: list[tuple[RequestContext, str]] = field(default_factory=list)
missing: bool = False
def list_referencing_workflows(self, context: RequestContext, agent_id: str) -> list[AgentReferencingWorkflow]:
self.calls.append((context, agent_id))
if self.missing:
raise AgentAppNotFoundError
return [
AgentReferencingWorkflow(
app_id="workflow-app",
app_name="Workflow",
app_mode="workflow",
app_icon_type=None,
app_icon=None,
app_icon_background=None,
app_updated_at=123,
workflow_id="workflow",
workflow_version="published",
node_ids=["node"],
)
]
@dataclass
class AgentServices:
features: FeatureService = field(default_factory=FeatureService)
access: AccessService = field(default_factory=AccessService)
@dataclass
class Services:
agent_apps: AgentServices = field(default_factory=AgentServices)
advanced_prompt_templates: AdvancedPromptTemplateService = field(default_factory=AdvancedPromptTemplateService)
@pytest.fixture
def services(monkeypatch: pytest.MonkeyPatch) -> Services:
services = Services()
for module in (agent_app_feature, agent_app_access, advanced_prompt_template):
monkeypatch.setattr(module, "application_services", lambda: services)
return services
def test_features_parse_full_state_and_drop_soul_fields(app: Flask, services: Services) -> None:
with app.test_request_context(
"/", method="POST", json={"opening_statement": "Hi", "speech_to_text": None, "model": {"name": "x"}}
):
result = unwrap(agent_app_feature.AgentAppFeatureConfigResource.post)(
agent_app_feature.AgentAppFeatureConfigResource(), CONTEXT, AGENT_ID
)
assert result == {"result": "success"}
assert services.agent_apps.features.calls == [(CONTEXT, str(AGENT_ID), {"opening_statement": "Hi"})]
@pytest.mark.parametrize("role", list(TenantAccountRole))
def test_feature_admission_enforces_editing_roles(
app: Flask, services: Services, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole
) -> None:
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
account = make_account(account_id="actor", name="Editor", email="editor@example.com", role=role)
monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "tenant"))
monkeypatch.setattr(flask_admission, "get_request_id", lambda: "request")
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
# Exercise the declared admission policy after setup/login/initialization.
view = unwrap(
agent_app_feature.AgentAppFeatureConfigResource.post,
stop=lambda handler: handler.__code__.co_name == "inject_request_context",
)
with app.test_request_context("/", method="POST", json={}):
if role in (TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR):
assert view(agent_app_feature.AgentAppFeatureConfigResource(), agent_id=AGENT_ID) == {"result": "success"}
assert services.agent_apps.features.calls == [(CONTEXT, str(AGENT_ID), {})]
else:
with pytest.raises(Forbidden):
view(agent_app_feature.AgentAppFeatureConfigResource(), agent_id=AGENT_ID)
assert services.agent_apps.features.calls == []
def test_agent_endpoints_keep_rbac_scenes() -> None:
for view, scene in (
(agent_app_feature.AgentAppFeatureConfigResource.post, agent_app_feature.RBACPermission.AGENT_EDIT),
(agent_app_access.AgentAppReferencingWorkflowsResource.get, agent_app_access.RBACPermission.AGENT_PREVIEW),
):
[check] = rbac_checks(view)
assert isinstance(check.locator, agent_app_access.AgentId)
assert check.scene == scene
def test_access_serializes_workflow_metadata(services: Services) -> None:
result = unwrap(agent_app_access.AgentAppReferencingWorkflowsResource.get)(object(), CONTEXT, AGENT_ID)
assert services.agent_apps.access.calls == [(CONTEXT, str(AGENT_ID))]
assert result["data"][0]["node_ids"] == ["node"]
assert result["data"][0]["app_updated_at"] == 123
services.agent_apps.access.missing = True
with pytest.raises(AgentNotFoundError):
unwrap(agent_app_access.AgentAppReferencingWorkflowsResource.get)(object(), CONTEXT, AGENT_ID)
@pytest.mark.parametrize("app_mode", ["chat", "completion", "invalid"])
@pytest.mark.usefixtures("services")
def test_prompt_response_preserves_omitted_fields(app: Flask, app_mode: str) -> None:
with app.test_request_context("/", query_string={"app_mode": app_mode, "model_mode": "chat", "model_name": "gpt"}):
result = unwrap(advanced_prompt_template.AdvancedPromptTemplateList.get)(object(), CONTEXT)
if app_mode == "invalid":
assert result == {}
else:
assert set(result) == {"chat_prompt_config"}
@@ -0,0 +1,182 @@
"""Transport parsing, permission declarations and sandbox error serialization."""
from collections.abc import Callable
from dataclasses import dataclass
from inspect import unwrap
from uuid import UUID
import pytest
from dify_agent.client import DifyAgentClientError, DifyAgentHTTPError, DifyAgentTimeoutError
from dify_agent.protocol import BindingFileListResponse, BindingFileReadResponse
from flask import Flask
from flask_restx import Resource
from controllers.console import agent_app_sandbox as module
from machinery.context import RequestContext
from services.agent.errors import AgentNotFoundError
from services.app.agent_app_contracts import (
AgentAppNotFoundError,
AgentSandboxBindingNotFoundError,
AgentSandboxCaller,
AgentSandboxDownload,
AgentSandboxDownloadUnavailableError,
AgentSandboxInfo,
AgentSandboxUnavailableError,
SandboxCaller,
WorkflowSandboxAppNotFoundError,
WorkflowSandboxCaller,
)
from tests.helpers.unit.controllers.error_body import raised_error
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
CONTEXT = RequestContext("request", "trace", "actor", "workspace")
RESOURCE_ID = UUID("11111111-1111-1111-1111-111111111111")
class SandboxService:
def __init__(self) -> None:
self.calls: list[tuple[str, RequestContext, SandboxCaller, str]] = []
self.error: Exception | None = None
def record(self, operation: str, context: RequestContext, caller: SandboxCaller, path: str = "") -> None:
self.calls.append((operation, context, caller, path))
if self.error:
raise self.error
def get_info(self, context: RequestContext, caller: SandboxCaller) -> AgentSandboxInfo:
self.record("info", context, caller)
return AgentSandboxInfo(workspace_cwd=".")
def list_files(self, context: RequestContext, caller: SandboxCaller, path: str) -> BindingFileListResponse:
self.record("list", context, caller, path)
return BindingFileListResponse(path=path, entries=[], truncated=False)
def read_file(self, context: RequestContext, caller: SandboxCaller, path: str) -> BindingFileReadResponse:
self.record("read", context, caller, path)
return BindingFileReadResponse(path=path, size=5, truncated=False, binary=False, text="hello")
def download_file(self, context: RequestContext, caller: SandboxCaller, path: str) -> AgentSandboxDownload:
self.record("download", context, caller, path)
return AgentSandboxDownload(url="https://files.example/report.txt")
@dataclass
class AgentServices:
sandbox: SandboxService
@dataclass
class Services:
agent_apps: AgentServices
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch) -> SandboxService:
service = SandboxService()
monkeypatch.setattr(module, "application_services", lambda: Services(AgentServices(service)))
return service
@pytest.mark.parametrize(
("resource", "method", "verb", "operation", "workflow"),
[
(module.AgentAppSandboxInfoResource, module.AgentAppSandboxInfoResource.get, "get", "info", False),
(module.AgentAppSandboxListResource, module.AgentAppSandboxListResource.get, "get", "list", False),
(module.AgentAppSandboxReadResource, module.AgentAppSandboxReadResource.get, "get", "read", False),
(
module.AgentAppSandboxDownloadResource,
module.AgentAppSandboxDownloadResource.post,
"post",
"download",
False,
),
(module.WorkflowAgentSandboxListResource, module.WorkflowAgentSandboxListResource.get, "get", "list", True),
(module.WorkflowAgentSandboxReadResource, module.WorkflowAgentSandboxReadResource.get, "get", "read", True),
(
module.WorkflowAgentSandboxDownloadResource,
module.WorkflowAgentSandboxDownloadResource.post,
"post",
"download",
True,
),
],
)
def test_controller_parses_and_serializes(
app: Flask,
service: SandboxService,
resource: type[Resource],
method: Callable[..., object],
verb: str,
operation: str,
workflow: bool,
) -> None:
payload = {"node_execution_id": "execution"} if workflow else {"caller_type": "build_draft", "caller_id": "draft"}
if operation != "info":
payload["path"] = "~/report.txt"
kwargs = {"json": payload} if verb == "post" else {"query_string": payload}
params = (RESOURCE_ID, RESOURCE_ID, "node") if workflow else (RESOURCE_ID,)
with app.test_request_context("/", method=verb.upper(), **kwargs):
result = unwrap(method)(resource(), CONTEXT, *params)
caller = (
WorkflowSandboxCaller(str(RESOURCE_ID), str(RESOURCE_ID), "node", "execution")
if workflow
else (AgentSandboxCaller(str(RESOURCE_ID), "build_draft", "draft"))
)
assert service.calls == [(operation, CONTEXT, caller, "" if operation == "info" else "~/report.txt")]
if operation == "info":
assert result == {"workspace_cwd": "."}
elif operation == "download":
assert result == {"url": "https://files.example/report.txt"}
elif operation == "read":
assert result == {"path": "~/report.txt", "size": 5, "truncated": False, "binary": False, "text": "hello"}
else:
assert result == {"path": "~/report.txt", "entries": [], "truncated": False}
[check] = rbac_checks(method)
if workflow:
assert isinstance(check.locator, module.PlainApp)
assert check.scene == module.RBACPermission.APP_VIEW_LAYOUT
else:
assert isinstance(check.locator, module.AgentId)
assert check.scene == (
module.RBACPermission.AGENT_EDIT if operation == "download" else module.RBACPermission.AGENT_PREVIEW
)
@pytest.mark.parametrize(
("error", "code", "message", "status"),
[
(AgentSandboxBindingNotFoundError("no active binding"), "no_active_binding", "no active binding", 404),
(AgentSandboxUnavailableError("unavailable"), "inspector_unavailable", "unavailable", 503),
(
AgentSandboxDownloadUnavailableError("cannot download"),
"binding_file_download_unavailable",
"cannot download",
502,
),
(DifyAgentHTTPError(409, {"code": "conflict", "message": "busy"}), "conflict", "busy", 409),
(DifyAgentHTTPError(500, "backend exploded"), "agent_backend_error", "backend exploded", 500),
(DifyAgentTimeoutError("connection refused"), "agent_backend_unreachable", "connection refused", 502),
(DifyAgentClientError("transport failed"), "agent_backend_unreachable", "transport failed", 502),
],
)
def test_sandbox_error_responses(
app: Flask, service: SandboxService, error: Exception, code: str, message: str, status: int
) -> None:
service.error = error
with app.test_request_context("/?caller_type=conversation&caller_id=conversation"):
result = raised_error(lambda: unwrap(module.AgentAppSandboxInfoResource.get)(object(), CONTEXT, RESOURCE_ID))
assert result == ({"code": code, "message": message}, status)
@pytest.mark.parametrize(
("error", "expected"),
[
(AgentAppNotFoundError(), AgentNotFoundError),
(WorkflowSandboxAppNotFoundError(), module.AppNotFoundError),
(RuntimeError("unexpected"), RuntimeError),
],
)
def test_resource_errors_keep_existing_http_contract(error: Exception, expected: type[Exception]) -> None:
with pytest.raises(expected):
module._handle(error)
@@ -0,0 +1,627 @@
"""Unit tests for the console agent config inspector routes.
These tests unwrap the Flask decorators and focus on version resolution,
workflow-node agent binding, and service delegation for the new config surface.
"""
from __future__ import annotations
from datetime import datetime
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
from uuid import UUID
import pytest
from flask import Flask
from pydantic import ValidationError
from sqlalchemy import event
from sqlalchemy.orm import Session
from controllers.console.app import agent_config_inspector as inspector
from controllers.console.app.agent_config_inspector import (
AgentConfigFileDownloadApi,
AgentConfigFilePreviewApi,
AgentConfigFilesApi,
AgentConfigFilesByAgentApi,
AgentConfigManifestApi,
AgentConfigManifestByAgentApi,
AgentConfigSkillFileDownloadApi,
AgentConfigSkillFileDownloadByAgentApi,
AgentConfigSkillFilePreviewByAgentApi,
AgentConfigSkillInspectByAgentApi,
AgentConfigSkillsApi,
AgentConfigSkillUploadByAgentApi,
)
from extensions.storage.storage_type import StorageType
from models.account import Account
from models.agent import (
Agent,
AgentConfigDraft,
AgentConfigDraftType,
AgentScope,
AgentSource,
WorkflowAgentBindingType,
WorkflowAgentNodeBinding,
)
from models.agent_config_entities import AgentSoulConfig, WorkflowNodeJobConfig
from models.enums import CreatorUserRole
from models.model import App, AppMode, UploadFile
from models.workflow import Workflow, WorkflowType
from services.agent_config_service import AgentConfigServiceError
from tests.helpers.unit.controllers.error_body import raised_error
_MOD = "controllers.console.app.agent_config_inspector"
app = Flask(__name__)
def _raw(method):
return unwrap(method)
_APP = App(
id="app-1",
tenant_id="tenant-1",
name="Agent app",
description="",
mode=AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
_APP.bound_agent_id_with_session = lambda *, session: "agent-1" # type: ignore[method-assign]
_USER = Account(name="User", email="user@example.com")
_USER.id = "acct-1"
def test_resolve_bound_agent_uses_injected_session(unbound_session: Session):
session = unbound_session
resolver = MagicMock(return_value="agent-1")
app_model = App(
id="app-2",
tenant_id="tenant-1",
name="Agent app",
description="",
mode=AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
app_model.bound_agent_id_with_session = resolver # type: ignore[method-assign]
result = inspector._resolve_agent_id(session, app_model, None)
assert result == "agent-1"
resolver.assert_called_once_with(session=session)
assert resolver.call_args.kwargs["session"] is session
def test_manifest_by_agent_resolves_build_draft_version(unbound_session: Session):
raw = _raw(AgentConfigManifestByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.manifest.return_value = {
"agent_id": "agent-1",
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
"skills": {"items": []},
"files": {"items": []},
"env_keys": [],
"note": "",
}
body = raw(AgentConfigManifestByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1")
assert body["config_version"]["kind"] == "build_draft"
assert config_service.return_value.manifest.call_args.kwargs["config_version_id"] == "build-draft-1"
assert config_service.return_value.manifest.call_args.kwargs["config_version_kind"].value == "build_draft"
def test_manifest_resolves_workflow_node_agent_and_normal_draft(unbound_session: Session):
raw = _raw(AgentConfigManifestApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.manifest.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"skills": {"items": []},
"files": {"items": []},
"env_keys": [],
"note": "",
}
body = raw(AgentConfigManifestApi(), unbound_session, _USER, _APP)
assert body["agent_id"] == "wf-agent-9"
assert composer.resolve_workflow_node_agent_id.call_args.kwargs["node_id"] == "node-1"
assert config_service.return_value.manifest.call_args.kwargs["config_version_kind"].value == "draft"
def test_normal_draft_read_resolution_does_not_commit(sqlite_session: Session) -> None:
session = sqlite_session
commits: list[str] = []
event.listen(session, "after_commit", lambda _session: commits.append("commit"))
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
version_id, version_kind = inspector._resolve_console_version(
session=session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
assert version_id == "draft-1"
assert version_kind.value == "draft"
assert commits == []
def test_normal_config_reads_fall_back_to_snapshot_without_creating_draft(unbound_session: Session) -> None:
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {"draft": None, "active_config_snapshot": {"id": "snapshot-1"}}
version_id, version_kind = inspector._resolve_console_version(
session=unbound_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_not_called()
assert version_id == "snapshot-1"
assert version_kind.value == "snapshot"
def test_stale_inline_config_reads_use_effective_snapshot(unbound_session: Session) -> None:
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {
"agent": {"scope": "workflow_only"},
"draft": {"id": "draft-1", "base_snapshot_id": "snapshot-1"},
"active_config_snapshot": {"id": "snapshot-2"},
}
version_id, version_kind = inspector._resolve_console_version(
session=unbound_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_not_called()
assert version_id == "snapshot-2"
assert version_kind.value == "snapshot"
def test_config_write_prepares_draft_before_independent_service_session(sqlite_session: Session) -> None:
commits: list[str] = []
event.listen(sqlite_session, "after_commit", lambda _session: commits.append("commit"))
with app.test_request_context("/", method="POST"), patch(f"{_MOD}.AgentComposerService") as composer:
composer.prepare_agent_composer_draft.return_value = SimpleNamespace(id="draft-1")
target = inspector._resolve_target(
session=sqlite_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_called_once_with(
session=sqlite_session, tenant_id="tenant-1", agent_id="agent-1", account_id="acct-1"
)
composer.load_agent_composer.assert_not_called()
assert target.version_id == "draft-1"
assert target.version_kind.value == "draft"
assert commits == ["commit"]
def test_skill_inspect_by_agent_returns_strict_json_response(unbound_session: Session):
raw = _raw(AgentConfigSkillInspectByAgentApi.get)
with app.test_request_context("/"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.inspect_skill.return_value = {
"id": "pdf-toolkit",
"name": "pdf-toolkit",
"description": "Work with PDFs.",
"size": 42,
"mime_type": "application/zip",
"hash": "sha256:abc",
"source": "config_skill_zip",
"files": [
{"path": "SKILL.md", "name": "SKILL.md", "type": "file", "previewable": True, "downloadable": True}
],
"skill_md": {
"path": "SKILL.md",
"size": 24,
"truncated": False,
"binary": False,
"text": "# PDF Toolkit\nUse it.\n",
},
"warnings": [],
}
response = raw(
AgentConfigSkillInspectByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "pdf-toolkit"
)
assert response.status_code == 200
assert response.get_json()["name"] == "pdf-toolkit"
assert b"PDF Toolkit" in response.get_data()
def test_file_preview_api_passes_through_and_maps_errors(unbound_session: Session):
raw = _raw(AgentConfigFilePreviewApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.preview_file.return_value = {
"name": "sample.txt",
"size": 5,
"truncated": False,
"binary": False,
"text": "hello",
}
body = raw(AgentConfigFilePreviewApi(), unbound_session, _USER, _APP, "sample.txt")
assert body["text"] == "hello"
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.preview_file.side_effect = AgentConfigServiceError(
"config_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(AgentConfigFilePreviewApi(), unbound_session, _USER, _APP, "missing.txt")
)
assert status == 404
assert body["code"] == "config_file_not_found"
def test_skill_upload_by_agent_delegates_after_version_resolution(unbound_session: Session):
raw = _raw(AgentConfigSkillUploadByAgentApi.post)
with app.test_request_context("/?draft_type=debug_build"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(
f"{_MOD}._upload_skill_for_target",
return_value=(
{
"skill": {"id": "alpha", "name": "alpha", "file_id": "tool-file-1", "description": "Alpha"},
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
},
201,
),
) as upload_skill,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
body, status = raw(AgentConfigSkillUploadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1")
assert status == 201
assert body["skill"]["name"] == "alpha"
assert upload_skill.call_args.kwargs["version_id"] == "build-draft-1"
assert upload_skill.call_args.kwargs["version_kind"].value == "build_draft"
def test_file_upload_by_agent_delegates_to_service_owned_upload_lookup(unbound_session: Session):
raw = _raw(AgentConfigFilesByAgentApi.post)
with app.test_request_context("/?draft_type=debug_build", json={"upload_file_id": "upload-1"}):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.push_file_for_console.return_value = {
"file": {"id": "guide.txt", "name": "guide.txt", "file_id": "upload-1"},
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
}
body, status = raw(
AgentConfigFilesByAgentApi(),
inspector.AgentConfigFileUploadPayload(upload_file_id="upload-1"),
unbound_session,
"tenant-1",
_USER,
"agent-1",
)
assert status == 201
assert body["file"]["name"] == "guide.txt"
assert config_service.return_value.push_file_for_console.call_args.kwargs["upload_file_id"] == "upload-1"
assert config_service.return_value.push_file_for_console.call_args.kwargs["config_version_id"] == "build-draft-1"
assert (
config_service.return_value.push_file_for_console.call_args.kwargs["config_version_kind"].value == "build_draft"
)
def test_skill_list_api_uses_config_list_shape(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillsApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.list_skills.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [{"id": "alpha", "name": "alpha", "file_id": "tool-file-1", "description": "Alpha"}],
}
body = raw(AgentConfigSkillsApi(), unbound_session, _USER, _APP)
assert body["items"][0]["name"] == "alpha"
assert body["items"][0]["file_id"] == "tool-file-1"
assert config_service.return_value.list_skills.call_args.kwargs["agent_id"] == "wf-agent-9"
def test_file_list_api_uses_config_list_shape(unbound_session: Session) -> None:
raw = _raw(AgentConfigFilesApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.list_files.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [
{
"id": "guide.txt",
"name": "guide.txt",
"file_id": "upload-file-1",
"hash": "sha256:file-1",
"mime_type": "text/plain",
"size": 7,
}
],
}
body = raw(AgentConfigFilesApi(), unbound_session, _USER, _APP)
assert body == {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [
{
"id": "guide.txt",
"name": "guide.txt",
"file_id": "upload-file-1",
"hash": "sha256:file-1",
"mime_type": "text/plain",
"size": 7,
}
],
}
assert config_service.return_value.list_files.call_args.kwargs["agent_id"] == "wf-agent-9"
def test_skill_file_preview_by_agent_reads_path_query(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFilePreviewByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.preview_skill_file.return_value = {
"path": "references/guide.md",
"size": 11,
"truncated": False,
"binary": False,
"text": "hello world",
}
body = raw(AgentConfigSkillFilePreviewByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha")
assert body["path"] == "references/guide.md"
assert config_service.return_value.preview_skill_file.call_args.kwargs["path"] == "references/guide.md"
def test_skill_file_download_by_agent_returns_proxy_url(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
patch(
f"{_MOD}.url_for",
return_value="/console/api/agent/agent-1/config/skills/alpha/files/content?path=references%2Fguide.md&draft_type=debug_build",
),
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.return_value = "references/guide.md"
response = raw(
AgentConfigSkillFileDownloadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha"
)
assert response.status_code == 200
assert response.get_json()["url"].endswith(
"/agent/agent-1/config/skills/alpha/files/content?path=references%2Fguide.md&draft_type=debug_build"
)
def test_skill_file_download_by_agent_validates_member_path(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/missing.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.side_effect = AgentConfigServiceError(
"config_skill_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(
AgentConfigSkillFileDownloadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha"
)
)
assert status == 404
assert body["code"] == "config_skill_file_not_found"
def test_skill_file_download_api_forwards_workflow_node_and_draft_type(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1&draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
patch(
f"{_MOD}.url_for",
return_value="/console/api/apps/app-1/agent/config/skills/alpha/files/content?node_id=node-1&draft_type=debug_build&path=references%2Fguide.md",
) as url_for_mock,
):
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.return_value = "references/guide.md"
response = raw(AgentConfigSkillFileDownloadApi(), unbound_session, _USER, _APP, "alpha")
assert response.status_code == 200
assert response.get_json()["url"].endswith(
"/apps/app-1/agent/config/skills/alpha/files/content?node_id=node-1&draft_type=debug_build&path=references%2Fguide.md"
)
assert url_for_mock.call_args.kwargs == {
"_external": False,
"app_id": "app-1",
"draft_type": "debug_build",
"name": "alpha",
"node_id": "node-1",
"path": "references/guide.md",
}
def test_skill_file_download_api_propagates_member_lookup_404s(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1&path=references/missing.md"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.resolve_skill_file_member_path.side_effect = AgentConfigServiceError(
"config_skill_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(AgentConfigSkillFileDownloadApi(), unbound_session, _USER, _APP, "alpha")
)
assert status == 404
assert body["code"] == "config_skill_file_not_found"
def test_file_download_api_returns_signed_url_json(unbound_session: Session) -> None:
raw = _raw(AgentConfigFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.download_file_url.return_value = "https://example.com/guide.txt"
response = raw(AgentConfigFileDownloadApi(), unbound_session, _USER, _APP, "guide.txt")
assert response.status_code == 200
assert response.get_json() == {"url": "https://example.com/guide.txt"}
@pytest.mark.parametrize("upload_ids", [[], ["invalid-uuid"]])
def test_batch_file_upload_payload_requires_nonempty_uuid_list(upload_ids: list[str]) -> None:
with pytest.raises(ValidationError):
inspector.AgentConfigFilesUploadPayload.model_validate({"upload_file_ids": upload_ids})
@pytest.mark.parametrize("workflow_node", [False, True])
def test_batch_file_upload_routes_bind_and_serialize_real_workspace_files(
sqlite_session: Session, workflow_node: bool
) -> None:
tenant_id = "11111111-1111-1111-1111-111111111111"
agent_id = "22222222-2222-2222-2222-222222222222"
app_id = "33333333-3333-3333-3333-333333333333"
account_id = "44444444-4444-4444-4444-444444444444"
draft_id = "55555555-5555-5555-5555-555555555555"
file_id = "66666666-6666-6666-6666-666666666666"
workflow_id = "77777777-7777-7777-7777-777777777777"
user = Account(name="Batch uploader", email="batch@example.com")
user.id = account_id
app_model = App(
id=app_id,
tenant_id=tenant_id,
name="Batch app",
description="",
mode=AppMode.WORKFLOW if workflow_node else AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
agent = Agent(
id=agent_id,
tenant_id=tenant_id,
app_id=app_id,
name="Batch agent",
scope=AgentScope.WORKFLOW_ONLY if workflow_node else AgentScope.ROSTER,
source=AgentSource.WORKFLOW if workflow_node else AgentSource.AGENT_APP,
)
draft = AgentConfigDraft(
id=draft_id,
tenant_id=tenant_id,
agent_id=agent_id,
draft_type=AgentConfigDraftType.DRAFT,
config_snapshot=AgentSoulConfig(),
)
upload = UploadFile(
tenant_id=tenant_id,
storage_type=StorageType.LOCAL,
key="uploads/batch.txt",
name="batch.txt",
size=5,
extension="txt",
mime_type="text/plain",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account_id,
created_at=datetime(2025, 1, 1),
used=False,
)
upload.id = file_id
sqlite_session.add_all([app_model, agent, draft, upload])
if workflow_node:
sqlite_session.add(
Workflow(
id=workflow_id,
tenant_id=tenant_id,
app_id=app_id,
type=WorkflowType.WORKFLOW,
version="draft",
graph="{}",
_features="{}",
created_by=account_id,
)
)
sqlite_session.add(
WorkflowAgentNodeBinding(
tenant_id=tenant_id,
app_id=app_id,
workflow_id=workflow_id,
workflow_version="draft",
node_id="node-1",
binding_type=WorkflowAgentBindingType.INLINE_AGENT,
agent_id=agent_id,
node_job_config=WorkflowNodeJobConfig(),
)
)
sqlite_session.commit()
payload = inspector.AgentConfigFilesUploadPayload(upload_file_ids=[UUID(file_id)])
query = "/?node_id=node-1&draft_type=draft" if workflow_node else "/?draft_type=draft"
with app.test_request_context(query, method="POST"):
if workflow_node:
endpoint = inspector.AgentConfigFilesUploadApi()
body, status = _raw(endpoint.post)(endpoint, payload, sqlite_session, user, app_model)
else:
endpoint = inspector.AgentConfigFilesUploadByAgentApi()
body, status = _raw(endpoint.post)(endpoint, payload, sqlite_session, tenant_id, user, UUID(agent_id))
assert status == 201
assert body["files"] == [
{
"id": "batch.txt",
"name": "batch.txt",
"file_id": file_id,
"is_missing": False,
"size": 5,
"mime_type": "text/plain",
"hash": None,
}
]
assert body["config_version"] == {"id": draft_id, "kind": "draft", "writable": True}
sqlite_session.expire_all()
persisted = sqlite_session.get(AgentConfigDraft, draft_id)
assert persisted is not None
assert [file_ref.file_id for file_ref in persisted.config_snapshot.config_files] == [file_id]
@@ -0,0 +1,138 @@
from configs import dify_config
from controllers.console.app import annotation as annotation_module
from tasks.annotation.batch_import_annotations_task import batch_import_annotations_task
def test_annotation_reply_payload_valid() -> None:
"""Test AnnotationReplyPayload with valid data."""
payload = annotation_module.AnnotationReplyPayload(
score_threshold=0.5,
embedding_provider_name="openai",
embedding_model_name="text-embedding-3-small",
)
assert payload.score_threshold == 0.5
assert payload.embedding_provider_name == "openai"
assert payload.embedding_model_name == "text-embedding-3-small"
def test_annotation_setting_update_payload_valid() -> None:
"""Test AnnotationSettingUpdatePayload with valid data."""
payload = annotation_module.AnnotationSettingUpdatePayload(
score_threshold=0.75,
)
assert payload.score_threshold == 0.75
def test_annotation_list_query_defaults() -> None:
"""Test AnnotationListQuery with default parameters."""
query = annotation_module.AnnotationListQuery()
assert query.page == 1
assert query.limit == 20
assert query.keyword == ""
def test_annotation_list_query_custom_page() -> None:
"""Test AnnotationListQuery with custom page."""
query = annotation_module.AnnotationListQuery(page=3, limit=50)
assert query.page == 3
assert query.limit == 50
def test_annotation_list_query_with_keyword() -> None:
"""Test AnnotationListQuery with keyword."""
query = annotation_module.AnnotationListQuery(keyword="test")
assert query.keyword == "test"
def test_create_annotation_payload_with_message_id() -> None:
"""Test CreateAnnotationPayload with message ID."""
payload = annotation_module.CreateAnnotationPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
question="What is AI?",
)
assert payload.message_id == "550e8400-e29b-41d4-a716-446655440000"
assert payload.question == "What is AI?"
def test_create_annotation_payload_with_text() -> None:
"""Test CreateAnnotationPayload with text content."""
payload = annotation_module.CreateAnnotationPayload(
question="What is ML?",
answer="Machine learning is...",
)
assert payload.question == "What is ML?"
assert payload.answer == "Machine learning is..."
def test_update_annotation_payload() -> None:
"""Test UpdateAnnotationPayload."""
payload = annotation_module.UpdateAnnotationPayload(
question="Updated question",
answer="Updated answer",
)
assert payload.question == "Updated question"
assert payload.answer == "Updated answer"
def test_annotation_reply_status_query_enable() -> None:
"""Test AnnotationReplyStatusQuery with enable action."""
query = annotation_module.AnnotationReplyStatusQuery(action="enable")
assert query.action == "enable"
def test_annotation_reply_status_query_disable() -> None:
"""Test AnnotationReplyStatusQuery with disable action."""
query = annotation_module.AnnotationReplyStatusQuery(action="disable")
assert query.action == "disable"
def test_annotation_file_payload_valid() -> None:
"""Test AnnotationFilePayload with valid message ID."""
payload = annotation_module.AnnotationFilePayload(message_id="550e8400-e29b-41d4-a716-446655440000")
assert payload.message_id == "550e8400-e29b-41d4-a716-446655440000"
class TestAnnotationImportTaskOptimization:
"""Test optimizations in batch import task."""
def test_task_is_registered_with_queue(self) -> None:
"""Test that task is registered with the correct queue."""
# Celery sets `queue` on the registered task at runtime; the Task type does not declare it.
assert batch_import_annotations_task.queue == "dataset" # pyrefly: ignore[missing-attribute]
class TestConfigurationValues:
"""Test that security configuration values are properly set."""
def test_rate_limit_configs_exist(self) -> None:
"""Test that rate limit configurations are defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_RATE_LIMIT_PER_MINUTE")
assert hasattr(dify_config, "ANNOTATION_IMPORT_RATE_LIMIT_PER_HOUR")
assert dify_config.ANNOTATION_IMPORT_RATE_LIMIT_PER_MINUTE > 0
assert dify_config.ANNOTATION_IMPORT_RATE_LIMIT_PER_HOUR > 0
def test_file_size_limit_config_exists(self) -> None:
"""Test that file size limit configuration is defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_FILE_SIZE_LIMIT")
assert dify_config.ANNOTATION_IMPORT_FILE_SIZE_LIMIT > 0
assert dify_config.ANNOTATION_IMPORT_FILE_SIZE_LIMIT <= 10 # Reasonable max (10MB)
def test_record_limit_configs_exist(self) -> None:
"""Test that record limit configurations are defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_MAX_RECORDS")
assert hasattr(dify_config, "ANNOTATION_IMPORT_MIN_RECORDS")
assert dify_config.ANNOTATION_IMPORT_MAX_RECORDS > 0
assert dify_config.ANNOTATION_IMPORT_MIN_RECORDS > 0
assert dify_config.ANNOTATION_IMPORT_MIN_RECORDS < dify_config.ANNOTATION_IMPORT_MAX_RECORDS
def test_concurrency_limit_config_exists(self) -> None:
"""Test that concurrency limit configuration is defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_MAX_CONCURRENT")
assert dify_config.ANNOTATION_IMPORT_MAX_CONCURRENT > 0
assert dify_config.ANNOTATION_IMPORT_MAX_CONCURRENT <= 10 # Reasonable upper bound
def test_annotation_count_response() -> None:
assert annotation_module.AnnotationCountResponse(count=10).count == 10
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,918 @@
import io
import zipfile
from collections.abc import Callable, Iterator
from dataclasses import dataclass, field
from inspect import unwrap
from typing import BinaryIO, Protocol, cast
from unittest.mock import Mock
from uuid import UUID, uuid4
import httpx
import pytest
from flask import Flask
from flask_restx import Resource
from pydantic import ValidationError
from sqlalchemy import Engine, event, select
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from constants.dsl_version import CURRENT_APP_DSL_VERSION
from controllers.console.app import app as app_module
from controllers.console.app import app_import as console
from controllers.console.app import app_import as controller
from controllers.console.app import app_import as import_module
from controllers.console.app.error import AppNotFoundError, DraftWorkflowNotSync
from controllers.inner_api.app import dsl as inner
from controllers.openapi import app_dsl as openapi
from controllers.openapi._errors import OpenApiErrorFormatter
from controllers.openapi._models import AppDslImportPayload
from core.rbac import RBACPermission
from enums import DeploymentEdition
from extensions.ext_redis import redis_client
from libs.external_api import ExternalApi
from machinery.context import RequestContext
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from models.model import App, AppMode
from services import app_import_source
from services.agent.errors import InvalidRosterAgentPackageError
from services.agent.roster_package_importer import RosterAgentPackageImportResult
from services.app.console_gateway import AppTransferGateway, EnterpriseConsoleAppAccess
from services.app_dsl_service import AppDslService, PendingData
from services.app_package_service import AppPackageService, PreparedAppPackage
from services.billing_client import transport
from services.enterprise.enterprise_service import EnterpriseService
from services.entities.dsl_entities import AppImportPackage, AppImportParams, DslImportWarning, Import, ImportStatus
from services.entities.feature_entities import FeatureModel, LimitationModel
from services.errors.app import DraftChangedError
from services.errors.base import NoPermissionError
from services.feature_service import FeatureService
from services.plugin.dependencies_analysis import DependenciesAnalysisService
from services.recommended_app_package_service import RecommendedAgentPackageSource, RecommendedAppPackageService
from services.system_feature_service import SystemFeatureService
from tests.helpers.unit.config_override import apply_config_overrides
from tests.unit_tests.controllers.conftest import ControllerTestServices
"""Console imports finalize persistence before publishing permissions and access settings."""
class TestAppImportApiCases:
@staticmethod
@pytest.fixture
def import_context(sqlite_session_factory: sessionmaker[Session]) -> RequestContext:
account_id, tenant_id = str(uuid4()), str(uuid4())
account = Account(name="Importer", email="importer@example.com")
account.id = account_id
tenant = Tenant(name="Workspace")
tenant.id = tenant_id
with sqlite_session_factory.begin() as session:
session.add_all(
[
account,
tenant,
TenantAccountJoin(tenant_id=tenant_id, account_id=account_id, role=TenantAccountRole.OWNER),
]
)
return RequestContext("import-request", None, account_id, tenant_id)
@staticmethod
@pytest.fixture
def connections(sqlite_engine: Engine) -> Iterator[set[object]]:
checked_out: set[object] = set()
def checkout(connection: object, *_args: object) -> None:
checked_out.add(connection)
def checkin(connection: object, *_args: object) -> None:
checked_out.remove(connection)
event.listen(sqlite_engine, "checkout", checkout)
event.listen(sqlite_engine, "checkin", checkin)
try:
yield checked_out
assert not checked_out
finally:
event.remove(sqlite_engine, "checkout", checkout)
event.remove(sqlite_engine, "checkin", checkin)
@staticmethod
@pytest.mark.usefixtures("app_query_services")
@pytest.mark.parametrize("confirm", [False, True])
@pytest.mark.parametrize("overwrite", [False, True])
@pytest.mark.parametrize("status", list(ImportStatus))
def test_import_transaction_and_response_contract(
app: Flask,
sqlite_session_factory: sessionmaker[Session],
import_context: RequestContext,
connections: set[object],
monkeypatch: pytest.MonkeyPatch,
config_overrides,
status: ImportStatus,
overwrite: bool,
confirm: bool,
) -> None:
config_overrides(RBAC_ENABLED=True, DEPLOYMENT_EDITION="COMMUNITY")
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *a, **k: True
)
app_id = str(uuid4())
result = Import(id="import-1", status=status, app_id=app_id, app_created=not overwrite)
pending = PendingData(
tenant_id=import_context.active_workspace_id,
account_id=import_context.account_id,
import_mode="yaml-content",
yaml_content="app: {}",
app_id=app_id if overwrite else None,
)
monkeypatch.setattr(redis_client, "get", lambda _key: pending.model_dump_json())
def persist(dsl: AppDslService, *, account: Account, **_kwargs) -> Import:
assert not connections, "Actor lookup must release its connection before starting the DSL operation"
assert account.id == import_context.account_id
assert account.current_tenant_id == import_context.active_workspace_id
dsl._session.add(
App(
id=app_id,
tenant_id=account.current_tenant_id,
name="Imported",
mode=AppMode.WORKFLOW,
enable_site=True,
enable_api=True,
)
)
dsl._session.flush()
return result
monkeypatch.setattr(AppDslService, "confirm_import" if confirm else "import_app", persist)
permissions: list[str] = []
access_updates: list[tuple[str, str]] = []
def get_permissions(_self, context: RequestContext, imported_id: str) -> list[str]:
assert not connections
assert context == import_context
with sqlite_session_factory() as session:
assert session.get(App, imported_id) is not None
permissions.append(imported_id)
return ["app.acl.view_layout"]
def update_access(imported_id: str, access_mode: str) -> None:
assert not connections, "WebApp access initialization must follow transaction completion"
access_updates.append((imported_id, access_mode))
monkeypatch.setattr(EnterpriseConsoleAppAccess, "created_permissions", get_permissions)
monkeypatch.setattr(SystemFeatureService, "is_webapp_auth_enabled", lambda: True)
monkeypatch.setattr(EnterpriseService.WebAppAuth, "update_app_access_mode", update_access)
with app.test_request_context(
method="POST",
json={
"mode": "yaml-content",
"yaml_content": "app: {}",
"app_id": app_id if overwrite else None,
},
):
if confirm:
api = controller.AppImportConfirmApi()
response, status_code = unwrap(api.post)(api, import_context, import_id="import-1")
else:
api = controller.AppImportApi()
response, status_code = unwrap(api.post)(api, import_context)
with sqlite_session_factory() as session:
assert (session.get(App, app_id) is not None) is (status != ImportStatus.FAILED)
completed = status in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}
assert permissions == ([app_id] if completed and not overwrite else [])
assert response["permission_keys"] == (["app.acl.view_layout"] if permissions else [])
# Overwrites keep the existing web app access mode; only completed creations get the private default.
assert access_updates == ([(app_id, "private")] if completed and not overwrite else [])
assert status_code == (
400 if status == ImportStatus.FAILED else 202 if status == ImportStatus.PENDING and not confirm else 200
)
@staticmethod
@pytest.mark.usefixtures("app_query_services")
@pytest.mark.parametrize("missing", [False, True])
def test_check_dependencies_releases_database_before_plugin_io(
app: Flask,
import_context: RequestContext,
sqlite_session_factory: sessionmaker[Session],
connections: set[object],
monkeypatch: pytest.MonkeyPatch,
missing: bool,
) -> None:
app_id = str(uuid4())
if not missing:
with sqlite_session_factory.begin() as session:
session.add(
App(
id=app_id,
tenant_id=import_context.active_workspace_id,
name="Imported",
mode=AppMode.CHAT,
enable_site=True,
enable_api=True,
)
)
monkeypatch.setattr(redis_client, "get", lambda _key: '{"dependencies":[]}')
called = []
def check(*, tenant_id: str, dependencies):
assert not connections
assert tenant_id == import_context.active_workspace_id
called.append(dependencies)
return []
monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", check)
api = controller.AppImportCheckDependenciesApi()
with app.test_request_context():
if missing:
with pytest.raises(AppNotFoundError):
unwrap(api.get)(api, import_context, app_id=app_id)
assert called == []
else:
response, code = unwrap(api.get)(api, import_context, app_id=app_id)
assert code == 200
assert response == {"leaked_dependencies": []}
assert called == [[]]
@staticmethod
@pytest.mark.parametrize("confirm", [False, True])
def test_permission_errors_are_mapped_at_http_boundary(
app_query_services, app: Flask, monkeypatch, confirm: bool
) -> None:
def denied(*_args, **_kwargs):
raise NoPermissionError("Import denied")
monkeypatch.setattr(app_query_services.apps.console, "confirm_import" if confirm else "import_app", denied)
context = RequestContext("request", None, "actor", "workspace")
with app.test_request_context(method="POST", json={"mode": "yaml-content"}):
if confirm:
api = controller.AppImportConfirmApi()
with pytest.raises(Forbidden, match="Import denied"):
unwrap(api.post)(api, context, import_id="import-1")
else:
api = controller.AppImportApi()
with pytest.raises(Forbidden, match="Import denied"):
unwrap(api.post)(api, context)
@staticmethod
def test_confirming_an_import_whose_draft_changed_is_a_conflict(
app_query_services, app: Flask, monkeypatch
) -> None:
"""A pending openapi import carries a draft_hash; a console confirm after the draft changed must not 500."""
def changed(*_args, **_kwargs):
raise DraftChangedError()
monkeypatch.setattr(app_query_services.apps.console, "confirm_import", changed)
context = RequestContext("request", None, "actor", "workspace")
with app.test_request_context(method="POST"):
api = controller.AppImportConfirmApi()
with pytest.raises(DraftWorkflowNotSync) as exc_info:
unwrap(api.post)(api, context, import_id="import-1")
assert exc_info.value.code == 409
@staticmethod
def test_import_response_schema_hides_creation_marker() -> None:
assert "app_created" not in controller.console_ns.models[Import.__name__].__schema__["properties"]
def _roster_archive() -> io.BytesIO:
source = io.BytesIO()
with zipfile.ZipFile(source, "w") as archive:
# Fixed timestamp: passing a filename string stamps the current local
# time (2-second ZIP resolution), so two archives built across a
# timestamp boundary differ byte-for-byte and flake the assertion below.
info = zipfile.ZipInfo("manifest.yaml", date_time=(1980, 1, 1, 0, 0, 0))
archive.writestr(info, "format: dify.roster-agent")
source.seek(0)
return source
def _mock_download(monkeypatch: pytest.MonkeyPatch, content: bytes | None = None) -> list[str]:
calls: list[str] = []
def fetch(method: str, url: str, **_kwargs: object) -> httpx.Response:
calls.append(url)
return httpx.Response(
200,
content=content if content is not None else _roster_archive().getvalue(),
request=httpx.Request(method, url),
)
monkeypatch.setattr(app_import_source.remote_fetcher, "make_request", fetch)
return calls
@dataclass(frozen=True)
class AgentImportCall:
tenant_id: str
account: Account
content: bytes
@dataclass
class Imports:
context: RequestContext
dsl_calls: list[AppImportParams] = field(default_factory=list)
packages: list[PreparedAppPackage] = field(default_factory=list)
agent_calls: list[AgentImportCall] = field(default_factory=list)
status: ImportStatus = ImportStatus.COMPLETED
app_created: bool = False
warnings: list[DslImportWarning] = field(default_factory=list)
def dsl(
self, context: RequestContext, params: AppImportParams, *, package: AppImportPackage | None = None
) -> Import:
assert context == self.context
self.dsl_calls.append(params)
if package is not None:
assert isinstance(package, PreparedAppPackage)
assert not package.archive.closed
self.packages.append(package)
return Import(id="import-1", status=self.status, app_id="app-1", app_created=self.app_created)
def agent(self, *, source: BinaryIO, tenant_id: str, account: Account) -> RosterAgentPackageImportResult:
self.agent_calls.append(AgentImportCall(tenant_id, account, source.read()))
return RosterAgentPackageImportResult(app_id="app-1", agent_id="agent-1", warnings=self.warnings)
def _post(
app: Flask,
imports: Imports,
*,
json: dict[str, object] | None = None,
data: dict[str, object] | None = None,
) -> tuple[dict[str, object], int]:
api = import_module.AppImportApi()
with app.test_request_context("/console/api/apps/imports", method="POST", json=json, data=data):
return cast(tuple[dict[str, object], int], unwrap(api.post)(api, imports.context))
class TestRosterPackageRoutesCases:
@staticmethod
@pytest.fixture
def imports(
app_query_services: ControllerTestServices,
sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> Imports:
config_overrides(RBAC_ENABLED=False, DEPLOYMENT_EDITION="COMMUNITY")
actor, tenant = str(uuid4()), str(uuid4())
account = Account(name="Importer", email="importer@example.com")
account.id = actor
workspace = Tenant(name="Workspace")
workspace.id = tenant
with sqlite_session_factory.begin() as session:
session.add_all(
[
account,
workspace,
TenantAccountJoin(tenant_id=tenant, account_id=actor, role=TenantAccountRole.OWNER),
]
)
result = Imports(RequestContext("request", None, actor, tenant))
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", result.dsl)
monkeypatch.setattr(transfers._agent_importer, "import_package", result.agent)
monkeypatch.setattr("services.app.console_gateway.SystemFeatureService.is_webapp_auth_enabled", lambda: False)
return result
@staticmethod
def test_existing_import_route_dispatches_json_without_changing_payload(app: Flask, imports: Imports) -> None:
data, status = _post(app, imports, json={"mode": "yaml-content", "yaml_content": "app: {}"})
assert status == 200
assert data["status"] == "completed"
assert [params.model_dump() for params in imports.dsl_calls] == [
AppImportParams(mode="yaml-content", yaml_content="app: {}").model_dump()
]
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize(
"url",
[
"https://example.com/download?id=123",
"https://example.com/agent.ifpkg",
" https://example.com/agent.IFPKG?token=secret#download ",
],
)
def test_package_url_uses_agent_import(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, url: str
) -> None:
fetched = _mock_download(monkeypatch)
data, status = _post(app, imports, json={"mode": "yaml-url", "yaml_url": url})
assert status == 200
assert data["app_mode"] == "agent"
assert data["status"] == "completed"
assert len(fetched) == 1
assert imports.dsl_calls == []
(call,) = imports.agent_calls
assert call.tenant_id == imports.context.active_workspace_id
assert call.account.id == imports.context.account_id
assert call.account.is_admin_or_owner is True
@staticmethod
@pytest.mark.parametrize(
"url", ["https://example.com/app.yaml", "https://example.com/download", "https://example.com/agent.ifpkg"]
)
def test_yaml_url_keeps_dsl_import_without_package_retry(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, url: str
) -> None:
imports.status = ImportStatus.FAILED
fetched = _mock_download(monkeypatch, b"app: {}")
_, status = _post(
app, imports, json={"mode": "yaml-url", "yaml_url": url, "app_id": "existing", "name": "Renamed"}
)
assert status == 400
assert (
imports.dsl_calls[0].model_dump()
== AppImportParams(
mode="yaml-content", yaml_content="app: {}", app_id="existing", name="Renamed"
).model_dump()
)
assert len(fetched) == 1
assert imports.agent_calls == []
@staticmethod
def test_url_without_any_import_permission_does_not_download(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
fetched = _mock_download(monkeypatch)
with pytest.raises(Forbidden):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert fetched == []
@staticmethod
@pytest.mark.parametrize("is_yaml", [False, True])
def test_url_quota_is_enforced_after_content_detection(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
is_yaml: bool,
) -> None:
config_overrides(DEPLOYMENT_EDITION="CLOUD")
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", AppTransferGateway.import_dsl.__get__(transfers))
features = FeatureModel(apps=LimitationModel(size=1, limit=1))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_a, **_k: features)
_mock_download(monkeypatch, b"app: {mode: workflow}" if is_yaml else _roster_archive().getvalue())
if is_yaml:
with pytest.raises(Forbidden, match="number of apps"):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert imports.agent_calls == []
assert imports.dsl_calls == []
else:
data, status = _post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert status == 200
assert data["app_mode"] == "agent"
@staticmethod
def test_url_rejects_content_that_is_neither_yaml_nor_package(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch
) -> None:
fetched = _mock_download(monkeypatch, b"[invalid")
with pytest.raises(InvalidRosterAgentPackageError):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert len(fetched) == 1
@staticmethod
@pytest.mark.parametrize("has_warning", [False, True])
def test_existing_import_route_accepts_package_and_preserves_import_response(
app: Flask, imports: Imports, has_warning: bool
) -> None:
imports.warnings = (
[DslImportWarning(code="agent_skill_missing", path="skills.s_000001", message="Missing Skill")]
if has_warning
else []
)
data, status = _post(app, imports, data={"file": (_roster_archive(), "agent.ifpkg")})
assert status == 200
assert data["app_id"] == "app-1"
assert data["app_mode"] == "agent"
assert data["status"] == ("completed-with-warnings" if has_warning else "completed")
assert data["warnings"] == [warning.model_dump(mode="json") for warning in imports.warnings]
assert data["id"]
assert imports.agent_calls[0].content == _roster_archive().getvalue()
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("denied", [RBACPermission.AGENT_CREATE, RBACPermission.AGENT_IMPORT_EXPORT_DSL])
def test_package_import_checks_agent_permissions_before_materializing_resources(
app: Flask,
imports: Imports,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
denied: RBACPermission,
from_url: bool,
) -> None:
config_overrides(RBAC_ENABLED=True)
_mock_download(monkeypatch)
scenes: list[RBACPermission] = []
def check(*_args: object, scene: RBACPermission, **_kwargs: object) -> bool:
scenes.append(scene)
return scene != denied
monkeypatch.setattr("services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", check)
kwargs: dict[str, dict[str, object]] = (
{"json": {"mode": "yaml-url", "yaml_url": "https://example.com/agent.ifpkg"}}
if from_url
else {"data": {"file": (_roster_archive(), "agent.ifpkg")}}
)
with pytest.raises(Forbidden):
_post(app, imports, **kwargs)
assert denied in scenes
if not from_url:
assert RBACPermission.APP_IMPORT_EXPORT_DSL not in scenes
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
def test_package_import_rejects_overwrite(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, from_url: bool
) -> None:
_mock_download(monkeypatch)
kwargs: dict[str, dict[str, object]] = (
{"json": {"mode": "yaml-url", "yaml_url": "https://example.com/agent.ifpkg", "app_id": "existing"}}
if from_url
else {"data": {"app_id": "existing", "file": (_roster_archive(), "agent.ifpkg")}}
)
with pytest.raises(InvalidRosterAgentPackageError, match="overwriting"):
_post(app, imports, **kwargs)
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("app_id", [None, "existing"])
@pytest.mark.parametrize("status", [ImportStatus.COMPLETED, ImportStatus.PENDING, ImportStatus.FAILED])
def test_ordinary_package_import_uses_dsl_permissions_and_confirmation(
app: Flask,
imports: Imports,
monkeypatch: pytest.MonkeyPatch,
app_id: str | None,
status: ImportStatus,
from_url: bool,
) -> None:
imports.status = status
dsl = "kind: app\nversion: 99.0.0\napp:\n mode: workflow\n"
with AppPackageService().export(dsl=dsl, name="Workflow", workflow_tools=[]) as package:
form: dict[str, object] = {"file": (package.archive, "workflow.ifpkg"), "name": "Renamed"}
if app_id:
form["app_id"] = app_id
if from_url:
_mock_download(monkeypatch, package.archive.read())
data, code = _post(
app,
imports,
json={
"mode": "yaml-url",
"yaml_url": "https://example.com/workflow.ifpkg",
"name": "Renamed",
"app_id": app_id,
},
)
else:
data, code = _post(app, imports, data=form)
assert code == {ImportStatus.FAILED: 400, ImportStatus.PENDING: 202}.get(status, 200)
assert len(imports.packages) == 1
assert imports.packages[0].archive.closed
assert data["status"] == status
assert len(imports.dsl_calls) == 1
assert (
imports.dsl_calls[0].model_dump()
== AppImportParams(mode="yaml-content", yaml_content=dsl, name="Renamed", app_id=app_id).model_dump()
)
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("overwrite", [False, True])
def test_ordinary_package_import_keeps_access_mode_on_overwrite(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, overwrite: bool, from_url: bool
) -> None:
imports.app_created = not overwrite
access_updates: list[tuple[str, str]] = []
monkeypatch.setattr("services.app.console_gateway.SystemFeatureService.is_webapp_auth_enabled", lambda: True)
monkeypatch.setattr(
EnterpriseService.WebAppAuth,
"update_app_access_mode",
lambda app_id, access_mode: access_updates.append((app_id, access_mode)),
)
app_id = "app-1" if overwrite else None
with AppPackageService().export(
dsl="kind: app\napp:\n mode: workflow\n", name="Workflow", workflow_tools=[]
) as package:
if from_url:
_mock_download(monkeypatch, package.archive.read())
_data, code = _post(
app,
imports,
json={"mode": "yaml-url", "yaml_url": "https://example.com/workflow.ifpkg", "app_id": app_id},
)
else:
form: dict[str, object] = {"file": (package.archive, "workflow.ifpkg")}
if app_id:
form["app_id"] = app_id
_data, code = _post(app, imports, data=form)
assert code == 200
assert access_updates == ([] if overwrite else [("app-1", "private")])
@staticmethod
def test_export_query_rejects_conflicting_version_selectors() -> None:
with pytest.raises(ValidationError, match="version_id and workflow_id cannot be used together"):
app_module.AppExportQuery.model_validate(
{"version_id": "11111111-1111-4111-8111-111111111111", "workflow_id": "workflow-1"}
)
@staticmethod
def test_template_import_resolves_catalog_source_and_preserves_overrides(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
template_id = UUID("11111111-1111-4111-8111-111111111111")
version_id = UUID("22222222-2222-4222-8222-222222222222")
source = RecommendedAgentPackageSource("source-tenant", "source-agent", version_id)
catalog = Mock()
catalog.get_package_source.return_value = source
transfers._recommended_packages = RecommendedAppPackageService(sources=catalog, exporter=Mock())
import_template = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_template", import_template)
data, status = _post(
app,
imports,
json={
"mode": "template",
"template_id": str(template_id),
"version_id": str(version_id),
"name": "My Agent",
"app_id": "",
},
)
assert status == 200
assert data["app_id"] == "new-app"
assert data["app_mode"] == "agent"
catalog.get_package_source.assert_called_once_with(str(template_id), version_id)
import_template.assert_called_once()
assert import_template.call_args.kwargs["source"] == source
assert import_template.call_args.kwargs["tenant_id"] == imports.context.active_workspace_id
assert import_template.call_args.kwargs["account"].id == imports.context.account_id
assert import_template.call_args.kwargs["name"] == "My Agent"
@staticmethod
def test_template_import_rejects_unlisted_source(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
catalog = Mock()
catalog.get_package_source.return_value = None
transfers._recommended_packages = RecommendedAppPackageService(sources=catalog, exporter=Mock())
import_template = Mock()
monkeypatch.setattr(transfers._agent_importer, "import_template", import_template)
with pytest.raises(import_module.RecommendedAppNotFoundHttpError):
_post(
app,
imports,
json={
"mode": "template",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
},
)
import_template.assert_not_called()
@staticmethod
def test_package_url_import_preserves_overrides(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
import_url = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_package_url", import_url)
data, status = _post(
app,
imports,
json={"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg", "name": "My Agent"},
)
assert status == 200
assert data["app_id"] == "new-app"
import_url.assert_called_once()
assert import_url.call_args.kwargs["url"] == "https://example.com/agent.ifpkg"
assert import_url.call_args.kwargs["name"] == "My Agent"
@staticmethod
def test_package_url_retains_legacy_optional_selectors(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
import_url = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_package_url", import_url)
data, status = _post(
app,
imports,
json={
"mode": "ifpkg-url",
"package_url": "https://example.com/agent.ifpkg",
"app_id": "",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
},
)
assert status == 200
assert data["app_id"] == "new-app"
import_url.assert_called_once()
assert import_url.call_args.kwargs["url"] == "https://example.com/agent.ifpkg"
@staticmethod
@pytest.mark.parametrize("mode", ["template", "ifpkg-url"])
def test_template_import_checks_permissions_before_accessing_source(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
mode: str,
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
importer = Mock()
monkeypatch.setattr(transfers, "_agent_importer", importer)
payload: dict[str, object] = (
{
"mode": "template",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
}
if mode == "template"
else {"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg"}
)
with pytest.raises(Forbidden):
_post(app, imports, json=payload)
importer.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
"extra",
[
{"app_id": "existing"},
{"yaml_content": "app: {}"},
],
)
def test_package_url_rejects_ambiguous_sources(app: Flask, imports: Imports, extra: dict[str, str]) -> None:
with pytest.raises(InvalidRosterAgentPackageError):
_post(app, imports, json={"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg", **extra})
@staticmethod
@pytest.mark.parametrize("quota", [False, True])
def test_ordinary_package_import_checks_permission_and_quota(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
quota: bool,
) -> None:
config_overrides(RBAC_ENABLED=not quota, DEPLOYMENT_EDITION="CLOUD" if quota else "COMMUNITY")
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", AppTransferGateway.import_dsl.__get__(transfers))
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
features = FeatureModel(apps=LimitationModel(size=1, limit=1))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_a, **_k: features)
with AppPackageService().export(
dsl="kind: app\napp: {mode: workflow}\n", name="Workflow", workflow_tools=[]
) as package:
with pytest.raises(Forbidden):
_post(app, imports, data={"file": (package.archive, "workflow.ifpkg")})
assert imports.dsl_calls == []
"""Quota failures retain their HTTP semantics across both app import surfaces."""
class _EndpointView(Protocol):
__handler__: Callable[..., tuple[object, int]]
class TestAppImportQuotaCases:
@staticmethod
@pytest.mark.parametrize(
("surface", "confirm"),
[("console", False), ("console", True), ("openapi", False), ("openapi", True), ("inner", False)],
)
@pytest.mark.parametrize("failure", ["timeout", "upstream_503", "invalid_response", "quota_exhausted"])
def test_import_quota_failure_http_status(
app_query_services: ControllerTestServices,
sqlite_session: Session,
monkeypatch: pytest.MonkeyPatch,
surface: str,
confirm: bool,
failure: str,
) -> None:
apply_config_overrides(
monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, INNER_API=True, INNER_API_KEY="test-inner-api-key"
)
monkeypatch.setattr("controllers.console.wraps._is_setup_completed", lambda: True)
account = Account(name="Importer", email="importer@example.com")
tenant = Tenant(name="Workspace")
account.id, tenant.id = str(uuid4()), str(uuid4())
sqlite_session.add_all(
[
account,
tenant,
TenantAccountJoin(tenant_id=tenant.id, account_id=account.id, role=TenantAccountRole.OWNER),
]
)
sqlite_session.commit()
context = RequestContext("request-1", None, account.id, tenant.id)
content = (
f"version: {CURRENT_APP_DSL_VERSION}\napp: {{name: Imported, mode: workflow}}\n"
"workflow: {graph: {nodes: [], edges: []}, features: {}}\n"
)
pending = PendingData(
tenant_id=tenant.id, account_id=account.id, import_mode="yaml-content", yaml_content=content
)
monkeypatch.setattr(redis_client, "get", lambda _: pending.model_dump_json())
def unexpected_side_effect(*_args: object, **_kwargs: object) -> None:
pytest.fail("A failed quota check must preserve pending data and avoid database writes")
monkeypatch.setattr(redis_client, "delete", unexpected_side_effect)
monkeypatch.setattr(AppDslService, "_create_or_update_app", unexpected_side_effect)
if failure == "quota_exhausted":
monkeypatch.setattr(
FeatureService,
"get_features",
lambda *_args, **_kwargs: FeatureModel(apps=LimitationModel(size=5, limit=5)),
)
else:
def failed_billing(*_args: object, **_kwargs: object) -> httpx.Response:
if failure == "timeout":
raise httpx.ReadTimeout("Private billing timeout details")
if failure == "upstream_503":
return httpx.Response(503, text="Private billing failure details")
return httpx.Response(200, json={"subscription": "Private invalid billing response"})
monkeypatch.setattr(transport, "_send", failed_billing)
app = Flask(__name__)
app.config["TESTING"] = True
app.extensions["application_services"] = app_query_services
api = ExternalApi(app, error_body_formatter=OpenApiErrorFormatter() if surface == "openapi" else None)
class AdmittedImport(Resource):
def post(self) -> tuple[object, int]:
if surface == "inner":
return inner.EnterpriseAppDSLImport().post(workspace_id=tenant.id)
if surface == "console":
if confirm:
controller = console.AppImportConfirmApi()
return unwrap(controller.post)(controller, context, import_id="pending-1")
controller = console.AppImportApi()
return unwrap(controller.post)(controller, context)
if confirm:
controller = openapi.AppDslImportConfirmApi()
return cast(_EndpointView, controller.post).__handler__(
controller, context, workspace_id=tenant.id, import_id="pending-1"
)
controller = openapi.AppDslImportApi()
return cast(_EndpointView, controller.post).__handler__(
controller,
context,
workspace_id=tenant.id,
body=AppDslImportPayload(mode="yaml-content", yaml_content=content),
)
api.add_resource(AdmittedImport, "/imports")
response = app.test_client().post(
"/imports",
json={"mode": "yaml-content", "yaml_content": content, "creator_email": account.email},
headers={"X-Inner-Api-Key": "test-inner-api-key"},
)
assert response.status_code == (403 if failure == "quota_exhausted" else 500)
assert "Private" not in response.get_data(as_text=True)
assert sqlite_session.scalar(select(App.id).where(App.tenant_id == tenant.id)) is None
@@ -0,0 +1,912 @@
from __future__ import annotations
import io
from collections.abc import Callable, Iterator
from inspect import unwrap
from unittest.mock import patch
from uuid import UUID
import pytest
from flask import Flask, Response
from sqlalchemy import Engine, event
from sqlalchemy.orm import Session
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden, InternalServerError, UnprocessableEntity
from controllers.console import wraps
from controllers.console.app import audio
from controllers.console.app import audio as audio_module
from controllers.console.app.audio import (
AgentChatMessageAudioApi,
AgentChatMessageTextApi,
AgentTextToSpeechVoicesApi,
ChatMessageAudioApi,
ChatMessageTextApi,
TextModesApi,
TextToSpeechPayload,
TextToSpeechVoiceQuery,
)
from controllers.console.app.error import (
AppUnavailableError,
AudioTooLargeError,
CompletionRequestError,
NoAudioUploadedError,
ProviderModelCurrentlyNotSupportError,
ProviderNotInitializeError,
ProviderNotSupportSpeechToTextError,
ProviderQuotaExceededError,
SpeechToTextDisabledError,
UnsupportedAudioTypeError,
)
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models import Account
from models import App as _audio_App
from models import AppMode as _audio_AppMode
from models.agent import Agent, AgentConfigDraftType, AgentKind, AgentScope, AgentSource, AgentStatus
from models.agent_config_entities import AgentSoulConfig
from models.model import App as _agent_audio_readonly_App
from models.model import AppMode as _agent_audio_readonly_AppMode
from services.agent.composer_service import AgentComposerService
from services.agent.errors import AgentNotFoundError, AgentVersionNotFoundError
from services.app_ref_service import AppRef, MessageRef
from services.audio_service import AudioService
from services.errors.app_model_config import AppModelConfigBrokenError
from services.errors.audio import (
AudioTooLargeServiceError,
NoAudioUploadedServiceError,
ProviderNotSupportSpeechToTextServiceError,
SpeechToTextDisabledServiceError,
UnsupportedAudioTypeServiceError,
)
from tests.helpers.unit.audio_runtime_fixtures import AudioRuntimeObservations
from tests.helpers.unit.model_factories import make_account, make_app
AGENT_ID = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
def _agent(scope: AgentScope = AgentScope.WORKFLOW_ONLY) -> Agent:
workflow_only = scope == AgentScope.WORKFLOW_ONLY
return Agent(
id=str(AGENT_ID),
tenant_id="tenant-1",
name="Audio agent",
agent_kind=AgentKind.DIFY_AGENT,
scope=scope,
source=AgentSource.WORKFLOW if workflow_only else AgentSource.AGENT_APP,
status=AgentStatus.ACTIVE,
app_id="parent-app-1" if workflow_only else "runtime-app-1",
backing_app_id="runtime-app-1" if workflow_only else None,
workflow_id="workflow-1" if workflow_only else None,
workflow_node_id="node-1" if workflow_only else None,
created_by="account-1",
updated_by="account-1",
)
class TestAgentAudioReadonlyCases:
@staticmethod
@pytest.fixture(autouse=True)
def audio_identity(monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]) -> None:
config_overrides(LOGIN_DISABLED=True, RBAC_ENABLED=True)
monkeypatch.setattr(wraps, "_is_setup_completed", lambda: True)
monkeypatch.setattr(wraps, "current_account_with_tenant", lambda: (make_account(), "tenant-1"))
monkeypatch.setattr(audio, "enforce_rbac_checks", lambda **_kwargs: None)
@staticmethod
@pytest.fixture
def persistence_events(sqlite_engine: Engine) -> Iterator[list[str]]:
observed: list[str] = []
def record_statement(
_connection: object,
_cursor: object,
statement: str,
_parameters: object,
_context: object,
_executemany: bool,
) -> None:
operation = statement.lstrip().split(maxsplit=1)[0].upper()
if operation in {"INSERT", "UPDATE", "DELETE"}:
observed.append(operation)
def record_commit(_session: Session) -> None:
observed.append("COMMIT")
event.listen(sqlite_engine, "before_cursor_execute", record_statement)
event.listen(Session, "before_commit", record_commit)
try:
yield observed
finally:
event.remove(sqlite_engine, "before_cursor_execute", record_statement)
event.remove(Session, "before_commit", record_commit)
@staticmethod
@pytest.fixture(params=["voices", "preview"])
def request_audio(
request: pytest.FixtureRequest, app: Flask, audio_runtime: AudioRuntimeObservations
) -> tuple[Callable[[], object], AudioRuntimeObservations]:
if request.param == "voices":
audio_runtime.voices = [{"name": "Echo", "value": "echo"}]
def invoke() -> object:
with app.test_request_context(f"/console/api/agent/{AGENT_ID}/text-to-audio/voices?language=en-US"):
return audio.AgentTextToSpeechVoicesApi().get(agent_id=AGENT_ID)
else:
audio_runtime.tts_result = b"ID3audio"
def invoke() -> object:
with app.test_request_context(
f"/console/api/agent/{AGENT_ID}/text-to-audio",
method="POST",
json={"text": "Preview this voice", "voice": "echo"},
):
response = audio.AgentChatMessageTextApi().post(agent_id=AGENT_ID)
assert response is not None
try:
assert response.get_data() == b"ID3audio"
assert response.content_type == "audio/mpeg"
return response
finally:
response.close()
return invoke, audio_runtime
@staticmethod
@pytest.mark.parametrize("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])
def test_audio_uses_existing_runtime_state_without_writes(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
scope: AgentScope,
) -> None:
agent = _agent(scope)
runtime_app = make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)
sqlite_session.add_all([agent, runtime_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
response = invoke()
assert len(provider.resolutions) == 1
assert response is not None
assert persistence_events == []
@staticmethod
def test_audio_does_not_materialize_a_missing_workflow_backing_app(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
) -> None:
agent = _agent()
agent.backing_app_id = None
parent_app = make_app(app_id="parent-app-1", mode=_agent_audio_readonly_AppMode.WORKFLOW)
sqlite_session.add_all([agent, parent_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
with pytest.raises(AgentNotFoundError):
invoke()
assert provider.resolutions == []
assert provider.daemon_calls == []
assert persistence_events == []
sqlite_session.refresh(agent)
assert agent.backing_app_id is None
assert sqlite_session.get(_agent_audio_readonly_App, "runtime-app-1") is None
@staticmethod
@pytest.mark.parametrize("foreign_owner", ["agent", "app"])
def test_audio_scopes_both_agent_and_runtime_app_to_the_current_tenant(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
foreign_owner: str,
) -> None:
agent = _agent()
runtime_app = make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)
if foreign_owner == "agent":
agent.tenant_id = "tenant-2"
else:
runtime_app.tenant_id = "tenant-2"
sqlite_session.add_all([agent, runtime_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
with pytest.raises(AgentNotFoundError):
invoke()
assert provider.resolutions == []
assert provider.daemon_calls == []
assert persistence_events == []
@staticmethod
@pytest.mark.parametrize(
("provider_error", "expected_error"),
[
(ProviderTokenNotInitError("No TTS model configured"), ProviderNotInitializeError),
(QuotaExceededError(), ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError(), ProviderModelCurrentlyNotSupportError),
(InvokeError("TTS provider unavailable"), CompletionRequestError),
(ValueError("Unknown voice"), ValueError),
(RuntimeError("Unexpected provider failure"), InternalServerError),
],
)
def test_provider_failures_preserve_error_contract_and_readonly_state(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
provider_error: Exception,
expected_error: type[Exception],
) -> None:
sqlite_session.add_all(
[_agent(AgentScope.ROSTER), make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)]
)
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
provider.lookup_error = provider_error
with pytest.raises(expected_error):
invoke()
assert len(provider.resolutions) == 1
assert persistence_events == []
def _file_data():
return FileStorage(stream=io.BytesIO(b"audio"), filename="audio.wav", content_type="audio/wav")
def _app(*, app_id: str = "a1", tenant_id: str = "tenant-1") -> _audio_App:
return make_app(app_id=app_id, tenant_id=tenant_id, name="Audio app", icon_type=None, max_active_requests=0)
def _account(account_id: str = "account-1") -> Account:
return make_account(account_id=account_id, name="Audio account", email=f"{account_id}@example.com")
class TestAudioCases:
@staticmethod
def test_console_audio_api_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: {"text": "ok"})
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
response = handler(api, app_model=app_model)
assert response == {"text": "ok"}
@staticmethod
def test_console_audio_api_accepts_published_agent_apps() -> None:
assert _audio_AppMode.AGENT in audio_module._CONSOLE_AUDIO_TRANSCRIPT_APP_MODES
@staticmethod
def test_agent_console_audio_api_uses_agent_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
agent_soul = AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": True}}})
calls: dict[str, object] = {}
def resolve_agent_runtime_app_model(**kwargs):
calls["resolver"] = kwargs
return app_model
def load_agent_soul_for_debug(**kwargs):
calls["draft"] = kwargs
return agent_soul
def transcript_agent_asr(**kwargs):
calls["asr"] = kwargs
return {"text": "agent transcript"}
def enforce_rbac_checks(**kwargs):
calls["rbac"] = kwargs
monkeypatch.setattr(audio_module, "resolve_agent_runtime_app_model", resolve_agent_runtime_app_model)
monkeypatch.setattr(audio_module, "enforce_rbac_checks", enforce_rbac_checks)
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
monkeypatch.setattr(AudioService, "transcript_agent_asr", transcript_agent_asr)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
session = unbound_session
current_user = _account()
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data(), "draft_type": "debug_build"},
):
response = handler(
api,
session=session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response == {"text": "agent transcript"}
assert calls["resolver"] == {"session": session, "tenant_id": "tenant-1", "agent_id": agent_id}
rbac_call = calls["rbac"]
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == "account-1"
assert rbac_call["path_args"] == {"app_id": "backing-app-1"}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.APP_TEST_AND_RUN
assert isinstance(rbac_check.locator, audio_module.PlainApp)
assert calls["draft"] == {
"tenant_id": "tenant-1",
"agent_id": str(agent_id),
"account_id": "account-1",
"draft_type": AgentConfigDraftType.DEBUG_BUILD,
"session": session,
}
assert calls["asr"] == {
"app_model": app_model,
"agent_soul": agent_soul,
"file": calls["asr"]["file"],
"session": session,
"end_user": None,
}
@staticmethod
def test_agent_console_audio_api_defaults_to_normal_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
captured: dict[str, object] = {}
monkeypatch.setattr(
audio_module,
"resolve_agent_runtime_app_model",
lambda **_kwargs: _app(app_id="backing-app-1"),
)
def load_agent_soul_for_debug(**kwargs):
captured.update(kwargs)
return AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": True}}})
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
monkeypatch.setattr(AudioService, "transcript_agent_asr", lambda **_kwargs: {"text": "ok"})
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data()},
):
response = handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
assert response == {"text": "ok"}
assert captured["draft_type"] == AgentConfigDraftType.DRAFT
@staticmethod
def test_agent_console_audio_api_checks_rbac_with_backing_app_id(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
soul_loaded = False
monkeypatch.setattr(audio_module, "resolve_agent_runtime_app_model", lambda **_kwargs: app_model)
def deny_access(**kwargs):
assert kwargs["path_args"] == {"app_id": "backing-app-1"}
raise Forbidden()
def load_agent_soul_for_debug(**_kwargs):
nonlocal soul_loaded
soul_loaded = True
return AgentSoulConfig()
monkeypatch.setattr(audio_module, "enforce_rbac_checks", deny_access)
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data()},
):
with pytest.raises(Forbidden):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
assert soul_loaded is False
@staticmethod
def test_agent_console_audio_api_preserves_missing_build_draft_404(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
monkeypatch.setattr(
audio_module,
"resolve_agent_runtime_app_model",
lambda **_kwargs: _app(app_id="backing-app-1"),
)
monkeypatch.setattr(
AgentComposerService,
"load_agent_soul_for_debug",
lambda **_kwargs: (_ for _ in ()).throw(AgentVersionNotFoundError()),
)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data(), "draft_type": "debug_build"},
):
with pytest.raises(AgentVersionNotFoundError):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
@staticmethod
@pytest.mark.parametrize(
("exc", "expected"),
[
(AppModelConfigBrokenError(), AppUnavailableError),
(NoAudioUploadedServiceError(), NoAudioUploadedError),
(AudioTooLargeServiceError("too big"), AudioTooLargeError),
(UnsupportedAudioTypeServiceError(), UnsupportedAudioTypeError),
(ProviderNotSupportSpeechToTextServiceError(), ProviderNotSupportSpeechToTextError),
(SpeechToTextDisabledServiceError(), SpeechToTextDisabledError),
(ProviderTokenNotInitError("token"), ProviderNotInitializeError),
(QuotaExceededError(), ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError(), ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke"), CompletionRequestError),
],
)
def test_console_audio_api_error_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch, exc, expected) -> None:
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(exc))
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
with pytest.raises(expected):
handler(api, app_model=app_model)
@staticmethod
def test_console_audio_api_unhandled_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(RuntimeError("boom"))
)
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
with pytest.raises(InternalServerError):
handler(api, app_model=app_model)
@staticmethod
def test_console_text_api_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "ok"})
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/text-to-audio",
method="POST",
json={"text": "hello", "voice": "v"},
):
response = handler(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "ok"}
@staticmethod
def test_console_text_api_builds_message_ref(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app(app_id="app-1")
calls = {}
def fake_transcript_tts(**kwargs):
calls.update(kwargs)
return {"audio": "ok"}
monkeypatch.setattr(AudioService, "transcript_tts", fake_transcript_tts)
with (
app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello", "message_id": "message-1"},
),
patch("controllers.console.app.audio.current_user", _account()),
):
response = handler(api, TextToSpeechPayload(text="hello", message_id="message-1"), app_model=app_model)
assert response == {"audio": "ok"}
assert calls["message_ref"] == MessageRef(AppRef("tenant-1", "app-1"), "message-1", account_id="account-1")
@staticmethod
def test_console_text_api_error_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
AudioService, "transcript_tts", lambda **_kwargs: (_ for _ in ()).throw(QuotaExceededError())
)
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/text-to-audio",
method="POST",
json={"text": "hello"},
):
with pytest.raises(ProviderQuotaExceededError):
handler(api, TextToSpeechPayload(text="hello"), app_model=app_model)
@staticmethod
def test_console_text_modes_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
expected_voices = [{"name": "Voice 1", "value": "voice-1"}]
monkeypatch.setattr(AudioService, "transcript_tts_voices", lambda **_kwargs: expected_voices)
api = TextModesApi()
handler = unwrap(api.get)
app_model = _app(tenant_id="t1")
with app.test_request_context("/console/api/apps/app/text-to-audio/voices?language=en", method="GET"):
response = handler(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert response == expected_voices
@staticmethod
def test_audio_to_text_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
response_payload = {"text": "hello"}
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: response_payload)
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"x"), "sample.wav")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
response = method(api, app_model=app_model)
assert response == response_payload
@staticmethod
def test_audio_to_text_maps_audio_too_large(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
monkeypatch.setattr(
AudioService,
"transcript_asr",
lambda **_kwargs: (_ for _ in ()).throw(AudioTooLargeServiceError("too large")),
)
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"x"), "sample.wav")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
with pytest.raises(AudioTooLargeError):
method(api, app_model=app_model)
@staticmethod
def test_text_to_audio_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "ok"})
app_model = _app(app_id="app-1")
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello"},
):
response = method(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "ok"}
@staticmethod
def test_text_to_audio_voices_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = TextModesApi()
method = unwrap(api.get)
expected_voices = [{"name": "Voice 1", "value": "voice-1"}]
monkeypatch.setattr(AudioService, "transcript_tts_voices", lambda **_kwargs: expected_voices)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio/voices",
method="GET",
query_string={"language": "en-US"},
):
response = method(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert response == expected_voices
@staticmethod
def test_audio_to_text_with_invalid_file(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: {"text": "test"})
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"invalid"), "sample.xyz")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
# Should not raise, AudioService is mocked
response = method(api, app_model=app_model)
assert response == {"text": "test"}
@staticmethod
def test_text_to_audio_with_language_param(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "test"})
app_model = _app(app_id="app-1")
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello", "language": "en-US"},
):
response = method(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "test"}
@staticmethod
def test_text_to_audio_voices_with_language_filter(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = TextModesApi()
method = unwrap(api.get)
monkeypatch.setattr(
AudioService,
"transcript_tts_voices",
lambda **_kwargs: [{"name": "Voice 1", "value": "voice-1"}],
)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio/voices?language=en-US",
method="GET",
):
response = method(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert isinstance(response, list)
@staticmethod
def test_agent_text_to_speech_voices_uses_backing_app_and_language(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
current_user = _account()
voices = [{"name": "Voice 1", "value": "voice-1"}]
api = AgentTextToSpeechVoicesApi()
with (
patch.object(
audio_module, "resolve_existing_agent_runtime_app_model", return_value=app_model
) as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
patch.object(AudioService, "transcript_tts_voices", return_value=voices) as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices?language=en-US"),
):
response = unwrap(api.get)(
api,
TextToSpeechVoiceQuery(language="en-US"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response == voices
resolve_app.assert_called_once_with(session=unbound_session, tenant_id="tenant-1", agent_id=agent_id)
check_access.assert_called_once()
rbac_call = check_access.call_args.kwargs
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == current_user.id
assert rbac_call["path_args"] == {"agent_id": str(agent_id)}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.AGENT_PREVIEW
assert isinstance(rbac_check.locator, audio_module.AgentId)
get_voices.assert_called_once_with(tenant_id="tenant-1", language="en-US")
@staticmethod
def test_agent_text_to_speech_voices_does_not_query_provider_without_permission(
app: Flask, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi()
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks", side_effect=Forbidden()),
patch.object(AudioService, "transcript_tts_voices") as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices?language=en-US"),
pytest.raises(Forbidden),
):
unwrap(api.get)(
api,
TextToSpeechVoiceQuery(language="en-US"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
get_voices.assert_not_called()
resolve_app.assert_not_called()
@staticmethod
def test_agent_text_to_speech_voices_rejects_missing_language(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi()
view = unwrap(api.get)
# Stop at the innermost decorator so request validation runs without the auth and session layers.
handler = unwrap(api.get, stop=lambda f: f.__dict__.get("__wrapped__") is view)
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices", method="GET"),
pytest.raises(UnprocessableEntity),
):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
check_access.assert_not_called()
resolve_app.assert_not_called()
@staticmethod
@pytest.mark.parametrize("message_id", [None, "019ef3d2-b24c-7803-b428-18b5ee8fb854"])
def test_agent_text_to_speech_returns_audio_with_scoped_message(
app: Flask, unbound_session: Session, message_id: str | None
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
current_user = _account()
payload = TextToSpeechPayload(text="Preview this voice", voice="voice-1", message_id=message_id)
audio = Response(b"RIFF\x00\x00\x00\x00WAVE", content_type="audio/wav")
api = AgentChatMessageTextApi()
with (
patch.object(
audio_module, "resolve_existing_agent_runtime_app_model", return_value=app_model
) as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
patch.object(AudioService, "transcript_tts", return_value=audio) as synthesize,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio", method="POST"),
):
response = unwrap(api.post)(
api,
req_data=payload,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response.get_data() == audio.get_data()
assert response.content_type == "audio/wav"
resolve_app.assert_called_once_with(session=unbound_session, tenant_id="tenant-1", agent_id=agent_id)
check_access.assert_called_once()
rbac_call = check_access.call_args.kwargs
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == current_user.id
assert rbac_call["path_args"] == {"agent_id": str(agent_id)}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.AGENT_TEST_AND_RUN
assert isinstance(rbac_check.locator, audio_module.AgentId)
synthesize.assert_called_once_with(
app_model=app_model,
session=unbound_session,
text=payload.text,
voice=payload.voice,
message_ref=MessageRef(AppRef("tenant-1", "backing-app-1"), message_id, account_id=current_user.id)
if message_id
else None,
is_draft=True,
)
@staticmethod
def test_agent_text_to_speech_denies_access_before_resolving_app(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentChatMessageTextApi()
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks", side_effect=Forbidden()),
patch.object(AudioService, "transcript_tts") as synthesize,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio", method="POST"),
pytest.raises(Forbidden),
):
unwrap(api.post)(
api,
req_data=TextToSpeechPayload(text="Preview"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
resolve_app.assert_not_called()
synthesize.assert_not_called()
@staticmethod
@pytest.mark.parametrize("voices", [False, True])
def test_agent_tts_preserves_missing_agent_error(app: Flask, unbound_session: Session, voices: bool) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi() if voices else AgentChatMessageTextApi()
handler = unwrap(api.get if isinstance(api, AgentTextToSpeechVoicesApi) else api.post)
args: dict[str, object] = {
"session": unbound_session,
"current_tenant_id": "tenant-1",
"current_user": _account(),
"agent_id": agent_id,
}
if voices:
args["req_data"] = TextToSpeechVoiceQuery(language="en-US")
else:
args["req_data"] = TextToSpeechPayload(text="Preview")
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model", side_effect=AgentNotFoundError()),
patch.object(audio_module, "enforce_rbac_checks"),
patch.object(AudioService, "transcript_tts") as synthesize,
patch.object(AudioService, "transcript_tts_voices") as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio?language=en-US"),
pytest.raises(AgentNotFoundError),
):
handler(api, **args)
synthesize.assert_not_called()
get_voices.assert_not_called()
@@ -0,0 +1,155 @@
from __future__ import annotations
from decimal import Decimal
from sqlalchemy.orm import Session
from fields.conversation_fields import ConversationResponseSource
from graphon.enums import WorkflowExecutionStatus
from models import Account, EndUser, Message, MessageAnnotation, MessageFeedback
from models.enums import (
ConversationFromSource,
CreatorUserRole,
EndUserType,
FeedbackFromSource,
FeedbackRating,
InvokeFrom,
WorkflowRunTriggeredFrom,
)
from models.model import AppMode, Conversation
from models.workflow import WorkflowRun, WorkflowType
from tests.helpers.unit.model_factories import make_conversation
def _make_account() -> Account:
account = Account(name="Account", email="account@example.com", timezone="UTC")
account.id = "u1"
return account
def _conversation(*, conversation_id: str = "c1", app_id: str = "app-1") -> Conversation:
return make_conversation(
conversation_id=conversation_id,
app_id=app_id,
inputs={},
introduction="",
system_instruction="",
system_instruction_tokens=0,
status="normal",
invoke_from=InvokeFrom.EXPLORE,
from_source=ConversationFromSource.CONSOLE,
from_account_id="u1",
)
def test_conversation_response_source_uses_caller_session(sqlite_session: Session) -> None:
account = _make_account()
end_user = EndUser(
id="end-user-1",
tenant_id="tenant-1",
app_id="app-1",
type=EndUserType.SERVICE_API,
external_user_id="external-user-1",
name="End user",
session_id="end-user-session",
)
conversation = _conversation()
conversation.mode = AppMode.ADVANCED_CHAT
conversation.override_model_configs = "{}"
conversation.summary = "summary"
conversation.inputs = {"topic": "support"}
conversation.from_end_user_id = end_user.id
conversation.from_account_id = account.id
message = Message(
id="message-1",
app_id=conversation.app_id,
model_provider=None,
model_id=None,
override_model_configs=None,
conversation_id=conversation.id,
_inputs={},
query="first question",
message={},
message_tokens=1,
message_unit_price=Decimal(0),
message_price_unit=Decimal("0.001"),
answer="answer",
answer_tokens=1,
answer_unit_price=Decimal(0),
answer_price_unit=Decimal("0.001"),
parent_message_id=None,
provider_response_latency=0,
total_price=Decimal(0),
currency="USD",
error=None,
message_metadata=None,
invoke_from=InvokeFrom.EXPLORE,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=end_user.id,
from_account_id=account.id,
workflow_run_id="run-1",
app_mode=AppMode.ADVANCED_CHAT,
)
annotation = MessageAnnotation(
app_id=conversation.app_id,
question="question",
content="annotation",
account_id=account.id,
conversation_id=conversation.id,
message_id=message.id,
)
feedbacks = [
MessageFeedback(
app_id=conversation.app_id,
conversation_id=conversation.id,
message_id=message.id,
rating=rating,
from_source=source,
from_account_id=account.id,
)
for source, rating in (
(FeedbackFromSource.USER, FeedbackRating.LIKE),
(FeedbackFromSource.USER, FeedbackRating.DISLIKE),
(FeedbackFromSource.ADMIN, FeedbackRating.LIKE),
)
]
workflow_run = WorkflowRun(
id="run-1",
tenant_id="tenant-1",
app_id=conversation.app_id,
workflow_id="workflow-1",
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
version="1",
graph="{}",
inputs="{}",
status=WorkflowExecutionStatus.SUCCEEDED,
outputs="{}",
error=None,
elapsed_time=1,
total_tokens=1,
total_steps=1,
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
finished_at=None,
exceptions_count=0,
)
sqlite_session.add_all([account, end_user, conversation, message, annotation, workflow_run, *feedbacks])
sqlite_session.commit()
source = ConversationResponseSource(conversation, session=sqlite_session)
assert source.inputs == {"topic": "support"}
assert source.model_config == {"model_id": None, "provider": None}
assert source.summary_or_query == "summary"
assert source.annotated is True
annotation_source = source.annotation
assert annotation_source is not None
assert annotation_source.account is account
assert source.message_count == 1
assert source.user_feedback_stats == {"like": 1, "dislike": 1}
assert source.admin_feedback_stats == {"like": 1, "dislike": 0}
assert source.status_count == {"success": 1, "failed": 0, "partial_success": 0, "paused": 0}
assert source.first_message is not None
assert source.from_end_user_session_id == "end-user-session"
assert source.from_account_name == "Account"
@@ -0,0 +1,245 @@
"""Console conversation-variable behavior through the decorated resource and real SQL."""
from collections.abc import Callable
from datetime import datetime, timedelta
from typing import TypedDict, cast
from unittest.mock import create_autospec
from uuid import UUID
import pytest
from flask import Flask
from sqlalchemy import Engine
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden, UnprocessableEntity
from controllers.console.app.conversation_variables import ConversationVariablesApi
from controllers.console.app.error import AppNotFoundError
from controllers.console.workspace.error import AccountNotInitializedError
from controllers.console.wraps import RBACPermission
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from factories import variable_factory
from libs import login
from models import AppMode, ConversationVariable
from models.account import Account, AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from services.enterprise.rbac_service import RBACService
from tests.helpers.unit.model_factories import make_account, make_app, make_tenant
APP_ID = "11111111-1111-1111-1111-111111111111"
OTHER_APP_ID = "22222222-2222-2222-2222-222222222222"
CONVERSATION_ID = "33333333-3333-3333-3333-333333333333"
class VariablePage(TypedDict):
page: int
limit: int
total: int
has_more: bool
data: list[dict[str, str | int | None]]
@pytest.fixture(autouse=True)
def admitted_account(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
) -> Account:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, LOGIN_DISABLED=True, RBAC_ENABLED=False)
account = make_account(tenant=make_tenant(), role=TenantAccountRole.NORMAL)
monkeypatch.setattr(login, "_resolve_current_user", lambda: account)
# Legacy admission still reads through the request session. New query
# adapters use the separately owned session factory bound to the same DB.
monkeypatch.setattr(db, "session", sqlite_session)
monkeypatch.setattr(type(db), "engine", property(lambda _self: sqlite_engine))
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.CLOUD,
initialization_password="",
redis=create_autospec(RedisClientWrapper, instance=True),
)
monkeypatch.setitem(app.extensions, "application_services", services)
sqlite_session.add(make_app(app_id=APP_ID, mode=AppMode.ADVANCED_CHAT))
sqlite_session.commit()
return account
def _get(app: Flask, *, app_id: str = APP_ID, conversation_id: str | None = CONVERSATION_ID) -> VariablePage:
params: dict[str, str] = {} if conversation_id is None else {"conversation_id": conversation_id}
with app.test_request_context(f"/console/api/apps/{app_id}/conversation-variables", query_string=params):
response = ConversationVariablesApi().get(app_id=UUID(app_id))
assert isinstance(response, dict)
return cast(VariablePage, response)
def _variable(
name: str,
*,
app_id: str = APP_ID,
conversation_id: str = CONVERSATION_ID,
value_type: str = "string",
value: object = "value",
) -> ConversationVariable:
variable = variable_factory.build_conversation_variable_from_mapping(
{"id": f"draft-{name}", "name": name, "value_type": value_type, "value": value, "description": "description"}
)
return ConversationVariable.from_variable(app_id=app_id, conversation_id=conversation_id, variable=variable)
@pytest.mark.parametrize(
("value_type", "value", "exposed_type", "exposed_value"),
[
("string", "hello", "string", "hello"),
("integer", 42, "number", "42"),
("float", 1.5, "number", "1.5"),
("boolean", True, "boolean", "True"),
("array[string]", ["a", "b"], "array[string]", "['a', 'b']"),
("object", {"key": "value"}, "object", "{'key': 'value'}"),
("array[object]", [{"x": 1}], "array[object]", "[{'x': 1}]"),
],
)
def test_variable_wire_values_and_storage_id(
app: Flask,
sqlite_session: Session,
value_type: str,
value: object,
exposed_type: str,
exposed_value: str,
) -> None:
row = _variable("example", value_type=value_type, value=value)
row.created_at = datetime(2026, 1, 1)
row.updated_at = datetime(2026, 1, 2)
sqlite_session.add(row)
sqlite_session.commit()
response = _get(app)
assert response == {
"page": 1,
"limit": 100,
"total": 1,
"has_more": False,
"data": [
{
"id": row.id,
"name": "example",
"value_type": exposed_type,
"value": exposed_value,
"description": "description",
"created_at": int(row.created_at.timestamp()),
"updated_at": int(row.updated_at.timestamp()),
}
],
}
assert row.id != row.to_variable().id
def test_variables_are_scoped_by_app_and_conversation(app: Flask, sqlite_session: Session) -> None:
sqlite_session.add_all(
[
make_app(app_id=OTHER_APP_ID, tenant_id="tenant-2", mode=AppMode.ADVANCED_CHAT),
_variable("visible"),
_variable("other-app", app_id=OTHER_APP_ID),
_variable("other-conversation", conversation_id="44444444-4444-4444-4444-444444444444"),
]
)
sqlite_session.commit()
assert [item["name"] for item in _get(app)["data"]] == ["visible"]
@pytest.mark.parametrize("count", [0, 101])
def test_first_hundred_variables_keep_existing_envelope_and_order(
app: Flask, sqlite_session: Session, count: int
) -> None:
for index in reversed(range(count)):
row = _variable(f"var-{index}")
row.created_at = datetime(2026, 1, 1) + timedelta(seconds=index)
sqlite_session.add(row)
sqlite_session.commit()
response = _get(app)
assert response["page"] == 1
assert response["limit"] == 100
assert response["total"] == min(count, 100)
assert response["has_more"] is False
assert [item["name"] for item in response["data"]] == [f"var-{index}" for index in range(min(count, 100))]
@pytest.mark.parametrize("condition", ["missing", "other-workspace", "wrong-mode"])
@pytest.mark.parametrize("conversation_id", [None, CONVERSATION_ID])
def test_app_admission_precedes_query_validation(
app: Flask, sqlite_session: Session, condition: str, conversation_id: str | None
) -> None:
if condition != "missing":
sqlite_session.add(
make_app(
app_id=OTHER_APP_ID,
tenant_id="tenant-2" if condition == "other-workspace" else "tenant-1",
mode=AppMode.CHAT if condition == "wrong-mode" else AppMode.ADVANCED_CHAT,
)
)
sqlite_session.commit()
with pytest.raises(AppNotFoundError) as error:
_get(app, app_id=OTHER_APP_ID, conversation_id=conversation_id)
expected = (
"App mode is not in the supported list: {'advanced-chat'}" if condition == "wrong-mode" else "App not found."
)
assert error.value.description == expected
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
def test_hidden_workflow_agent_app_stays_hidden(app: Flask, sqlite_session: Session, status: AgentStatus) -> None:
sqlite_session.add(make_app(app_id=OTHER_APP_ID, mode=AppMode.AGENT))
sqlite_session.add(
Agent(
tenant_id="tenant-1",
name="Workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
status=status,
backing_app_id=OTHER_APP_ID,
)
)
sqlite_session.commit()
with pytest.raises(AppNotFoundError, match="App not found"):
_get(app, app_id=OTHER_APP_ID)
def test_missing_query_is_422_only_after_app_admission(app: Flask) -> None:
with pytest.raises(UnprocessableEntity, match="conversation_id"):
_get(app, conversation_id=None)
@pytest.mark.parametrize("allowed", [False, True])
def test_rbac_policy_is_enforced_before_query_validation(
app: Flask,
admitted_account: Account,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
allowed: bool,
) -> None:
config_overrides(RBAC_ENABLED=True)
check = create_autospec(RBACService.CheckAccess.check, return_value=allowed)
monkeypatch.setattr(RBACService.CheckAccess, "check", check)
expected_error = UnprocessableEntity if allowed else Forbidden
with pytest.raises(expected_error):
_get(app, conversation_id=None)
assert check.call_count == 1
assert check.call_args.args == ("tenant-1", admitted_account.id)
assert check.call_args.kwargs["scene"] == RBACPermission.APP_CREATE_AND_MANAGEMENT
def test_uninitialized_account_cannot_read(app: Flask, admitted_account: Account) -> None:
admitted_account.status = AccountStatus.UNINITIALIZED
with pytest.raises(AccountNotInitializedError):
_get(app, conversation_id=None)
@@ -0,0 +1,883 @@
from __future__ import annotations
import json
from inspect import unwrap as _generator_api_unwrap
from unittest.mock import MagicMock
import pytest
from flask import Flask, request
from sqlalchemy.orm import Session
from controllers.console.app import generator as generator_module
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.app.generator import (
InstructionGeneratePayload,
InstructionTemplatePayload,
RuleCodeGeneratePayload,
RuleGeneratePayload,
RuleStructuredOutputPayload,
WorkflowGeneratePayload,
WorkflowInstructionSuggestionsPayload,
)
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models.model import App, AppMode
from models.workflow import Workflow
from tests.helpers.unit.model_factories import make_workflow
def _persist_app(session: Session, *, tenant_id: str = "t1") -> App:
app_model = App(
id="app-1",
tenant_id=tenant_id,
name="Workflow App",
description="",
mode=AppMode.WORKFLOW,
enable_site=False,
enable_api=False,
max_active_requests=None,
)
session.add(app_model)
session.commit()
return app_model
def _generator_api_model_config_payload():
return {"provider": "openai", "name": "gpt-4o", "mode": "chat", "completion_params": {}}
def _workflow(graph_dict: dict[str, object]) -> Workflow:
return make_workflow(workflow_id="workflow-1", tenant_id="t1", graph=graph_dict)
def _install_workflow_service(monkeypatch: pytest.MonkeyPatch, workflow):
class _Service:
app_model = None
session = None
def get_draft_workflow(self, app_model, session=None):
self.app_model = app_model
self.session = session
return workflow
service = _Service()
monkeypatch.setattr(generator_module, "WorkflowService", lambda: service)
return service
def test_rule_generate_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleGenerateApi()
method = _generator_api_unwrap(api.post)
rule_config = {
"prompt": "You are a helpful assistant.",
"variables": ["topic"],
"opening_statement": "Hi",
"error": "",
}
monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", lambda **_kwargs: rule_config)
with app.test_request_context(
"/console/api/rule-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
):
response = method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")
assert response == rule_config
def test_rule_code_generate_maps_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleCodeGenerateApi()
method = _generator_api_unwrap(api.post)
def _raise(*_args, **_kwargs):
raise ProviderTokenNotInitError("missing token")
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)
with app.test_request_context(
"/console/api/rule-code-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
):
with pytest.raises(ProviderNotInitializeError):
method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_app_not_found(app: Flask, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session, tenant_id="other-tenant")
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "app app-1 not found"
assert sqlite_session.get(App, "app-1") is not None
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_workflow_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session)
_install_workflow_service(monkeypatch, workflow=None)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "workflow app-1 not found"
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_node_missing(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session)
workflow = _workflow({"nodes": []})
_install_workflow_service(monkeypatch, workflow=workflow)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "node node-1 not found"
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_code_node(app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
app_model = _persist_app(sqlite_session)
workflow = _workflow(
{
"nodes": [
{"id": "node-1", "data": {"type": "code"}},
]
}
)
workflow_service = _install_workflow_service(monkeypatch, workflow=workflow)
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", lambda **_kwargs: {"code": "x"})
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")
assert response == {"code": "x"}
assert workflow_service.app_model is app_model
assert workflow_service.session is sqlite_session
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_legacy_modify(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {"instruction": "ok"}
monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _capture)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "old",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")
assert response == {"instruction": "ok"}
assert captured["session"] is sqlite_session
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_incompatible_params(app: Flask, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "incompatible parameters"
def test_instruction_template_prompt(app: Flask) -> None:
api = generator_module.InstructionGenerationTemplateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate/template",
method="POST",
json={"type": "prompt"},
):
response = method(api, InstructionTemplatePayload.model_validate(request.get_json()))
assert "data" in response
def test_instruction_template_invalid_type(app: Flask) -> None:
api = generator_module.InstructionGenerationTemplateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate/template",
method="POST",
json={"type": "unknown"},
):
with pytest.raises(ValueError, match="Invalid type: unknown"):
method(api, InstructionTemplatePayload.model_validate(request.get_json()))
# ─ /workflow-generate ─────────────────────────────────────────────────────────
def _workflow_generate_payload() -> dict:
return {
"mode": "workflow",
"instruction": "Summarize a URL",
"ideal_output": "A 3-sentence summary.",
"model_config": _generator_api_model_config_payload(),
}
def _workflow_graph(*, node_id: str | None = None) -> dict:
nodes = []
if node_id:
nodes.append(
{
"id": node_id,
"type": "custom",
"position": {"x": 0, "y": 0},
"data": {"type": "start", "title": "Start"},
}
)
return {"nodes": nodes, "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}}
def _stub_workflow_service(monkeypatch: pytest.MonkeyPatch, returns=None, raises: Exception | None = None):
def _call(**_kwargs):
if raises is not None:
raise raises
return returns or {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _call)
def test_workflow_generate_returns_service_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
expected = {
"graph": _workflow_graph(node_id="node-1"),
"message": "Summarize",
"app_name": "",
"icon": "",
"error": "",
"errors": [],
"mode": None,
}
expected["graph"]["nodes"][0]["parentId"] = "container-1"
_stub_workflow_service(monkeypatch, returns=expected)
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert response == expected
def test_workflow_generate_response_schema_is_concrete() -> None:
schema = generator_module.WorkflowGenerateResponse.model_json_schema()
assert schema["properties"]["graph"]["$ref"].endswith("/$defs/WorkflowGraph")
error_items = schema["properties"]["errors"]["items"]
assert error_items["$ref"].endswith("/$defs/WorkflowGenerateErrorResponse")
assert set(schema["$defs"]["WorkflowGenerateErrorCode"]["enum"]) == {
code.value for code in generator_module.WorkflowGenerateErrorCode
}
def test_workflow_generate_maps_provider_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""ProviderTokenNotInitError → ProviderNotInitializeError so the frontend
can render the same "provider missing" UX as /rule-generate."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=ProviderTokenNotInitError("missing token"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderNotInitializeError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_quota_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import ProviderQuotaExceededError
from core.errors.error import QuotaExceededError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=QuotaExceededError())
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderQuotaExceededError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_model_not_support_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import ProviderModelCurrentlyNotSupportError
from core.errors.error import ModelCurrentlyNotSupportError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=ModelCurrentlyNotSupportError("not supported"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderModelCurrentlyNotSupportError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_invoke_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import CompletionRequestError
from graphon.model_runtime.errors.invoke import InvokeError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=InvokeError("LLM unreachable"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(CompletionRequestError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_accepts_advanced_chat_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""The payload Literal must accept advanced-chat as well as workflow."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
payload = _workflow_generate_payload()
payload["mode"] = "advanced-chat"
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=payload,
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["mode"] == "advanced-chat"
assert captured["instruction"] == "Summarize a URL"
assert captured["ideal_output"] == "A 3-sentence summary."
def test_workflow_generate_forwards_current_graph_for_refine(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""cmd+k `/refine`: the optional current_graph field reaches the service."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
graph = _workflow_graph(node_id="node1")
payload = _workflow_generate_payload()
payload["current_graph"] = graph
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=payload,
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["current_graph"] == graph
def test_workflow_generate_current_graph_defaults_to_none(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Omitting current_graph (the `/create` path) forwards None to the service."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["current_graph"] is None
def test_workflow_generate_accepts_auto_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 3: the payload Literal must accept ``auto``; the controller forwards
it unchanged (the service resolves it) and returns the resolved ``mode``."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
"mode": "advanced-chat",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
payload = _workflow_generate_payload()
payload["mode"] = "auto"
with app.test_request_context("/console/api/workflow-generate", method="POST", json=payload):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["mode"] == "auto"
assert response["mode"] == "advanced-chat"
# ─ /workflow-generate/suggestions ─────────────────────────────────────────────
def test_generate_instruction_suggestions_parses_and_cleans(monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (i): a mocked default model returning a JSON array is parsed + cleaned."""
from core.llm_generator import llm_generator as llm_gen_module
instance = MagicMock()
instance.invoke_llm.return_value.message.get_text_content.return_value = '["Summarize a URL", "Translate text"]'
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
tenant_id="t1", mode="workflow", count=4
)
assert result == ["Summarize a URL", "Translate text"]
def test_generate_instruction_suggestions_dedupes_and_caps(monkeypatch: pytest.MonkeyPatch) -> None:
"""Whitespace / surrounding quotes are stripped, case-insensitive dupes dropped, capped to count."""
from core.llm_generator import llm_generator as llm_gen_module
instance = MagicMock()
instance.invoke_llm.return_value.message.get_text_content.return_value = (
'[" Summarize a URL ", "summarize a URL", "\'Translate text\'", "Draft an email", "Extra idea"]'
)
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
tenant_id="t1", mode="advanced-chat", count=3
)
assert result == ["Summarize a URL", "Translate text", "Draft an email"]
def test_generate_instruction_suggestions_no_default_model_returns_empty(monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (ii): a missing default model degrades to an empty list, never raising."""
from core.llm_generator import llm_generator as llm_gen_module
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.side_effect = ProviderTokenNotInitError(
"no default model"
)
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(tenant_id="t1", mode="workflow")
assert result == []
def test_workflow_instruction_suggestions_route_returns_list(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (iii): the route wraps the generator output in {"suggestions": [...]}."""
api = generator_module.WorkflowInstructionSuggestionsApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _suggest(**kwargs):
captured.update(kwargs)
return ["Summarize a URL", "Translate text"]
monkeypatch.setattr(generator_module.LLMGenerator, "generate_workflow_instruction_suggestions", _suggest)
with app.test_request_context(
"/console/api/workflow-generate/suggestions",
method="POST",
json={"mode": "workflow", "language": "French", "count": 3},
):
response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")
assert response == {"suggestions": ["Summarize a URL", "Translate text"]}
assert captured["mode"] == "workflow"
assert captured["language"] == "French"
assert captured["count"] == 3
def test_workflow_instruction_suggestions_route_empty_is_valid_200(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (iii): an empty list is a valid soft-fail response."""
api = generator_module.WorkflowInstructionSuggestionsApi()
method = _generator_api_unwrap(api.post)
monkeypatch.setattr(
generator_module.LLMGenerator,
"generate_workflow_instruction_suggestions",
lambda **_kwargs: [],
)
with app.test_request_context(
"/console/api/workflow-generate/suggestions",
method="POST",
json={"mode": "advanced-chat"},
):
response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")
assert response == {"suggestions": []}
# ─ /workflow-generate/stream ──────────────────────────────────────────────────
def _read_sse_frames(response) -> list[dict]:
"""Decode an SSE Response body into its parsed ``data:`` JSON frames."""
body = response.get_data(as_text=True)
frames = []
for chunk in body.strip().split("\n\n"):
chunk = chunk.strip()
if chunk.startswith("data: "):
frames.append(json.loads(chunk[len("data: ") :]))
return frames
def test_workflow_generate_stream_emits_plan_then_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 2c: the stream endpoint writes one SSE frame per service event."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
def _stream(**_kwargs):
yield ("plan", {"title": "Summarizer", "mode": "workflow", "nodes": []})
yield ("result", {"graph": _workflow_graph(), "error": "", "mode": "workflow"})
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)
with app.test_request_context(
"/console/api/workflow-generate/stream",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert response.mimetype == "text/event-stream"
frames = _read_sse_frames(response)
assert [f["event"] for f in frames] == ["plan", "result"]
assert frames[0]["title"] == "Summarizer"
assert frames[1]["mode"] == "workflow"
def test_workflow_generate_stream_provider_error_emits_result_event(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Task 2c: a provider-init error becomes a single MODEL_ERROR result frame, not a non-SSE error."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
def _stream(**_kwargs):
raise ProviderTokenNotInitError("missing token")
yield # pragma: no cover - marks this a generator
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)
with app.test_request_context(
"/console/api/workflow-generate/stream",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
frames = _read_sse_frames(response)
assert len(frames) == 1
assert frames[0]["event"] == "result"
assert frames[0]["errors"][0]["code"] == "MODEL_ERROR"
assert frames[0]["graph"]["nodes"] == []
def test_workflow_generate_stream_rejects_empty_instruction(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 2c: empty instructions get a normal 400 JSON BEFORE the stream opens."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
payload = _workflow_generate_payload()
payload["instruction"] = " "
with app.test_request_context("/console/api/workflow-generate/stream", method="POST", json=payload):
response, status = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert status == 400
assert response["errors"][0]["code"] == "EMPTY_INSTRUCTION"
def _generator_api_missing_unwrap(func):
"""Unwrap a decorated function to test it directly."""
while hasattr(func, "__wrapped__"):
func = func.__wrapped__
return func
def _generator_api_missing_model_config_payload():
return {
"provider": "test_provider",
"name": "test_model",
"mode": "chat",
"completion_params": {},
}
def test_rule_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", _raise)
with app.test_request_context(
"/console/api/rule-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")
def test_rule_code_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleCodeGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)
with app.test_request_context(
"/console/api/rule-code-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")
def test_structured_output_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleStructuredOutputGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_structured_output", _raise)
with app.test_request_context(
"/console/api/structured-output-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleStructuredOutputPayload.model_validate(request.get_json()), "t1")
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_instruction_generate_exceptions(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _raise)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "old",
"instruction": "do it",
"model_config": _generator_api_missing_model_config_payload(),
},
):
with pytest.raises(expected_exception):
method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")
@@ -0,0 +1,374 @@
import datetime as _mcp_server_response_datetime
from collections.abc import Callable, Sequence
from dataclasses import dataclass, field
from datetime import datetime as _mcp_server_admission_datetime
from inspect import unwrap
from types import SimpleNamespace
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Conflict, Forbidden, NotFound, UnprocessableEntity
from controllers.common.rbac import PlainApp, RBACCheck
from controllers.console import console_ns, flask_admission
from controllers.console.app import mcp_server
from controllers.console.app import mcp_server as module
from controllers.console.app.error import AppNotFoundError
from controllers.console.app.mcp_server import (
AppMCPServerController,
AppMCPServerRefreshController,
AppMCPServerResponse,
)
from controllers.console.wraps import RBACPermission
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.mcp_server_service import (
AppMCPServerAlreadyExistsError,
AppMCPServerAppNotFoundError,
AppMCPServerNotFoundError,
AppMCPServerRecord,
AppMCPServerStatus,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account
"""App MCP Server routes retain their role and RBAC policy under unified admission."""
_MCP_SERVER_ADMISSION_APP_ID = UUID("11111111-1111-1111-1111-111111111111")
_MCP_SERVER_ADMISSION_RECORD = AppMCPServerRecord(
id="server",
name="name",
server_code="code",
description="description",
status=AppMCPServerStatus.ACTIVE,
parameters="{}",
created_at=_mcp_server_admission_datetime(2024, 1, 1),
updated_at=_mcp_server_admission_datetime(2024, 1, 1),
)
MUTATIONS = [
AppMCPServerController.post,
AppMCPServerController.put,
AppMCPServerRefreshController.post,
]
def admission(method: Callable[..., object]) -> Callable[..., object]:
return unwrap(method, stop=lambda view: "inject_request_context" in view.__code__.co_qualname)
class TestMcpServerAdmissionCases:
@staticmethod
@pytest.mark.parametrize("method", MUTATIONS)
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_readonly_roles_cannot_mutate(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], role: TenantAccountRole
) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
with app.test_request_context(), pytest.raises(Forbidden):
admission(method)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
@staticmethod
@pytest.mark.parametrize(
("method", "permission"),
[
(AppMCPServerController.get, RBACPermission.APP_VIEW_LAYOUT),
(AppMCPServerController.post, RBACPermission.APP_EDIT),
(AppMCPServerController.put, RBACPermission.APP_EDIT),
(AppMCPServerRefreshController.post, RBACPermission.APP_EDIT),
],
)
def test_rbac_checks_keep_app_scope(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], permission: RBACPermission
) -> None:
account = make_account(role=TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
called = []
def denied(
*, tenant_id: str, account_id: str, checks: Sequence[RBACCheck], path_args: dict[str, object]
) -> None:
assert (tenant_id, account_id) == ("workspace", account.id)
assert path_args == {"app_id": _MCP_SERVER_ADMISSION_APP_ID}
assert len(checks) == 1
assert checks[0].scene == permission
assert isinstance(checks[0].locator, PlainApp)
called.append(True)
raise Forbidden
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
with app.test_request_context(), pytest.raises(Forbidden):
admission(method)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
assert called == [True]
@staticmethod
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_edit_roles_reach_service_with_request_context(
app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole
) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
contexts: list[RequestContext] = []
def refresh(context: RequestContext, _app_id: str) -> AppMCPServerRecord:
contexts.append(context)
return _MCP_SERVER_ADMISSION_RECORD
monkeypatch.setattr(
mcp_server,
"application_services",
lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(refresh=refresh)),
)
with app.test_request_context(method="POST", headers={"X-Trace-Id": "trace"}):
response = admission(AppMCPServerRefreshController.post)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
assert isinstance(response, dict)
assert response["id"] == _MCP_SERVER_ADMISSION_RECORD.id
assert [(c.account_id, c.active_workspace_id, c.trace_id) for c in contexts] == [
(account.id, "workspace", "trace")
]
@staticmethod
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_readonly_roles_can_read(app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)
monkeypatch.setattr(
mcp_server,
"application_services",
lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(get=lambda _context, _app_id: None)),
)
with app.test_request_context():
assert admission(AppMCPServerController.get)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID) == {}
CONTEXT = RequestContext("request", None, "account", "workspace")
SERVER_ID = "abcdefab-1234-4567-89ab-abcdefabcdef"
_MCP_SERVER_RESPONSE_APP_ID = UUID("11111111-1111-1111-1111-111111111111")
_MCP_SERVER_RESPONSE_RECORD = AppMCPServerRecord(
id="server",
name="name",
server_code="code",
description="description",
status=AppMCPServerStatus.ACTIVE,
parameters='{"timeout": 30}',
created_at=_mcp_server_response_datetime.datetime(2024, 1, 1, tzinfo=_mcp_server_response_datetime.UTC),
updated_at=_mcp_server_response_datetime.datetime(2024, 1, 2, tzinfo=_mcp_server_response_datetime.UTC),
)
@dataclass
class Servers:
result: AppMCPServerRecord | None = _MCP_SERVER_RESPONSE_RECORD
error: Exception | None = None
calls: list[tuple[str, str, dict[str, object]]] = field(default_factory=list)
def get(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:
return self._call("get", app_id)
def create(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
return self._call("create", app_id, **kwargs)
def update(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
return self._call("update", app_id, **kwargs)
def refresh(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:
return self._call("refresh", app_id)
def _call(self, method: str, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
self.calls.append((method, app_id, kwargs))
if self.error is not None:
raise self.error
return self.result
class TestMcpServerResponseCases:
@staticmethod
@pytest.fixture
def servers(monkeypatch: pytest.MonkeyPatch) -> Servers:
servers = Servers()
monkeypatch.setattr(module, "application_services", lambda: SimpleNamespace(app_mcp_servers=servers))
return servers
class TestAppMCPServerResponse:
def test_parameters_json_string_parsed(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": '{"key": "value"}',
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == {"key": "value"}
def test_parameters_invalid_json_returns_original(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": "not-valid-json",
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == "not-valid-json"
def test_parameters_dict_passthrough(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {"already": "parsed"},
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == {"already": "parsed"}
def test_parameters_json_array_parsed(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": '["a", "b"]',
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == ["a", "b"]
def test_timestamps_normalized(self) -> None:
dt = _mcp_server_response_datetime.datetime(2024, 1, 1, 0, 0, 0, tzinfo=_mcp_server_response_datetime.UTC)
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {},
"created_at": dt,
"updated_at": dt,
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.created_at == int(dt.timestamp())
assert resp.updated_at == int(dt.timestamp())
def test_timestamps_none(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {},
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.created_at is None
assert resp.updated_at is None
@staticmethod
def test_get_serializes_record_and_missing_server(servers: Servers) -> None:
method = unwrap(module.AppMCPServerController.get)
response = method(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert response["parameters"] == {"timeout": 30}
assert response["created_at"] == 1704067200
servers.result = None
assert method(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID) == {}
@staticmethod
def test_post_parses_input_and_returns_201(app: Flask, servers: Servers) -> None:
with app.test_request_context(method="POST", json={"parameters": {"timeout": 30}}):
response, status = unwrap(module.AppMCPServerController.post)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert status == 201
assert response["id"] == "server"
assert servers.calls == [
("create", str(_MCP_SERVER_RESPONSE_APP_ID), {"description": None, "parameters": {"timeout": 30}})
]
@staticmethod
@pytest.mark.parametrize("candidate", [SERVER_ID, SERVER_ID.upper(), UUID(SERVER_ID).hex, "{" + SERVER_ID + "}"])
def test_put_normalizes_server_id_and_passes_status(app: Flask, servers: Servers, candidate: str) -> None:
body = {"id": candidate, "parameters": {}, "description": "updated", "status": "inactive"}
with app.test_request_context(method="PUT", json=body):
unwrap(module.AppMCPServerController.put)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert servers.calls == [
(
"update",
str(_MCP_SERVER_RESPONSE_APP_ID),
{"server_id": SERVER_ID, "description": "updated", "parameters": {}, "status": "inactive"},
)
]
@staticmethod
@pytest.mark.parametrize(
"body",
[
pytest.param({"id": "not-a-uuid", "parameters": {}}, id="malformed-id"),
pytest.param({"id": SERVER_ID, "parameters": {}, "status": "paused"}, id="unknown-status"),
pytest.param({"id": SERVER_ID, "parameters": {}, "status": ""}, id="blank-status"),
],
)
def test_put_rejects_invalid_payload_before_calling_service(
app: Flask, servers: Servers, body: dict[str, object]
) -> None:
with app.test_request_context(method="PUT", json=body), pytest.raises(UnprocessableEntity):
unwrap(module.AppMCPServerController.put)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert servers.calls == []
@staticmethod
@pytest.mark.parametrize(
"method",
[
module.AppMCPServerController.get,
module.AppMCPServerController.post,
module.AppMCPServerController.put,
module.AppMCPServerRefreshController.post,
],
)
def test_unavailable_app_becomes_app_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:
servers.error = AppMCPServerAppNotFoundError()
with (
app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}),
pytest.raises(AppNotFoundError) as error,
):
unwrap(method)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert error.value.description == AppNotFoundError.description
@staticmethod
@pytest.mark.parametrize("method", [module.AppMCPServerController.put, module.AppMCPServerRefreshController.post])
def test_missing_server_becomes_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:
servers.error = AppMCPServerNotFoundError()
with app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}), pytest.raises(NotFound):
unwrap(method)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
@staticmethod
def test_duplicate_create_becomes_409(app: Flask, servers: Servers) -> None:
servers.error = AppMCPServerAlreadyExistsError()
with app.test_request_context(method="POST", json={"parameters": {}}), pytest.raises(Conflict):
unwrap(module.AppMCPServerController.post)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
@staticmethod
def test_routes_stay_app_scoped() -> None:
route_map = {resource.__name__: urls for resource, urls, _, _ in console_ns.resources}
assert route_map["AppMCPServerController"] == ("/apps/<uuid:app_id>/server",)
assert route_map["AppMCPServerRefreshController"] == ("/apps/<uuid:app_id>/server/refresh",)
assert not hasattr(module.AppMCPServerRefreshController, "get")
@@ -0,0 +1,273 @@
from __future__ import annotations
from datetime import UTC, datetime
import pytest
from flask import Flask
from sqlalchemy.orm import Session
from controllers.console.app import message as message_module
from core.app.entities.app_invoke_entities import InvokeFrom
from fields.conversation_fields import MessageResponseSource
from models.account import Account
from models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRating
from models.model import (
App,
AppAnnotationHitHistory,
AppMode,
Conversation,
Message,
MessageAgentThought,
MessageAnnotation,
MessageFeedback,
)
def _account() -> Account:
account = Account(name="Account", email="account@example.com")
account.id = "account-1"
return account
def _app(*, app_id: str = "app-1") -> App:
return App(
id=app_id,
tenant_id="tenant-1",
name="Chat App",
description="",
mode=AppMode.CHAT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
def _persist_message(session: Session, *, message_id: str, app_id: str = "app-1") -> Message:
conversation = Conversation(
app_id=app_id,
app_model_config_id=None,
model_provider=None,
override_model_configs=None,
model_id=None,
mode=AppMode.CHAT,
name="Conversation",
_inputs={},
introduction="",
system_instruction="",
system_instruction_tokens=0,
status="normal",
invoke_from=InvokeFrom.DEBUGGER,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=None,
from_account_id="account-1",
)
conversation.id = "conversation-1"
message = Message(
app_id=app_id,
conversation_id=conversation.id,
_inputs={},
query="query",
message="",
message_tokens=0,
message_unit_price=0,
message_price_unit=0,
answer="answer",
answer_tokens=0,
answer_unit_price=0,
answer_price_unit=0,
provider_response_latency=0,
total_price=0,
currency="USD",
invoke_from=InvokeFrom.DEBUGGER,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=None,
from_account_id="account-1",
app_mode=AppMode.CHAT,
)
message.id = message_id
session.add_all([_account(), _app(app_id=app_id), conversation, message])
session.flush()
return message
class TestMessageApiCases:
@staticmethod
def test_message_response_source_uses_caller_session_for_nested_fields(sqlite_session: Session) -> None:
session = sqlite_session
message_id = "550e8400-e29b-41d4-a716-446655440000"
message = _persist_message(sqlite_session, message_id=message_id)
message.inputs = {"topic": "support"}
feedback = MessageFeedback(
app_id=message.app_id,
conversation_id=message.conversation_id,
message_id=message.id,
rating=FeedbackRating.LIKE,
from_source=FeedbackFromSource.USER,
from_account_id="account-1",
)
annotation = MessageAnnotation(
app_id=message.app_id,
question="Question",
content="Answer",
account_id="account-1",
conversation_id=message.conversation_id,
message_id=message.id,
)
annotation.id = "annotation-1"
annotation_hit = AppAnnotationHitHistory(
app_id=message.app_id,
annotation_id=annotation.id,
source="annotation",
question="Question",
account_id="account-1",
score=0.0,
message_id=message.id,
annotation_question="Question",
annotation_content="Answer",
)
thought = MessageAgentThought(
message_id=message.id,
position=1,
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
thought="Consider the request",
tool_labels_str="{}",
tool_meta_str="{}",
)
sqlite_session.add_all([feedback, annotation, annotation_hit, thought])
sqlite_session.commit()
source = MessageResponseSource(message, session=session)
assert source.inputs == {"topic": "support"}
assert source.user_feedback is feedback
assert source.feedbacks[0].from_account.id == "account-1"
annotation_source = source.annotation
assert annotation_source is not None
assert annotation_source.account.id == "account-1"
annotation_hit_history_source = source.annotation_hit_history
assert annotation_hit_history_source is not None
assert annotation_hit_history_source.annotation_create_account.id == "account-1"
assert source.agent_thoughts == [thought]
assert source.message_files == []
@staticmethod
def test_chat_messages_query_valid(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test valid ChatMessagesQuery with all fields."""
query = message_module.ChatMessagesQuery(
conversation_id="550e8400-e29b-41d4-a716-446655440000",
first_id="550e8400-e29b-41d4-a716-446655440001",
limit=50,
)
assert query.limit == 50
@staticmethod
def test_chat_messages_query_defaults(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test ChatMessagesQuery with defaults."""
query = message_module.ChatMessagesQuery(conversation_id="550e8400-e29b-41d4-a716-446655440000")
assert query.first_id is None
assert query.limit == 20
@staticmethod
def test_chat_messages_query_empty_first_id(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test ChatMessagesQuery converts empty first_id to None."""
query = message_module.ChatMessagesQuery(
conversation_id="550e8400-e29b-41d4-a716-446655440000",
first_id="",
)
assert query.first_id is None
@staticmethod
def test_message_feedback_payload_valid_like(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload with like rating."""
payload = message_module.AppMessageFeedbackPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
rating="like",
content="Good answer",
)
assert payload.rating == "like"
assert payload.content == "Good answer"
@staticmethod
def test_message_feedback_payload_valid_dislike(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload with dislike rating."""
payload = message_module.AppMessageFeedbackPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
rating="dislike",
)
assert payload.rating == "dislike"
@staticmethod
def test_message_feedback_payload_no_rating(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload without rating."""
payload = message_module.AppMessageFeedbackPayload(message_id="550e8400-e29b-41d4-a716-446655440000")
assert payload.rating is None
@staticmethod
@staticmethod
def test_message_detail_response_normalizes_aliases_and_timestamp(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Test MessageDetailResponse normalizes alias fields and datetime timestamps."""
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
response = message_module.MessageDetailResponse.model_validate(
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"conversation_id": "550e8400-e29b-41d4-a716-446655440001",
"inputs": {"foo": "bar"},
"query": "hello",
"message": [{"text": "hello"}],
"message_tokens": 7,
"answer": "world",
"answer_tokens": 11,
"provider_response_latency": 1.25,
"from_source": "user",
"from_end_user_id": None,
"from_account_id": "550e8400-e29b-41d4-a716-446655440002",
"feedbacks": [],
"workflow_run_id": None,
"annotation": None,
"annotation_hit_history": None,
"status": "normal",
"created_at": created_at,
"agent_thoughts": [],
"message_files": [],
"message_metadata_dict": {"token_usage": 3},
"error": None,
"parent_message_id": None,
"extra_contents": [],
}
)
assert response.answer == "world"
assert response.message_tokens == 7
assert response.answer_tokens == 11
assert response.provider_response_latency == 1.25
assert response.metadata == {"token_usage": 3}
assert response.created_at == int(created_at.timestamp())
assert response.model_dump(mode="json") == {
"id": "550e8400-e29b-41d4-a716-446655440000",
"conversation_id": "550e8400-e29b-41d4-a716-446655440001",
"inputs": {"foo": "bar"},
"query": "hello",
"message": [{"text": "hello"}],
"message_tokens": 7,
"answer": "world",
"answer_tokens": 11,
"provider_response_latency": 1.25,
"from_source": "user",
"from_end_user_id": None,
"from_account_id": "550e8400-e29b-41d4-a716-446655440002",
"feedbacks": [],
"workflow_run_id": None,
"annotation": None,
"annotation_hit_history": None,
"created_at": int(created_at.timestamp()),
"agent_thoughts": [],
"message_files": [],
"metadata": {"token_usage": 3},
"retriever_resources": [],
"status": "normal",
"error": None,
"parent_message_id": None,
"extra_contents": [],
}
@@ -0,0 +1,894 @@
from __future__ import annotations
import importlib
import json
import os
from copy import deepcopy
from dataclasses import dataclass
from inspect import unwrap
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import DEFAULT, MagicMock
from uuid import uuid4
import pytest
import yaml
from flask import Flask
from flask.testing import FlaskClient
from flask_restx import Resource
from sqlalchemy import func, select
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, object_session, sessionmaker
from controllers.common import session as controller_session
from controllers.console.app import model_config as model_config_module
from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
from core.app.app_config.easy_ui_based_app.model_config import manager as model_config_manager_module
from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigManager
from core.app.apps.chat.app_config_manager import ChatAppConfigManager
from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
from fields.app_model_config_response import AppModelConfigResponse
from libs.external_api import ExternalApi
from models.model import App, AppMode, AppModelConfig
from models.provider_ids import ModelProviderID
app_wraps_module = importlib.import_module("controllers.console.app.wraps")
def _model_config_payload(**fields: object) -> dict[str, object]:
return {
"model": {
"provider": "langgenius/openai/openai",
"name": "gpt-4o-mini",
"completion_params": {},
},
**fields,
}
def _existing_publish_configs() -> list[tuple[str, AppMode, dict[str, object]]]:
recommended_apps_path = Path(__file__).resolve().parents[5] / "constants" / "recommended_apps.json"
recommended_apps = json.loads(recommended_apps_path.read_text())["app_details"]
cases = []
for app_detail in recommended_apps.values():
payload = yaml.safe_load(app_detail["export_data"]).get("model_config")
if payload is not None:
cases.append((app_detail["name"], AppMode.value_of(app_detail["mode"]), payload))
# Mirrors the publish body's advanced-prompt, dataset-selection, and feature fields.
cases.append(
(
"configuration-editor-publish",
AppMode.CHAT,
_model_config_payload(
model={
"provider": "langgenius/openai/openai",
"name": "gpt-4o",
"mode": "chat",
"completion_params": {"temperature": 0.7},
},
pre_prompt="",
prompt_type="advanced",
chat_prompt_config={"prompt": [{"role": "system", "text": "hi"}]},
completion_prompt_config={
"prompt": {"text": "completion"},
"conversation_histories_role": {"assistant_prefix": "assistant", "user_prefix": "user"},
},
user_input_form=[{"text-input": {"label": "Name", "variable": "name", "required": True}}],
dataset_query_variable="context",
dataset_configs={
"retrieval_model": "multiple",
"datasets": {"datasets": [{"dataset": {"enabled": True, "id": "dataset-1"}}]},
},
agent_mode={"enabled": True, "max_iteration": 3, "strategy": "function_call", "tools": []},
external_data_tools=[],
more_like_this={"enabled": True},
opening_statement="hello",
suggested_questions=["how are you?"],
suggested_questions_after_answer={"enabled": False},
speech_to_text={"enabled": False},
text_to_speech={"enabled": False, "voice": "", "language": ""},
retriever_resource={"enabled": True},
sensitive_word_avoidance={"enabled": False},
file_upload={
"enabled": True,
"image": {
"enabled": True,
"detail": "high",
"number_limits": 2,
"transfer_methods": ["local_file"],
},
},
system_parameters={
"audio_file_size_limit": 1,
"file_size_limit": 1,
"image_file_size_limit": 1,
"video_file_size_limit": 1,
"workflow_file_upload_limit": 1,
},
),
)
)
return cases
@dataclass
class _ModelConfigHttp:
client: FlaskClient
app_model: App
session: Session
validate_configuration: MagicMock
signal: MagicMock
@pytest.fixture
def model_config_http(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> _ModelConfigHttp:
app_model = App(
id="app-1",
mode=AppMode.CHAT,
app_model_config_id="config-0",
updated_by=None,
)
original_config = AppModelConfig(app_id=app_model.id, created_by="u1", updated_by="u1")
original_config.id = "config-0"
sqlite_session.add(original_config)
sqlite_session.commit()
validate_configuration = MagicMock(
wraps=model_config_module.AppModelConfigService.validate_configuration,
return_value={"pre_prompt": "Validated prompt"},
)
monkeypatch.setattr(model_config_module.AppModelConfigService, "validate_configuration", validate_configuration)
signal = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", signal)
class ModelConfigHttpResource(Resource):
def post(self):
# Admission is supplied by this harness; parsing and HTTP errors use the real controller and API.
return unwrap(model_config_module.ModelConfigResource.post)(
model_config_module.ModelConfigResource(), sqlite_session, "t1", "u1", app_model=app_model
)
http_app = Flask(__name__)
http_app.config.update(TESTING=True)
ExternalApi(http_app).add_resource(ModelConfigHttpResource, "/apps/app-1/model-config")
return _ModelConfigHttp(http_app.test_client(), app_model, sqlite_session, validate_configuration, signal)
@pytest.fixture
def real_model_config_validation(model_config_http: _ModelConfigHttp, monkeypatch: pytest.MonkeyPatch) -> None:
assembly = MagicMock()
assembly.model_provider_factory.get_providers.return_value = [SimpleNamespace(provider="langgenius/openai/openai")]
assembly.provider_manager.get_configurations.return_value.get_models.return_value = [
SimpleNamespace(model="gpt-4o-mini", model_properties={"mode": "chat"})
]
monkeypatch.setattr(model_config_manager_module, "create_plugin_model_assembly", lambda **_kwargs: assembly)
monkeypatch.setattr(DatasetConfigManager, "is_dataset_exists", lambda *_args: True)
monkeypatch.setattr(
model_config_module.ToolManager,
"get_agent_tool_runtime",
MagicMock(side_effect=ValueError("Tool provider is unavailable in this test")),
)
model_config_http.validate_configuration.return_value = DEFAULT
def test_post_preserves_configuration_wire_for_business_validation(model_config_http: _ModelConfigHttp) -> None:
payload = _model_config_payload(
model={
"provider": "langgenius/openai/openai",
"name": "gpt-4o-mini",
"mode": "chat",
"completion_params": {
"temperature": 0,
"stop": [],
"provider_options": {"cache": False, "routing": {"fallback": None}},
},
},
pre_prompt="Answer {{topic}}",
prompt_type="advanced",
chat_prompt_config={"prompt": [{"role": "system", "text": "Answer {{topic}}"}]},
completion_prompt_config={
"prompt": {"text": "{{topic}}"},
"conversation_histories_role": {"user_prefix": "Human", "assistant_prefix": "Assistant"},
},
user_input_form=[
{"text-input": {"label": "Topic", "variable": "topic", "required": False, "default": ""}},
{"select": {"label": "Style", "variable": "style", "options": ["brief", "detailed"], "required": True}},
],
dataset_query_variable="topic",
dataset_configs={
"retrieval_model": "multiple",
"top_k": 3,
"score_threshold": 0,
"score_threshold_enabled": False,
"datasets": {"datasets": [{"dataset": {"id": "dataset-1", "enabled": True}}]},
"weights": {
"vector_setting": {
"vector_weight": 0.7,
"embedding_provider_name": "provider",
"embedding_model_name": "model",
},
"keyword_setting": {"keyword_weight": 0.3},
},
},
agent_mode={
"enabled": True,
"strategy": "function_call",
"max_iteration": 5,
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "search",
"tool_parameters": {
"query": "{{topic}}",
"limit": 0,
"filters": {"archived": False, "tags": ["docs", None, {"score": 0.5}]},
},
}
],
},
file_upload={
"enabled": True,
"number_limits": 3,
"allowed_file_types": ["image", "document"],
"allowed_file_extensions": [".pdf"],
"allowed_file_upload_methods": ["local_file", "remote_url"],
"image": {"enabled": True, "number_limits": 3, "transfer_methods": ["remote_url"]},
},
external_data_tools=[
{
"enabled": True,
"type": "api",
"label": "Context",
"variable": "context",
"config": {"api_based_extension_id": "extension-1", "options": {"limit": 0, "enabled": False}},
}
],
opening_statement="Hello",
suggested_questions=["What can you do?"],
suggested_questions_after_answer={"enabled": True},
more_like_this={"enabled": False},
speech_to_text={"enabled": True},
text_to_speech={"enabled": True, "voice": "alloy", "language": "en-US"},
retriever_resource={"enabled": True},
sensitive_word_avoidance={
"enabled": True,
"type": "keywords",
"config": {"keywords": "blocked", "inputs_config": {"enabled": True, "preset_response": ""}},
},
)
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, response.get_json()
assert response.get_json() == {"result": "success"}
model_config_http.validate_configuration.assert_called_once_with(
tenant_id="t1", config=payload, app_mode=AppMode.CHAT, session=model_config_http.session
)
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
assert stored_config.pre_prompt == "Validated prompt"
assert model_config_http.signal.call_args.kwargs["session"] is model_config_http.session
@pytest.mark.parametrize(
"optional_fields",
[
{},
{
"pre_prompt": "",
"opening_statement": "",
"suggested_questions": [],
"chat_prompt_config": None,
"completion_prompt_config": None,
"file_upload": None,
"dataset_configs": {"score_threshold": 0, "score_threshold_enabled": False},
"agent_mode": {"enabled": False, "tools": []},
"speech_to_text": {"enabled": False},
"text_to_speech": {"enabled": False, "voice": ""},
"external_data_tools": [],
},
],
ids=["omitted", "explicit-empty-disabled-and-null"],
)
def test_post_keeps_optional_values_for_domain_defaults(
model_config_http: _ModelConfigHttp, optional_fields: dict[str, object]
) -> None:
payload = _model_config_payload(**optional_fields)
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, response.get_json()
assert model_config_http.validate_configuration.call_args.kwargs["config"] == payload
@pytest.mark.parametrize(("case_name", "app_mode", "payload"), _existing_publish_configs())
def test_post_preserves_existing_publish_results(
model_config_http: _ModelConfigHttp,
monkeypatch: pytest.MonkeyPatch,
case_name: str,
app_mode: AppMode,
payload: dict[str, object],
) -> None:
selected_model = payload["model"]
assert isinstance(selected_model, dict)
assembly = MagicMock()
assembly.model_provider_factory.get_providers.return_value = [
SimpleNamespace(provider=str(ModelProviderID(selected_model["provider"])))
]
assembly.provider_manager.get_configurations.return_value.get_models.return_value = [
SimpleNamespace(model=selected_model["name"], model_properties={"mode": selected_model.get("mode", "chat")})
]
monkeypatch.setattr(model_config_manager_module, "create_plugin_model_assembly", lambda **_kwargs: assembly)
monkeypatch.setattr(
model_config_module.ToolManager,
"get_agent_tool_runtime",
MagicMock(side_effect=ValueError("Tool provider is unavailable in this test")),
)
config_manager = {
AppMode.CHAT: ChatAppConfigManager,
AppMode.COMPLETION: CompletionAppConfigManager,
AppMode.AGENT_CHAT: AgentChatAppConfigManager,
}[app_mode]
expected_config = config_manager.config_validate("t1", deepcopy(payload), model_config_http.session)
expected_record = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1").from_model_config_dict(
expected_config
)
assert "system_parameters" not in expected_config
assert "annotation_reply" not in expected_config
model_config_http.app_model.mode = app_mode
model_config_http.validate_configuration.return_value = DEFAULT
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, (case_name, response.get_json())
assert response.get_json() == {"result": "success"}
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
assert stored_config.to_dict(annotation_reply={"enabled": False}) == expected_record.to_dict(
annotation_reply={"enabled": False}
), case_name
assert model_config_http.signal.call_args.kwargs["session"] is model_config_http.session
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION, AppMode.AGENT_CHAT])
@pytest.mark.usefixtures("real_model_config_validation")
@pytest.mark.parametrize(
("fields", "stored_path", "expected_value"),
[
(
{
"chat_prompt_config": {"prompt": [{"text": "Chat", "role": "system"}]},
"completion_prompt_config": {"prompt": {"text": "Completion"}},
},
("completion_prompt_config", "prompt"),
{"text": "Completion"},
),
(
{"text_to_speech": {}, "suggested_questions_after_answer": {}},
("text_to_speech",),
{"enabled": False, "voice": "", "language": ""},
),
(
{
"user_input_form": [
{
"text-input": {
"label": "Topic",
"variable": "topic",
"max_length": None,
"json_schema": None,
"icon": None,
"extension": {"values": [None, False, 0]},
}
}
]
},
("user_input_form",),
[
{
"text-input": {
"label": "Topic",
"variable": "topic",
"max_length": None,
"json_schema": None,
"icon": None,
"required": False,
"extension": {"values": [None, False, 0]},
}
}
],
),
(
{"user_input_form": [{"select": {"label": "Topic", "variable": "topic", "options": None}}]},
("user_input_form",),
[{"select": {"label": "Topic", "variable": "topic", "options": [], "required": False}}],
),
(
{"dataset_configs": {"datasets": {}}},
("dataset_configs", "datasets"),
{"strategy": "router", "datasets": []},
),
(
{"file_upload": {"image_config": {"enabled": None}}},
("file_upload",),
{"image_config": {"enabled": None}},
),
(
{
"agent_mode": {
"strategy": "react",
"tools": [
{
"enabled": None,
"provider_type": "builtin",
"provider_id": "time",
"tool_name": "time",
"tool_parameters": {},
"credential_id": None,
"plugin_unique_identifier": None,
}
],
"prompt": None,
}
},
("agent_mode", "tools"),
[
{
"provider_type": "builtin",
"provider_id": "time",
"tool_name": "time",
"tool_parameters": {},
"credential_id": None,
"plugin_unique_identifier": None,
"enabled": False,
}
],
),
],
ids=[
"completion-prompt-without-role",
"omitted-feature-options",
"nullable-input-values-and-json-extensions",
"select-null-options",
"empty-dataset-collection",
"image-config-null-extension",
"nullable-agent-credentials-and-prompt",
],
)
def test_post_persists_readable_configuration_variants(
model_config_http: _ModelConfigHttp,
app_mode: AppMode,
fields: dict[str, object],
stored_path: tuple[str, ...],
expected_value: object,
) -> None:
model_config_http.app_model.mode = app_mode
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload(**deepcopy(fields)))
assert response.status_code == 200, response.get_json()
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
wire = stored_config.to_dict(annotation_reply={"enabled": False})
AppModelConfigResponse.model_validate(
{
**wire,
"created_by": stored_config.created_by,
"created_at": stored_config.created_at,
"updated_by": stored_config.updated_by,
"updated_at": stored_config.updated_at,
}
)
actual: object = wire
for key in stored_path:
assert isinstance(actual, dict)
actual = actual[key]
assert actual == expected_value
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION])
@pytest.mark.parametrize("strategy", ["router", "react"])
@pytest.mark.usefixtures("real_model_config_validation")
def test_post_keeps_legacy_tools_readable_across_planning_strategies(
model_config_http: _ModelConfigHttp, app_mode: AppMode, strategy: str
) -> None:
model_config_http.app_model.mode = app_mode
tools = [
{
"extension": {"values": [None, False]},
"dataset": {"id": "00000000-0000-0000-0000-000000000001", "enabled": None},
},
{"google_search": {"enabled": None}},
{"web_reader": {}},
{"wikipedia": {"enabled": False}},
{"current_datetime": {"enabled": True}},
{"sensitive-word-avoidance": {"enabled": False, "words": [], "canned_response": ""}},
]
response = model_config_http.client.post(
"/apps/app-1/model-config", json=_model_config_payload(agent_mode={"strategy": strategy, "tools": tools})
)
assert response.status_code == 200, response.get_json()
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
AppModelConfigResponse.model_validate(
{
**stored_config.to_dict(annotation_reply={"enabled": False}),
"created_by": stored_config.created_by,
"created_at": stored_config.created_at,
"updated_by": stored_config.updated_by,
"updated_at": stored_config.updated_at,
}
)
assert stored_config.agent_mode_dict["tools"] == [
{
"dataset": {"id": "00000000-0000-0000-0000-000000000001", "enabled": False},
"extension": {"values": [None, False]},
},
{"google_search": {"enabled": False}},
{"web_reader": {"enabled": False}},
{"wikipedia": {"enabled": False}},
{"current_datetime": {"enabled": True}},
{"sensitive-word-avoidance": {"enabled": False, "words": [], "canned_response": ""}},
]
@pytest.mark.parametrize(
"invalid_fields",
[
{"model": "gpt-4o-mini"},
{"model": {"provider": "langgenius/openai/openai", "name": "gpt-4o-mini", "completion_params": []}},
{"user_input_form": {"text-input": {"variable": "topic"}}},
{"file_upload": []},
{"chat_prompt_config": {"prompt": [{"role": "system", "text": {"invalid": "prompt"}}]}},
{"completion_prompt_config": {"conversation_histories_role": {"user_prefix": []}}},
{"user_input_form": [{"select": {"label": "Style", "variable": "style", "options": {"brief": True}}}]},
{"dataset_configs": {"weights": {"vector_setting": {"vector_weight": {"invalid": 0.7}}}}},
{
"agent_mode": {
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "search",
"tool_parameters": [],
}
]
}
},
{"file_upload": {"image": {"transfer_methods": "remote_url"}}},
{"speech_to_text": {"enabled": {"invalid": True}}},
{"external_data_tools": [{"enabled": True, "type": "api", "config": []}]},
{"chat_prompt_config": {"prompt": [{"text": "Missing role"}]}},
{"chat_prompt_config": {"prompt": None}},
{"completion_prompt_config": {"conversation_histories_role": {"user_prefix": "Human"}}},
{"text_to_speech": {"voice": None}},
{"suggested_questions_after_answer": {"model": None}},
{
"suggested_questions_after_answer": {
"model": {"provider": "provider", "name": "model", "completion_params": None}
}
},
{"file_upload": {"allowed_file_types": None}},
{"user_input_form": [{"text-input": {"label": "Topic", "variable": "topic", "options": None}}]},
{"dataset_configs": {"datasets": {"datasets": [{"dataset": {"enabled": None}}]}}},
{"file_upload": {"image": {"enabled": None}}},
{"dataset_configs": {"datasets": {"strategy": "router"}}},
{"dataset_configs": {"weights": {"vector_setting": {"vector_weight": 0.7}}}},
{"dataset_configs": {"metadata_filtering_conditions": {"conditions": [{"comparison_operator": "is"}]}}},
{"dataset_configs": {"retrieval_model": "unsupported"}},
{
"dataset_configs": {
"metadata_filtering_conditions": {
"conditions": [{"name": "topic", "comparison_operator": "unsupported"}]
}
}
},
{"suggested_questions_after_answer": {"model": {"provider": "p", "name": "m", "mode": "unsupported"}}},
{"agent_mode": {"tools": [{}]}},
{"agent_mode": {"tools": [{"enabled": False}]}},
{"agent_mode": {"tools": [{"provider_type": "builtin", "provider_id": "time", "tool_name": "time"}]}},
{"agent_mode": {"tools": [{"dataset": None}]}},
],
ids=[
"model-string",
"completion-params-list",
"form-object",
"file-upload-list",
"chat-prompt-text-object",
"completion-prefix-list",
"form-options-object",
"dataset-weight-object",
"agent-tool-parameters-list",
"image-transfer-methods-string",
"feature-enabled-object",
"external-tool-config-list",
"chat-prompt-role-missing",
"chat-prompt-null",
"completion-assistant-prefix-missing",
"text-to-speech-voice-null",
"suggested-model-null",
"suggested-completion-params-null",
"allowed-file-types-null",
"text-input-options-null",
"modern-dataset-enabled-null",
"legacy-image-enabled-null",
"dataset-list-missing",
"retrieval-weights-incomplete",
"metadata-condition-name-missing",
"retrieval-mode-unsupported",
"metadata-comparison-unsupported",
"suggested-model-mode-unsupported",
"empty-agent-tool",
"agent-tool-only-enabled",
"provider-tool-parameters-missing",
"legacy-dataset-null",
],
)
def test_post_rejects_invalid_wire_before_business_validation(
model_config_http: _ModelConfigHttp, invalid_fields: dict[str, object]
) -> None:
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload(**invalid_fields))
assert response.status_code == 400, response.get_json()
assert response.get_json()["code"] == "invalid_param"
model_config_http.validate_configuration.assert_not_called()
model_config_http.signal.assert_not_called()
assert model_config_http.app_model.app_model_config_id == "config-0"
assert model_config_http.session.scalar(select(func.count()).select_from(AppModelConfig)) == 1
def test_post_keeps_business_validation_as_the_configuration_policy_owner(model_config_http: _ModelConfigHttp) -> None:
model_config_http.validate_configuration.side_effect = ValueError("model.name must be in the specified model list")
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload())
assert response.status_code == 400, response.get_json()
assert response.get_json()["message"] == "model.name must be in the specified model list"
model_config_http.signal.assert_not_called()
assert model_config_http.app_model.app_model_config_id == "config-0"
assert model_config_http.session.scalar(select(func.count()).select_from(AppModelConfig)) == 1
def _assert_no_implicit_app_config_properties() -> None:
# `App.is_agent` and `App.app_model_config` used to be poisoned here with a
# raising property. Neither exists as an implicit accessor any more, so their
# absence enforces the same thing outright — assert it instead of
# monkeypatching an attribute that is gone.
assert not hasattr(App, "is_agent")
assert not hasattr(App, "app_model_config")
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION])
@pytest.mark.parametrize("sqlite_session", [(AppModelConfig,)], indirect=True)
def test_post_updates_non_agent_model_config_without_implicit_properties(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
app_mode: AppMode,
sqlite_session: Session,
) -> None:
"""Flush a non-agent config through the injected session without legacy model properties."""
api = model_config_module.ModelConfigResource()
method = unwrap(api.post)
app_model = App(
id="app-1",
mode=app_mode,
app_model_config_id="config-0",
updated_by=None,
)
original_config = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1")
original_config.id = "config-0"
original_config.agent_mode = None
sqlite_session.add(original_config)
sqlite_session.commit()
_assert_no_implicit_app_config_properties()
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {"pre_prompt": "hi"},
)
def _from_model_config_dict(self, model_config):
self.pre_prompt = model_config["pre_prompt"]
self.id = "config-1"
return self
monkeypatch.setattr(AppModelConfig, "from_model_config_dict", _from_model_config_dict)
send_mock = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", send_mock)
with app.test_request_context(
"/console/api/apps/app-1/model-config", method="POST", json=_model_config_payload(pre_prompt="hi")
):
response = method(api, sqlite_session, "t1", "u1", app_model=app_model)
assert send_mock.call_args.kwargs["session"] is sqlite_session
assert app_model.app_model_config_id == "config-1"
assert app_model.mode == app_mode
persisted_config = sqlite_session.get(AppModelConfig, "config-1")
assert persisted_config is not None
assert persisted_config.pre_prompt == "hi"
assert response["result"] == "success"
def test_post_uses_one_session_and_rolls_back_when_signal_fails(
app: Flask,
sqlite_engine: Engine,
monkeypatch: pytest.MonkeyPatch,
) -> None:
make_session = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
app_id = str(uuid4())
tenant_id = str(uuid4())
user_id = str(uuid4())
with make_session.begin() as setup_session:
original_config = AppModelConfig(app_id=app_id, created_by=user_id, updated_by=user_id)
original_config.agent_mode = json.dumps({"tools": []})
setup_session.add(original_config)
setup_session.flush()
original_config_id = original_config.id
setup_session.add(
App(
id=app_id,
tenant_id=tenant_id,
name="Atomic app",
description="",
mode=AppMode.AGENT_CHAT,
icon_type=None,
icon=None,
icon_background=None,
app_model_config_id=original_config_id,
enable_site=True,
enable_api=True,
max_active_requests=None,
created_by=user_id,
)
)
monkeypatch.setattr(controller_session.session_factory, "create_session", make_session)
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {"agent_mode": {"tools": []}},
)
captured: dict[str, object] = {}
def load_app_model(session, requested_app_id: str):
loaded_app = session.get(App, requested_app_id)
captured["load_session"] = session
return loaded_app
def fail_signal(sender: App, **kwargs: object) -> None:
signal_session = kwargs["session"]
assert object_session(sender) is signal_session
assert signal_session is captured["load_session"]
raise RuntimeError("signal failed")
monkeypatch.setattr(app_wraps_module, "_load_app_model", load_app_model)
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", fail_signal)
method = model_config_module.ModelConfigResource.post
while not os.path.normpath(method.__code__.co_filename).endswith(
os.path.join("controllers", "common", "session.py")
):
method = method.__wrapped__
assert os.path.normpath(method.__wrapped__.__code__.co_filename).endswith(
os.path.join("controllers", "console", "app", "wraps.py")
)
api = model_config_module.ModelConfigResource()
with (
app.test_request_context(
f"/console/api/apps/{app_id}/model-config", method="POST", json=_model_config_payload()
),
pytest.raises(RuntimeError, match="signal failed"),
):
method(
api,
current_tenant_id=tenant_id,
current_user_id=user_id,
app_id=app_id,
)
with make_session() as verification_session:
persisted_app = verification_session.get(App, app_id)
assert persisted_app is not None
assert persisted_app.app_model_config_id == original_config_id
config_count = verification_session.scalar(select(func.count()).select_from(AppModelConfig))
assert config_count == 1
@pytest.mark.parametrize("sqlite_session", [(AppModelConfig,)], indirect=True)
def test_post_encrypts_agent_tool_parameters(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
"""Agent parameter encryption reads and writes persisted model configurations."""
api = model_config_module.ModelConfigResource()
method = unwrap(api.post)
app_model = App(
id="app-1",
mode=AppMode.AGENT_CHAT,
app_model_config_id="config-0",
updated_by=None,
)
_assert_no_implicit_app_config_properties()
original_config = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1")
original_config.id = "config-0"
original_config.agent_mode = json.dumps(
{
"enabled": True,
"strategy": "function-calling",
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "tool",
"tool_parameters": {"secret": "masked"},
}
],
"prompt": None,
}
)
sqlite_session.add(original_config)
sqlite_session.commit()
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {
"pre_prompt": "hi",
"agent_mode": {
"enabled": True,
"strategy": "function-calling",
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "tool",
"tool_parameters": {"secret": "masked"},
}
],
"prompt": None,
},
},
)
monkeypatch.setattr(model_config_module.ToolManager, "get_agent_tool_runtime", lambda **_kwargs: object())
class _ParamManager:
def __init__(self, **_kwargs):
self.delete_called = False
def decrypt_tool_parameters(self, _value):
return {"secret": "decrypted"}
def mask_tool_parameters(self, _value):
return {"secret": "masked"}
def encrypt_tool_parameters(self, _value):
return {"secret": "encrypted"}
def delete_tool_parameters_cache(self):
self.delete_called = True
monkeypatch.setattr(model_config_module, "ToolParameterConfigurationManager", _ParamManager)
send_mock = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", send_mock)
with app.test_request_context(
"/console/api/apps/app-1/model-config", method="POST", json=_model_config_payload(pre_prompt="hi")
):
response = method(api, sqlite_session, "t1", "u1", app_model=app_model)
stored_config = sqlite_session.get(AppModelConfig, app_model.app_model_config_id)
assert stored_config is not None
stored_agent_mode = json.loads(stored_config.agent_mode)
assert app_model.mode == AppMode.AGENT_CHAT
assert stored_agent_mode["tools"][0]["tool_parameters"]["secret"] == "encrypted"
assert response["result"] == "success"
@@ -0,0 +1,793 @@
from __future__ import annotations
import inspect
import json
from collections.abc import Callable
from dataclasses import dataclass
from datetime import datetime
from types import SimpleNamespace
from unittest.mock import MagicMock
from uuid import UUID
import pytest
from dify_trace_sdk.testing import RecordingEgress
from flask import Flask
from sqlalchemy import func, select
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from controllers.common.rbac import PlainApp
from controllers.console import flask_admission
from controllers.console.app import app as app_module
from controllers.console.app import ops_trace as ops_trace_module
from controllers.console.app.error import (
AppNotFoundError,
InvalidTracingConfigError,
TracingConfigAlreadyExistsError,
TracingConfigConflictError,
TracingConfigNotFoundError,
TracingConfigProcessingError,
TracingConfigVerificationFailedError,
TracingProviderUnavailableError,
UnsupportedTracingProviderError,
)
from libs.exception import BaseHTTPException
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import Account, AccountStatus, TenantAccountRole
from models.model import TraceAppConfig
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from services.app_tracing_config_service import (
AppTracingConfigAlreadyExistsError,
AppTracingConfigAppNotFoundError,
AppTracingConfigConflictError,
AppTracingConfigInvalidConfigurationError,
AppTracingConfigInvalidProviderError,
AppTracingConfigNotFoundError,
AppTracingConfigProcessingError,
AppTracingConfigProviderUnavailableError,
AppTracingConfigRecord,
AppTracingConfigService,
AppTracingConfigVerificationFailedError,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_app
from tests.helpers.unit.services.tracing_ports import deployment_provider_configs
APP_ID = "11111111-1111-1111-1111-111111111111"
WORKSPACE_ID = "22222222-2222-2222-2222-222222222222"
ACCOUNT_ID = "33333333-3333-3333-3333-333333333333"
PROVIDER = "langfuse"
_MUTATION_METHODS = (
ops_trace_module.TraceAppConfigApi.post,
ops_trace_module.TraceAppConfigApi.patch,
ops_trace_module.TraceAppConfigApi.delete,
)
_CONTROLLER_METHODS: dict[str, Callable[..., object]] = {
"get": ops_trace_module.TraceAppConfigApi.get,
"post": ops_trace_module.TraceAppConfigApi.post,
"patch": ops_trace_module.TraceAppConfigApi.patch,
"delete": ops_trace_module.TraceAppConfigApi.delete,
}
def _service_method(tracing_configs: MagicMock, method_name: str) -> MagicMock:
return {
"get": tracing_configs.get,
"post": tracing_configs.create,
"patch": tracing_configs.update,
"delete": tracing_configs.delete,
}[method_name]
def _account(role: TenantAccountRole) -> Account:
account = Account(
name="Trace User",
email=f"{role.value}@example.com",
status=AccountStatus.ACTIVE,
)
account.id = ACCOUNT_ID
account.role = role
return account
def _request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id=ACCOUNT_ID,
active_workspace_id=WORKSPACE_ID,
)
def _original(method: Callable[..., object]) -> Callable[..., object]:
return inspect.unwrap(method)
def _admission_injector(method: Callable[..., object]) -> Callable[..., object]:
return inspect.unwrap(
method,
stop=lambda candidate: "allowed_roles" in inspect.getclosurevars(candidate).nonlocals,
)
@pytest.fixture
def tracing_configs(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
service = MagicMock()
monkeypatch.setattr(
ops_trace_module,
"application_services",
lambda: SimpleNamespace(app_tracing_configs=service),
)
return service
@dataclass(frozen=True)
class _ApplicationServices:
app_tracing_configs: AppTracingConfigService
@dataclass(frozen=True)
class _StoredConfigs:
"""Configurations persisted the way the provider gateway stores them, behind the real service."""
sessions: sessionmaker[Session]
egress: RecordingEgress
def add(self, tracing_provider: str, tracing_config: dict[str, str | None]) -> TraceAppConfig:
with self.sessions.begin() as session:
session.add(TraceAppConfig(app_id=APP_ID, tracing_provider=tracing_provider, tracing_config=tracing_config))
with self.sessions() as session:
return session.scalars(
select(TraceAppConfig).where(
TraceAppConfig.app_id == APP_ID, TraceAppConfig.tracing_provider == tracing_provider
)
).one()
def count(self) -> int:
with self.sessions() as session:
return session.scalar(select(func.count()).select_from(TraceAppConfig)) or 0
@pytest.fixture
def stored_configs(monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]) -> _StoredConfigs:
with sqlite_session_factory.begin() as session:
session.add(make_app(app_id=APP_ID, tenant_id=WORKSPACE_ID))
egress = RecordingEgress([], grpc_target=None)
service = AppTracingConfigService(
configs=SQLAlchemyAppTracingConfigRepository(session_factory=sqlite_session_factory),
provider=deployment_provider_configs(egress),
)
monkeypatch.setattr(
ops_trace_module, "application_services", lambda: _ApplicationServices(app_tracing_configs=service)
)
return _StoredConfigs(sqlite_session_factory, egress)
@pytest.mark.parametrize("method_name", ["get", "delete"])
def test_trace_config_read_when_absent_or_deleted_never_contacts_the_provider(
app: Flask, stored_configs: _StoredConfigs, method_name: str
) -> None:
if method_name == "delete":
stored_configs.add("weave", {"api_key": "ciphertext-api-key", "entity": "dify", "project": "traces"})
with app.test_request_context("/"):
result = _original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider="weave"),
_request_context(),
UUID(APP_ID),
)
assert result == ({"has_not_configured": True} if method_name == "get" else ("", 204))
assert stored_configs.count() == 0
assert stored_configs.egress.requests == []
@pytest.mark.parametrize(
("provider", "stored", "presented", "configured_secrets"),
[
pytest.param(
"langfuse",
{
"public_key": "ciphertext-public-key",
"secret_key": "ciphertext-secret-key",
"host": "https://langfuse.example.com",
"project_key": "project-1",
},
{"host": "https://langfuse.example.com", "project_url": "https://langfuse.example.com/project/project-1"},
["public_key", "secret_key"],
id="all-secrets-set",
),
pytest.param(
"databricks",
{
"host": "https://dbc.example.com",
"experiment_id": "7",
"client_id": "client-1",
"client_secret": "",
"personal_access_token": "ciphertext-token",
},
{
"host": "https://dbc.example.com",
"experiment_id": "7",
"client_id": "client-1",
"project_url": "https://dbc.example.com/ml/experiments/7/traces",
},
["personal_access_token"],
id="empty-secret-not-configured",
),
pytest.param(
"mlflow",
{"tracking_uri": "https://mlflow.example.com", "experiment_id": "7", "username": "admin", "password": None},
{
"tracking_uri": "https://mlflow.example.com",
"experiment_id": "7",
"username": "admin",
"project_url": "https://mlflow.example.com/#/experiments/7/traces",
},
[],
id="no-secrets-set",
),
],
)
def test_trace_app_config_get_returns_configured_secrets_and_never_secret_values(
app: Flask,
stored_configs: _StoredConfigs,
provider: str,
stored: dict[str, str | None],
presented: dict[str, str],
configured_secrets: list[str],
) -> None:
record = stored_configs.add(provider, stored)
with app.test_request_context(f"/?tracing_provider={provider}"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=provider),
_request_context(),
UUID(APP_ID),
)
assert result == {
"id": record.id,
"app_id": APP_ID,
"tracing_provider": provider,
"tracing_config": presented,
"configured_secrets": configured_secrets,
"is_active": True,
"created_at": str(record.created_at),
"updated_at": str(record.updated_at),
}
assert "ciphertext" not in json.dumps(result)
assert stored_configs.egress.requests == []
@pytest.mark.parametrize(
("failure", "expected"),
[
(AppTracingConfigProviderUnavailableError(), TracingProviderUnavailableError),
(AppTracingConfigNotFoundError(), TracingConfigNotFoundError),
(AppTracingConfigConflictError(), TracingConfigConflictError),
(AppTracingConfigInvalidConfigurationError(), InvalidTracingConfigError),
(AppTracingConfigProcessingError(), TracingConfigProcessingError),
],
)
def test_enable_tracing_maps_configuration_failures(
app: Flask, monkeypatch: pytest.MonkeyPatch, failure: Exception, expected: type[BaseHTTPException]
) -> None:
console_apps = MagicMock()
console_apps.set_trace.side_effect = failure
monkeypatch.setattr(
app_module,
"application_services",
lambda: SimpleNamespace(apps=SimpleNamespace(console=console_apps)),
)
with (
app.test_request_context(
"/",
method="POST",
json={"enabled": True, "tracing_provider": "weave"},
),
pytest.raises(expected) as caught,
):
_original(app_module.AppTraceApi.post)(
app_module.AppTraceApi(),
_request_context(),
UUID(APP_ID),
)
assert caught.value.code == expected.code
assert caught.value.error_code == expected.error_code
assert caught.value.__cause__ is failure
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_reject_read_only_member_when_rbac_is_disabled(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
method: Callable[..., object],
) -> None:
account = _account(TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission,
"current_account_with_tenant",
lambda: AccountWithTenant(account=account, tenant_id=WORKSPACE_ID),
)
with app.test_request_context(), pytest.raises(Forbidden):
_admission_injector(method)(None, app_id=UUID(APP_ID))
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_require_app_tracing_permission_when_rbac_is_enabled(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
method: Callable[..., object],
) -> None:
account = _account(TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr(
flask_admission,
"current_account_with_tenant",
lambda: AccountWithTenant(account=account, tenant_id=WORKSPACE_ID),
)
denied = MagicMock(side_effect=Forbidden())
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
with app.test_request_context(), pytest.raises(Forbidden):
_admission_injector(method)(None, app_id=UUID(APP_ID))
denied.assert_called_once()
call = denied.call_args.kwargs
assert call["tenant_id"] == WORKSPACE_ID
assert call["account_id"] == ACCOUNT_ID
assert call["path_args"] == {"app_id": UUID(APP_ID)}
(check,) = call["checks"]
assert check.scene == ops_trace_module.RBACPermission.APP_TRACING_CONFIG
assert isinstance(check.locator, PlainApp)
def test_trace_config_get_preserves_read_access_for_normal_member() -> None:
admission = _admission_injector(ops_trace_module.TraceAppConfigApi.get)
assert inspect.getclosurevars(admission).nonlocals["allowed_roles"] is None
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_preserve_legacy_edit_roles(method: Callable[..., object]) -> None:
admission = _admission_injector(method)
assert inspect.getclosurevars(admission).nonlocals["allowed_roles"] == frozenset(
{
TenantAccountRole.OWNER,
TenantAccountRole.ADMIN,
TenantAccountRole.EDITOR,
}
)
def test_trace_app_config_get_empty_returns_exact_legacy_body(
app: Flask,
tracing_configs: MagicMock,
) -> None:
tracing_configs.get.return_value = None
with app.test_request_context("/?tracing_provider=langfuse"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER),
_request_context(),
UUID(APP_ID),
)
assert result == {"has_not_configured": True}
tracing_configs.get.assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=PROVIDER,
)
@pytest.mark.parametrize(
("provider", "config", "configured_secrets"),
[
(
"langfuse",
{"host": "https://cloud.langfuse.com", "project_url": "https://cloud.langfuse.com/project/p-1"},
("public_key", "secret_key"),
),
(
"mlflow",
{
"tracking_uri": "http://localhost:5000",
"experiment_id": "0",
"username": None,
"project_url": "http://localhost:5000/#/experiments/0/traces",
},
(),
),
],
)
def test_trace_app_config_get_configured_returns_exact_body(
app: Flask,
tracing_configs: MagicMock,
provider: str,
config: dict[str, str | None],
configured_secrets: tuple[str, ...],
) -> None:
tracing_configs.get.return_value = AppTracingConfigRecord(
id="trace-config-1",
app_id=APP_ID,
tracing_provider=provider,
tracing_config=config,
is_active=True,
created_at=datetime(2026, 1, 2, 3, 4, 5),
updated_at=datetime(2026, 1, 3, 4, 5, 6),
configured_secrets=configured_secrets,
)
with app.test_request_context(f"/?tracing_provider={provider}"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=provider),
_request_context(),
UUID(APP_ID),
)
assert result == {
"id": "trace-config-1",
"app_id": APP_ID,
"tracing_provider": provider,
"tracing_config": config,
"configured_secrets": list(configured_secrets),
"is_active": True,
"created_at": "2026-01-02 03:04:05",
"updated_at": "2026-01-03 04:05:06",
}
@pytest.mark.parametrize(
("method_name", "expected_result"),
[
pytest.param("post", ({"result": "success"}, 201), id="create"),
pytest.param("patch", {"result": "success"}, id="update"),
],
)
@pytest.mark.parametrize(
("provider", "config"),
[
("langfuse", {"public_key": "pk", "secret_key": "sk"}),
("mlflow", {"tracking_uri": "", "experiment_id": "0", "username": None, "password": "******"}),
],
)
@pytest.mark.parametrize("activate", [False, True])
def test_trace_app_config_write_returns_expected_response(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
expected_result: object,
activate: bool,
provider: str,
config: dict[str, str | None],
) -> None:
payload = ops_trace_module.TraceConfigPayload(
tracing_provider=provider,
tracing_config=config,
activate=activate,
)
with app.test_request_context("/", method=method_name.upper()):
result = _original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
payload,
_request_context(),
UUID(APP_ID),
)
assert result == expected_result
_service_method(tracing_configs, method_name).assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=provider,
tracing_config=config,
activate=activate,
)
def test_trace_app_config_delete_returns_exact_204_response(
app: Flask,
tracing_configs: MagicMock,
) -> None:
with app.test_request_context("/?tracing_provider=langfuse", method="DELETE"):
result = _original(ops_trace_module.TraceAppConfigApi.delete)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER),
_request_context(),
UUID(APP_ID),
)
assert result == ("", 204)
tracing_configs.delete.assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=PROVIDER,
)
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_maps_missing_app_to_404(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = AppTracingConfigAppNotFoundError()
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"):
with pytest.raises(AppNotFoundError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == 404
assert exc_info.value.error_code == "app_not_found"
@pytest.mark.parametrize(
("method_name", "service_error", "expected_http_error", "expected_status", "expected_code"),
[
pytest.param(
"patch",
AppTracingConfigConflictError(),
TracingConfigConflictError,
409,
"tracing_config_conflict",
id="patch-concurrent-change",
),
pytest.param(
"get",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="get-unavailable-provider",
),
pytest.param(
"post",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="post-unavailable-provider",
),
pytest.param(
"patch",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="patch-unavailable-provider",
),
pytest.param(
"post",
AppTracingConfigAlreadyExistsError(),
TracingConfigAlreadyExistsError,
409,
"trace_config_already_exists",
id="already-exists",
),
pytest.param(
"patch",
AppTracingConfigNotFoundError(),
TracingConfigNotFoundError,
404,
"trace_config_not_found",
id="patch-not-found",
),
pytest.param(
"delete",
AppTracingConfigNotFoundError(),
TracingConfigNotFoundError,
404,
"trace_config_not_found",
id="delete-not-found",
),
pytest.param(
"get",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="get-unsupported-provider",
),
pytest.param(
"post",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="post-unsupported-provider",
),
pytest.param(
"patch",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="patch-unsupported-provider",
),
pytest.param(
"delete",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="delete-unsupported-provider",
),
pytest.param(
"post",
AppTracingConfigInvalidConfigurationError(),
InvalidTracingConfigError,
400,
"invalid_tracing_config",
id="post-invalid-config",
),
pytest.param(
"patch",
AppTracingConfigInvalidConfigurationError(),
InvalidTracingConfigError,
400,
"invalid_tracing_config",
id="patch-invalid-config",
),
pytest.param(
"post",
AppTracingConfigVerificationFailedError(),
TracingConfigVerificationFailedError,
400,
"tracing_config_verification_failed",
id="post-verification-failed",
),
pytest.param(
"patch",
AppTracingConfigVerificationFailedError(),
TracingConfigVerificationFailedError,
400,
"tracing_config_verification_failed",
id="patch-verification-failed",
),
pytest.param(
"get",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="get-processing-failed",
),
pytest.param(
"post",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="post-processing-failed",
),
pytest.param(
"patch",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="patch-processing-failed",
),
pytest.param(
"delete",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="delete-processing-failed",
),
],
)
def test_trace_app_config_maps_application_errors_at_the_controller_boundary(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
service_error: Exception,
expected_http_error: type[BaseHTTPException],
expected_status: int,
expected_code: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = service_error
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"):
with pytest.raises(expected_http_error) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == expected_status
assert exc_info.value.error_code == expected_code
assert exc_info.value.data == {
"code": expected_code,
"message": exc_info.value.description,
"status": expected_status,
}
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_maps_untyped_value_errors_to_internal_error(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = ValueError("internal detail")
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"), pytest.raises(TracingConfigProcessingError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == 500
assert exc_info.value.error_code == "tracing_config_processing_failed"
assert exc_info.value.description == "The tracing configuration could not be processed."
assert exc_info.value.data == {
"code": "tracing_config_processing_failed",
"message": "The tracing configuration could not be processed.",
"status": 500,
}
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_does_not_mask_unexpected_errors(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
unexpected_error = RuntimeError("unexpected")
service_method.side_effect = unexpected_error
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"), pytest.raises(RuntimeError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value is unexpected_error
@@ -0,0 +1,319 @@
"""Real HTTP and SQLite coverage for Console statistics admission.
Metric aggregation uses PostgreSQL/MySQL functions, so successful query results
are exercised by the controller integration tests against PostgreSQL. These tests
exercise the real identity and app queries without substituting query services.
"""
from collections.abc import Iterator
from dataclasses import dataclass
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Blueprint, Flask, Response
from flask.testing import FlaskClient
from flask_restx import Resource
from redis import Redis
from sqlalchemy import Connection, Engine, event, text
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_CSRF_TOKEN
from controllers.console.app import statistic, workflow_statistic
from controllers.console.wraps import _is_setup_completed
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler
from extensions.ext_redis import RedisClientWrapper
from libs.datetime_utils import naive_utc_now
from libs.external_api import ExternalApi
from libs.passport import PassportService
from libs.token import _real_cookie_name, generate_csrf_token
from models import Account, DifySetup, Tenant, TenantAccountJoin
from models.account import AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource
from models.engine import db
from models.model import App, AppMode
from tests.helpers.unit.config_override import config_overrides_context
@dataclass(frozen=True)
class _Endpoint:
path: str
resource: type[Resource]
mode: AppMode
_ENDPOINTS = (
_Endpoint("statistics/daily-messages", statistic.DailyMessageStatistic, AppMode.CHAT),
_Endpoint("statistics/daily-conversations", statistic.DailyConversationStatistic, AppMode.CHAT),
_Endpoint("statistics/daily-end-users", statistic.DailyTerminalsStatistic, AppMode.CHAT),
_Endpoint("statistics/token-costs", statistic.DailyTokenCostStatistic, AppMode.CHAT),
_Endpoint("statistics/average-session-interactions", statistic.AverageSessionInteractionStatistic, AppMode.CHAT),
_Endpoint("statistics/user-satisfaction-rate", statistic.UserSatisfactionRateStatistic, AppMode.CHAT),
_Endpoint("statistics/average-response-time", statistic.AverageResponseTimeStatistic, AppMode.COMPLETION),
_Endpoint("statistics/tokens-per-second", statistic.TokensPerSecondStatistic, AppMode.CHAT),
_Endpoint(
"workflow/statistics/daily-conversations", workflow_statistic.WorkflowDailyRunsStatistic, AppMode.WORKFLOW
),
_Endpoint(
"workflow/statistics/daily-terminals", workflow_statistic.WorkflowDailyTerminalsStatistic, AppMode.WORKFLOW
),
_Endpoint("workflow/statistics/token-costs", workflow_statistic.WorkflowDailyTokenCostStatistic, AppMode.WORKFLOW),
_Endpoint(
"workflow/statistics/average-app-interactions",
workflow_statistic.WorkflowAverageAppInteractionStatistic,
AppMode.WORKFLOW,
),
)
@dataclass(frozen=True)
class _Harness:
client: FlaskClient
session_factory: sessionmaker[Session]
account_id: str
tenant_id: str
headers: dict[str, str]
sessions: list[Session]
def create_app(self, mode: AppMode, *, tenant_id: str | None = None) -> str:
with self.session_factory.begin() as session:
app = App(
tenant_id=tenant_id or self.tenant_id,
name="Statistics app",
mode=mode,
created_by=self.account_id,
enable_api=True,
enable_site=True,
)
session.add(app)
session.flush()
return app.id
def get(self, endpoint: _Endpoint, app_id: str, *, query: dict[str, str] | None = None) -> TestResponse:
self.sessions.clear()
return self.client.get(f"/console/api/apps/{app_id}/{endpoint.path}", headers=self.headers, query_string=query)
@pytest.fixture
def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
with (
Redis() as redis_client,
config_overrides_context(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
RBAC_ENABLED=False,
LOGIN_DISABLED=False,
INIT_PASSWORD="",
SECRET_KEY="statistics-http-test-secret-at-least-32-bytes",
),
):
app = Flask(__name__)
app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
redis = RedisClientWrapper()
redis.initialize(redis_client)
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis,
)
app.extensions["application_services"] = services
bind_account_loader(app, services.accounts.identity.load_user)
login_manager = DifyLoginManager()
login_manager.request_loader(load_user_from_request)
login_manager.unauthorized_handler(unauthorized_handler)
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
for endpoint in _ENDPOINTS:
api.add_resource(endpoint.resource, f"/apps/<uuid:app_id>/{endpoint.path}")
app.register_blueprint(blueprint)
now = naive_utc_now()
with sqlite_session_factory.begin() as session:
account = Account(
email="statistics@example.com",
name="Statistics viewer",
status=AccountStatus.ACTIVE,
initialized_at=now,
timezone="America/New_York",
)
account.last_active_at = now
tenant = Tenant(name="Statistics workspace")
session.add_all([account, tenant, DifySetup(version="test")])
session.flush()
session.add(
TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
role=TenantAccountRole.OWNER,
current=True,
)
)
account_id, tenant_id = account.id, tenant.id
# Complete the one-time setup check before observing request transactions.
# The legacy setup cache still owns a Flask-scoped Session independently.
with app.app_context():
_is_setup_completed.reset_success()
assert _is_setup_completed()
db.session.remove()
client = app.test_client()
csrf_token = generate_csrf_token(account_id)
client.set_cookie(_real_cookie_name("csrf_token"), csrf_token)
headers = {
"Authorization": f"Bearer {PassportService().issue({'user_id': account_id})}",
HEADER_NAME_CSRF_TOKEN: csrf_token,
}
sessions: list[Session] = []
def observe_session(session: Session, transaction: SessionTransaction, connection: Connection) -> None:
sessions.append(session)
@app.after_request
def assert_request_sessions_closed(response: Response) -> Response:
assert all(not session.in_transaction() and not session.identity_map for session in sessions)
return response
event.listen(Session, "after_begin", observe_session)
try:
yield _Harness(client, sqlite_session_factory, account_id, tenant_id, headers, sessions)
finally:
event.remove(Session, "after_begin", observe_session)
_is_setup_completed.reset_success()
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("visibility", ["missing", "different-workspace", "non-normal", "workflow-only"])
def test_statistics_reject_inaccessible_apps(harness: _Harness, endpoint: _Endpoint, visibility: str) -> None:
app_id = str(uuid4())
if visibility != "missing":
app_id = harness.create_app(
endpoint.mode, tenant_id=str(uuid4()) if visibility == "different-workspace" else None
)
with harness.session_factory.begin() as session:
app = session.get(App, app_id)
assert app is not None
if visibility == "non-normal":
# Persist a historical status not accepted by the current enum.
session.execute(
text("UPDATE apps SET status = :status WHERE id = :app_id"),
{"status": "archived", "app_id": app_id},
)
elif visibility == "workflow-only":
app.mode = AppMode.AGENT
session.add(
Agent(
tenant_id=harness.tenant_id,
name="Hidden workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
app_id=str(uuid4()),
backing_app_id=app_id,
)
)
response = harness.get(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "app_not_found"
assert response.content_type == "application/json"
assert harness.sessions
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("field", ["start", "end"])
def test_statistics_reject_invalid_dates_after_app_admission(
harness: _Harness, endpoint: _Endpoint, field: str
) -> None:
app_id = harness.create_app(endpoint.mode)
response = harness.get(endpoint, app_id, query={field: "not-a-date"})
assert response.status_code == HTTPStatus.BAD_REQUEST
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "invalid_param"
assert "not-a-date" in body["message"]
assert harness.sessions
@pytest.mark.parametrize(
("endpoint", "unsupported_mode"),
[
(_ENDPOINTS[4], AppMode.COMPLETION),
(_ENDPOINTS[6], AppMode.CHAT),
(_ENDPOINTS[11], AppMode.ADVANCED_CHAT),
],
ids=["session-interactions", "response-time", "workflow-interactions"],
)
def test_statistics_preserve_app_mode_restrictions(
harness: _Harness, endpoint: _Endpoint, unsupported_mode: AppMode
) -> None:
app_id = harness.create_app(unsupported_mode)
response = harness.get(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "app_not_found"
assert "App mode is not in the supported list" in body["message"]
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_session_interactions_admits_supported_chat_modes_before_date_validation(
harness: _Harness, mode: AppMode
) -> None:
app_id = harness.create_app(mode)
response = harness.get(_ENDPOINTS[4], app_id, query={"start": "invalid-date"})
assert response.status_code == HTTPStatus.BAD_REQUEST
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "invalid_param"
def test_statistics_require_console_authentication(harness: _Harness) -> None:
app_id = harness.create_app(AppMode.CHAT)
response = harness.client.get(f"/console/api/apps/{app_id}/statistics/daily-messages")
assert response.status_code == HTTPStatus.UNAUTHORIZED
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "unauthorized"
def test_statistics_require_valid_csrf_token(harness: _Harness) -> None:
app_id = harness.create_app(AppMode.CHAT)
response = harness.client.get(
f"/console/api/apps/{app_id}/statistics/daily-messages",
headers={"Authorization": harness.headers["Authorization"]},
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "unauthorized"
assert body["message"] == "CSRF token is missing or invalid."
@pytest.mark.parametrize("query_type", [statistic.StatisticTimeRangeQuery, workflow_statistic.WorkflowStatisticQuery])
def test_statistics_treat_blank_date_bounds_as_absent(
query_type: type[statistic.StatisticTimeRangeQuery] | type[workflow_statistic.WorkflowStatisticQuery],
) -> None:
query = query_type(start="", end="")
assert query.start is None
assert query.end is None
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,52 @@
from __future__ import annotations
from datetime import UTC, datetime
from controllers.console.app import workflow_app_log as workflow_app_log_module
from graphon.enums import WorkflowExecutionStatus
def test_workflow_app_log_query_parses_bool_and_datetime() -> None:
query = workflow_app_log_module.WorkflowAppLogQuery.model_validate(
{
"detail": "true",
"created_at__before": "2026-01-02T03:04:05Z",
"page": "2",
"limit": "10",
}
)
assert query.detail is True
assert query.created_at__before == datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
assert query.page == 2
assert query.limit == 10
def test_workflow_app_log_pagination_response_normalizes_nested_fields() -> None:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
response = workflow_app_log_module.WorkflowAppLogPaginationResponse.model_validate(
{
"page": 1,
"limit": 20,
"total": 1,
"has_more": False,
"data": [
{
"id": "log-1",
"workflow_run": {
"id": "run-1",
"status": WorkflowExecutionStatus.SUCCEEDED,
"created_at": created_at,
"finished_at": created_at,
},
"details": {"trigger_metadata": {}},
"created_by_account": {"id": "acc-1", "name": "acc", "email": "acc@example.com"},
"created_at": created_at,
}
],
}
).model_dump(mode="json")
assert response["data"][0]["workflow_run"]["status"] == "succeeded"
assert response["data"][0]["workflow_run"]["created_at"] == int(created_at.timestamp())
assert response["data"][0]["created_at"] == int(created_at.timestamp())
@@ -0,0 +1,510 @@
"""Console workflow comment routes keep their admission policy and wire contracts on the application service."""
from __future__ import annotations
from collections.abc import Callable
from contextlib import AbstractContextManager, nullcontext
from dataclasses import dataclass
from datetime import datetime
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, PropertyMock, patch
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden, HTTPException
from controllers.common.errors import ForbiddenError, InvalidArgumentError, NotFoundError
from controllers.console import console_ns, flask_admission
from controllers.console.app import workflow_comment as workflow_comment_module
from controllers.console.app.error import AppNotFoundError
from controllers.console.app.workflow_comment import (
WorkflowCommentDetailApi,
WorkflowCommentListApi,
WorkflowCommentMentionUsersApi,
WorkflowCommentReplyApi,
WorkflowCommentReplyDetailApi,
WorkflowCommentResolveApi,
)
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.workflow_comment_service import (
InvalidMentionedUserIdError,
InvalidWorkflowCommentContentError,
WorkflowCommentAccount,
WorkflowCommentAppNotFoundError,
WorkflowCommentCreated,
WorkflowCommentDetail,
WorkflowCommentDraft,
WorkflowCommentEdit,
WorkflowCommentMentionRecord,
WorkflowCommentNotFoundError,
WorkflowCommentPermissionError,
WorkflowCommentReplyDraft,
WorkflowCommentReplyNotFoundError,
WorkflowCommentReplyRecord,
WorkflowCommentResolved,
WorkflowCommentSummary,
WorkflowCommentUpdated,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account
WORKSPACE_ID = "tenant-123"
APP_ID = UUID("11111111-1111-1111-1111-111111111111")
JAN_1_2024_NOON = datetime(2024, 1, 1, 12, 0, 0)
JAN_1_2024_NOON_TS = int(JAN_1_2024_NOON.timestamp())
JAN_1_2024_1201 = datetime(2024, 1, 1, 12, 1, 0)
JAN_1_2024_1201_TS = int(JAN_1_2024_1201.timestamp())
JAN_1_2024_1202 = datetime(2024, 1, 1, 12, 2, 0)
JAN_1_2024_1202_TS = int(JAN_1_2024_1202.timestamp())
JAN_1_2024_1203 = datetime(2024, 1, 1, 12, 3, 0)
JAN_1_2024_1203_TS = int(JAN_1_2024_1203.timestamp())
AUTHOR = WorkflowCommentAccount(
id="account-123", name="tester", email="tester@example.com", avatar="https://example.com/avatar.png"
)
AUTHOR_JSON = {
"id": "account-123",
"name": "tester",
"email": "tester@example.com",
"avatar_url": "https://example.com/avatar.png",
}
MENTIONED = WorkflowCommentAccount(id="account-456", name="mentioned", email="mentioned@example.com", avatar=None)
MENTIONED_JSON = {"id": "account-456", "name": "mentioned", "email": "mentioned@example.com", "avatar_url": None}
def admission(method: Callable[..., object]) -> Callable[..., object]:
"""Skip setup/login wrappers and enter at the admission adapter that builds the RequestContext."""
return unwrap(method, stop=lambda view: "inject_request_context" in view.__code__.co_qualname)
@pytest.fixture
def comments(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
service = MagicMock()
members = MagicMock()
monkeypatch.setattr(
workflow_comment_module,
"application_services",
lambda: SimpleNamespace(workflow_comments=service, workspaces=SimpleNamespace(member_queries=members)),
)
service.members = members
return service
def _admit(monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole, *, rbac_enabled: bool = False) -> str:
account = make_account(account_id="account-123", role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=rbac_enabled)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, WORKSPACE_ID)
)
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
return account.id
def _payload(payload: dict[str, object] | None) -> AbstractContextManager[object]:
if payload is None:
return nullcontext()
return patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload)
@dataclass(frozen=True)
class WriteCase:
method: Callable[..., object]
http_method: str
kwargs: dict[str, object]
service: Callable[[MagicMock], MagicMock]
service_return: object = None
payload: dict[str, object] | None = None
CREATE_COMMENT = WriteCase(
WorkflowCommentListApi.post,
"POST",
{"app_id": APP_ID},
lambda comments: comments.create_comment,
WorkflowCommentCreated(id="comment-1", created_at=JAN_1_2024_NOON),
{"content": "hello", "position_x": 1.0, "position_y": 2.0, "mentioned_user_ids": []},
)
UPDATE_COMMENT = WriteCase(
WorkflowCommentDetailApi.put,
"PUT",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.update_comment,
WorkflowCommentUpdated(id="comment-1", updated_at=JAN_1_2024_NOON),
{"content": "hello"},
)
DELETE_COMMENT = WriteCase(
WorkflowCommentDetailApi.delete,
"DELETE",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.delete_comment,
)
RESOLVE_COMMENT = WriteCase(
WorkflowCommentResolveApi.post,
"POST",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.resolve_comment,
WorkflowCommentResolved(id="comment-1", resolved=True, resolved_at=JAN_1_2024_NOON, resolved_by="account-123"),
)
CREATE_REPLY = WriteCase(
WorkflowCommentReplyApi.post,
"POST",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.create_reply,
WorkflowCommentCreated(id="reply-1", created_at=JAN_1_2024_NOON),
{"content": "reply", "mentioned_user_ids": []},
)
UPDATE_REPLY = WriteCase(
WorkflowCommentReplyDetailApi.put,
"PUT",
{"app_id": APP_ID, "comment_id": "comment-1", "reply_id": "reply-1"},
lambda comments: comments.update_reply,
WorkflowCommentUpdated(id="reply-1", updated_at=JAN_1_2024_NOON),
{"content": "reply", "mentioned_user_ids": []},
)
DELETE_REPLY = WriteCase(
WorkflowCommentReplyDetailApi.delete,
"DELETE",
{"app_id": APP_ID, "comment_id": "comment-1", "reply_id": "reply-1"},
lambda comments: comments.delete_reply,
)
WRITE_CASES = [
pytest.param(CREATE_COMMENT, id="create-comment"),
pytest.param(UPDATE_COMMENT, id="update-comment"),
pytest.param(DELETE_COMMENT, id="delete-comment"),
pytest.param(RESOLVE_COMMENT, id="resolve-comment"),
pytest.param(CREATE_REPLY, id="create-reply"),
pytest.param(UPDATE_REPLY, id="update-reply"),
pytest.param(DELETE_REPLY, id="delete-reply"),
]
def _call(app: Flask, case: WriteCase) -> object:
with app.test_request_context(method=case.http_method, json=case.payload), _payload(case.payload):
return admission(case.method)(None, **case.kwargs)
@pytest.mark.parametrize("case", WRITE_CASES)
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_write_endpoints_reject_read_only_roles(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
with pytest.raises(Forbidden):
_call(app, case)
case.service(comments).assert_not_called()
@pytest.mark.parametrize("case", WRITE_CASES)
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_write_endpoints_admit_edit_roles(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
case.service(comments).return_value = case.service_return
_call(app, case)
case.service(comments).assert_called_once()
@pytest.mark.parametrize("case", WRITE_CASES)
def test_rbac_replaces_the_legacy_role_gate(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase
) -> None:
# Like `edit_permission_required`, the role gate is skipped under RBAC; these routes declare no RBAC checks.
_admit(monkeypatch, TenantAccountRole.NORMAL, rbac_enabled=True)
case.service(comments).return_value = case.service_return
_call(app, case)
case.service(comments).assert_called_once()
def test_create_comment_passes_request_context_and_typed_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
account_id = _admit(monkeypatch, TenantAccountRole.EDITOR)
comments.create_comment.return_value = CREATE_COMMENT.service_return
payload: dict[str, object] = {
"content": "hello",
"position_x": 1.0,
"position_y": 2.0,
"mentioned_user_ids": ["user-1"],
}
with app.test_request_context(method="POST", json=payload), _payload(payload):
result = admission(WorkflowCommentListApi.post)(None, app_id=APP_ID)
assert result == ({"id": "comment-1", "created_at": JAN_1_2024_NOON_TS}, 201)
context, app_id, draft = comments.create_comment.call_args.args
assert isinstance(context, RequestContext)
assert (context.account_id, context.active_workspace_id) == (account_id, WORKSPACE_ID)
assert app_id == str(APP_ID)
assert draft == WorkflowCommentDraft(
content="hello", position_x=1.0, position_y=2.0, mentioned_user_ids=("user-1",)
)
def test_update_comment_keeps_omitted_mentions_omitted(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_comment.return_value = UPDATE_COMMENT.service_return
payload: dict[str, object] = {"content": "hello", "position_x": 10.0, "position_y": 20.0}
with app.test_request_context(method="PUT", json=payload), _payload(payload):
result = admission(WorkflowCommentDetailApi.put)(None, app_id=APP_ID, comment_id="comment-1")
assert result == {"id": "comment-1", "updated_at": JAN_1_2024_NOON_TS}
_, _, comment_id, edit = comments.update_comment.call_args.args
assert comment_id == "comment-1"
assert edit == WorkflowCommentEdit(content="hello", position_x=10.0, position_y=20.0, mentioned_user_ids=None)
def test_reply_update_passes_typed_draft(app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_reply.return_value = UPDATE_REPLY.service_return
payload: dict[str, object] = {"content": "reply", "mentioned_user_ids": ["user-1"]}
with app.test_request_context(method="PUT", json=payload), _payload(payload):
result = admission(WorkflowCommentReplyDetailApi.put)(
None, app_id=APP_ID, comment_id="comment-1", reply_id="reply-1"
)
assert result == {"id": "reply-1", "updated_at": JAN_1_2024_NOON_TS}
_, _, comment_id, reply_id, draft = comments.update_reply.call_args.args
assert (comment_id, reply_id) == ("comment-1", "reply-1")
assert draft == WorkflowCommentReplyDraft(content="reply", mentioned_user_ids=("user-1",))
@pytest.mark.parametrize(
("case", "expected"),
[
pytest.param(
RESOLVE_COMMENT,
{"id": "comment-1", "resolved": True, "resolved_at": JAN_1_2024_NOON_TS, "resolved_by": "account-123"},
id="resolve",
),
pytest.param(CREATE_REPLY, ({"id": "reply-1", "created_at": JAN_1_2024_NOON_TS}, 201), id="create-reply"),
pytest.param(DELETE_COMMENT, ("", 204), id="delete-comment"),
pytest.param(DELETE_REPLY, ("", 204), id="delete-reply"),
],
)
def test_mutation_endpoints_serialize_responses(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, expected: object
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
case.service(comments).return_value = case.service_return
assert _call(app, case) == expected
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_list_comments_serializes_summaries_for_any_member(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
comments.list_comments.return_value = (
WorkflowCommentSummary(
id="comment-1",
position_x=1.5,
position_y=2.5,
content="hello",
created_by="account-123",
created_by_account=AUTHOR,
created_at=datetime.fromtimestamp(1_700_000_000),
updated_at=datetime.fromtimestamp(1_700_000_001),
resolved=False,
resolved_at=None,
resolved_by=None,
resolved_by_account=None,
reply_count=0,
mention_count=0,
participants=(AUTHOR,),
),
)
with app.test_request_context():
response = admission(WorkflowCommentListApi.get)(None, app_id=APP_ID)
assert response == {
"data": [
{
"id": "comment-1",
"position_x": 1.5,
"position_y": 2.5,
"content": "hello",
"created_by": "account-123",
"created_by_account": AUTHOR_JSON,
"created_at": 1_700_000_000,
"updated_at": 1_700_000_001,
"resolved": False,
"resolved_at": None,
"resolved_by": None,
"resolved_by_account": None,
"reply_count": 0,
"mention_count": 0,
"participants": [AUTHOR_JSON],
}
]
}
def test_get_comment_serializes_detail(app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.get_comment.return_value = WorkflowCommentDetail(
id="comment-1",
position_x=1.5,
position_y=2.5,
content="hello",
created_by="account-123",
created_by_account=AUTHOR,
created_at=JAN_1_2024_NOON,
updated_at=JAN_1_2024_1201,
resolved=True,
resolved_at=JAN_1_2024_1202,
resolved_by="account-123",
resolved_by_account=AUTHOR,
replies=(
WorkflowCommentReplyRecord(
id="reply-1",
content="reply",
created_by="account-456",
created_by_account=MENTIONED,
created_at=JAN_1_2024_1203,
),
),
mentions=(
WorkflowCommentMentionRecord(
mentioned_user_id="account-456", mentioned_user_account=MENTIONED, reply_id="reply-1"
),
),
)
with app.test_request_context():
response = admission(WorkflowCommentDetailApi.get)(None, app_id=APP_ID, comment_id="comment-1")
assert response == {
"id": "comment-1",
"position_x": 1.5,
"position_y": 2.5,
"content": "hello",
"created_by": "account-123",
"created_by_account": AUTHOR_JSON,
"created_at": JAN_1_2024_NOON_TS,
"updated_at": JAN_1_2024_1201_TS,
"resolved": True,
"resolved_at": JAN_1_2024_1202_TS,
"resolved_by": "account-123",
"resolved_by_account": AUTHOR_JSON,
"replies": [
{
"id": "reply-1",
"content": "reply",
"created_by": "account-456",
"created_by_account": MENTIONED_JSON,
"created_at": JAN_1_2024_1203_TS,
}
],
"mentions": [
{"mentioned_user_id": "account-456", "mentioned_user_account": MENTIONED_JSON, "reply_id": "reply-1"}
],
}
_, app_id, comment_id = comments.get_comment.call_args.args
assert (app_id, comment_id) == (str(APP_ID), "comment-1")
def test_mention_users_requires_the_app_and_lists_workspace_members(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.members.list_members.return_value = [
SimpleNamespace(
id="account-456",
name="mentioned",
email="mentioned@example.com",
avatar=None,
last_login_at=None,
last_active_at=None,
created_at=JAN_1_2024_NOON,
role="normal",
status="active",
)
]
with app.test_request_context():
result = admission(WorkflowCommentMentionUsersApi.get)(None, app_id=APP_ID)
assert isinstance(result, tuple)
response, status = result
assert isinstance(response, dict)
assert status == 200
assert [user["id"] for user in response["users"]] == ["account-456"]
comments.ensure_app.assert_called_once()
assert comments.ensure_app.call_args.args[1] == str(APP_ID)
comments.members.list_members.assert_called_once_with(WORKSPACE_ID)
def test_mention_users_rejects_unaddressable_app(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.ensure_app.side_effect = WorkflowCommentAppNotFoundError
with app.test_request_context(), pytest.raises(AppNotFoundError):
admission(WorkflowCommentMentionUsersApi.get)(None, app_id=APP_ID)
comments.members.list_members.assert_not_called()
@pytest.mark.parametrize(
("error", "expected_type", "expected_message"),
[
pytest.param(WorkflowCommentAppNotFoundError(), AppNotFoundError, "App not found.", id="app"),
pytest.param(WorkflowCommentNotFoundError(), NotFoundError, "Comment not found", id="comment"),
pytest.param(WorkflowCommentReplyNotFoundError(), NotFoundError, "Reply not found", id="reply"),
pytest.param(
WorkflowCommentPermissionError("Only the comment creator can update it"),
ForbiddenError,
"Only the comment creator can update it",
id="permission",
),
pytest.param(
InvalidWorkflowCommentContentError("Comment content cannot be empty"),
InvalidArgumentError,
"Comment content cannot be empty",
id="content",
),
pytest.param(
InvalidMentionedUserIdError("bad"), InvalidArgumentError, "bad is not a valid uuid.", id="mention-id"
),
],
)
def test_domain_errors_map_to_existing_transport_errors(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
comments: MagicMock,
error: Exception,
expected_type: type[Exception],
expected_message: str,
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_comment.side_effect = error
with pytest.raises(expected_type) as raised:
_call(app, UPDATE_COMMENT)
exception = raised.value
message = exception.description if isinstance(exception, HTTPException) else str(exception)
assert message == expected_message
def test_workflow_comment_response_schemas_are_registered() -> None:
assert workflow_comment_module.WorkflowCommentBasicList.__name__ in console_ns.models
assert workflow_comment_module.WorkflowCommentDetail.__name__ in console_ns.models
@@ -0,0 +1,481 @@
"""Unit tests for the Node Output Inspector controller (Stage 4 §8).
The controller has two non-trivial moving parts:
1. :func:`_sse_envelope` — wire-format builder for the SSE ``{event, data, id}``
records (decision D-5).
2. :func:`_stream_inspector_events` — the SSE generator that fans the redis
pub/sub stream out as snapshot / node_changed / workflow_run_completed /
error events.
We exercise both as plain functions with mocked dependencies (service +
``inspector_events.subscribe``) — going through Flask routes would multiply
the test scaffolding without buying additional confidence in the core
behaviour.
The Resource classes themselves are trivial wrappers (``_service().method()``
+ ``_InspectorNotFound`` translation), and are touched here only by import so
codecov sees them as exercised; their detailed behaviour is locked down by
the service-level tests in
``tests/unit_tests/services/workflow/test_node_output_inspector_service.py``.
"""
from __future__ import annotations
import json
from collections.abc import Iterator
from unittest.mock import ANY, MagicMock
from uuid import UUID
import pytest
from controllers.console.app import workflow_node_output_inspector as ctrl
from graphon.enums import WorkflowExecutionStatus
from models import App, AppMode
from models.model import IconType
from services.workflow.inspector_events import InspectorMessage
from services.workflow.node_output_inspector_service import (
NodeOutputInspectorError,
NodeOutputStatus,
NodeOutputsView,
NodeStatus,
WorkflowRunSnapshotView,
)
# ──────────────────────────────────────────────────────────────────────────────
# Fixtures
# ──────────────────────────────────────────────────────────────────────────────
@pytest.fixture
def app_model() -> App:
"""A real transient ``App`` the controller passes through to the service.
The SSE generator never reads its attributes — just forwards it — so a
transient mapped instance is sufficient.
"""
return App(
id="app-1",
tenant_id="tenant-1",
name="Inspector app",
description="",
mode=AppMode.WORKFLOW,
icon_type=IconType.EMOJI,
icon="robot",
icon_background="#FFFFFF",
enable_site=True,
enable_api=True,
max_active_requests=None,
)
@pytest.fixture
def run_id() -> UUID:
return UUID("00000000-0000-0000-0000-0000000000aa")
def _snapshot_view(*, status: str, node_id: str = "agent-1") -> WorkflowRunSnapshotView:
return WorkflowRunSnapshotView(
workflow_run_id="00000000-0000-0000-0000-0000000000aa",
workflow_run_status=WorkflowExecutionStatus(status),
node_outputs=[
NodeOutputsView(
node_id=node_id,
node_kind="agent",
node_display_name="Greeter",
node_status=NodeStatus.RUNNING if status == "running" else NodeStatus.READY,
outputs=[],
)
],
)
def _node_view(*, node_id: str = "agent-1", node_status: NodeStatus = NodeStatus.READY) -> NodeOutputsView:
return NodeOutputsView(
node_id=node_id,
node_kind="agent",
node_display_name="Greeter",
node_status=node_status,
outputs=[],
)
# ──────────────────────────────────────────────────────────────────────────────
# _sse_envelope
# ──────────────────────────────────────────────────────────────────────────────
def test_sse_envelope_serializes_dict_payload():
out = ctrl._sse_envelope("snapshot", {"foo": "bar"}, 7)
lines = out.rstrip("\n").split("\n")
assert lines[0] == "event: snapshot"
assert lines[1] == "id: 7"
assert lines[2] == 'data: {"foo": "bar"}'
assert out.endswith("\n\n") # SSE record separator
def test_sse_envelope_passes_strings_through_unmodified():
"""A raw string payload (e.g. ``:keepalive``) is emitted as-is."""
out = ctrl._sse_envelope("snapshot", ":keepalive", 1)
assert "data: :keepalive\n" in out
def test_sse_envelope_handles_unicode_payload():
out = ctrl._sse_envelope("node_changed", {"name": "你好"}, 3)
assert "你好" in out # ensure_ascii=False
# ──────────────────────────────────────────────────────────────────────────────
# _stream_inspector_events — fast path (already-terminal run)
# ──────────────────────────────────────────────────────────────────────────────
def _drain(stream: Iterator[str]) -> list[str]:
return list(stream)
def _stream(app_model, run_id) -> Iterator[str]:
"""Open the stream the way the handlers do: resolve the run first, then generate."""
return ctrl._stream_inspector_events(app_model, run_id, ctrl._initial_snapshot(app_model, run_id))
def _parse(record: str) -> tuple[str, dict | None]:
"""Pull ``event`` + ``data`` (json-decoded) out of one SSE record."""
event = None
data: dict | None = None
for line in record.rstrip("\n").split("\n"):
if line.startswith("event: "):
event = line[len("event: ") :]
elif line.startswith("data: "):
try:
data = json.loads(line[len("data: ") :])
except json.JSONDecodeError:
data = None
assert event is not None
return event, data
@pytest.fixture
def patch_service(monkeypatch: pytest.MonkeyPatch):
"""Replace ``_service()`` with a MagicMock per-test."""
fake = MagicMock()
monkeypatch.setattr(ctrl, "_service", lambda: fake)
return fake
@pytest.fixture
def patch_subscribe(monkeypatch: pytest.MonkeyPatch):
"""Patch the pub/sub subscribe iterator."""
def _make(messages: list[InspectorMessage | None]):
def _subscribe(workflow_run_id: str, *, timeout_seconds: float = 1.0):
for m in messages:
if m is None:
# heartbeat sentinel
yield InspectorMessage(
kind="node_changed",
workflow_run_id=workflow_run_id,
node_id=None,
status=None,
)
else:
yield m
monkeypatch.setattr(ctrl.inspector_events, "subscribe", _subscribe)
return _make
def test_stream_fast_path_when_run_already_terminal(patch_service, app_model, run_id):
"""A run that's already ``succeeded`` should produce ``snapshot`` →
``workflow_run_completed`` and close without subscribing to pub/sub."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="succeeded")
records = _drain(_stream(app_model, run_id))
assert len(records) == 2
e0, d0 = _parse(records[0])
e1, d1 = _parse(records[1])
assert e0 == "snapshot"
assert d0 is not None
assert d0["workflow_run_status"] == "succeeded"
assert e1 == "workflow_run_completed"
assert d1 is not None
assert d1["workflow_run_status"] == "succeeded"
def test_stream_fast_path_each_terminal_status(patch_service, app_model, run_id):
"""All four terminal statuses take the fast-path. Note the enum value for
partial success is the hyphenated ``partial-succeeded``."""
for terminal in ("succeeded", "failed", "stopped", "partial-succeeded"):
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status=terminal)
records = _drain(_stream(app_model, run_id))
events = [_parse(r)[0] for r in records]
assert events == ["snapshot", "workflow_run_completed"], terminal
def test_initial_snapshot_raises_the_404_before_the_response_exists(patch_service, app_model, run_id):
"""A missing run must be an HTTP 404. The handlers resolve the snapshot before building the
streaming ``Response``; raising inside the generator would arrive after the 200 went out."""
patch_service.snapshot_workflow_run.side_effect = NodeOutputInspectorError(
"workflow_run_not_found", "Workflow run not found."
)
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._initial_snapshot(app_model, run_id)
assert exc.value.error_code == "workflow_run_not_found"
assert not patch_service.node_detail.called
# ──────────────────────────────────────────────────────────────────────────────
# _stream_inspector_events — live path (run is running)
# ──────────────────────────────────────────────────────────────────────────────
def test_stream_live_emits_snapshot_then_node_changed_then_completion(
patch_service, patch_subscribe, app_model, run_id
):
"""Happy path: snapshot → 2× node_changed → workflow_run_completed."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.return_value = _node_view(node_id="agent-1")
msgs = [
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="succeeded"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
patch_subscribe(msgs)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "node_changed", "node_changed", "workflow_run_completed"]
# node_detail should be called once per delta (not once per heartbeat)
assert patch_service.node_detail.call_count == 2
def test_stream_emits_heartbeat_after_n_idle_ticks(
patch_service, patch_subscribe, monkeypatch: pytest.MonkeyPatch, app_model, run_id
):
"""When pub/sub returns the heartbeat sentinel ``_HEARTBEAT_EVERY_TICKS``
times in a row, the generator emits a ``:keepalive`` SSE comment."""
monkeypatch.setattr(ctrl, "_HEARTBEAT_EVERY_TICKS", 2)
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.return_value = _node_view()
# 2 heartbeats → keepalive, then real message + completion.
patch_subscribe(
[
None,
None,
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="failed"),
]
)
records = _drain(_stream(app_model, run_id))
raw = "".join(records)
assert ":keepalive\n\n" in raw
assert "workflow_run_completed" in raw
def test_stream_hard_timeout_force_closes_without_terminal(
patch_service, patch_subscribe, monkeypatch: pytest.MonkeyPatch, app_model, run_id
):
"""If the engine crashes / drops the terminal event, the generator force-
closes after ``_STREAM_HARD_TIMEOUT_TICKS`` ticks rather than hanging."""
monkeypatch.setattr(ctrl, "_STREAM_HARD_TIMEOUT_TICKS", 3)
monkeypatch.setattr(ctrl, "_HEARTBEAT_EVERY_TICKS", 100) # avoid keepalive noise
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
# 5 heartbeats, no terminal → generator should bail after 3 ticks.
patch_subscribe([None] * 10)
records = _drain(_stream(app_model, run_id))
events = [_parse(r)[0] for r in records]
assert events == ["snapshot"] # only snapshot, then forced close
def test_stream_skips_messages_with_missing_node_id(patch_service, patch_subscribe, app_model, run_id):
"""Defensive: malformed node_changed without node_id is silently dropped."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "workflow_run_completed"]
assert patch_service.node_detail.call_count == 0
def test_stream_skips_node_detail_404_without_breaking_stream(patch_service, patch_subscribe, app_model, run_id):
"""When node_detail 404s mid-stream (node still being persisted), the
generator just drops that delta and keeps streaming."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.side_effect = NodeOutputInspectorError("node_not_in_workflow_run", "transient")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "workflow_run_completed"]
def test_stream_emits_error_event_on_node_detail_unexpected_exception(
patch_service, patch_subscribe, app_model, run_id
):
"""Any non-Inspector exception (DB outage, JSON decode error) becomes a
user-visible ``error`` SSE record; the stream keeps running."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.side_effect = RuntimeError("db gone")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
records = _drain(_stream(app_model, run_id))
events = [_parse(r) for r in records]
kinds = [e for e, _ in events]
assert kinds == ["snapshot", "error", "workflow_run_completed"]
err_event, err_data = events[1]
assert err_data is not None
assert err_data["node_id"] == "agent-1"
assert "failed" in err_data["message"]
def test_stream_workflow_completed_status_falls_back_to_unknown(patch_service, patch_subscribe, app_model, run_id):
"""If the pub/sub message arrives with status=None (publish race), the SSE
payload still carries ``workflow_run_status`` with the ``unknown``
sentinel so the frontend never sees a missing field."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_subscribe(
[InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status=None)]
)
records = _drain(_stream(app_model, run_id))
e, d = _parse(records[-1])
assert e == "workflow_run_completed"
assert d is not None
assert d["workflow_run_status"] == "unknown"
# ──────────────────────────────────────────────────────────────────────────────
# Resource classes — import-level smoke + service-method delegation
# ──────────────────────────────────────────────────────────────────────────────
def test_resource_classes_are_registered():
"""All 8 Inspector Resource classes must be importable from the module so
flask-restx can discover them via the namespace decorators."""
for name in (
"WorkflowDraftRunNodeOutputsApi",
"WorkflowDraftRunNodeOutputDetailApi",
"WorkflowDraftRunNodeOutputPreviewApi",
"WorkflowDraftRunNodeOutputEventsApi",
"WorkflowPublishedRunNodeOutputsApi",
"WorkflowPublishedRunNodeOutputDetailApi",
"WorkflowPublishedRunNodeOutputPreviewApi",
"WorkflowPublishedRunNodeOutputEventsApi",
):
assert hasattr(ctrl, name), name
def test_inspector_not_found_preserves_error_code():
"""Sanity: the controller's bespoke 404 wrapper hangs onto the
Inspector's specific error code rather than collapsing to a generic
``not_found``."""
err = NodeOutputInspectorError("node_not_in_workflow_run", "boom")
wrapped = ctrl._inspector_not_found(err)
assert isinstance(wrapped, ctrl.NodeNotInWorkflowRunError)
assert wrapped.error_code == "node_not_in_workflow_run"
assert wrapped.code == 404
assert wrapped.description == "boom"
def test_inspector_not_found_relays_codes_the_contract_does_not_know():
relayed = ctrl._inspector_not_found(NodeOutputInspectorError("inspector_offline", "later"))
assert relayed.code == 404
assert relayed.data == {"code": "inspector_offline", "message": "later", "status": 404}
# ──────────────────────────────────────────────────────────────────────────────
# _serve_* — shared REST handler bodies (covered by both draft + published)
# ──────────────────────────────────────────────────────────────────────────────
def test_serve_snapshot_happy_path(patch_service, app_model, run_id):
"""Returns the snapshot view as JSON-serialisable dict."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
result = ctrl._serve_snapshot(app_model, run_id)
assert isinstance(result, dict)
assert result["workflow_run_id"] == "00000000-0000-0000-0000-0000000000aa"
patch_service.snapshot_workflow_run.assert_called_once_with(
app_model=app_model, workflow_run_id=str(run_id), session=ANY
)
def test_serve_snapshot_translates_inspector_error_to_404(patch_service, app_model, run_id):
"""``NodeOutputInspectorError`` becomes the controller's 404 wrapper with
the specific ``error_code`` preserved."""
patch_service.snapshot_workflow_run.side_effect = NodeOutputInspectorError("workflow_run_not_found", "no such run")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_snapshot(app_model, run_id)
assert exc.value.error_code == "workflow_run_not_found"
def test_serve_node_detail_happy_path(patch_service, app_model, run_id):
patch_service.node_detail.return_value = _node_view(node_id="agent-1")
result = ctrl._serve_node_detail(app_model, run_id, "agent-1")
assert result["node_id"] == "agent-1"
patch_service.node_detail.assert_called_once_with(
app_model=app_model, workflow_run_id=str(run_id), node_id="agent-1", session=ANY
)
def test_serve_node_detail_translates_inspector_error(patch_service, app_model, run_id):
patch_service.node_detail.side_effect = NodeOutputInspectorError("node_not_in_workflow_run", "missing")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_node_detail(app_model, run_id, "ghost")
assert exc.value.error_code == "node_not_in_workflow_run"
def test_serve_output_preview_happy_path(patch_service, app_model, run_id):
from services.workflow.node_output_inspector_service import (
DeclaredOutputType,
OutputPreviewView,
)
patch_service.output_preview.return_value = OutputPreviewView(
node_id="agent-1",
output_name="text",
type=DeclaredOutputType.STRING,
status=NodeOutputStatus.READY,
value="Hello",
)
result = ctrl._serve_output_preview(app_model, run_id, "agent-1", "text")
assert result["value"] == "Hello"
assert result["status"] == "ready"
patch_service.output_preview.assert_called_once_with(
app_model=app_model,
workflow_run_id=str(run_id),
node_id="agent-1",
output_name="text",
session=ANY,
)
def test_serve_output_preview_translates_inspector_error(patch_service, app_model, run_id):
patch_service.output_preview.side_effect = NodeOutputInspectorError("node_output_not_declared", "no such output")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_output_preview(app_model, run_id, "agent-1", "phantom")
assert exc.value.error_code == "node_output_not_declared"
# ──────────────────────────────────────────────────────────────────────────────
# Note: the Resource ``.get`` methods themselves (6 REST + 2 SSE) are
# 1-line delegators to the helpers above. They can't be called directly in a
# unit test because their decorator stack (``@setup_required`` /
# ``@login_required`` / ``@account_initialization_required`` /
# ``@get_app_model``) needs a real Flask request context + DB-backed account.
# The integration test in
# ``tests/e2e_tests/middleware/services/test_node_output_inspector_service.py``
# (and the E2E driver in /tmp/e2e_inspector_sse_published.py) exercise them
# through the HTTP stack.
# ──────────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,638 @@
from __future__ import annotations
import json
from collections.abc import Callable
from datetime import UTC, datetime
from inspect import unwrap
from types import SimpleNamespace
from typing import Any, Literal
from unittest.mock import Mock
import pytest
from flask import Flask, request
from flask_restx import marshal
from pytest_mock import MockerFixture
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from controllers.common.errors import NotFoundError
from controllers.common.rbac import locators as rbac_locators
from controllers.console.app import workflow_run as workflow_run_module
from core.rbac import RBACPermission, RBACResourceScope
from extensions.ext_database import db
from fields.workflow_run_fields import node_execution_response_source
from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
from machinery.context import RequestContext
from models import Account, App, AppMode
from models.enums import CreatorUserRole, WorkflowRunTriggeredFrom
from models.workflow import (
WorkflowNodeExecutionModel,
WorkflowNodeExecutionTriggeredFrom,
WorkflowRun,
WorkflowType,
)
from repositories.sqlalchemy_api_workflow_node_execution_repository import (
DifyAPISQLAlchemyWorkflowNodeExecutionRepository,
)
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
from services.enterprise.rbac_service import RBACService
from services.workflow_node_execution_trace_service import WorkflowNodeExecutionTrace
from services.workflow_run_service import WorkflowRunPauseDetails, WorkflowRunPausedNode, WorkflowRunService
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account, make_app
from tests.helpers.unit.rbac_fakes import RBACDomain
"""Controller tests for Console workflow pause details."""
def _workflow_pause_details_api_request_context(*, workspace_id: str = "tenant-1") -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id=workspace_id,
)
def _workflow_pause_details_api_mock_application_services(monkeypatch: pytest.MonkeyPatch, workflow_runs: Mock) -> None:
monkeypatch.setattr(
workflow_run_module,
"application_services",
lambda: SimpleNamespace(workflow_runs=workflow_runs),
)
class TestWorkflowPauseDetailsApiCases:
@staticmethod
@pytest.mark.parametrize("form_version", ["1", "2"])
def test_pause_details_returns_backstage_input_url(
app: Flask, monkeypatch: pytest.MonkeyPatch, form_version: Literal["1", "2"]
) -> None:
apply_config_overrides(monkeypatch, APP_WEB_URL="https://web.example.com/")
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = WorkflowRunPauseDetails(
paused_at=datetime(2024, 1, 1, 12, 0, 0),
paused_nodes=(
WorkflowRunPausedNode(
node_id="node-1",
node_title="Ask Name",
form_id="form-1",
form_version=form_version,
form_token="backstage-token",
),
),
)
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_pause_details_api_request_context()
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
response, status = handler(api, request_context, workflow_run_id="run-1")
assert status == 200
assert response == {
"paused_at": "2024-01-01T12:00:00Z",
"paused_nodes": [
{
"node_id": "node-1",
"node_title": "Ask Name",
"pause_type": {
"type": "human_input",
"form_id": "form-1",
"form_version": form_version,
"backstage_input_url": "https://web.example.com/form/backstage-token",
},
}
],
}
workflow_runs.get_pause_details.assert_called_once_with(
request_context,
workflow_run_id="run-1",
)
@staticmethod
def test_pause_details_maps_missing_or_inaccessible_run_to_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = None
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_pause_details_api_request_context(workspace_id="other-tenant")
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, request_context, workflow_run_id="run-1")
workflow_runs.get_pause_details.assert_called_once_with(
request_context,
workflow_run_id="run-1",
)
@staticmethod
def test_pause_details_returns_empty_response_for_non_paused_run(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = WorkflowRunPauseDetails(paused_at=None, paused_nodes=())
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
response, status = handler(api, _workflow_pause_details_api_request_context(), workflow_run_id="run-1")
assert status == 200
assert response == {"paused_at": None, "paused_nodes": []}
@staticmethod
def test_pause_details_response_schema_is_registered() -> None:
assert workflow_run_module.WorkflowPauseDetailsResponse.__name__ in workflow_run_module.console_ns.models
def _serialize_200_response(handler, payload: Any) -> Any:
response_doc = getattr(handler, "__apidoc__", {}).get("responses", {}).get("200")
if response_doc is None:
return payload
response_model = response_doc[1]
if isinstance(response_model, dict):
return marshal(payload, response_model)
return payload
def _account(session: Session) -> Account:
account = make_account(name="Alice", email="alice@example.com")
session.add(account)
session.commit()
return account
def _app() -> App:
return make_app(name="Workflow run app", mode=AppMode.WORKFLOW)
def _workflow_run_api_request_context(*, workspace_id: str = "tenant-1") -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id=workspace_id,
)
def _workflow_run_api_mock_application_services(
monkeypatch: pytest.MonkeyPatch, workflow_runs: Mock | WorkflowRunService
) -> None:
monkeypatch.setattr(
workflow_run_module,
"application_services",
lambda: SimpleNamespace(workflow_runs=workflow_runs),
)
def _workflow_run_summary(session: Session, **overrides: object) -> WorkflowRun:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
workflow_run = WorkflowRun(
id="run-1",
tenant_id="tenant-1",
app_id="app-1",
workflow_id="workflow-1",
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
version="v1",
graph='{"nodes": []}',
inputs='{"query": "hello"}',
status=WorkflowExecutionStatus.SUCCEEDED,
outputs='{"answer": "world"}',
error=None,
elapsed_time=1.5,
total_tokens=10,
total_steps=2,
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
finished_at=created_at,
exceptions_count=0,
)
workflow_run.created_at = created_at
for name, value in overrides.items():
setattr(workflow_run, name, value)
workflow_run.retry_index = 0
session.add(workflow_run)
session.commit()
return workflow_run
def _workflow_run_node_execution(session: Session) -> WorkflowNodeExecutionModel:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
execution = WorkflowNodeExecutionModel(
id="node-exec-1",
tenant_id="tenant-1",
app_id="app-1",
workflow_id="workflow-1",
triggered_from=WorkflowNodeExecutionTriggeredFrom.WORKFLOW_RUN,
workflow_run_id="run-1",
index=1,
predecessor_node_id=None,
node_execution_id="node-execution-1",
node_id="node-1",
node_type="start",
title="Start",
agent_workspace_binding_id=None,
inputs=json.dumps({"query": "hello"}),
process_data=json.dumps({"step": "prepared"}),
outputs=json.dumps({"answer": "world"}),
status=WorkflowNodeExecutionStatus.SUCCEEDED,
error=None,
elapsed_time=1.0,
execution_metadata=json.dumps({"total_tokens": 3}),
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
finished_at=created_at,
)
execution.created_at = created_at
execution.offload_data = []
session.add(execution)
session.commit()
return execution
class TestWorkflowRunApiCases:
@staticmethod
def test_workflow_run_list_returns_frontend_history_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_paginate_workflow_runs.return_value = SimpleNamespace(
limit=10,
has_more=False,
data=[workflow_run],
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs?limit=10", method="GET"):
payload = handler(
api,
sqlite_session,
workflow_run_module.WorkflowRunListQuery(limit=10),
request_context,
app_model=_app(),
)
response = _serialize_200_response(api.get, payload)
assert response["limit"] == 10
assert response["has_more"] is False
assert response["data"][0] == {
"id": "run-1",
"version": "v1",
"status": "succeeded",
"elapsed_time": 1.5,
"total_tokens": 10,
"total_steps": 2,
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_at": 1767323045,
"finished_at": 1767323045,
"exceptions_count": 0,
"retry_index": 0,
}
workflow_runs.get_paginate_workflow_runs.assert_called_once_with(
request_context,
app_id="app-1",
args={"limit": 10},
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
)
@staticmethod
def test_advanced_chat_workflow_run_list_keeps_message_fields(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(
sqlite_session,
conversation_id="conversation-1",
message_id="message-1",
)
workflow_runs = Mock()
workflow_runs.get_paginate_advanced_chat_workflow_runs.return_value = SimpleNamespace(
limit=1,
has_more=True,
data=[workflow_run],
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.AdvancedChatAppWorkflowRunListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/advanced-chat/workflow-runs?limit=1", method="GET"):
payload = handler(
api,
sqlite_session,
workflow_run_module.WorkflowRunListQuery(limit=1),
request_context,
app_model=_app(),
)
response = _serialize_200_response(api.get, payload)
assert response["data"][0]["conversation_id"] == "conversation-1"
assert response["data"][0]["message_id"] == "message-1"
workflow_runs.get_paginate_advanced_chat_workflow_runs.assert_called_once_with(
request_context,
app_id="app-1",
args={"limit": 1},
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
)
@staticmethod
def test_workflow_run_count_passes_filters_to_application_service(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_workflow_runs_count.return_value = {
"total": 2,
"running": 0,
"succeeded": 2,
"failed": 0,
"stopped": 0,
"partial-succeeded": 0,
}
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
query = workflow_run_module.WorkflowRunCountQuery(
status="succeeded",
time_range="7d",
triggered_from="app-run",
)
api = workflow_run_module.WorkflowRunCountApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/count", method="GET"):
payload = handler(api, query, request_context, app_model=_app())
assert payload == {
"total": 2,
"running": 0,
"succeeded": 2,
"failed": 0,
"stopped": 0,
"partial_succeeded": 0,
}
workflow_runs.get_workflow_runs_count.assert_called_once_with(
request_context,
app_id="app-1",
status="succeeded",
time_range="7d",
triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
)
@staticmethod
def test_workflow_run_detail_returns_frontend_detail_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_workflow_run.return_value = workflow_run
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunDetailApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1", method="GET"):
payload = handler(api, sqlite_session, request_context, app_model=_app(), run_id="run-1")
response = _serialize_200_response(api.get, payload)
assert response == {
"id": "run-1",
"version": "v1",
"graph": {"nodes": []},
"inputs": {"query": "hello"},
"status": "succeeded",
"outputs": {"answer": "world"},
"error": None,
"elapsed_time": 1.5,
"total_tokens": 10,
"total_steps": 2,
"created_by_role": "account",
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_by_end_user": None,
"created_at": 1767323045,
"finished_at": 1767323045,
"exceptions_count": 0,
}
workflow_runs.get_workflow_run.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
def test_workflow_run_detail_maps_missing_run_to_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
workflow_runs = Mock()
workflow_runs.get_workflow_run.return_value = None
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context(workspace_id="tenant-2")
api = workflow_run_module.WorkflowRunDetailApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1", method="GET"):
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, sqlite_session, request_context, app_model=_app(), run_id="run-1")
workflow_runs.get_workflow_run.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
def test_workflow_run_node_executions_return_frontend_trace_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
execution = _workflow_run_node_execution(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_workflow_run_node_executions.return_value = [
node_execution_response_source(execution, session=sqlite_session)
]
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
monkeypatch.setattr(db, "session", lambda: sqlite_session)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions", method="GET"):
payload = handler(api, request_context, app_model=_app(), run_id="run-1")
response = _serialize_200_response(api.get, payload)
assert response == {
"data": [
{
"id": "node-exec-1",
"index": 1,
"predecessor_node_id": None,
"node_id": "node-1",
"node_type": "start",
"title": "Start",
"inputs": {"query": "hello"},
"process_data": {"step": "prepared"},
"outputs": {"answer": "world"},
"status": "succeeded",
"error": None,
"elapsed_time": 1.0,
"execution_metadata": {"total_tokens": 3},
"extras": {},
"created_at": 1767323045,
"created_by_role": "account",
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_by_end_user": None,
"finished_at": 1767323045,
"inputs_truncated": False,
"outputs_truncated": False,
"process_data_truncated": False,
}
]
}
workflow_runs.get_workflow_run_node_executions.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
@pytest.fixture
def workflow_run_service(sqlite_session_factory: sessionmaker[Session]) -> WorkflowRunService:
return WorkflowRunService(
session_factory=sqlite_session_factory,
workflow_runs=DifyAPISQLAlchemyWorkflowRunRepository(sqlite_session_factory),
node_executions=DifyAPISQLAlchemyWorkflowNodeExecutionRepository(sqlite_session_factory),
)
@staticmethod
@pytest.mark.parametrize("source_access", ["granted", "maintainer", "rbac-disabled"])
def test_workflow_tool_children_preserve_source_identity(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
rbac_domain: RBACDomain,
config_overrides: Callable[..., None],
source_access: str,
workflow_run_service: WorkflowRunService,
mocker: MockerFixture,
) -> None:
config_overrides(RBAC_ENABLED=source_access != "rbac-disabled")
monkeypatch.setattr(rbac_locators, "application_services", lambda: rbac_domain)
sqlite_session.add(
make_app(app_id="source-app", maintainer="account-1" if source_access == "maintainer" else None)
)
sqlite_session.commit()
monkeypatch.setattr(db, "session", sqlite_session)
check_access = mocker.patch.object(RBACService.CheckAccess, "check", return_value=source_access == "granted")
workflow_runs = workflow_run_service
child_traces = [
WorkflowNodeExecutionTrace(
id="child-row",
tenant_id="tenant-1",
app_id="source-app",
workflow_id="source-workflow",
triggered_from="workflow-tool",
node_execution_id="source-execution",
created_by="account-1",
outputs={"answer": "world"},
)
]
get_children = mocker.patch.object(
workflow_runs, "get_workflow_tool_node_executions", return_value=child_traces
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowToolNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions/parent/children"):
response = handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
get_children.return_value = None
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
assert response["data"][0]["node_execution_id"] == "source-execution"
assert response["data"][0]["outputs"] == {"answer": "world"}
if source_access == "granted":
check_access.assert_called_once_with(
"tenant-1",
"account-1",
scene=RBACPermission.APP_CREATE_AND_MANAGEMENT,
resource_type=RBACResourceScope.APP,
resource_id="source-app",
)
else:
check_access.assert_not_called()
get_children.assert_called_with(context, app_id="app-1", run_id="run-1", node_execution_id="parent")
@staticmethod
@pytest.mark.parametrize("source_app_ids", [("source-app",), ("allowed-source", "source-app")])
def test_workflow_tool_children_deny_any_unauthorized_source(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
rbac_domain: RBACDomain,
config_overrides: Callable[..., None],
source_app_ids: tuple[str, ...],
workflow_run_service: WorkflowRunService,
mocker: MockerFixture,
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(rbac_locators, "application_services", lambda: rbac_domain)
sqlite_session.add_all(make_app(app_id=app_id) for app_id in ("app-1", "allowed-source", "source-app"))
sqlite_session.commit()
monkeypatch.setattr(db, "session", sqlite_session)
check_access = mocker.patch.object(
RBACService.CheckAccess,
"check",
side_effect=lambda *_args, resource_id, **_kwargs: resource_id != "source-app",
)
workflow_runs = workflow_run_service
child_traces = [
WorkflowNodeExecutionTrace(
id=f"{app_id}-row",
tenant_id="tenant-1",
app_id=app_id,
workflow_id=f"{app_id}-workflow",
triggered_from="workflow-tool",
created_by="account-1",
inputs={"secret": "source input"},
process_data={"secret": "source internals"},
outputs={"secret": "source output"},
)
for app_id in source_app_ids
]
get_children = mocker.patch.object(
workflow_runs, "get_workflow_tool_node_executions", return_value=child_traces
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowToolNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions/parent/children"):
request.view_args = {"app_id": "app-1"}
with pytest.raises(Forbidden, match="permission to view this tool's internal execution details") as error:
handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
assert error.value.code == 403
assert check_access.call_args.kwargs["resource_id"] == "source-app"
get_children.assert_called_once_with(context, app_id="app-1", run_id="run-1", node_execution_id="parent")
@@ -0,0 +1,459 @@
"""Workflow trigger routes use real admission, composition, and SQLite transactions."""
from collections.abc import Iterator
from dataclasses import dataclass
from datetime import datetime
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Blueprint, Flask, Response
from flask.testing import FlaskClient
from flask_restx import Resource
from redis import Redis
from sqlalchemy import Connection, Engine, event, select, text
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_CSRF_TOKEN
from controllers.console.app import workflow_trigger
from controllers.console.wraps import _is_setup_completed
from core.trigger.utils.endpoint import base_url
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler
from extensions.ext_redis import RedisClientWrapper
from libs.datetime_utils import naive_utc_now
from libs.external_api import ExternalApi
from libs.passport import PassportService
from libs.token import _real_cookie_name, generate_csrf_token
from models import Account, DifySetup, Tenant, TenantAccountJoin
from models.account import AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource
from models.engine import db
from models.enums import AppTriggerStatus, AppTriggerType
from models.model import App, AppMode
from models.trigger import AppTrigger, WorkflowWebhookTrigger
from tests.helpers.unit.config_override import config_overrides_context
_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
@dataclass(frozen=True)
class _Endpoint:
method: str
path: str
resource: type[Resource]
_ENDPOINTS = (
_Endpoint("GET", "workflows/triggers/webhook", workflow_trigger.WebhookTriggerApi),
_Endpoint("GET", "triggers", workflow_trigger.AppTriggersApi),
_Endpoint("POST", "trigger-enable", workflow_trigger.AppTriggerEnableApi),
)
@dataclass(frozen=True)
class _Harness:
client: FlaskClient
session_factory: sessionmaker[Session]
account_id: str
tenant_id: str
headers: dict[str, str]
sessions: list[Session]
def create_app(self, *, tenant_id: str | None = None, mode: AppMode = AppMode.WORKFLOW) -> str:
with self.session_factory.begin() as session:
app = App(
tenant_id=tenant_id or self.tenant_id,
name="Trigger app",
mode=mode,
created_by=self.account_id,
maintainer=self.account_id,
enable_api=True,
enable_site=True,
)
session.add(app)
session.flush()
return app.id
def create_trigger(
self,
app_id: str,
*,
tenant_id: str | None = None,
trigger_type: AppTriggerType = AppTriggerType.TRIGGER_PLUGIN,
status: AppTriggerStatus = AppTriggerStatus.ENABLED,
created_at: datetime = _CREATED_AT,
) -> str:
with self.session_factory.begin() as session:
trigger = AppTrigger(
tenant_id=tenant_id or self.tenant_id,
app_id=app_id,
node_id="node-1",
trigger_type=trigger_type,
title="Trigger",
provider_name="langgenius/github/github",
status=status,
)
trigger.created_at = created_at
trigger.updated_at = created_at
session.add(trigger)
session.flush()
return trigger.id
def create_webhook(self, app_id: str, *, tenant_id: str | None = None, node_id: str = "node-1") -> str:
with self.session_factory.begin() as session:
webhook = WorkflowWebhookTrigger(
app_id=app_id,
tenant_id=tenant_id or self.tenant_id,
node_id=node_id,
webhook_id=str(uuid4())[:24],
created_by=self.account_id,
)
webhook.created_at = _CREATED_AT
session.add(webhook)
session.flush()
return webhook.id
def set_role(self, role: TenantAccountRole) -> None:
with self.session_factory.begin() as session:
membership = session.scalar(
select(TenantAccountJoin).where(TenantAccountJoin.account_id == self.account_id)
)
assert membership is not None
membership.role = role
def call(self, endpoint: _Endpoint, app_id: str) -> TestResponse:
self.sessions.clear()
if endpoint.method == "POST":
return self.client.post(
f"/console/api/apps/{app_id}/{endpoint.path}",
headers=self.headers,
json={"trigger_id": str(uuid4()), "enable_trigger": True},
)
return self.client.get(
f"/console/api/apps/{app_id}/{endpoint.path}", headers=self.headers, query_string={"node_id": "node-1"}
)
def enable(self, app_id: str, payload: dict[str, object]) -> TestResponse:
self.sessions.clear()
return self.client.post(f"/console/api/apps/{app_id}/trigger-enable", headers=self.headers, json=payload)
@pytest.fixture
def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
with (
Redis() as redis_client,
config_overrides_context(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
RBAC_ENABLED=False,
LOGIN_DISABLED=False,
INIT_PASSWORD="",
SECRET_KEY="trigger-http-test-secret-at-least-32-bytes",
CONSOLE_API_URL="https://console.example.test",
),
):
app = Flask(__name__)
app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
redis = RedisClientWrapper()
redis.initialize(redis_client)
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis,
)
app.extensions["application_services"] = services
bind_account_loader(app, services.accounts.identity.load_user)
login_manager = DifyLoginManager()
login_manager.request_loader(load_user_from_request)
login_manager.unauthorized_handler(unauthorized_handler)
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
for endpoint in _ENDPOINTS:
api.add_resource(endpoint.resource, f"/apps/<uuid:app_id>/{endpoint.path}")
app.register_blueprint(blueprint)
now = naive_utc_now()
with sqlite_session_factory.begin() as session:
account = Account(
email="triggers@example.com",
name="Trigger editor",
status=AccountStatus.ACTIVE,
initialized_at=now,
)
account.last_active_at = now
tenant = Tenant(name="Trigger workspace")
session.add_all([account, tenant, DifySetup(version="test")])
session.flush()
session.add(
TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
role=TenantAccountRole.OWNER,
current=True,
)
)
account_id, tenant_id = account.id, tenant.id
# The legacy setup cache has a separate scoped session. Warm and remove
# it before observing the transaction boundaries of each actual request.
with app.app_context():
_is_setup_completed.reset_success()
assert _is_setup_completed()
db.session.remove()
client = app.test_client()
csrf_token = generate_csrf_token(account_id)
client.set_cookie(_real_cookie_name("csrf_token"), csrf_token)
headers = {
"Authorization": f"Bearer {PassportService().issue({'user_id': account_id})}",
HEADER_NAME_CSRF_TOKEN: csrf_token,
}
sessions: list[Session] = []
def observe_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
sessions.append(session)
@app.after_request
def assert_request_sessions_closed(response: Response) -> Response:
assert all(not session.in_transaction() and not session.identity_map for session in sessions)
return response
event.listen(Session, "after_begin", observe_session)
try:
yield _Harness(client, sqlite_session_factory, account_id, tenant_id, headers, sessions)
finally:
event.remove(Session, "after_begin", observe_session)
_is_setup_completed.reset_success()
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("visibility", ["missing", "different-workspace", "non-normal", "workflow-only", "wrong-mode"])
def test_triggers_reject_inaccessible_apps(harness: _Harness, endpoint: _Endpoint, visibility: str) -> None:
app_id = str(uuid4())
if visibility != "missing":
app_id = harness.create_app(tenant_id=str(uuid4()) if visibility == "different-workspace" else None)
with harness.session_factory.begin() as session:
app = session.get(App, app_id)
assert app is not None
if visibility == "non-normal":
session.execute(text("UPDATE apps SET status = 'archived' WHERE id = :app_id"), {"app_id": app_id})
elif visibility == "wrong-mode":
app.mode = AppMode.CHAT
elif visibility == "workflow-only":
app.mode = AppMode.AGENT
session.add(
Agent(
tenant_id=harness.tenant_id,
name="Hidden workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
app_id=str(uuid4()),
backing_app_id=app_id,
)
)
response = harness.call(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "app_not_found"
assert response.content_type == "application/json"
assert harness.sessions
def test_list_empty_triggers(harness: _Harness) -> None:
response = harness.call(_ENDPOINTS[1], harness.create_app())
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {"data": []}
def test_list_orders_and_serializes_triggers_without_leaking_other_owners(harness: _Harness) -> None:
app_id = harness.create_app()
older = harness.create_trigger(app_id, created_at=datetime(2025, 1, 1))
same_time = [
harness.create_trigger(app_id, trigger_type=trigger_type, status=status)
for trigger_type, status in zip(AppTriggerType, AppTriggerStatus, strict=True)
]
expected_statuses = dict(zip(same_time, AppTriggerStatus, strict=True))
expected_statuses[older] = AppTriggerStatus.ENABLED
harness.create_trigger(app_id, tenant_id=str(uuid4()))
harness.create_trigger(harness.create_app())
response = harness.call(_ENDPOINTS[1], app_id)
assert response.status_code == HTTPStatus.OK
data = response.get_json()["data"]
assert [item["id"] for item in data] == sorted(same_time, reverse=True) + [older]
for item in data:
assert set(item) == {
"id",
"trigger_type",
"title",
"node_id",
"provider_name",
"icon",
"status",
"created_at",
"updated_at",
}
assert item["title"] == "Trigger"
assert item["node_id"] == "node-1"
assert item["provider_name"] == "langgenius/github/github"
assert item["status"] == expected_statuses[item["id"]].value
if item["trigger_type"] == AppTriggerType.TRIGGER_PLUGIN:
assert item["icon"] == (
"https://console.example.test/console/api/workspaces/current/tool-provider/builtin/"
"langgenius/github/github/icon"
)
else:
assert item["icon"] == ""
if item["id"] in same_time:
assert item["created_at"] == "2026-01-02T03:04:05"
assert item["updated_at"] == "2026-01-02T03:04:05"
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_editor_roles_can_disable_and_enable_with_committed_status(harness: _Harness, role: TenantAccountRole) -> None:
harness.set_role(role)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
for enabled, expected in [(False, AppTriggerStatus.DISABLED), (True, AppTriggerStatus.ENABLED)]:
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": enabled})
assert response.status_code == HTTPStatus.OK
body = response.get_json()
assert body["id"] == trigger_id
assert body["status"] == expected.value
assert body["icon"].endswith("/langgenius/github/github/icon")
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == expected
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_read_only_roles_cannot_update_trigger(harness: _Harness, role: TenantAccountRole) -> None:
harness.set_role(role)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.FORBIDDEN
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
assert harness.call(_ENDPOINTS[1], app_id).status_code == HTTPStatus.OK
@pytest.mark.parametrize("missing_field", ["trigger_id", "enable_trigger"])
def test_invalid_update_payload_does_not_write(harness: _Harness, missing_field: str) -> None:
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
payload: dict[str, object] = {"trigger_id": trigger_id, "enable_trigger": False}
del payload[missing_field]
response = harness.enable(app_id, payload)
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
@pytest.mark.parametrize("target", ["missing", "other-app", "other-tenant"])
def test_update_rejects_trigger_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
app_id = harness.create_app()
trigger_id = str(uuid4())
if target == "other-app":
trigger_id = harness.create_trigger(harness.create_app())
elif target == "other-tenant":
trigger_id = harness.create_trigger(app_id, tenant_id=str(uuid4()))
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "app_trigger_not_found"
if target != "missing":
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
def test_webhook_returns_detached_configuration_and_urls(harness: _Harness) -> None:
app_id = harness.create_app()
webhook_id = harness.create_webhook(app_id)
with harness.session_factory() as session:
webhook = session.get(WorkflowWebhookTrigger, webhook_id)
assert webhook is not None
external_id = webhook.webhook_id
response = harness.call(_ENDPOINTS[0], app_id)
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {
"id": webhook_id,
"webhook_id": external_id,
"node_id": "node-1",
"webhook_url": f"{str(base_url).rstrip('/')}/triggers/webhook/{external_id}",
"webhook_debug_url": f"{str(base_url).rstrip('/')}/triggers/webhook-debug/{external_id}",
"created_at": "2026-01-02T03:04:05",
}
@pytest.mark.parametrize("target", ["missing", "other-app", "other-tenant", "other-node"])
def test_webhook_rejects_references_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
app_id = harness.create_app()
if target == "other-app":
harness.create_webhook(harness.create_app())
elif target == "other-tenant":
harness.create_webhook(app_id, tenant_id=str(uuid4()))
elif target == "other-node":
harness.create_webhook(app_id, node_id="node-2")
response = harness.call(_ENDPOINTS[0], app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "webhook_trigger_not_found"
def test_app_owner_with_rbac_enabled_uses_real_owner_admission(harness: _Harness) -> None:
harness.set_role(TenantAccountRole.NORMAL)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
with config_overrides_context(RBAC_ENABLED=True):
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.OK
assert response.get_json()["status"] == AppTriggerStatus.DISABLED
def test_update_requires_csrf_before_persistence(harness: _Harness) -> None:
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
harness.sessions.clear()
response = harness.client.post(
f"/console/api/apps/{app_id}/trigger-enable",
headers={"Authorization": harness.headers["Authorization"]},
json={"trigger_id": trigger_id, "enable_trigger": False},
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
@@ -0,0 +1,141 @@
from __future__ import annotations
from inspect import getsource
from uuid import uuid4
import pytest
from sqlalchemy.orm import Session
from controllers.common.session import with_session
from controllers.console.app import completion as completion_module
from controllers.console.app import workflow as workflow_module
from controllers.console.app import wraps as wraps_module
from controllers.console.app.error import AppNotFoundError
from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from models.model import App, AppMode
def _persist_app(sqlite_session: Session, *, mode: AppMode = AppMode.CHAT) -> App:
app_model = App(
tenant_id=str(uuid4()),
name="Test App",
mode=mode,
enable_site=True,
enable_api=True,
)
app_model.id = str(uuid4())
sqlite_session.add(app_model)
sqlite_session.commit()
return app_model
def test_get_app_model_injects_model(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
@wraps_module.get_app_model
def handler(app_model):
return app_model.id
assert handler(app_id=app_model.id) == app_model.id
def test_get_app_model_rejects_wrong_mode(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
@wraps_module.get_app_model(mode=[AppMode.COMPLETION])
def handler(app_model):
return app_model.id
with pytest.raises(AppNotFoundError):
handler(app_id=app_model.id)
def test_get_app_model_requires_app_id() -> None:
@wraps_module.get_app_model
def handler(app_model):
return app_model.id
with pytest.raises(ValueError, match="missing app_id in path parameters"):
handler()
def test_wraps_with_session_reexports_common_session_decorator() -> None:
assert wraps_module.with_session is with_session
def test_get_app_model_prefers_injected_session(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
class Handler:
@wraps_module.get_app_model
def get(self, _injected_session, app_model):
return app_model.id
# An unbound real Session fails on query, so success proves the injected
# request Session was preferred over the legacy scoped-session fallback.
with Session() as scoped_session:
monkeypatch.setattr(wraps_module.db, "session", scoped_session)
assert Handler().get(sqlite_session, app_id=app_model.id) == app_model.id
@pytest.mark.parametrize("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
@pytest.mark.parametrize("inject_session", [False, True])
def test_get_app_model_hides_only_workflow_backing_apps(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
scope: AgentScope,
status: AgentStatus,
inject_session: bool,
) -> None:
app_model = _persist_app(sqlite_session, mode=AppMode.AGENT)
workflow_only = scope == AgentScope.WORKFLOW_ONLY
sqlite_session.add(
Agent(
tenant_id=app_model.tenant_id,
name="Bound agent",
scope=scope,
source=AgentSource.WORKFLOW if workflow_only else AgentSource.AGENT_APP,
status=status,
app_id=None if workflow_only else app_model.id,
backing_app_id=app_model.id if workflow_only else None,
)
)
sqlite_session.commit()
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
class Handler:
@wraps_module.get_app_model
def get(self, *_args: object, app_model: App) -> str:
return app_model.id
args = (sqlite_session,) if inject_session else ()
if workflow_only:
with pytest.raises(AppNotFoundError):
Handler().get(*args, app_id=app_model.id)
else:
assert Handler().get(*args, app_id=app_model.id) == app_model.id
@pytest.mark.parametrize(
"resource",
[
completion_module.CompletionMessageApi,
completion_module.ChatMessageApi,
workflow_module.AdvancedChatDraftWorkflowRunApi,
workflow_module.DraftWorkflowRunApi,
workflow_module.DraftWorkflowTriggerRunApi,
workflow_module.DraftWorkflowTriggerRunAllApi,
],
)
def test_migrated_handlers_open_session_before_app_lookup(resource: type) -> None:
assert "@with_session\n @get_app_model" in getsource(resource)