chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
60158935f4
commit
6519682885
15831 files changed
+3063428
No files matched your search
Whitespace-only changes.
+32
@@ -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"}
|
||||
+182
@@ -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)
|
||||
+627
@@ -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"
|
||||
+245
@@ -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
|
||||
+481
@@ -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)
|
||||
Reference in new issue
Block a user