Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
from __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