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

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

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

No files matched your search

Whitespace-only changes.
@@ -0,0 +1,26 @@
import pytest
from pydantic import ValidationError
from controllers.service_api.app.annotation import (
AnnotationCreatePayload,
AnnotationListQuery,
AnnotationReplyActionPayload,
)
def test_payload_models_preserve_defaults_numeric_strings_and_zero_threshold() -> None:
assert AnnotationListQuery.model_validate({}).model_dump() == {"page": 1, "limit": 20, "keyword": ""}
assert AnnotationListQuery.model_validate({"page": "2", "limit": "5", "keyword": "refund"}).model_dump() == {
"page": 2,
"limit": 5,
"keyword": "refund",
}
assert AnnotationCreatePayload(question="", answer="").model_dump() == {"question": "", "answer": ""}
assert (
AnnotationReplyActionPayload.model_validate(
{"embedding_provider_name": "openai", "embedding_model_name": "embedding", "score_threshold": 0.0}
).score_threshold
== 0.0
)
with pytest.raises(ValidationError):
AnnotationCreatePayload.model_validate({"question": "Q"})
@@ -0,0 +1,372 @@
"""SQLite-backed tests for Service API application controllers.
The authentication decorator resolves the app, tenant, and tenant owner before
the controller delegates application queries to the App Definition service.
"""
from collections.abc import Iterator
from dataclasses import dataclass
from types import SimpleNamespace
from unittest.mock import Mock
from uuid import uuid4
import pytest
from flask import Flask
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.exceptions import Forbidden, Unauthorized
from controllers.service_api.app import app as app_controller
from controllers.service_api.app import site as site_controller
from controllers.service_api.app.app import AppInfoApi, AppMetaApi, AppParameterApi
from controllers.service_api.app.error import AgentNotPublishedError, AppUnavailableError
from controllers.service_api.app.site import AppSiteApi
from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole, TenantStatus
from models.base import TypeBase
from models.model import App, AppMode
from services.app_definition_query_service import (
AppDefinitionNotPublishedError,
AppDefinitionSummary,
AppDefinitionUnavailableError,
AppSiteConfiguration,
)
@dataclass(frozen=True)
class _DatabaseBinding:
session: scoped_session[Session]
@dataclass(frozen=True)
class _Token:
app_id: str
tenant_id: str
@dataclass(frozen=True)
class AppDatabase:
"""Persisted authentication state used by the decorated controller methods."""
session_maker: sessionmaker[Session]
tenant_id: str
app_id: str
def update_app(self, **values: object) -> None:
with self.session_maker.begin() as session:
app = session.get_one(App, self.app_id)
for key, value in values.items():
setattr(app, key, value)
def update_tenant(self, **values: object) -> None:
with self.session_maker.begin() as session:
tenant = session.get_one(Tenant, self.tenant_id)
for key, value in values.items():
setattr(tenant, key, value)
def delete_row(self, model: type[object], object_id: str) -> None:
table = model.__table__ # type: ignore[attr-defined]
with self.session_maker.begin() as session:
session.execute(table.delete().where(table.c.id == object_id))
@pytest.fixture
def flask_app() -> Flask:
app = Flask(__name__)
app.config["TESTING"] = True
return app
@pytest.fixture
def app_db(sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch) -> Iterator[AppDatabase]:
"""Create the minimal authentication schema and bind its database reference."""
tables = [
Tenant.__table__,
Account.__table__,
TenantAccountJoin.__table__,
App.__table__,
]
TypeBase.metadata.create_all(sqlite_engine, tables=tables)
maker = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
registry = scoped_session(maker)
binding = _DatabaseBinding(session=registry)
monkeypatch.setattr("controllers.service_api.wraps.db", binding)
tenant_id = str(uuid4())
app_id = str(uuid4())
owner_id = str(uuid4())
with maker.begin() as session:
tenant = Tenant(name="Visible tenant")
tenant.id = tenant_id
owner = Account(name="Test Author", email="owner@example.com")
owner.id = owner_id
app = App(
id=app_id,
tenant_id=tenant_id,
name="Test App",
description="A test application",
mode=AppMode.CHAT,
icon_type=None,
icon=None,
icon_background=None,
enable_site=True,
enable_api=True,
max_active_requests=None,
created_by=owner_id,
)
session.add_all([tenant, owner, app])
session.add_all(
[
TenantAccountJoin(
tenant_id=tenant_id,
account_id=owner_id,
current=True,
role=TenantAccountRole.OWNER,
),
]
)
database = AppDatabase(
session_maker=maker,
tenant_id=tenant_id,
app_id=app_id,
)
try:
yield database
finally:
registry.remove()
@pytest.fixture
def authenticated_controller(app_db: AppDatabase, monkeypatch: pytest.MonkeyPatch) -> Iterator[AppDatabase]:
"""Patch only token validation and Flask login signaling around real ORM auth."""
monkeypatch.setattr(
"controllers.service_api.wraps.validate_and_get_api_token",
Mock(return_value=_Token(app_id=app_db.app_id, tenant_id=app_db.tenant_id)),
)
current_app = Mock()
current_app.login_manager = Mock()
current_app._get_current_object.return_value = Mock()
monkeypatch.setattr("controllers.service_api.wraps.current_app", current_app)
monkeypatch.setattr("controllers.service_api.wraps.user_logged_in", Mock())
return app_db
def test_get_parameters_queries_authenticated_app(
flask_app: Flask, authenticated_controller: AppDatabase, monkeypatch: pytest.MonkeyPatch
) -> None:
app_definitions = Mock()
app_definitions.get_public_parameters.return_value = get_parameters_from_feature_dict(
features_dict={"opening_statement": "Hello"},
user_input_form=[],
)
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/parameters", headers={"Authorization": "Bearer token"}):
response = AppParameterApi().get()
app_definitions.get_public_parameters.assert_called_once_with(authenticated_controller.app_id)
assert response["opening_statement"] == "Hello"
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(AppDefinitionNotPublishedError(), AgentNotPublishedError, id="not-published"),
pytest.param(AppDefinitionUnavailableError(), AppUnavailableError, id="unavailable"),
],
)
@pytest.mark.usefixtures("authenticated_controller")
def test_get_parameters_maps_query_errors(
flask_app: Flask,
monkeypatch: pytest.MonkeyPatch,
service_error: Exception,
http_error: type[Exception],
) -> None:
app_definitions = Mock()
app_definitions.get_public_parameters.side_effect = service_error
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/parameters", headers={"Authorization": "Bearer token"}):
with pytest.raises(http_error):
AppParameterApi().get()
def test_get_meta_queries_authenticated_app(
flask_app: Flask, authenticated_controller: AppDatabase, monkeypatch: pytest.MonkeyPatch
) -> None:
app_definitions = Mock()
app_definitions.get_tool_icons.return_value = {}
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/meta", headers={"Authorization": "Bearer token"}):
response = AppMetaApi().get()
app_definitions.get_tool_icons.assert_called_once_with(authenticated_controller.app_id)
assert response == {"tool_icons": {}}
@pytest.mark.usefixtures("authenticated_controller")
def test_get_meta_maps_unavailable_definition_to_app_unavailable(
flask_app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
app_definitions = Mock()
app_definitions.get_tool_icons.side_effect = AppDefinitionUnavailableError
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/meta", headers={"Authorization": "Bearer token"}):
with pytest.raises(AppUnavailableError) as raised:
AppMetaApi().get()
assert raised.value.data == {
"code": "app_unavailable",
"message": "App unavailable, please check your app configurations.",
"status": 400,
}
def test_get_info_queries_authenticated_app(
flask_app: Flask,
authenticated_controller: AppDatabase,
monkeypatch: pytest.MonkeyPatch,
) -> None:
app_definitions = Mock()
app_definitions.get_summary.return_value = AppDefinitionSummary(
name="Test App",
description="A test application",
tags=("test-tag",),
mode=AppMode.CHAT.value,
author_name="Test Author",
)
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/info", headers={"Authorization": "Bearer token"}):
response = AppInfoApi().get()
app_definitions.get_summary.assert_called_once_with(authenticated_controller.app_id)
assert response == {
"name": "Test App",
"description": "A test application",
"tags": ["test-tag"],
"mode": AppMode.CHAT.value,
"author_name": "Test Author",
}
@pytest.mark.usefixtures("authenticated_controller")
def test_get_info_maps_unavailable_app(
flask_app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
app_definitions = Mock()
app_definitions.get_summary.side_effect = AppDefinitionUnavailableError()
monkeypatch.setattr(
app_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/info", headers={"Authorization": "Bearer token"}):
with pytest.raises(AppUnavailableError):
AppInfoApi().get()
def test_get_site_configuration_queries_authenticated_app(
flask_app: Flask,
authenticated_controller: AppDatabase,
monkeypatch: pytest.MonkeyPatch,
) -> None:
app_definitions = Mock()
app_definitions.get_site_configuration.return_value = AppSiteConfiguration(
title="Test Site",
chat_color_theme="light",
chat_color_theme_inverted=False,
icon_type="emoji",
icon="robot",
icon_background="#ffffff",
description="A test site",
copyright=None,
privacy_policy=None,
input_placeholder="Ask anything",
custom_disclaimer=None,
default_language="en-US",
prompt_public=False,
show_workflow_steps=True,
use_icon_as_answer_icon=False,
)
monkeypatch.setattr(
site_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/site", headers={"Authorization": "Bearer token"}):
response = AppSiteApi().get()
app_definitions.get_site_configuration.assert_called_once_with(authenticated_controller.app_id)
assert response["title"] == "Test Site"
assert response["icon"] == "robot"
assert response["icon_url"] is None
@pytest.mark.usefixtures("authenticated_controller")
def test_get_site_configuration_maps_missing_site_to_forbidden(
flask_app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
app_definitions = Mock()
app_definitions.get_site_configuration.side_effect = AppDefinitionUnavailableError("Site not found")
monkeypatch.setattr(
site_controller,
"application_services",
Mock(return_value=SimpleNamespace(app_definitions=app_definitions)),
)
with flask_app.test_request_context("/site", headers={"Authorization": "Bearer token"}):
with pytest.raises(Forbidden):
AppSiteApi().get()
@pytest.mark.parametrize("state", ["missing", "disabled", "archived", "ownerless"])
def test_authentication_rejects_empty_or_invisible_database_state(
flask_app: Flask,
authenticated_controller: AppDatabase,
state: str,
) -> None:
expected_error: type[Exception] = Forbidden
if state == "missing":
authenticated_controller.delete_row(App, authenticated_controller.app_id)
elif state == "disabled":
authenticated_controller.update_app(enable_api=False)
elif state == "archived":
authenticated_controller.update_tenant(status=TenantStatus.ARCHIVE)
else:
with authenticated_controller.session_maker.begin() as session:
session.execute(TenantAccountJoin.__table__.delete())
expected_error = Unauthorized
with flask_app.test_request_context("/info", headers={"Authorization": "Bearer token"}):
with pytest.raises(expected_error):
AppInfoApi().get()
@@ -0,0 +1,351 @@
"""
Unit tests for Service API Audio controller.
Tests coverage for:
- TextToAudioPayload Pydantic model validation
- Error mapping patterns between service and API errors
- AudioService method interfaces
"""
import io
import uuid
from inspect import unwrap
from unittest.mock import patch
import pytest
from flask import Flask, request
from sqlalchemy.orm import Session
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import InternalServerError
from controllers.service_api.app.audio import AudioApi, TextApi, TextToAudioPayload
from controllers.service_api.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.enums import EndUserType
from models.model import App, EndUser
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.model_factories import make_app, make_end_user
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") -> App:
return make_app(app_id=app_id, tenant_id=tenant_id, name="Audio app", icon_type=None, max_active_requests=0)
def _end_user(*, end_user_id: str = "u1", external_user_id: str | None = None) -> EndUser:
return make_end_user(
end_user_id=end_user_id,
app_id="a1",
end_user_type=EndUserType.SERVICE_API,
external_user_id=external_user_id,
name="Audio user",
session_id=f"session-{end_user_id}",
)
# ---------------------------------------------------------------------------
# Pydantic Model Tests
# ---------------------------------------------------------------------------
class TestTextToAudioPayload:
"""Test suite for TextToAudioPayload Pydantic model."""
def test_payload_with_all_fields(self):
"""Test payload with all fields populated."""
payload = TextToAudioPayload(
message_id="msg_123",
voice="nova",
text="Hello, this is a test.",
streaming=False,
)
assert payload.message_id == "msg_123"
assert payload.voice == "nova"
assert payload.text == "Hello, this is a test."
assert payload.streaming is False
def test_payload_with_defaults(self):
"""Test payload with default values."""
payload = TextToAudioPayload()
assert payload.message_id is None
assert payload.voice is None
assert payload.text is None
assert payload.streaming is None
def test_payload_with_only_text(self):
"""Test payload with only text field."""
payload = TextToAudioPayload(text="Simple text to speech")
assert payload.text == "Simple text to speech"
assert payload.voice is None
assert payload.message_id is None
def test_payload_with_streaming_true(self):
"""Test payload with streaming enabled."""
payload = TextToAudioPayload(
text="Streaming test",
streaming=True,
)
assert payload.streaming is True
class TestAudioServiceInterface:
"""Test suite for AudioService interface methods."""
def test_transcript_asr_method_exists(self):
"""Test that AudioService.transcript_asr exists."""
assert hasattr(AudioService, "transcript_asr")
assert callable(AudioService.transcript_asr)
def test_transcript_tts_method_exists(self):
"""Test that AudioService.transcript_tts exists."""
assert hasattr(AudioService, "transcript_tts")
assert callable(AudioService.transcript_tts)
class TestServiceErrorTypes:
"""Test service error types used by audio controller."""
def test_no_audio_uploaded_service_error(self):
"""Test NoAudioUploadedServiceError exists."""
error = NoAudioUploadedServiceError()
assert error is not None
def test_audio_too_large_service_error(self):
"""Test AudioTooLargeServiceError with message."""
error = AudioTooLargeServiceError("File too large")
assert "File too large" in str(error)
def test_unsupported_audio_type_service_error(self):
"""Test UnsupportedAudioTypeServiceError exists."""
error = UnsupportedAudioTypeServiceError()
assert error is not None
def test_provider_not_support_speech_to_text_service_error(self):
"""Test ProviderNotSupportSpeechToTextServiceError exists."""
error = ProviderNotSupportSpeechToTextServiceError()
assert error is not None
# ---------------------------------------------------------------------------
# Mocked Behavior Tests
# ---------------------------------------------------------------------------
class TestAudioServiceMockedBehavior:
"""Test AudioService behavior with mocked methods."""
@pytest.fixture
def mock_app(self):
"""Create an app model."""
from models.model import App
app = App(
id=str(uuid.uuid4()),
)
return app
@pytest.fixture
def mock_file(self):
"""Create a file upload."""
return FileStorage(stream=io.BytesIO(b"audio"), filename="test_audio.mp3", content_type="audio/mpeg")
@patch.object(AudioService, "transcript_asr")
def test_transcript_asr_returns_response(self, mock_asr, mock_app, mock_file, sqlite_session: Session):
"""Test ASR transcription returns response dict."""
mock_response = {"text": "Transcribed text"}
mock_asr.return_value = mock_response
result = AudioService.transcript_asr(
app_model=mock_app,
file=mock_file,
session=sqlite_session,
end_user="user_123",
)
assert result["text"] == "Transcribed text"
@patch.object(AudioService, "transcript_tts")
def test_transcript_tts_returns_response(self, mock_tts, mock_app, sqlite_session: Session):
"""Test TTS transcription returns response."""
mock_response = {"audio": "base64_audio_data"}
mock_tts.return_value = mock_response
result = AudioService.transcript_tts(
app_model=mock_app,
session=sqlite_session,
text="Hello world",
voice="nova",
end_user="user_123",
)
assert result["audio"] == "base64_audio_data"
assert mock_tts.call_args.kwargs["session"] is sqlite_session
class TestAudioApi:
def test_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
calls: dict[str, object] = {}
def fake_transcript_asr(**kwargs: object) -> dict[str, str]:
calls.update(kwargs)
return {"text": "ok"}
monkeypatch.setattr(AudioService, "transcript_asr", fake_transcript_asr)
api = AudioApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
with app.test_request_context("/audio-to-text", method="POST", data={"file": _file_data()}):
response = handler(api, sqlite_session, app_model=app_model, end_user=end_user)
assert response == {"text": "ok"}
assert calls["session"] is sqlite_session
@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_error_mapping(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
exc: Exception,
expected: type[Exception],
) -> None:
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(exc))
api = AudioApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
with app.test_request_context("/audio-to-text", method="POST", data={"file": _file_data()}):
with pytest.raises(expected):
handler(api, sqlite_session, app_model=app_model, end_user=end_user)
def test_unhandled_error(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
monkeypatch.setattr(
AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(RuntimeError("boom"))
)
api = AudioApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
with app.test_request_context("/audio-to-text", method="POST", data={"file": _file_data()}):
with pytest.raises(InternalServerError):
handler(api, sqlite_session, app_model=app_model, end_user=end_user)
class TestTextApi:
def test_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "ok"})
api = TextApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user(end_user_id="end-user-1", external_user_id="ext")
with app.test_request_context(
"/text-to-audio",
method="POST",
json={"text": "hello", "voice": "v"},
):
payload = TextToAudioPayload.model_validate(request.get_json() or {})
response = handler(api, payload, sqlite_session, app_model=app_model, end_user=end_user)
assert response == {"audio": "ok"}
def test_success_with_message_ref(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
calls = {}
def fake_transcript_tts(**kwargs):
calls.update(kwargs)
return {"audio": "ok"}
monkeypatch.setattr(AudioService, "transcript_tts", fake_transcript_tts)
api = TextApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user(end_user_id="end-user-1", external_user_id="ext")
with app.test_request_context(
"/text-to-audio",
method="POST",
json={"text": "hello", "message_id": "message-1"},
):
payload = TextToAudioPayload.model_validate(request.get_json() or {})
response = handler(api, payload, sqlite_session, app_model=app_model, end_user=end_user)
assert response == {"audio": "ok"}
assert calls["message_ref"] == MessageRef(AppRef("tenant-1", "a1"), "message-1", end_user_id="end-user-1")
assert calls["session"] is sqlite_session
@pytest.mark.parametrize(
("exc", "expected"),
[
(QuotaExceededError(), ProviderQuotaExceededError),
(RuntimeError("internal provider failure"), InternalServerError),
],
)
def test_error_mapping(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
exc: Exception,
expected: type[Exception],
) -> None:
def raise_error(**_kwargs: object) -> None:
raise exc
monkeypatch.setattr(AudioService, "transcript_tts", raise_error)
api = TextApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user(end_user_id="end-user-1", external_user_id="ext")
with app.test_request_context("/text-to-audio", method="POST", json={"text": "hello"}):
payload = TextToAudioPayload.model_validate(request.get_json() or {})
with pytest.raises(expected):
handler(api, payload, sqlite_session, app_model=app_model, end_user=end_user)
@@ -0,0 +1,966 @@
import sys
import uuid
from decimal import Decimal
from inspect import unwrap
from unittest.mock import MagicMock, Mock, patch
import pytest
from flask import Flask
from pydantic import ValidationError
from pytest_mock import MockerFixture
from sqlalchemy import Engine
from sqlalchemy.orm import Session
from werkzeug.exceptions import BadRequest, NotFound
import services
from controllers.service_api.app import completion as completion_module
from controllers.service_api.app import workflow as workflow_module
from controllers.service_api.app.completion import (
ChatApi,
ChatRequestPayload,
ChatStopApi,
CompletionApi,
CompletionRequestPayload,
CompletionStopApi,
)
from controllers.service_api.app.error import (
AgentNotPublishedError,
AppUnavailableError,
CompletionRequestError,
ConversationCompletedError,
NotChatAppError,
WorkflowVersionExecutionNotAllowedError,
)
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from core.app.apps.agent_app.errors import AgentAppNotPublishedError
from core.errors.error import QuotaExceededError
from core.helper.trace_id_helper import get_trace_session_id
from enums import CloudPlan, DeploymentEdition
from graphon.model_runtime.errors.invoke import InvokeError
from graphon.model_runtime.errors.invoke import InvokeRateLimitError as ProviderInvokeRateLimitError
from models.base import TypeBase
from models.enums import ConversationFromSource, EndUserType
from models.model import App, AppMode, Conversation, EndUser, IconType, Message
from services.app_generate_service import AppGenerateService
from services.app_task_service import AppTaskService
from services.billing_service import BillingService
from services.conversation_service import ConversationService
from services.errors.app import IsDraftWorkflowError, WorkflowIdFormatError, WorkflowNotFoundError
from services.errors.conversation import ConversationNotExistsError
from services.errors.llm import InvokeRateLimitError
from tests.helpers import billing_builders as builders
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_app, make_end_user
class TestChatRequestPayloadCases:
@staticmethod
def test_chat_request_payload_accepts_blank_conversation_id():
payload = ChatRequestPayload.model_validate({"inputs": {}, "query": "hello", "conversation_id": ""})
assert payload.conversation_id is None
@staticmethod
def test_chat_request_payload_validates_uuid():
conversation_id = str(uuid.uuid4())
payload = ChatRequestPayload.model_validate(
{"inputs": {}, "query": "hello", "conversation_id": conversation_id}
)
assert payload.conversation_id == conversation_id
@staticmethod
def test_chat_request_payload_rejects_invalid_uuid():
with pytest.raises(ValidationError):
ChatRequestPayload.model_validate({"inputs": {}, "query": "hello", "conversation_id": "invalid"})
"""
Unit tests for Service API Completion controllers.
Tests coverage for:
- CompletionRequestPayload and ChatRequestPayload Pydantic models
- App mode validation logic
- Error mapping from service layer to HTTP errors
Focus on:
- Pydantic model validation (especially UUID normalization)
- Error types and their mappings
"""
def _persist_completion_state(session: Session, mode: AppMode) -> tuple[App, EndUser, Conversation, Message]:
tenant_id = str(uuid.uuid4())
app_model = App(
id=str(uuid.uuid4()),
tenant_id=tenant_id,
name="Completion App",
mode=mode,
icon_type=IconType.EMOJI,
icon="chat",
icon_background="#FFFFFF",
enable_site=False,
enable_api=True,
)
end_user = EndUser(
id=str(uuid.uuid4()),
tenant_id=tenant_id,
app_id=app_model.id,
type=EndUserType.SERVICE_API,
name="API User",
session_id=f"session-{uuid.uuid4()}",
)
conversation = Conversation(
id=str(uuid.uuid4()),
app_id=app_model.id,
mode=mode,
name="Conversation",
_inputs={},
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
message = Message(
id=str(uuid.uuid4()),
app_id=app_model.id,
conversation_id=conversation.id,
_inputs={},
query="Hello",
message={},
message_unit_price=Decimal(0),
answer="Hi",
answer_unit_price=Decimal(0),
currency="USD",
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
app_mode=mode,
)
session.add_all([app_model, end_user, conversation, message])
session.commit()
return app_model, end_user, conversation, message
class TestCompletionCases:
@staticmethod
@pytest.fixture
def orm_session(sqlite_engine: Engine):
models = (App, EndUser, Conversation, Message)
tables = [model.metadata.tables[model.__tablename__] for model in models]
TypeBase.metadata.create_all(sqlite_engine, tables=tables)
with Session(sqlite_engine, expire_on_commit=False) as session:
yield session
class TestCompletionRequestPayload:
"""Test suite for CompletionRequestPayload Pydantic model."""
def test_payload_with_required_fields(self):
"""Test payload with only required inputs field."""
payload = CompletionRequestPayload(inputs={"name": "test"})
assert payload.inputs == {"name": "test"}
assert payload.query == ""
assert payload.files is None
assert payload.response_mode is None
assert payload.retriever_from == "dev"
def test_payload_with_all_fields(self):
"""Test payload with all fields populated."""
payload = CompletionRequestPayload(
inputs={"user_input": "Hello"},
query="What is AI?",
files=[{"type": "image", "url": "http://example.com/image.png"}],
response_mode="streaming",
retriever_from="api",
)
assert payload.inputs == {"user_input": "Hello"}
assert payload.query == "What is AI?"
assert payload.files == [{"type": "image", "url": "http://example.com/image.png"}]
assert payload.response_mode == "streaming"
assert payload.retriever_from == "api"
def test_payload_response_mode_blocking(self):
"""Test payload with blocking response mode."""
payload = CompletionRequestPayload(inputs={}, response_mode="blocking")
assert payload.response_mode == "blocking"
def test_payload_empty_inputs(self):
"""Test payload with empty inputs dict."""
payload = CompletionRequestPayload(inputs={})
assert payload.inputs == {}
def test_payload_complex_inputs(self):
"""Test payload with complex nested inputs."""
complex_inputs = {
"user": {"name": "Alice", "age": 30},
"context": ["item1", "item2"],
"settings": {"theme": "dark", "notifications": True},
}
payload = CompletionRequestPayload(inputs=complex_inputs)
assert payload.inputs == complex_inputs
class TestChatRequestPayload:
"""Test suite for ChatRequestPayload Pydantic model."""
def test_payload_with_required_fields(self):
"""Test payload with required fields."""
payload = ChatRequestPayload(inputs={"key": "value"}, query="Hello")
assert payload.inputs == {"key": "value"}
assert payload.query == "Hello"
assert payload.conversation_id is None
assert payload.auto_generate_name is True
def test_payload_normalizes_valid_uuid_conversation_id(self):
"""Test that valid UUID conversation_id is normalized."""
valid_uuid = str(uuid.uuid4())
payload = ChatRequestPayload(inputs={}, query="test", conversation_id=valid_uuid)
assert payload.conversation_id == valid_uuid
def test_payload_normalizes_empty_string_conversation_id_to_none(self):
"""Test that empty string conversation_id becomes None."""
payload = ChatRequestPayload(inputs={}, query="test", conversation_id="")
assert payload.conversation_id is None
def test_payload_normalizes_whitespace_conversation_id_to_none(self):
"""Test that whitespace-only conversation_id becomes None."""
payload = ChatRequestPayload(inputs={}, query="test", conversation_id=" ")
assert payload.conversation_id is None
def test_payload_rejects_invalid_uuid_conversation_id(self):
"""Test that invalid UUID format raises ValueError."""
with pytest.raises(
ValueError, match="1 validation error for ChatRequestPayload\\\nconversation_id"
) as exc_info:
ChatRequestPayload(inputs={}, query="test", conversation_id="not-a-uuid")
assert "valid UUID" in str(exc_info.value)
def test_payload_with_workflow_id(self):
"""Test payload with workflow_id for advanced chat."""
payload = ChatRequestPayload(inputs={}, query="test", workflow_id="workflow_123")
assert payload.workflow_id == "workflow_123"
def test_payload_streaming_mode(self):
"""Test payload with streaming response mode."""
payload = ChatRequestPayload(inputs={}, query="test", response_mode="streaming")
assert payload.response_mode == "streaming"
def test_payload_auto_generate_name_false(self):
"""Test payload with auto_generate_name explicitly false."""
payload = ChatRequestPayload(inputs={}, query="test", auto_generate_name=False)
assert payload.auto_generate_name is False
def test_payload_with_files(self):
"""Test payload with file attachments."""
files = [
{"type": "image", "transfer_method": "remote_url", "url": "http://example.com/img.png"},
{"type": "document", "transfer_method": "local_file", "upload_file_id": "file_123"},
]
payload = ChatRequestPayload(inputs={}, query="test", files=files)
assert payload.files == files
assert len(payload.files) == 2
class TestCompletionErrorMappings:
"""Test error type mappings for completion endpoints."""
def test_conversation_not_exists_error_exists(self):
"""Test ConversationNotExistsError can be raised."""
error = services.errors.conversation.ConversationNotExistsError()
assert isinstance(error, services.errors.conversation.ConversationNotExistsError)
def test_conversation_completed_error_exists(self):
"""Test ConversationCompletedError can be raised."""
error = services.errors.conversation.ConversationCompletedError()
assert isinstance(error, services.errors.conversation.ConversationCompletedError)
api_error = ConversationCompletedError()
assert api_error is not None
def test_app_model_config_broken_error_exists(self):
"""Test AppModelConfigBrokenError can be raised."""
error = services.errors.app_model_config.AppModelConfigBrokenError()
assert isinstance(error, services.errors.app_model_config.AppModelConfigBrokenError)
api_error = AppUnavailableError()
assert api_error is not None
def test_workflow_not_found_error_exists(self):
"""Test WorkflowNotFoundError can be raised."""
error = WorkflowNotFoundError("Workflow not found")
assert isinstance(error, WorkflowNotFoundError)
def test_is_draft_workflow_error_exists(self):
"""Test IsDraftWorkflowError can be raised."""
error = IsDraftWorkflowError("Workflow is in draft state")
assert isinstance(error, IsDraftWorkflowError)
def test_workflow_id_format_error_exists(self):
"""Test WorkflowIdFormatError can be raised."""
error = WorkflowIdFormatError("Invalid workflow ID format")
assert isinstance(error, WorkflowIdFormatError)
def test_invoke_rate_limit_error_exists(self):
"""Test InvokeRateLimitError can be raised."""
error = InvokeRateLimitError("Rate limit exceeded")
assert isinstance(error, InvokeRateLimitError)
class TestAppModeValidation:
"""Test app mode validation logic patterns."""
def test_completion_mode_is_valid_for_completion_endpoint(self):
"""Test that COMPLETION mode is valid for completion endpoints."""
assert AppMode.COMPLETION == AppMode.COMPLETION
def test_chat_modes_are_distinct_from_completion(self):
"""Test that chat modes are distinct from completion mode."""
chat_modes = {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
assert AppMode.COMPLETION not in chat_modes
def test_workflow_mode_is_distinct_from_chat_modes(self):
"""Test that WORKFLOW mode is not a chat mode."""
chat_modes = {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
assert AppMode.WORKFLOW not in chat_modes
def test_not_chat_app_error_can_be_raised(self):
"""Test NotChatAppError can be raised for non-chat apps."""
error = NotChatAppError()
assert error is not None
def test_all_app_modes_are_defined(self):
"""Test that all expected app modes are defined."""
expected_modes = [
"COMPLETION",
"CHAT",
"AGENT_CHAT",
"AGENT",
"ADVANCED_CHAT",
"WORKFLOW",
"CHANNEL",
"RAG_PIPELINE",
]
for mode_name in expected_modes:
assert hasattr(AppMode, mode_name), f"AppMode.{mode_name} should exist"
class TestAppGenerateService:
"""Test AppGenerateService integration patterns."""
def test_generate_method_exists(self):
"""Test that AppGenerateService.generate method exists."""
assert hasattr(AppGenerateService, "generate")
assert callable(AppGenerateService.generate)
@patch.object(AppGenerateService, "generate")
def test_generate_returns_response(self, mock_generate, orm_session: Session):
"""Test that generate returns expected response format."""
expected = {"answer": "Hello!"}
mock_generate.return_value = expected
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
result = AppGenerateService.generate(
app_model=app_model,
user=end_user,
args={"query": "Hi"},
invoke_from=Mock(),
session=orm_session,
streaming=False,
)
assert result == expected
@patch.object(AppGenerateService, "generate")
def test_generate_raises_conversation_not_exists(self, mock_generate, orm_session: Session):
"""Test generate raises ConversationNotExistsError."""
mock_generate.side_effect = services.errors.conversation.ConversationNotExistsError()
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with pytest.raises(services.errors.conversation.ConversationNotExistsError):
AppGenerateService.generate(
app_model=app_model,
user=end_user,
args={},
invoke_from=Mock(),
session=orm_session,
streaming=False,
)
@patch.object(AppGenerateService, "generate")
def test_generate_raises_quota_exceeded(self, mock_generate, orm_session: Session):
"""Test generate raises QuotaExceededError."""
mock_generate.side_effect = QuotaExceededError()
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with pytest.raises(QuotaExceededError):
AppGenerateService.generate(
app_model=app_model,
user=end_user,
args={},
invoke_from=Mock(),
session=orm_session,
streaming=False,
)
@patch.object(AppGenerateService, "generate")
def test_generate_raises_invoke_error(self, mock_generate, orm_session: Session):
"""Test generate raises InvokeError."""
mock_generate.side_effect = InvokeError("Model invocation failed")
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with pytest.raises(InvokeError):
AppGenerateService.generate(
app_model=app_model,
user=end_user,
args={},
invoke_from=Mock(),
session=orm_session,
streaming=False,
)
class TestCompletionControllerLogic:
"""Test CompletionApi and ChatApi controller logic directly."""
@pytest.fixture
def app(self):
"""Create Flask test application."""
from flask import Flask
app = Flask(__name__)
app.config["TESTING"] = True
return app
@patch("controllers.service_api.app.completion.service_api_ns")
@patch("controllers.service_api.app.completion.AppGenerateService")
def test_completion_api_post_success(
self, mock_generate_service, mock_service_api_ns, app: Flask, orm_session: Session
):
"""Test CompletionApi.post success path."""
from controllers.service_api.app.completion import CompletionApi
# Setup mocks
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
payload_dict = {"inputs": {"text": "hello"}, "response_mode": "blocking"}
mock_service_api_ns.payload = payload_dict
mock_generate_service.generate.return_value = {"text": "response"}
with app.test_request_context():
# Helper for compact_generate_response logic check
with patch("controllers.service_api.app.completion.helper.compact_generate_response") as mock_compact:
mock_compact.return_value = {"text": "compacted"}
api = CompletionApi()
response = unwrap(api.post)(api, orm_session, app_model, end_user)
assert response == {"text": "compacted"}
mock_generate_service.generate.assert_called_once()
@patch("controllers.service_api.app.completion.service_api_ns")
def test_completion_api_post_wrong_app_mode(self, mock_service_api_ns, app: Flask, orm_session: Session):
"""Test CompletionApi.post with wrong app mode."""
from controllers.service_api.app.completion import CompletionApi
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context():
with pytest.raises(AppUnavailableError):
unwrap(CompletionApi().post)(CompletionApi(), orm_session, app_model, end_user)
@patch("controllers.service_api.app.completion.service_api_ns")
@patch("controllers.service_api.app.completion.AppGenerateService")
def test_chat_api_post_success(
self, mock_generate_service, mock_service_api_ns, app: Flask, orm_session: Session
):
"""Test ChatApi.post success path."""
from controllers.service_api.app.completion import ChatApi
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
payload_dict = {"inputs": {}, "query": "hello", "response_mode": "blocking"}
mock_service_api_ns.payload = payload_dict
mock_generate_service.generate.return_value = {"text": "response"}
with app.test_request_context():
with patch("controllers.service_api.app.completion.helper.compact_generate_response") as mock_compact:
mock_compact.return_value = {"text": "compacted"}
api = ChatApi()
response = unwrap(api.post)(api, orm_session, app_model, end_user)
assert response == {"text": "compacted"}
@patch("controllers.service_api.app.completion.service_api_ns")
def test_chat_api_post_wrong_app_mode(self, mock_service_api_ns, app: Flask, orm_session: Session):
"""Test ChatApi.post with wrong app mode."""
from controllers.service_api.app.completion import ChatApi
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with app.test_request_context():
with pytest.raises(NotChatAppError):
unwrap(ChatApi().post)(ChatApi(), orm_session, app_model, end_user)
@patch("controllers.service_api.app.completion.AppTaskService")
def test_completion_stop_api_success(self, mock_task_service, app: Flask, orm_session: Session):
"""Test CompletionStopApi.post success."""
from controllers.service_api.app.completion import CompletionStopApi
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with app.test_request_context():
api = CompletionStopApi()
response = api.post.__wrapped__(api, app_model, end_user, "task_id")
assert response == ({"result": "success"}, 200)
mock_task_service.stop_task.assert_called_once()
@patch("controllers.service_api.app.completion.AppTaskService")
def test_chat_stop_api_success(self, mock_task_service, app: Flask, orm_session: Session):
"""Test ChatStopApi.post success."""
from controllers.service_api.app.completion import ChatStopApi
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context():
api = ChatStopApi()
response = api.post.__wrapped__(api, app_model, end_user, "task_id")
assert response == ({"result": "success"}, 200)
mock_task_service.stop_task.assert_called_once()
class TestChatRequestPayloadController:
def test_normalizes_conversation_id(self) -> None:
payload = ChatRequestPayload.model_validate(
{"inputs": {}, "query": "hi", "conversation_id": " ", "response_mode": "blocking"}
)
assert payload.conversation_id is None
with pytest.raises(ValidationError):
ChatRequestPayload.model_validate({"inputs": {}, "query": "hi", "conversation_id": "bad-id"})
class TestCompletionApiController:
def test_wrong_mode(self, app: Flask, orm_session: Session) -> None:
api = CompletionApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context("/completion-messages", method="POST", json={"inputs": {}}):
with pytest.raises(AppUnavailableError):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
def test_conversation_not_found(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session
) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(ConversationNotExistsError()),
)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
api = CompletionApi()
handler = unwrap(api.post)
with app.test_request_context("/completion-messages", method="POST", json={"inputs": {}}):
with pytest.raises(NotFound):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
class TestCompletionStopApiController:
def test_wrong_mode(self, app: Flask, orm_session: Session) -> None:
api = CompletionStopApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context("/completion-messages/1/stop", method="POST"):
with pytest.raises(AppUnavailableError):
handler(api, app_model=app_model, end_user=end_user, task_id="t1")
def test_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session) -> None:
stop_mock = Mock()
monkeypatch.setattr(AppTaskService, "stop_task", stop_mock)
api = CompletionStopApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with app.test_request_context("/completion-messages/1/stop", method="POST"):
response, status = handler(api, app_model=app_model, end_user=end_user, task_id="t1")
assert status == 200
assert response == {"result": "success"}
class TestChatApiController:
@pytest.mark.parametrize(
("source_error", "http_error", "status_code", "error_code"),
[
pytest.param(InvokeRateLimitError, InvokeRateLimitHttpError, 429, "rate_limit_error", id="cloud-quota"),
pytest.param(
ProviderInvokeRateLimitError, CompletionRequestError, 400, "completion_request_error", id="provider"
),
],
)
def test_maps_rate_limits_by_source(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
orm_session: Session,
source_error: type[InvokeRateLimitError | ProviderInvokeRateLimitError],
http_error: type[InvokeRateLimitHttpError | CompletionRequestError],
status_code: int,
error_code: str,
) -> None:
generate = Mock(side_effect=source_error("rate limit reached"))
monkeypatch.setattr(AppGenerateService, "generate", generate)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.ADVANCED_CHAT)
api = ChatApi()
handler = unwrap(api.post)
with app.test_request_context(
"/chat-messages", method="POST", json={"inputs": {}, "query": "hi", "response_mode": "blocking"}
):
with pytest.raises(http_error) as exc_info:
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
generate.assert_called_once()
assert exc_info.value.code == status_code
assert exc_info.value.error_code == error_code
assert exc_info.value.description == "rate limit reached"
def test_rejects_sandbox_plan_workflow_version(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture, orm_session: Session
) -> None:
sys.modules["controllers.service_api.app.completion"]
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
billing_get_info = mocker.patch.object(
BillingService, "get_info", return_value=builders.subscription_info("sandbox")
)
generate = Mock()
monkeypatch.setattr(AppGenerateService, "generate", generate)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.ADVANCED_CHAT)
workflow_id = str(uuid.uuid4())
with app.test_request_context(
"/chat-messages",
method="POST",
json={"inputs": {}, "query": "hi", "workflow_id": workflow_id},
):
with pytest.raises(WorkflowVersionExecutionNotAllowedError) as exc_info:
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
billing_get_info.assert_called_once_with(app_model.tenant_id, exclude_vector_space=True)
generate.assert_not_called()
assert exc_info.value.code == 403
assert exc_info.value.error_code == "workflow_version_execution_not_allowed"
@pytest.mark.parametrize(
("deployment_edition", "plan", "workflow_id"),
[
(DeploymentEdition.COMMUNITY, CloudPlan.SANDBOX, str(uuid.uuid4())),
(DeploymentEdition.ENTERPRISE, CloudPlan.SANDBOX, str(uuid.uuid4())),
(DeploymentEdition.CLOUD, CloudPlan.PROFESSIONAL, str(uuid.uuid4())),
(DeploymentEdition.CLOUD, CloudPlan.SANDBOX, None),
],
ids=["community-version", "enterprise-version", "cloud-paid-version", "cloud-default-version"],
)
def test_allows_default_or_entitled_workflow_version_execution(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
orm_session: Session,
deployment_edition: DeploymentEdition,
plan: CloudPlan,
workflow_id: str | None,
) -> None:
completion_module = sys.modules["controllers.service_api.app.completion"]
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=deployment_edition)
billing_get_info = mocker.patch.object(
BillingService, "get_info", return_value=builders.subscription_info(plan)
)
generate = Mock(return_value={"result": "ok"})
monkeypatch.setattr(AppGenerateService, "generate", generate)
monkeypatch.setattr(completion_module.helper, "compact_generate_response", lambda response: response)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.ADVANCED_CHAT)
request_json = {"inputs": {}, "query": "hi"}
if workflow_id:
request_json["workflow_id"] = workflow_id
with app.test_request_context("/chat-messages", method="POST", json=request_json):
response = handler(api, session=orm_session, app_model=app_model, end_user=end_user)
assert response == {"result": "ok"}
generate.assert_called_once()
if deployment_edition == DeploymentEdition.CLOUD and workflow_id:
billing_get_info.assert_called_once_with(app_model.tenant_id, exclude_vector_space=True)
else:
billing_get_info.assert_not_called()
def test_wrong_mode(self, app: Flask, orm_session: Session) -> None:
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with app.test_request_context("/chat-messages", method="POST", json={"inputs": {}, "query": "hi"}):
with pytest.raises(NotChatAppError):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
def test_workflow_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(WorkflowNotFoundError("missing")),
)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context("/chat-messages", method="POST", json={"inputs": {}, "query": "hi"}):
with pytest.raises(NotFound):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
def test_draft_workflow(self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(IsDraftWorkflowError("draft")),
)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context("/chat-messages", method="POST", json={"inputs": {}, "query": "hi"}):
with pytest.raises(BadRequest):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
def test_agent_not_published_error_mapped(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session
) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(
AgentAppNotPublishedError("Agent has not been published")
),
)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.AGENT)
with app.test_request_context("/chat-messages", method="POST", json={"inputs": {}, "query": "hi"}):
with pytest.raises(AgentNotPublishedError):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
def test_invalid_conversation_id_fails_fast_as_not_found(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, orm_session: Session
) -> None:
# A well-formed but nonexistent conversation_id must fail fast as 404, before the
# streaming generator is created. Previously the lookup only ran inside the generator,
# so an invalid id surfaced as a hang instead of a clean error.
get_conversation_mock = Mock(side_effect=ConversationNotExistsError())
monkeypatch.setattr(ConversationService, "get_conversation", get_conversation_mock)
generate_mock = Mock(return_value={"text": "unused"})
monkeypatch.setattr(AppGenerateService, "generate", generate_mock)
api = ChatApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.CHAT)
with app.test_request_context(
"/chat-messages",
method="POST",
json={"inputs": {}, "query": "hi", "conversation_id": str(uuid.uuid4())},
):
with pytest.raises(NotFound):
handler(api, session=orm_session, app_model=app_model, end_user=end_user)
# The lookup must run before generation, so the generator is never started.
generate_mock.assert_not_called()
assert get_conversation_mock.call_args.kwargs["session"] is orm_session
class TestChatStopApiController:
def test_wrong_mode(self, app: Flask, orm_session: Session) -> None:
api = ChatStopApi()
handler = unwrap(api.post)
app_model, end_user, _, _ = _persist_completion_state(orm_session, AppMode.COMPLETION)
with app.test_request_context("/chat-messages/1/stop", method="POST"):
with pytest.raises(NotChatAppError):
handler(api, app_model=app_model, end_user=end_user, task_id="t1")
class _Request:
def __init__(self, *, headers=None, args=None, json=None, is_json=True):
self.headers = headers or {}
self.args = args or {}
self.json = json
self.is_json = is_json
def _app(mode: AppMode) -> App:
return make_app(mode=mode, icon_type=None)
def _end_user() -> EndUser:
return make_end_user(end_user_id="user-1", end_user_type=EndUserType.SERVICE_API)
def _assert_generate_trace_session_id(mock_generate_service: MagicMock, expected: str) -> None:
_, kwargs = mock_generate_service.generate.call_args
assert kwargs["args"]["trace_session_id"] == expected
class TestTraceSessionIdParsingCases:
@staticmethod
def test_trace_session_id_header_query_body_priority_matches_service_api_contract():
req = _Request(
headers={"X-Trace-Session-Id": "header"},
args={"trace_session_id": "query"},
json={"trace_session_id": "body"},
)
assert get_trace_session_id(req) == "header"
@staticmethod
def test_trace_session_id_invalid_highest_priority_raises_bad_request():
req = _Request(
headers={"X-Trace-Session-Id": " "},
args={"trace_session_id": "query"},
json={"trace_session_id": "body"},
)
with pytest.raises(BadRequest):
get_trace_session_id(req)
@staticmethod
@patch("controllers.service_api.app.completion.AppGenerateService")
@patch("controllers.service_api.app.completion.service_api_ns")
def test_chat_api_rejects_invalid_highest_priority_query_trace_session_id_without_generating(
mock_service_api_ns: MagicMock,
mock_generate_service: MagicMock,
app: Flask,
):
payload = {"inputs": {}, "query": "hello", "trace_session_id": "body-session"}
mock_service_api_ns.payload = payload
with app.test_request_context(
"/chat-messages?trace_session_id=%20%20%20",
method="POST",
json=payload,
):
with pytest.raises(BadRequest):
completion_module.ChatApi().post.__wrapped__(
completion_module.ChatApi(),
_app(AppMode.CHAT),
_end_user(),
)
mock_generate_service.generate.assert_not_called()
@staticmethod
@patch("controllers.service_api.app.workflow.AppGenerateService")
@patch("controllers.service_api.app.workflow.service_api_ns")
def test_workflow_run_api_rejects_invalid_highest_priority_body_trace_session_id_without_generating(
mock_service_api_ns: MagicMock,
mock_generate_service: MagicMock,
app: Flask,
):
payload = {"inputs": {}, "trace_session_id": 123}
mock_service_api_ns.payload = payload
with app.test_request_context("/workflows/run", method="POST", json=payload):
with pytest.raises(BadRequest):
workflow_module.WorkflowRunApi().post.__wrapped__(
workflow_module.WorkflowRunApi(),
_app(AppMode.WORKFLOW),
_end_user(),
)
mock_generate_service.generate.assert_not_called()
@staticmethod
@patch("controllers.service_api.app.completion.helper.compact_generate_response", return_value={"answer": "ok"})
@patch("controllers.service_api.app.completion.AppGenerateService")
@patch("controllers.service_api.app.completion.service_api_ns")
def test_completion_api_passes_header_trace_session_id_when_body_value_is_invalid_lower_priority(
mock_service_api_ns: MagicMock,
mock_generate_service: MagicMock,
mock_compact: MagicMock,
app: Flask,
):
payload = {"inputs": {}, "trace_session_id": 123}
mock_service_api_ns.payload = payload
mock_generate_service.generate.return_value = "response"
with app.test_request_context(
"/completion-messages",
method="POST",
json=payload,
headers={"X-Trace-Session-Id": " header-session "},
):
response = completion_module.CompletionApi().post.__wrapped__(
completion_module.CompletionApi(),
_app(AppMode.COMPLETION),
_end_user(),
)
assert response == {"answer": "ok"}
_assert_generate_trace_session_id(mock_generate_service, "header-session")
@staticmethod
@patch("controllers.service_api.app.completion.helper.compact_generate_response", return_value={"answer": "ok"})
@patch("controllers.service_api.app.completion.AppGenerateService")
@patch("controllers.service_api.app.completion.service_api_ns")
def test_chat_api_passes_query_trace_session_id_when_body_value_is_invalid_lower_priority(
mock_service_api_ns: MagicMock,
mock_generate_service: MagicMock,
mock_compact: MagicMock,
app: Flask,
):
payload = {"inputs": {}, "query": "hello", "trace_session_id": 123}
mock_service_api_ns.payload = payload
mock_generate_service.generate.return_value = "response"
with app.test_request_context(
"/chat-messages?trace_session_id=query-session",
method="POST",
json=payload,
):
response = completion_module.ChatApi().post.__wrapped__(
completion_module.ChatApi(),
_app(AppMode.CHAT),
_end_user(),
)
assert response == {"answer": "ok"}
_assert_generate_trace_session_id(mock_generate_service, "query-session")
@staticmethod
@patch("controllers.service_api.app.workflow.helper.compact_generate_response", return_value={"result": "ok"})
@patch("controllers.service_api.app.workflow.AppGenerateService")
@patch("controllers.service_api.app.workflow.service_api_ns")
def test_workflow_run_api_passes_body_trace_session_id(
mock_service_api_ns: MagicMock,
mock_generate_service: MagicMock,
mock_compact: MagicMock,
app: Flask,
):
payload = {"inputs": {}, "trace_session_id": " body-session "}
mock_service_api_ns.payload = payload
mock_generate_service.generate.return_value = "response"
with app.test_request_context("/workflows/run", method="POST", json=payload):
response = workflow_module.WorkflowRunApi().post.__wrapped__(
workflow_module.WorkflowRunApi(),
_app(AppMode.WORKFLOW),
_end_user(),
)
assert response == {"result": "ok"}
_assert_generate_trace_session_id(mock_generate_service, "body-session")
@@ -0,0 +1,463 @@
import uuid
from datetime import UTC, datetime
from typing import Literal
import pytest
from pydantic import ValidationError
import services
from controllers.console.explore.conversation import ConversationRenamePayload as ConsolePayload
from controllers.service_api.app.conversation import (
ConversationListQuery,
ConversationRenamePayload,
ConversationVariableInfiniteScrollPaginationResponse,
ConversationVariableResponse,
ConversationVariablesQuery,
ConversationVariableUpdatePayload,
)
from controllers.service_api.app.conversation import ConversationRenamePayload as ServicePayload
from controllers.service_api.app.error import NotChatAppError
from fields._value_type_serializer import serialize_value_type
from graphon.variables import StringSegment
from graphon.variables.types import SegmentType
from models.model import App, AppMode
"""
Unit tests for Service API Conversation controllers.
Tests coverage for:
- ConversationListQuery, ConversationRenamePayload Pydantic models
- ConversationVariablesQuery with SQL injection prevention
- ConversationVariableUpdatePayload
- App mode validation for chat-only endpoints
Focus on:
- Pydantic model validation including security checks
- SQL injection prevention in variable name filtering
- Error types and mappings
"""
class TestConversationCases:
class TestConversationListQuery:
"""Test suite for ConversationListQuery Pydantic model."""
def test_query_with_defaults(self) -> None:
"""Test query with default values."""
query = ConversationListQuery()
assert query.last_id is None
assert query.limit == 20
assert query.sort_by == "-updated_at"
def test_query_with_last_id(self) -> None:
"""Test query with pagination last_id."""
last_id = str(uuid.uuid4())
query = ConversationListQuery(last_id=last_id)
assert str(query.last_id) == last_id
def test_query_limit_boundaries(self) -> None:
"""Test query respects limit boundaries."""
query_min = ConversationListQuery(limit=1)
assert query_min.limit == 1
query_max = ConversationListQuery(limit=100)
assert query_max.limit == 100
@pytest.mark.parametrize(
"sort_by",
[
"created_at",
"-created_at",
"updated_at",
"-updated_at",
],
)
def test_query_valid_sort_options(
self, sort_by: Literal["created_at", "-created_at", "updated_at", "-updated_at"]
) -> None:
"""Test all valid sort_by options."""
query = ConversationListQuery(sort_by=sort_by)
assert query.sort_by == sort_by
class TestConversationRenamePayload:
"""Test suite for ConversationRenamePayload Pydantic model."""
def test_payload_with_name(self) -> None:
"""Test payload with explicit name."""
payload = ConversationRenamePayload(name="My New Chat", auto_generate=False)
assert payload.name == "My New Chat"
assert payload.auto_generate is False
def test_payload_with_auto_generate(self) -> None:
"""Test payload with auto_generate enabled."""
payload = ConversationRenamePayload(auto_generate=True)
assert payload.auto_generate is True
assert payload.name is None
def test_payload_requires_name_when_auto_generate_false(self) -> None:
"""Test that name is required when auto_generate is False."""
with pytest.raises(
ValueError,
match=(
"1 validation error for ConversationRenamePayload\\\n Value error, "
"name is required when auto_generate is false"
),
) as exc_info:
ConversationRenamePayload(auto_generate=False)
assert "name is required when auto_generate is false" in str(exc_info.value)
def test_payload_requires_non_empty_name_when_auto_generate_false(self) -> None:
"""Test that empty string name is rejected."""
with pytest.raises(
ValueError,
match=(
"1 validation error for ConversationRenamePayload\\\n Value error, "
"name is required when auto_generate is false"
),
):
ConversationRenamePayload(name="", auto_generate=False)
def test_payload_requires_non_whitespace_name_when_auto_generate_false(self) -> None:
"""Test that whitespace-only name is rejected."""
with pytest.raises(
ValueError,
match=(
"1 validation error for ConversationRenamePayload\\\n Value error, "
"name is required when auto_generate is false"
),
):
ConversationRenamePayload(name=" ", auto_generate=False)
def test_payload_name_with_special_characters(self) -> None:
"""Test payload with name containing special characters."""
payload = ConversationRenamePayload(name="Chat #1 - (Test) & More!", auto_generate=False)
assert payload.name == "Chat #1 - (Test) & More!"
def test_payload_name_with_unicode(self) -> None:
"""Test payload with Unicode characters in name."""
payload = ConversationRenamePayload(name="对话 📝 Чат", auto_generate=False)
assert payload.name == "对话 📝 Чат"
class TestConversationVariablesQuery:
"""Test suite for ConversationVariablesQuery Pydantic model."""
def test_query_with_defaults(self) -> None:
"""Test query with default values."""
query = ConversationVariablesQuery()
assert query.last_id is None
assert query.limit == 20
assert query.variable_name is None
def test_query_with_variable_name(self) -> None:
"""Test query with valid variable_name filter."""
query = ConversationVariablesQuery(variable_name="user_preference")
assert query.variable_name == "user_preference"
def test_query_allows_hyphen_in_variable_name(self) -> None:
"""Test that hyphens are allowed in variable names."""
query = ConversationVariablesQuery(variable_name="my-variable")
assert query.variable_name == "my-variable"
def test_query_allows_underscore_in_variable_name(self) -> None:
"""Test that underscores are allowed in variable names."""
query = ConversationVariablesQuery(variable_name="my_variable")
assert query.variable_name == "my_variable"
def test_query_allows_period_in_variable_name(self) -> None:
"""Test that periods are allowed in variable names."""
query = ConversationVariablesQuery(variable_name="config.setting")
assert query.variable_name == "config.setting"
def test_query_rejects_sql_injection_single_quote(self) -> None:
"""Test that single quotes are rejected (SQL injection prevention)."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name="'; DROP TABLE users;--")
assert "can only contain" in str(exc_info.value)
def test_query_rejects_sql_injection_double_quote(self) -> None:
"""Test that double quotes are rejected."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name='name"test')
assert "can only contain" in str(exc_info.value)
def test_query_rejects_sql_injection_semicolon(self) -> None:
"""Test that semicolons are rejected."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name="name;malicious")
assert "can only contain" in str(exc_info.value)
def test_query_rejects_sql_injection_comment(self) -> None:
"""Test that SQL comments are rejected."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name="name--comment")
assert "invalid characters" in str(exc_info.value)
def test_query_rejects_special_characters(self) -> None:
"""Test that special characters are rejected."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name="name@domain")
assert "can only contain" in str(exc_info.value)
def test_query_rejects_backticks(self) -> None:
"""Test that backticks are rejected (SQL injection prevention)."""
with pytest.raises(
ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"
) as exc_info:
ConversationVariablesQuery(variable_name="`table`")
assert "can only contain" in str(exc_info.value)
def test_query_pagination_limits(self) -> None:
"""Test query pagination limit boundaries."""
query_min = ConversationVariablesQuery(limit=1)
assert query_min.limit == 1
query_max = ConversationVariablesQuery(limit=100)
assert query_max.limit == 100
class TestConversationVariableUpdatePayload:
"""Test suite for ConversationVariableUpdatePayload Pydantic model."""
def test_payload_with_string_value(self) -> None:
"""Test payload with string value."""
payload = ConversationVariableUpdatePayload(value="hello")
assert payload.value == "hello"
def test_payload_with_number_value(self) -> None:
"""Test payload with number value."""
payload = ConversationVariableUpdatePayload(value=42)
assert payload.value == 42
def test_payload_with_float_value(self) -> None:
"""Test payload with float value."""
payload = ConversationVariableUpdatePayload(value=float("3.14159"))
assert payload.value == float("3.14159")
def test_payload_with_list_value(self) -> None:
"""Test payload with list value."""
payload = ConversationVariableUpdatePayload(value=["a", "b", "c"])
assert payload.value == ["a", "b", "c"]
def test_payload_with_dict_value(self) -> None:
"""Test payload with dictionary value."""
payload = ConversationVariableUpdatePayload(value={"key": "value"})
assert payload.value == {"key": "value"}
def test_payload_with_none_value(self) -> None:
"""Test payload with None value."""
payload = ConversationVariableUpdatePayload(value=None)
assert payload.value is None
def test_payload_with_boolean_value(self) -> None:
"""Test payload with boolean value."""
payload = ConversationVariableUpdatePayload(value=True)
assert payload.value is True
def test_payload_with_nested_structure(self) -> None:
"""Test payload with deeply nested structure."""
nested = {"level1": {"level2": {"level3": ["a", "b", {"c": 123}]}}}
payload = ConversationVariableUpdatePayload(value=nested)
assert payload.value == nested
class TestConversationVariableResponseModels:
def test_variable_response_normalizes_value_type_and_timestamps(self) -> None:
"""Given an integer segment type and UTC timestamps, expose a number and epoch seconds."""
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
response = ConversationVariableResponse.model_validate(
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"name": "foo",
"value_type": SegmentType.INTEGER,
"value": 1,
"description": "desc",
"created_at": created_at,
"updated_at": created_at,
}
)
assert response.value_type == "number"
assert response.value == "1"
assert response.created_at == int(created_at.timestamp())
assert response.updated_at == int(created_at.timestamp())
def test_variable_response_normalizes_string_value_type_alias(self) -> None:
"""Given the integer type alias, expose the canonical number type."""
response = ConversationVariableResponse.model_validate(
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"name": "foo",
"value_type": SegmentType.INTEGER.value,
}
)
assert response.value_type == "number"
def test_variable_response_normalizes_callable_exposed_type(self) -> None:
"""Given a segment type with an exposed_type method, use its string result."""
response = ConversationVariableResponse.model_validate(
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"name": "foo",
"value_type": SegmentType.STRING,
}
)
assert response.value_type == "string"
def test_serialize_value_type_supports_segments_and_mappings(self) -> None:
"""Given a segment or value_type mapping, return its exposed type."""
assert serialize_value_type(StringSegment(value="hello")) == "string"
assert serialize_value_type({"value_type": SegmentType.INTEGER}) == "number"
def test_variable_pagination_response(self) -> None:
"""Given a valid pagination payload, preserve its limit, cursor state, and variable."""
response = ConversationVariableInfiniteScrollPaginationResponse.model_validate(
{
"limit": 1,
"has_more": False,
"data": [
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"name": "foo",
"value_type": "string",
"value": "bar",
}
],
}
)
assert response.limit == 1
assert response.has_more is False
assert len(response.data) == 1
assert response.data[0].name == "foo"
class TestConversationAppModeValidation:
"""Test app mode validation for conversation endpoints."""
@pytest.mark.parametrize(
"mode",
[
AppMode.CHAT,
AppMode.AGENT_CHAT.value,
AppMode.AGENT.value,
AppMode.ADVANCED_CHAT.value,
],
)
def test_chat_modes_are_valid_for_conversation_endpoints(self, mode: str) -> None:
"""Test that all chat modes are valid for conversation endpoints.
Verifies that CHAT, AGENT_CHAT, AGENT, and ADVANCED_CHAT modes pass
validation without raising NotChatAppError.
"""
app = App(
mode=AppMode(mode),
)
# Validation should pass without raising for chat modes
app_mode = AppMode.value_of(app.mode)
assert app_mode in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
def test_completion_mode_is_invalid_for_conversation_endpoints(self) -> None:
"""Test that COMPLETION mode is invalid for conversation endpoints.
Verifies that calling a conversation endpoint with a COMPLETION mode
app raises NotChatAppError.
"""
app = App(
mode=AppMode.COMPLETION,
)
app_mode = AppMode.value_of(app.mode)
assert app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
with pytest.raises(NotChatAppError):
raise NotChatAppError()
def test_workflow_mode_is_invalid_for_conversation_endpoints(self) -> None:
"""Test that WORKFLOW mode is invalid for conversation endpoints.
Verifies that calling a conversation endpoint with a WORKFLOW mode
app raises NotChatAppError.
"""
app = App(
mode=AppMode.WORKFLOW,
)
app_mode = AppMode.value_of(app.mode)
assert app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
with pytest.raises(NotChatAppError):
raise NotChatAppError()
class TestConversationErrorTypes:
"""Test conversation-related error types."""
def test_conversation_not_exists_error(self) -> None:
"""Test ConversationNotExistsError exists and can be raised."""
error = services.errors.conversation.ConversationNotExistsError()
assert isinstance(error, services.errors.conversation.ConversationNotExistsError)
def test_conversation_completed_error(self) -> None:
"""Test ConversationCompletedError exists."""
error = services.errors.conversation.ConversationCompletedError()
assert isinstance(error, services.errors.conversation.ConversationCompletedError)
def test_last_conversation_not_exists_error(self) -> None:
"""Test LastConversationNotExistsError exists."""
error = services.errors.conversation.LastConversationNotExistsError()
assert isinstance(error, services.errors.conversation.LastConversationNotExistsError)
def test_conversation_variable_not_exists_error(self) -> None:
"""Test ConversationVariableNotExistsError exists."""
error = services.errors.conversation.ConversationVariableNotExistsError()
assert isinstance(error, services.errors.conversation.ConversationVariableNotExistsError)
def test_conversation_variable_type_mismatch_error(self) -> None:
"""Test ConversationVariableTypeMismatchError exists."""
error = services.errors.conversation.ConversationVariableTypeMismatchError("Type mismatch")
assert isinstance(error, services.errors.conversation.ConversationVariableTypeMismatchError)
class TestConversationPayloadsController:
def test_rename_requires_name(self) -> None:
with pytest.raises(
ValueError,
match=(
"1 validation error for ConversationRenamePayload\\\n Value error, "
"name is required when auto_generate is false"
),
):
ConversationRenamePayload(auto_generate=False, name="")
def test_variables_query_invalid_name(self) -> None:
with pytest.raises(ValueError, match="1 validation error for ConversationVariablesQuery\\\nvariable_name"):
ConversationVariablesQuery(variable_name="bad;")
class TestConversationRenamePayloadCases:
from tests.unit_tests.conftest import app
app = staticmethod(app)
@staticmethod
@pytest.mark.parametrize("payload_cls", [ConsolePayload, ServicePayload])
def test_payload_allows_auto_generate_without_name(payload_cls: type[ConversationRenamePayload]) -> None:
"""Given either endpoint payload model, accept automatic naming without a name."""
payload = payload_cls.model_validate({"auto_generate": True})
assert payload.auto_generate is True
assert payload.name is None
@staticmethod
@pytest.mark.parametrize("payload_cls", [ConsolePayload, ServicePayload])
@pytest.mark.parametrize("value", [None, "", " "])
def test_payload_requires_name_when_not_auto_generate(
payload_cls: type[ConversationRenamePayload], value: str | None
) -> None:
"""Given either endpoint model and a blank name, reject manual naming with ValidationError."""
with pytest.raises(ValidationError):
payload_cls.model_validate({"name": value, "auto_generate": False})
@@ -0,0 +1,466 @@
"""
Unit tests for Service API File controllers.
Tests coverage for:
- File upload validation
- Error handling for file operations
- FileService integration
Focus on:
- File validation logic (size, type, filename)
- Error type mappings
- Service method interfaces
"""
import uuid
# =============================================================================
# API Endpoint Tests
#
# ``FileApi.post`` is wrapped by ``@validate_app_token(fetch_user_arg=...)``
# which preserves ``__wrapped__`` via ``functools.wraps``. We call the
# unwrapped method directly to bypass the decorator.
# =============================================================================
from inspect import unwrap
from unittest.mock import Mock, patch
import pytest
from flask import Flask
from controllers.common.errors import (
BlockedFileExtensionError,
FilenameNotExistsError,
FileTooLargeError,
NoFileUploadedError,
TooManyFilesError,
UnsupportedFileTypeError,
)
from fields.file_fields import FileResponse
from services.file_service import FileService
class TestFileResponse:
"""Test suite for FileResponse Pydantic model."""
def test_file_response_has_required_fields(self):
"""Test FileResponse model includes required fields."""
# Verify the model exists and can be imported
assert FileResponse is not None
assert hasattr(FileResponse, "model_fields")
class TestFileUploadErrors:
"""Test file upload error types."""
def test_no_file_uploaded_error_can_be_raised(self):
"""Test NoFileUploadedError can be raised."""
error = NoFileUploadedError()
assert error is not None
def test_too_many_files_error_can_be_raised(self):
"""Test TooManyFilesError can be raised."""
error = TooManyFilesError()
assert error is not None
def test_unsupported_file_type_error_can_be_raised(self):
"""Test UnsupportedFileTypeError can be raised."""
error = UnsupportedFileTypeError()
assert error is not None
def test_filename_not_exists_error_can_be_raised(self):
"""Test FilenameNotExistsError can be raised."""
error = FilenameNotExistsError()
assert error is not None
def test_file_too_large_error_can_be_raised(self):
"""Test FileTooLargeError can be raised."""
error = FileTooLargeError("File exceeds maximum size")
assert "File exceeds maximum size" in str(error) or error is not None
class TestFileServiceErrors:
"""Test FileService error types."""
def test_file_service_file_too_large_error_exists(self):
"""Test FileTooLargeError from services exists."""
import services.errors.file
error = services.errors.file.FileTooLargeError("File too large")
assert isinstance(error, services.errors.file.FileTooLargeError)
def test_file_service_unsupported_file_type_error_exists(self):
"""Test UnsupportedFileTypeError from services exists."""
import services.errors.file
error = services.errors.file.UnsupportedFileTypeError()
assert isinstance(error, services.errors.file.UnsupportedFileTypeError)
class TestFileService:
"""Test FileService interface and methods."""
def test_upload_file_method_exists(self):
"""Test FileService.upload_file method exists."""
assert hasattr(FileService, "upload_file")
assert callable(FileService.upload_file)
@patch.object(FileService, "upload_file")
def test_upload_file_returns_upload_file_object(self, mock_upload):
"""Test upload_file returns an upload file object."""
mock_file = Mock()
mock_file.id = str(uuid.uuid4())
mock_file.name = "test.pdf"
mock_file.size = 1024
mock_file.extension = "pdf"
mock_file.mime_type = "application/pdf"
mock_upload.return_value = mock_file
# Call the method directly without instantiation
assert mock_file.name == "test.pdf"
assert mock_file.extension == "pdf"
@patch.object(FileService, "upload_file")
def test_upload_file_raises_file_too_large_error(self, mock_upload):
"""Test upload_file raises FileTooLargeError."""
import services.errors.file
mock_upload.side_effect = services.errors.file.FileTooLargeError("File exceeds 15MB limit")
# Verify error type exists
with pytest.raises(services.errors.file.FileTooLargeError):
mock_upload(Mock(), Mock(), "user_id")
@patch.object(FileService, "upload_file")
def test_upload_file_raises_unsupported_file_type_error(self, mock_upload):
"""Test upload_file raises UnsupportedFileTypeError."""
import services.errors.file
mock_upload.side_effect = services.errors.file.UnsupportedFileTypeError()
# Verify error type exists
with pytest.raises(services.errors.file.UnsupportedFileTypeError):
mock_upload(Mock(), Mock(), "user_id")
class TestFileValidation:
"""Test file validation patterns."""
def test_valid_image_mimetype(self):
"""Test common image MIME types."""
valid_mimetypes = ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"]
for mimetype in valid_mimetypes:
assert mimetype.startswith("image/")
def test_valid_document_mimetype(self):
"""Test common document MIME types."""
valid_mimetypes = [
"application/pdf",
"application/msword",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"text/plain",
"text/csv",
]
for mimetype in valid_mimetypes:
assert mimetype is not None
assert len(mimetype) > 0
def test_filename_has_extension(self):
"""Test filename validation for extension presence."""
valid_filenames = ["document.pdf", "image.png", "data.csv", "report.docx"]
for filename in valid_filenames:
assert "." in filename
parts = filename.rsplit(".", 1)
assert len(parts) == 2
assert len(parts[1]) > 0 # Extension exists
def test_filename_without_extension_is_invalid(self):
"""Test that filename without extension can be detected."""
filename = "noextension"
assert "." not in filename
class TestFileUploadResponse:
"""Test file upload response structure."""
@patch.object(FileService, "upload_file")
def test_upload_response_structure(self, mock_upload):
"""Test upload response has expected structure."""
mock_file = Mock()
mock_file.id = str(uuid.uuid4())
mock_file.name = "test.pdf"
mock_file.size = 2048
mock_file.extension = "pdf"
mock_file.mime_type = "application/pdf"
mock_file.created_by = str(uuid.uuid4())
mock_file.created_at = Mock()
mock_upload.return_value = mock_file
# Verify expected fields exist on mock
assert hasattr(mock_file, "id")
assert hasattr(mock_file, "name")
assert hasattr(mock_file, "size")
assert hasattr(mock_file, "extension")
assert hasattr(mock_file, "mime_type")
assert hasattr(mock_file, "created_by")
assert hasattr(mock_file, "created_at")
@pytest.fixture
def mock_app_model():
from models import App
app = App(
id=str(uuid.uuid4()),
tenant_id=str(uuid.uuid4()),
)
return app
@pytest.fixture
def mock_end_user(mock_app_model):
from models import EndUser
user = EndUser(
id=str(uuid.uuid4()),
tenant_id=mock_app_model.tenant_id,
app_id=mock_app_model.id,
)
return user
class TestFileApiPost:
"""Test suite for FileApi.post() endpoint.
``post`` is wrapped by ``@validate_app_token(fetch_user_arg=...)``
which preserves ``__wrapped__``.
"""
@patch("controllers.service_api.app.file.application_services")
def test_upload_file_success(
self,
mock_application_services,
app: Flask,
mock_app_model,
mock_end_user,
):
"""Test successful file upload."""
from io import BytesIO
from controllers.service_api.app.file import FileApi
mock_upload = Mock()
mock_upload.id = str(uuid.uuid4())
mock_upload.name = "test.pdf"
mock_upload.size = 1024
mock_upload.extension = "pdf"
mock_upload.mime_type = "application/pdf"
mock_upload.created_by = str(mock_end_user.id)
mock_upload.created_by_role = "end_user"
mock_upload.created_at = 1700000000
mock_upload.preview_url = None
mock_upload.source_url = None
mock_upload.original_url = None
mock_upload.reference = None
mock_upload.user_id = None
mock_upload.tenant_id = mock_end_user.tenant_id
mock_upload.conversation_id = None
mock_upload.file_key = None
file_service = mock_application_services.return_value.files
file_service.upload_file.return_value = mock_upload
data = {"file": (BytesIO(b"file content"), "test.pdf", "application/pdf")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
response, status = unwrap(api.post)(
api,
app_model=mock_app_model,
end_user=mock_end_user,
)
assert status == 201
assert response["id"] == mock_upload.id
assert response["name"] == "test.pdf"
assert response["tenant_id"] == mock_end_user.tenant_id
file_service.upload_file.assert_called_once_with(
filename="test.pdf",
content=b"file content",
mimetype="application/pdf",
user=mock_end_user,
)
def test_upload_no_file(self, app: Flask, mock_app_model, mock_end_user):
"""Test NoFileUploadedError when no file in request."""
from controllers.service_api.app.file import FileApi
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data={},
):
api = FileApi()
with pytest.raises(NoFileUploadedError):
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
def test_upload_too_many_files(self, app: Flask, mock_app_model, mock_end_user):
"""Test TooManyFilesError when multiple files uploaded."""
from io import BytesIO
from controllers.service_api.app.file import FileApi
data = {
"file": (BytesIO(b"content1"), "file1.pdf", "application/pdf"),
"extra": (BytesIO(b"content2"), "file2.pdf", "application/pdf"),
}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(TooManyFilesError):
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
def test_upload_no_mimetype(self, app: Flask, mock_app_model, mock_end_user):
"""Test UnsupportedFileTypeError when file has no mimetype."""
from io import BytesIO
from controllers.service_api.app.file import FileApi
data = {"file": (BytesIO(b"content"), "test.bin", "")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(UnsupportedFileTypeError):
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
def test_upload_no_filename(self, app: Flask, mock_app_model, mock_end_user):
"""Test FilenameNotExistsError when the uploaded file has no filename."""
from io import BytesIO
from controllers.service_api.app.file import FileApi
data = {"file": (BytesIO(b"content"), "", "application/pdf")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(FilenameNotExistsError):
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
@patch("controllers.service_api.app.file.application_services")
def test_upload_file_too_large(
self,
mock_application_services,
app: Flask,
mock_app_model,
mock_end_user,
):
"""Test FileTooLargeError when file exceeds size limit."""
from io import BytesIO
import services.errors.file
from controllers.service_api.app.file import FileApi
service_error = services.errors.file.FileTooLargeError("File exceeds 15MB limit")
mock_application_services.return_value.files.upload_file.side_effect = service_error
data = {"file": (BytesIO(b"big content"), "big.pdf", "application/pdf")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(FileTooLargeError) as raised:
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
assert raised.value.__cause__ is service_error
@patch("controllers.service_api.app.file.application_services")
def test_upload_unsupported_file_type(
self,
mock_application_services,
app: Flask,
mock_app_model,
mock_end_user,
):
"""Test UnsupportedFileTypeError from FileService."""
from io import BytesIO
import services.errors.file
from controllers.service_api.app.file import FileApi
service_error = services.errors.file.UnsupportedFileTypeError()
mock_application_services.return_value.files.upload_file.side_effect = service_error
data = {"file": (BytesIO(b"content"), "test.xyz", "application/octet-stream")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(UnsupportedFileTypeError) as raised:
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
assert raised.value.__cause__ is service_error
@patch("controllers.service_api.app.file.application_services")
def test_upload_blocked_file_extension(
self,
mock_application_services,
app: Flask,
mock_app_model,
mock_end_user,
):
"""Test BlockedFileExtensionError from FileService."""
from io import BytesIO
import services.errors.file
from controllers.service_api.app.file import FileApi
service_error = services.errors.file.BlockedFileExtensionError("File extension '.exe' is blocked")
mock_application_services.return_value.files.upload_file.side_effect = service_error
data = {"file": (BytesIO(b"content"), "blocked.exe", "application/octet-stream")}
with app.test_request_context(
"/files/upload",
method="POST",
content_type="multipart/form-data",
data=data,
):
api = FileApi()
with pytest.raises(BlockedFileExtensionError) as raised:
unwrap(api.post)(api, app_model=mock_app_model, end_user=mock_end_user)
assert raised.value.code == 400
assert raised.value.error_code == "file_extension_blocked"
assert raised.value.data == {
"code": "file_extension_blocked",
"message": "The file extension is blocked for security reasons.",
"status": 400,
}
assert raised.value.__cause__ is service_error
@@ -0,0 +1,151 @@
"""Unit tests for the Service API file-preview transport boundary."""
from inspect import unwrap
from unittest.mock import Mock, patch
from uuid import UUID, uuid4
import pytest
from flask import Response
from controllers.service_api.app.error import FileAccessDeniedError, FileNotFoundError
from controllers.service_api.app.file_preview import FilePreviewApi, FilePreviewQuery
from models.model import App, EndUser
from services.message_file_preview_service import (
MessageFilePreview,
MessageFilePreviewAccessDeniedError,
MessageFilePreviewNotFoundError,
MessageFilePreviewRecord,
)
def _preview(
*,
mime_type: str | None = "image/jpeg",
name: str = "test_file.jpg",
extension: str = "jpg",
size: int = 1024,
) -> MessageFilePreview:
return MessageFilePreview(
content=iter([b"file content"]),
file=MessageFilePreviewRecord(
key="storage/key/test_file.jpg",
name=name,
size=size,
extension=extension,
mime_type=mime_type,
),
)
def _app() -> App:
return App(id=str(uuid4()), tenant_id=str(uuid4()))
def _get(
*,
api: FilePreviewApi,
args: FilePreviewQuery,
app_model: App,
file_id: UUID,
) -> Response:
return unwrap(api.get)(
api,
args=args,
app_model=app_model,
end_user=EndUser(id=str(uuid4()), app_id=app_model.id, tenant_id=app_model.tenant_id),
file_id=file_id,
)
class TestFilePreviewApi:
@patch("controllers.service_api.app.file_preview.application_services")
def test_get_uses_authenticated_app_scope(self, mock_application_services: Mock) -> None:
app_model = _app()
file_id = uuid4()
preview = _preview()
service = mock_application_services.return_value.message_file_previews
service.get_preview.return_value = preview
response = _get(
api=FilePreviewApi(),
args=FilePreviewQuery(),
app_model=app_model,
file_id=file_id,
)
service.get_preview.assert_called_once_with(
file_id=str(file_id),
app_id=app_model.id,
tenant_id=app_model.tenant_id,
)
assert response.response is preview.content
assert response.mimetype == "image/jpeg"
@pytest.mark.parametrize(
("service_error", "http_error"),
[
(MessageFilePreviewNotFoundError(), FileNotFoundError),
(MessageFilePreviewAccessDeniedError(), FileAccessDeniedError),
],
)
@patch("controllers.service_api.app.file_preview.application_services")
def test_get_maps_expected_errors(
self,
mock_application_services: Mock,
service_error: Exception,
http_error: type[Exception],
) -> None:
mock_application_services.return_value.message_file_previews.get_preview.side_effect = service_error
with pytest.raises(http_error):
_get(
api=FilePreviewApi(),
args=FilePreviewQuery(),
app_model=_app(),
file_id=uuid4(),
)
@patch("controllers.service_api.app.file_preview.application_services")
def test_get_does_not_mask_storage_errors(self, mock_application_services: Mock) -> None:
mock_application_services.return_value.message_file_previews.get_preview.side_effect = OSError("storage down")
with pytest.raises(OSError, match="storage down"):
_get(
api=FilePreviewApi(),
args=FilePreviewQuery(),
app_model=_app(),
file_id=uuid4(),
)
@pytest.mark.parametrize(
("preview", "as_attachment"),
[
(_preview(), False),
(_preview(name="报告 1.jpg"), True),
(_preview(mime_type="text/html", name="unsafe.html", extension="html"), False),
(_preview(mime_type="video/mp4", name="video.mp4", extension="mp4"), False),
(_preview(size=0), False),
],
)
def test_build_file_response(self, preview: MessageFilePreview, as_attachment: bool) -> None:
response = FilePreviewApi()._build_file_response(
preview=preview,
as_attachment=as_attachment,
)
assert response.direct_passthrough is True
assert response.headers["Cache-Control"] == "public, max-age=3600"
assert ("Content-Length" in response.headers) is (preview.file.size > 0)
if as_attachment:
assert response.headers["Content-Disposition"] == (
"attachment; filename*=UTF-8''%E6%8A%A5%E5%91%8A%201.jpg"
)
assert response.headers["Content-Type"] == "application/octet-stream"
elif preview.file.mime_type == "text/html":
assert response.headers["Content-Disposition"] == "attachment; filename*=UTF-8''unsafe.html"
assert response.headers["Content-Type"] == "application/octet-stream"
assert response.headers["X-Content-Type-Options"] == "nosniff"
else:
assert response.mimetype == preview.file.mime_type
if preview.file.mime_type == "video/mp4":
assert response.headers["Accept-Ranges"] == "bytes"
@@ -0,0 +1,339 @@
"""Unit tests for Service API human input form endpoints."""
from __future__ import annotations
import json
import sys
from datetime import UTC, datetime
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import Mock
import pytest
from flask import Flask, request
from sqlalchemy.engine import Engine
from werkzeug.exceptions import NotFound
from controllers.common.human_input import HumanInputFormSubmitPayload
from controllers.service_api.app.human_input_form import WorkflowHumanInputFormApi
from models.enums import EndUserType
from models.human_input import RecipientType
from models.model import App, AppMode, EndUser
def _app() -> App:
return App(
id="app-1",
tenant_id="tenant-1",
name="Service API app",
description="",
mode=AppMode.WORKFLOW,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
def _end_user() -> EndUser:
return EndUser(
id="end-user-1",
tenant_id="tenant-1",
app_id="app-1",
type=EndUserType.SERVICE_API,
external_user_id="external-user-1",
name="Service API user",
session_id="session-1",
)
def _configure_service(
monkeypatch: pytest.MonkeyPatch,
service_mock: Mock,
sqlite_engine: Engine,
) -> None:
workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
monkeypatch.setattr(workflow_module, "ServiceAPIHumanInputService", lambda _engine: service_mock)
monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=sqlite_engine))
class TestWorkflowHumanInputFormApi:
def test_get_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine) -> None:
definition = SimpleNamespace(
model_dump=lambda **_kwargs: {
"rendered_content": "Rendered form content",
"inputs": [{"output_variable_name": "name"}],
"default_values": {"name": "Alice", "age": 30, "meta": {"k": "v"}},
"user_actions": [{"id": "approve", "title": "Approve"}],
}
)
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=RecipientType.STANDALONE_WEB_APP,
expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
get_definition=lambda: definition,
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
service_mock.resolve_form_inputs.return_value = [
SimpleNamespace(model_dump=lambda **_kwargs: {"output_variable_name": "name"})
]
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.get)
app_model = _app()
with app.test_request_context("/form/human_input/token-1", method="GET"):
response = handler(api, app_model=app_model, form_token="token-1")
payload = json.loads(response.get_data(as_text=True))
assert payload == {
"form_content": "Rendered form content",
"inputs": [{"output_variable_name": "name"}],
"resolved_default_values": {"name": "Alice", "age": "30", "meta": '{"k": "v"}'},
"user_actions": [{"id": "approve", "title": "Approve"}],
"expiration_time": int(form.expiration_time.timestamp()),
}
service_mock.get_form_by_token.assert_called_once_with("token-1")
service_mock.resolve_form_inputs.assert_called_once_with(form)
service_mock.ensure_form_active.assert_called_once_with(form)
def test_get_resolves_runtime_select_values(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine
) -> None:
definition = SimpleNamespace(
model_dump=lambda **_kwargs: {
"rendered_content": "Rendered form content",
"inputs": [
{
"output_variable_name": "decision",
"option_source": {"type": "variable", "selector": ["start", "options"], "value": []},
}
],
"default_values": {},
"user_actions": [{"id": "approve", "title": "Approve"}],
}
)
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=RecipientType.STANDALONE_WEB_APP,
expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
get_definition=lambda: definition,
)
resolved_input = SimpleNamespace(
model_dump=lambda **_kwargs: {
"output_variable_name": "decision",
"option_source": {"type": "variable", "selector": ["start", "options"], "value": ["approve", "reject"]},
}
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
service_mock.resolve_form_inputs.return_value = [resolved_input]
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.get)
app_model = _app()
with app.test_request_context("/form/human_input/token-1", method="GET"):
response = handler(api, app_model=app_model, form_token="token-1")
payload = json.loads(response.get_data(as_text=True))
assert payload["inputs"][0]["option_source"]["value"] == ["approve", "reject"]
service_mock.resolve_form_inputs.assert_called_once_with(form)
def test_get_form_not_in_app(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine) -> None:
form = SimpleNamespace(
app_id="another-app",
tenant_id="tenant-1",
expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.get)
app_model = _app()
with app.test_request_context("/form/human_input/token-1", method="GET"):
with pytest.raises(NotFound):
handler(api, app_model=app_model, form_token="token-1")
@pytest.mark.parametrize(
"recipient_type",
[
RecipientType.CONSOLE,
RecipientType.BACKSTAGE,
RecipientType.EMAIL_MEMBER,
RecipientType.EMAIL_EXTERNAL,
],
)
def test_get_rejects_non_service_api_recipient_types(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
recipient_type: RecipientType,
) -> None:
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=recipient_type,
expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.get)
app_model = _app()
with app.test_request_context("/form/human_input/token-1", method="GET"):
with pytest.raises(NotFound):
handler(api, app_model=app_model, form_token="token-1")
service_mock.ensure_form_active.assert_not_called()
def test_post_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine) -> None:
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=RecipientType.STANDALONE_WEB_APP,
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
with app.test_request_context(
"/form/human_input/token-1",
method="POST",
json={"inputs": {"name": "Alice"}, "action": "approve", "user": "external-1"},
):
payload = HumanInputFormSubmitPayload.model_validate(request.get_json() or {})
response, status = handler(api, payload, app_model=app_model, end_user=end_user, form_token="token-1")
assert response == {}
assert status == 200
service_mock.submit_form_by_token.assert_called_once_with(
recipient_type=RecipientType.STANDALONE_WEB_APP,
form_token="token-1",
selected_action_id="approve",
form_data={"name": "Alice"},
submission_end_user_id="end-user-1",
)
def test_post_accepts_select_file_and_file_list_inputs(
self, app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine
) -> None:
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=RecipientType.STANDALONE_WEB_APP,
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
inputs = {
"decision": "approve",
"attachment": {
"transfer_method": "local_file",
"upload_file_id": "4e0d1b87-52f2-49f6-b8c6-95cd9c954b3e",
"type": "document",
},
"attachments": [
{
"transfer_method": "local_file",
"upload_file_id": "1a77f0df-c0e6-461c-987c-e72526f341ee",
"type": "document",
},
{
"transfer_method": "remote_url",
"url": "https://example.com/report.pdf",
"type": "document",
},
],
}
with app.test_request_context(
"/form/human_input/token-1",
method="POST",
json={"inputs": inputs, "action": "approve", "user": "external-1"},
):
payload = HumanInputFormSubmitPayload.model_validate(request.get_json() or {})
response, status = handler(api, payload, app_model=app_model, end_user=end_user, form_token="token-1")
assert response == {}
assert status == 200
service_mock.submit_form_by_token.assert_called_once_with(
recipient_type=RecipientType.STANDALONE_WEB_APP,
form_token="token-1",
selected_action_id="approve",
form_data=inputs,
submission_end_user_id="end-user-1",
)
def test_submit_payload_schema_documents_select_file_and_file_list_inputs(self) -> None:
schema = HumanInputFormSubmitPayload.model_json_schema()
inputs_schema = schema["properties"]["inputs"]
assert "select input" in inputs_schema["description"]
examples = inputs_schema["examples"]
assert examples[0]["decision"] == "approve"
assert examples[0]["attachment"]["transfer_method"] == "local_file"
assert examples[0]["attachment"]["upload_file_id"] == "4e0d1b87-52f2-49f6-b8c6-95cd9c954b3e"
assert examples[0]["attachments"][1]["transfer_method"] == "remote_url"
@pytest.mark.parametrize(
"recipient_type",
[
RecipientType.CONSOLE,
RecipientType.BACKSTAGE,
RecipientType.EMAIL_MEMBER,
RecipientType.EMAIL_EXTERNAL,
],
)
def test_post_rejects_non_service_api_recipient_types(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
recipient_type: RecipientType,
) -> None:
form = SimpleNamespace(
app_id="app-1",
tenant_id="tenant-1",
recipient_type=recipient_type,
)
service_mock = Mock()
service_mock.get_form_by_token.return_value = form
_configure_service(monkeypatch, service_mock, sqlite_engine)
api = WorkflowHumanInputFormApi()
handler = unwrap(api.post)
app_model = _app()
end_user = _end_user()
with app.test_request_context(
"/form/human_input/token-1",
method="POST",
json={"inputs": {"name": "Alice"}, "action": "approve", "user": "external-1"},
):
payload = HumanInputFormSubmitPayload.model_validate(request.get_json() or {})
with pytest.raises(NotFound):
handler(api, payload, app_model=app_model, end_user=end_user, form_token="token-1")
service_mock.submit_form_by_token.assert_not_called()
@@ -0,0 +1,783 @@
"""The existing Service API form contract applies to both HITL storage versions."""
import hashlib
import json
from collections.abc import Iterator
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from datetime import timedelta
from threading import Barrier
from typing import NoReturn
from uuid import uuid4
import pytest
import sqlalchemy as sa
from flask import Flask
from flask import request as flask_request
from flask.testing import FlaskClient
from flask_login import LoginManager
from flask_sqlalchemy import SQLAlchemy
from kombu.exceptions import OperationalError
from pydantic import JsonValue
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.exceptions import Unauthorized
from werkzeug.test import TestResponse
from controllers.service_api import wraps
from controllers.service_api.app import human_input_form as controller
from core.human_input import ButtonStyle
from core.human_input_v2.resolved_form import (
FileInput,
FileListInput,
ParagraphInput,
ResolvedForm,
SelectInput,
UserAction,
)
from core.human_input_v2.shared.values import TenantId
from core.workflow.nodes.human_input.entities import FormDefinition
from core.workflow.nodes.human_input.enums import HumanInputFormStatus
from core.workflow.nodes.human_input_v2.entities import Initiator
from extensions.ext_application_services import ApplicationServices
from extensions.storage.storage_type import StorageType
from graphon.enums import WorkflowExecutionStatus
from graphon.file.enums import FileTransferMethod, FileType
from graphon.variables.segments import ArrayFileSegment, FileSegment
from libs.datetime_utils import naive_utc_now
from libs.external_api import ExternalApi
from models.account import TenantAccountJoin, TenantAccountRole
from models.enums import CreatorUserRole, EndUserType, WorkflowRunTriggeredFrom
from models.human_input import HumanInputForm as LegacyForm
from models.human_input import HumanInputFormRecipient as LegacyRecipient
from models.human_input import RecipientType
from models.human_input_v2 import FormViewEvent, HumanInputAuditEvent, HumanInputDelivery, RecipientSubjectType
from models.human_input_v2 import HumanInputForm as V2Form
from models.human_input_v2 import HumanInputRecipient as V2Recipient
from models.model import ApiToken, ApiTokenType, AppMode, EndUser, UploadFile
from models.workflow import WorkflowPause, WorkflowRun, WorkflowType
from repositories.human_input_v2.delivery_repository import DeliveryCreateParams, InitiatorSnapshot, SubmissionAuthType
from repositories.human_input_v2.form_repository import FormCreateParams
from repositories.human_input_v2.recipient_repository import EndUserRecipientSubject, RecipientCreateParams
from repositories.human_input_v2.sqlalchemy_delivery_repository import SQLAlchemyDeliveryRepository
from repositories.human_input_v2.sqlalchemy_form_repository import SQLAlchemyFormRepository
from repositories.human_input_v2.sqlalchemy_recipient_repository import SQLAlchemyRecipientRepository
from tasks.app_generate.workflow_execute_task import resume_app_execution
from tests.helpers.unit.model_factories import make_account, make_app, make_tenant
_NOW = naive_utc_now().replace(microsecond=0)
_TOKEN = "service-approval-token"
_PATH = f"/v1/form/human_input/{_TOKEN}"
_HEADERS = {"Authorization": "Bearer test-app-key"}
_CONTENT = "Review {{#$output.note#}}: {{#$output.choice#}}"
_INPUTS: dict[str, JsonValue] = {"note": "Approved", "choice": "Yes"}
@dataclass
class Approval:
client: FlaskClient
sessions: sessionmaker[Session]
version: str
tenant_id: str
app_id: str
run_id: str
form_id: str
recipient_id: str
submitter_id: str
published: list[dict[str, object]]
def submit(self, *, inputs: dict[str, JsonValue], action: str = "approve", user: str = "reviewer") -> TestResponse:
return self.client.post(_PATH, headers=_HEADERS, json={"user": user, "action": action, "inputs": inputs})
def submission(self) -> dict[str, JsonValue] | None:
with self.sessions() as session:
if self.version == "1":
form = session.get(LegacyForm, self.form_id)
assert form is not None
return json.loads(form.submitted_data) if form.submitted_data is not None else None
form = session.get(V2Form, self.form_id)
assert form is not None
return json.loads(form.raw_submission_inputs) if form.raw_submission_inputs is not None else None
@pytest.fixture(scope="module")
def service_app() -> Flask:
"""One app with the service API namespace, which takes a few hundred milliseconds to mount.
Each test binds its own SQLite engine to the app for the duration of that test.
"""
application_http = Flask(__name__)
LoginManager().init_app(application_http)
ExternalApi(application_http, register_default_root=False).add_namespace(controller.service_api_ns, path="/v1")
return application_http
@pytest.fixture(params=["1", "2"])
def approval(
service_app: Flask,
sqlite_session_factory: sessionmaker[Session],
sqlite_engine: Engine,
monkeypatch: pytest.MonkeyPatch,
request: pytest.FixtureRequest,
account_application_services: ApplicationServices,
) -> Iterator[Approval]:
version = request.param
tenant = make_tenant(tenant_id=str(uuid4()))
owner = make_account(account_id=str(uuid4()))
application = make_app(app_id=str(uuid4()), tenant_id=tenant.id, mode=AppMode.WORKFLOW)
initiator = EndUser(
id=str(uuid4()),
tenant_id=tenant.id,
app_id=application.id,
type=EndUserType.SERVICE_API,
external_user_id="initiator",
session_id="initiator",
)
submitter = EndUser(
id=str(uuid4()),
tenant_id=tenant.id,
app_id=application.id,
type=EndUserType.SERVICE_API,
external_user_id="reviewer",
session_id="reviewer",
)
run = WorkflowRun(
id=str(uuid4()),
tenant_id=tenant.id,
app_id=application.id,
workflow_id=str(uuid4()),
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
version="1",
status=WorkflowExecutionStatus.PAUSED,
created_by_role=CreatorUserRole.END_USER,
created_by=initiator.id,
)
with sqlite_session_factory.begin() as session:
session.add_all([tenant, owner, application, initiator, submitter, run])
session.add(TenantAccountJoin(tenant_id=tenant.id, account_id=owner.id, role=TenantAccountRole.OWNER))
if version == "1":
definition = FormDefinition.model_validate(
{
"form_content": _CONTENT,
"rendered_content": _CONTENT,
"inputs": [
{
"type": "paragraph",
"output_variable_name": "note",
"default": {"type": "constant", "value": "Draft"},
},
{
"type": "select",
"output_variable_name": "choice",
"option_source": {"type": "constant", "value": ["Yes", "No"]},
},
],
"default_values": {"note": "Draft"},
"expiration_time": _NOW + timedelta(hours=1),
"user_actions": [{"id": "approve", "title": "Approve", "button_style": "primary"}],
}
)
legacy = LegacyForm(
id=str(uuid4()),
tenant_id=tenant.id,
app_id=application.id,
workflow_run_id=run.id,
node_id="approval",
form_definition=definition.model_dump_json(),
rendered_content=_CONTENT,
expiration_time=_NOW + timedelta(hours=1),
created_at=_NOW,
)
recipient = LegacyRecipient(
id=str(uuid4()),
form_id=legacy.id,
delivery_id=str(uuid4()),
recipient_type=RecipientType.STANDALONE_WEB_APP,
recipient_payload='{"TYPE":"standalone_web_app"}',
access_token=_TOKEN,
)
session.add_all([legacy, recipient])
form_id, recipient_id = legacy.id, recipient.id
else:
form = SQLAlchemyFormRepository(session, TenantId(tenant.id), application.id).create_form(
FormCreateParams(
workflow_run_id=run.id,
node_execution_id=str(uuid4()),
expiration_time=_NOW + timedelta(hours=1),
global_timeout_deadline=_NOW + timedelta(hours=2),
resolved_form=ResolvedForm(
title="Review",
legacy_form_content=_CONTENT,
parts=(
ParagraphInput(output_variable_name="note", default_value="Draft"),
SelectInput(output_variable_name="choice", options=("Yes", "No"), default_value=None),
),
actions=(UserAction(id="approve", title="Approve", button_style=ButtonStyle.PRIMARY),),
),
)
)
v2_recipient = SQLAlchemyRecipientRepository(session, form.tenant_id, form.id).create_recipients(
[
RecipientCreateParams(
subject=EndUserRecipientSubject(initiator.id), sources=(Initiator(),), name=None
)
]
)[0]
SQLAlchemyDeliveryRepository(session).create_delivery(
tenant_id=form.tenant_id,
form_id=form.id,
params=DeliveryCreateParams(
recipient_id=v2_recipient.id,
token_hash=hashlib.sha256(_TOKEN.encode()).hexdigest(),
auth_type=SubmissionAuthType.WEB_APP,
target_snapshot=InitiatorSnapshot(protected_form_token="unused-by-token-lookup"),
),
)
session.add(
WorkflowPause(workflow_id=run.workflow_id, workflow_run_id=run.id, state_object_key="checkpoint")
)
form_id, recipient_id = form.id, str(v2_recipient.id)
database_sessions = scoped_session(sqlite_session_factory)
database = SQLAlchemy()
monkeypatch.setattr(database, "session", database_sessions)
monkeypatch.setattr(wraps, "db", database)
monkeypatch.setattr(controller, "db", database)
def authenticate(_token_type: str) -> ApiToken:
if flask_request.headers.get("Authorization") != _HEADERS["Authorization"]:
raise Unauthorized("Invalid API token")
return ApiToken(app_id=application.id, type=ApiTokenType.APP, token="test-app-key")
def get_end_user(tenant_id: str, app_id: str, external_user_id: str | None) -> EndUser:
with sqlite_session_factory() as session:
end_user = session.scalar(
sa.select(EndUser).where(
EndUser.tenant_id == tenant_id,
EndUser.app_id == app_id,
EndUser.external_user_id == external_user_id,
)
)
assert end_user is not None
return end_user
monkeypatch.setattr(wraps, "validate_and_get_api_token", authenticate)
monkeypatch.setattr(
account_application_services.app_scoped_end_users.commands, "get_or_create_end_user", get_end_user
)
monkeypatch.setattr(
wraps,
"application_services",
lambda: account_application_services,
)
monkeypatch.setattr("services.human_input_service.naive_utc_now", lambda: _NOW)
monkeypatch.setattr("services.human_input_v2.submission_service.naive_utc_now", lambda: _NOW)
published: list[dict[str, object]] = []
def publish(*, kwargs: dict[str, object]) -> None:
with sqlite_session_factory() as session:
model = session.get(LegacyForm, form_id) if version == "1" else session.get(V2Form, form_id)
assert model is not None
assert model.status == HumanInputFormStatus.SUBMITTED
published.append(kwargs)
monkeypatch.setattr(resume_app_execution, "apply_async", publish)
monkeypatch.setitem(database._app_engines, service_app, {None: sqlite_engine})
yield Approval(
service_app.test_client(),
sqlite_session_factory,
version,
tenant.id,
application.id,
run.id,
form_id,
recipient_id,
submitter.id,
published,
)
database_sessions.remove()
@pytest.mark.parametrize(("remote_address", "expected_ip"), [("127.0.0.1", "127.0.0.1"), (None, None), ("", None)])
def test_get_without_user_returns_the_existing_form_definition(
approval: Approval, remote_address: str | None, expected_ip: str | None
) -> None:
response = approval.client.get(_PATH, headers=_HEADERS, environ_overrides={"REMOTE_ADDR": remote_address})
assert response.status_code == 200, response.json
assert response.json == {
"form_content": _CONTENT,
"inputs": [
{
"type": "paragraph",
"output_variable_name": "note",
"default": {"type": "constant", "selector": [], "value": "Draft"},
},
{
"type": "select",
"output_variable_name": "choice",
"option_source": {"type": "constant", "selector": [], "value": ["Yes", "No"]},
},
],
"resolved_default_values": {"note": "Draft"},
"user_actions": [{"id": "approve", "title": "Approve", "button_style": "primary"}],
"expiration_time": int((_NOW + timedelta(hours=1)).timestamp()),
}
assert approval.submission() is None
assert approval.published == []
with approval.sessions() as session:
audits = list(session.scalars(sa.select(HumanInputAuditEvent)))
if approval.version == "1":
assert audits == []
else:
assert len(audits) == 1
assert audits[0].tenant_id == approval.tenant_id
assert audits[0].form_id == approval.form_id
assert isinstance(audits[0].payload, FormViewEvent)
assert audits[0].payload.viewer_ip_address == expected_ip
@pytest.mark.parametrize("method", ["GET", "POST"])
def test_requires_an_app_api_token(approval: Approval, method: str) -> None:
response = approval.client.open(
_PATH, method=method, json={"user": "reviewer", "action": "approve", "inputs": _INPUTS}
)
assert response.status_code == 401
assert approval.submission() is None
def test_post_accepts_a_different_user_and_resumes_after_commit(approval: Approval) -> None:
response = approval.submit(inputs=_INPUTS)
assert response.status_code == 200, response.json
assert response.json == {}
assert approval.submission() == _INPUTS
assert approval.published == [{"payload": {"workflow_run_id": approval.run_id}}]
with approval.sessions() as session:
if approval.version == "1":
legacy = session.get(LegacyForm, approval.form_id)
assert legacy is not None
assert legacy.submission_end_user_id == approval.submitter_id
else:
audits = session.scalars(
sa.select(HumanInputAuditEvent).where(
HumanInputAuditEvent.tenant_id == approval.tenant_id,
HumanInputAuditEvent.form_id == approval.form_id,
)
).all()
assert [audit.payload.model_dump(mode="json") for audit in audits] == [
{
"type": "form_submission",
"recipient_id": approval.recipient_id,
"end_user_id": approval.submitter_id,
}
]
@pytest.mark.parametrize("note", [" Unchanged ", 123, False, None, {"detail": "approved"}, ["approved"]])
def test_preserves_paragraph_json_values_and_ignores_extra_input_fields(approval: Approval, note: JsonValue) -> None:
inputs: dict[str, JsonValue] = {"note": note, "choice": "Yes", "extra": {"metadata": True}}
response = approval.submit(inputs=inputs)
assert response.status_code == 200, response.json
assert approval.submission() == inputs
if approval.version == "2":
with approval.sessions() as session:
form = SQLAlchemyFormRepository(session, TenantId(approval.tenant_id), approval.app_id).get_form_by_id(
approval.form_id
)
assert form is not None
assert form.submission is not None
assert {
name: segment.to_object() for name, segment in form.submission.normalized_submission_data.items()
} == {
"note": note,
"choice": "Yes",
}
@pytest.mark.parametrize("approval", ["1"], indirect=True)
@pytest.mark.parametrize(
("note", "rendered_note"),
[
(" Unchanged ", " Unchanged "),
(123, "123"),
(False, "False"),
(None, ""),
({"detail": "approved"}, "{'detail': 'approved'}"),
(["approved"], "['approved']"),
],
)
def test_v1_json_paragraph_submission_resumes_the_node(approval: Approval, note: JsonValue, rendered_note: str) -> None:
from core.repositories.human_input_repository import HumanInputFormRepositoryImpl
from core.workflow.nodes.human_input.callback import DifyHITLCallback
from core.workflow.nodes.human_input.constants import OUTPUT_FIELD_RENDERED_CONTENT
from core.workflow.nodes.human_input.entities import HumanInputNodeData
from graphon.engine_events import NodeRunSucceededEvent
from graphon.enums import WorkflowNodeExecutionStatus
from graphon.nodes.human_input.entities import HumanInputNodeData as GraphHumanInputNodeData
from graphon.nodes.human_input.human_input_node import HumanInputNode
from graphon.runtime import RuntimeState, VariablePool
from graphon.runtime.init_params import InitParams
response = approval.submit(inputs={"note": note, "choice": "Yes"})
assert response.status_code == 200, response.json
with approval.sessions() as session:
form = session.get(LegacyForm, approval.form_id)
assert form is not None
definition = FormDefinition.model_validate_json(form.form_definition)
node_data = HumanInputNodeData(
title="Review",
form_content=definition.form_content,
inputs=definition.inputs,
user_actions=definition.user_actions,
)
repository = HumanInputFormRepositoryImpl(
tenant_id=approval.tenant_id, app_id=approval.app_id, workflow_execution_id=approval.run_id
)
node = HumanInputNode(
node_id="approval",
data=GraphHumanInputNodeData.model_validate(node_data.model_dump()),
init_params=InitParams(
workflow_id="workflow-1", graph_config={}, run_context={"workflow_run_id": approval.run_id}, call_depth=0
),
runtime_state=RuntimeState(workflow_id="workflow-1", variable_pool=VariablePool(), start_at=0),
hitl_callback=DifyHITLCallback(
form_repository=repository, node_data=node_data, workflow_execution_id=approval.run_id
),
)
node.bind_execution_id(approval.form_id)
event = list(node.run())[-1]
assert isinstance(event, NodeRunSucceededEvent)
completed = event.node_run_result
assert completed.status == WorkflowNodeExecutionStatus.SUCCEEDED
assert completed.edge_source_handle == "approve"
assert completed.outputs["note"].to_object() == note
assert completed.outputs[OUTPUT_FIELD_RENDERED_CONTENT].to_object() == f"Review {rendered_note}: Yes"
@pytest.mark.parametrize(
("action", "inputs"),
[
("unknown", _INPUTS),
("approve", {"note": "Approved"}),
("approve", {"note": "Approved", "choice": "unknown"}),
("approve", {"note": "Approved", "choice": 123}),
],
)
def test_invalid_form_data_does_not_submit_or_resume(
approval: Approval, action: str, inputs: dict[str, JsonValue]
) -> None:
response = approval.submit(inputs=inputs, action=action)
assert response.status_code == 400, response.json
assert response.json is not None
assert response.json["code"] == "invalid_form_data"
assert approval.submission() is None
assert approval.published == []
def test_post_requires_user(approval: Approval) -> None:
response = approval.client.post(_PATH, headers=_HEADERS, json={"action": "approve", "inputs": _INPUTS})
assert response.status_code == 400
assert approval.submission() is None
def test_post_ignores_additional_request_fields(approval: Approval) -> None:
response = approval.client.post(
_PATH,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS, "metadata": {"client": "legacy-sdk"}},
)
assert response.status_code == 200, response.json
assert response.json == {}
def test_accepted_submission_stays_successful_when_the_resume_broker_is_unavailable(
approval: Approval,
monkeypatch: pytest.MonkeyPatch,
) -> None:
def reject_enqueue(**_kwargs: object) -> NoReturn:
raise OperationalError("Broker unavailable")
monkeypatch.setattr(resume_app_execution, "apply_async", reject_enqueue)
response = approval.submit(inputs=_INPUTS)
assert response.status_code == 200, response.json
assert response.json == {}
assert approval.submission() == _INPUTS
def test_duplicate_submission_preserves_first_response_and_returns_412(approval: Approval) -> None:
assert approval.submit(inputs=_INPUTS).status_code == 200
response = approval.submit(inputs={"note": "Changed", "choice": "No"}, user="initiator")
assert response.status_code == 412, response.json
assert response.json is not None
assert response.json["code"] == "human_input_form_submitted"
assert approval.submission() == _INPUTS
assert len(approval.published) == 1
read = approval.client.get(_PATH, headers=_HEADERS)
assert read.status_code == 412
assert read.json is not None
assert read.json["code"] == "human_input_form_submitted"
@pytest.mark.parametrize("method", ["GET", "POST"])
def test_unknown_token_returns_not_found(approval: Approval, method: str) -> None:
response = approval.client.open(
"/v1/form/human_input/unknown",
method=method,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS},
)
assert response.status_code == 404
assert response.json is not None
assert response.json["code"] == "not_found"
@pytest.mark.parametrize("method", ["GET", "POST"])
@pytest.mark.parametrize("owner", ["tenant_id", "app_id"])
def test_rejects_forms_outside_the_authenticated_application(approval: Approval, method: str, owner: str) -> None:
model = LegacyForm if approval.version == "1" else V2Form
with approval.sessions.begin() as session:
session.execute(sa.update(model).where(model.id == approval.form_id).values({owner: str(uuid4())}))
response = approval.client.open(
_PATH,
method=method,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS},
)
assert response.status_code == 404
assert approval.submission() is None
assert approval.published == []
@pytest.mark.parametrize("method", ["GET", "POST"])
@pytest.mark.parametrize("expiration", ["node", "global", "timeout", "expired"])
def test_expired_forms_return_412_without_submission(approval: Approval, method: str, expiration: str) -> None:
model = LegacyForm if approval.version == "1" else V2Form
with approval.sessions.begin() as session:
updates: dict[str, object]
match expiration:
case "node":
updates = {"expiration_time": _NOW}
case "global":
updates = (
{"created_at": _NOW - timedelta(days=365)}
if approval.version == "1"
else {"global_timeout_deadline": _NOW}
)
case "timeout":
updates = {"status": HumanInputFormStatus.TIMEOUT}
case _:
updates = {"status": HumanInputFormStatus.EXPIRED}
session.execute(sa.update(model).where(model.id == approval.form_id).values(updates))
response = approval.client.open(
_PATH,
method=method,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS},
)
assert response.status_code == 412, response.json
assert response.json is not None
assert response.json["code"] == "human_input_form_expired"
assert approval.submission() is None
assert approval.published == []
@pytest.mark.parametrize("method", ["GET", "POST"])
def test_rejects_console_recipient_tokens(approval: Approval, method: str) -> None:
with approval.sessions.begin() as session:
if approval.version == "1":
session.execute(
sa.update(LegacyRecipient)
.where(LegacyRecipient.id == approval.recipient_id)
.values(
recipient_type=RecipientType.CONSOLE,
recipient_payload='{"TYPE":"console"}',
)
)
else:
session.execute(
sa.update(V2Recipient)
.where(V2Recipient.id == approval.recipient_id)
.values(
subject_type=RecipientSubjectType.CONTACT,
subject_value=str(uuid4()),
)
)
response = approval.client.open(
_PATH,
method=method,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS},
)
assert response.status_code == 404
assert approval.submission() is None
assert approval.published == []
def test_submits_existing_upload_references_for_file_and_file_list_inputs(approval: Approval) -> None:
upload = UploadFile(
tenant_id=approval.tenant_id,
storage_type=StorageType.LOCAL,
key="approval/report.txt",
name="report.txt",
size=8,
extension="txt",
mime_type="text/plain",
created_by_role=CreatorUserRole.END_USER,
created_by=approval.submitter_id,
created_at=_NOW,
used=False,
)
file_parts = (
FileInput(
output_variable_name="attachment",
allowed_file_types=(FileType.DOCUMENT,),
allowed_file_extensions=(".txt",),
allowed_file_upload_methods=(FileTransferMethod.LOCAL_FILE,),
),
FileListInput(
output_variable_name="attachments",
allowed_file_types=(FileType.DOCUMENT,),
allowed_file_extensions=(".txt",),
allowed_file_upload_methods=(FileTransferMethod.LOCAL_FILE,),
number_limits=2,
),
)
with approval.sessions.begin() as session:
session.add(upload)
if approval.version == "1":
legacy = session.get(LegacyForm, approval.form_id)
assert legacy is not None
definition = json.loads(legacy.form_definition)
definition["inputs"].extend(
[
{
"type": "file",
"output_variable_name": "attachment",
"allowed_file_types": ["document"],
"allowed_file_extensions": [".txt"],
"allowed_file_upload_methods": ["local_file"],
},
{
"type": "file-list",
"output_variable_name": "attachments",
"allowed_file_types": ["document"],
"allowed_file_extensions": [".txt"],
"allowed_file_upload_methods": ["local_file"],
"number_limits": 2,
},
]
)
legacy.form_definition = json.dumps(definition)
else:
form = session.get(V2Form, approval.form_id)
assert form is not None
form.resolved_form = form.resolved_form.model_copy(
update={"parts": (*form.resolved_form.parts, *file_parts)}
)
mapping: dict[str, JsonValue] = {"transfer_method": "local_file", "upload_file_id": upload.id, "type": "document"}
response = approval.submit(inputs={**_INPUTS, "attachment": mapping, "attachments": [mapping]})
assert response.status_code == 200, response.json
assert response.json == {}
with approval.sessions() as session:
if approval.version == "1":
legacy = session.get(LegacyForm, approval.form_id)
assert legacy is not None
assert legacy.submitted_data is not None
submitted = json.loads(legacy.submitted_data)
assert submitted["attachment"]["related_id"] == upload.id
assert submitted["attachments"][0]["related_id"] == upload.id
else:
form_snapshot = SQLAlchemyFormRepository(
session, TenantId(approval.tenant_id), approval.app_id
).get_form_by_id(approval.form_id)
assert form_snapshot is not None
assert form_snapshot.submission is not None
attachment = form_snapshot.submission.normalized_submission_data["attachment"]
attachments = form_snapshot.submission.normalized_submission_data["attachments"]
assert isinstance(attachment, FileSegment)
assert attachment.value.related_id == upload.id
assert isinstance(attachments, ArrayFileSegment)
assert attachments.value[0].related_id == upload.id
assert len(approval.published) == 1
@pytest.mark.parametrize("approval", ["2"], indirect=True)
@pytest.mark.parametrize("method", ["GET", "POST"])
@pytest.mark.parametrize("auth_type", [SubmissionAuthType.CONSOLE, SubmissionAuthType.EMAIL_OTP, SubmissionAuthType.IM])
def test_v2_rejects_tokens_from_other_authentication_surfaces(
approval: Approval,
method: str,
auth_type: SubmissionAuthType,
) -> None:
with approval.sessions.begin() as session:
session.execute(
sa.update(HumanInputDelivery)
.where(HumanInputDelivery.form_id == approval.form_id)
.values(
auth_type=auth_type,
)
)
response = approval.client.open(
_PATH,
method=method,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": _INPUTS},
)
assert response.status_code == 404
assert approval.submission() is None
assert approval.published == []
@pytest.mark.parametrize("approval", ["2"], indirect=True)
@pytest.mark.parametrize("checkpoint", ["missing", "resumed", "run_not_paused"])
def test_v2_requires_an_active_paused_workflow_before_accepting_submission(approval: Approval, checkpoint: str) -> None:
with approval.sessions.begin() as session:
match checkpoint:
case "missing":
session.execute(sa.delete(WorkflowPause).where(WorkflowPause.workflow_run_id == approval.run_id))
case "resumed":
session.execute(
sa.update(WorkflowPause)
.where(WorkflowPause.workflow_run_id == approval.run_id)
.values(
resumed_at=_NOW,
)
)
case _:
session.execute(
sa.update(WorkflowRun)
.where(WorkflowRun.id == approval.run_id)
.values(
status=WorkflowExecutionStatus.RUNNING,
)
)
response = approval.submit(inputs=_INPUTS)
assert response.status_code == 400, response.json
assert response.json is not None
assert response.json["code"] == "bad_request"
assert approval.submission() is None
assert approval.published == []
with approval.sessions() as session:
assert session.scalar(sa.select(sa.func.count()).select_from(HumanInputAuditEvent)) == 0
@pytest.mark.parametrize("approval", ["2"], indirect=True)
def test_concurrent_v2_submissions_accept_only_one_response(approval: Approval) -> None:
ready = Barrier(2)
def submit(note: str) -> int:
ready.wait(timeout=10)
with approval.client.application.test_client() as client:
response = client.post(
_PATH,
headers=_HEADERS,
json={"user": "reviewer", "action": "approve", "inputs": {"note": note, "choice": "Yes"}},
)
return response.status_code
with ThreadPoolExecutor(max_workers=2) as executor:
statuses = list(executor.map(submit, ["First", "Second"]))
assert sorted(statuses) == [200, 412]
assert len(approval.published) == 1
with approval.sessions() as session:
assert session.scalar(sa.select(sa.func.count()).select_from(HumanInputAuditEvent)) == 1
@@ -0,0 +1,203 @@
"""Request model and error-type validation for Service API message endpoints."""
import uuid
import pytest
from controllers.service_api.app.error import NotChatAppError
from controllers.service_api.app.message import (
FeedbackListQuery,
MessageFeedbackPayload,
MessageListQuery,
)
from models.model import AppMode
from services.errors.message import (
FirstMessageNotExistsError,
MessageNotExistsError,
SuggestedQuestionsAfterAnswerDisabledError,
)
class TestMessageListQuery:
"""Test suite for MessageListQuery Pydantic model."""
def test_query_requires_conversation_id(self) -> None:
"""Test conversation_id is required."""
conversation_id = str(uuid.uuid4())
query = MessageListQuery(conversation_id=conversation_id)
assert query.conversation_id == conversation_id
def test_query_with_defaults(self) -> None:
"""Test query with default values."""
conversation_id = str(uuid.uuid4())
query = MessageListQuery(conversation_id=conversation_id)
assert query.first_id is None
assert query.limit == 20
def test_query_with_first_id(self) -> None:
"""Test query with first_id for pagination."""
conversation_id = str(uuid.uuid4())
first_id = str(uuid.uuid4())
query = MessageListQuery(conversation_id=conversation_id, first_id=first_id)
assert str(query.first_id) == first_id
def test_query_with_custom_limit(self) -> None:
"""Test query with custom limit."""
conversation_id = str(uuid.uuid4())
query = MessageListQuery(conversation_id=conversation_id, limit=50)
assert query.limit == 50
def test_query_limit_boundaries(self) -> None:
"""Test query respects limit boundaries."""
conversation_id = str(uuid.uuid4())
query_min = MessageListQuery(conversation_id=conversation_id, limit=1)
assert query_min.limit == 1
query_max = MessageListQuery(conversation_id=conversation_id, limit=100)
assert query_max.limit == 100
def test_query_rejects_limit_below_minimum(self) -> None:
"""Test query rejects limit < 1."""
conversation_id = str(uuid.uuid4())
with pytest.raises(ValueError, match="1 validation error for MessageListQuery\\\nlimit"):
MessageListQuery(conversation_id=conversation_id, limit=0) # pyrefly: ignore[bad-argument-type]
def test_query_rejects_limit_above_maximum(self) -> None:
"""Test query rejects limit > 100."""
conversation_id = str(uuid.uuid4())
with pytest.raises(ValueError, match="1 validation error for MessageListQuery\\\nlimit"):
MessageListQuery(conversation_id=conversation_id, limit=101) # pyrefly: ignore[bad-argument-type]
class TestMessageFeedbackPayload:
"""Test suite for MessageFeedbackPayload Pydantic model."""
def test_payload_with_defaults(self) -> None:
"""Test payload with default values."""
payload = MessageFeedbackPayload()
assert payload.rating is None
assert payload.content is None
def test_payload_with_like_rating(self) -> None:
"""Test payload with like rating."""
payload = MessageFeedbackPayload(rating="like")
assert payload.rating == "like"
def test_payload_with_dislike_rating(self) -> None:
"""Test payload with dislike rating."""
payload = MessageFeedbackPayload(rating="dislike")
assert payload.rating == "dislike"
def test_payload_with_content_only(self) -> None:
"""Test payload with content but no rating."""
payload = MessageFeedbackPayload(content="This response was helpful")
assert payload.content == "This response was helpful"
assert payload.rating is None
def test_payload_with_rating_and_content(self) -> None:
"""Test payload with both rating and content."""
payload = MessageFeedbackPayload(rating="like", content="Great answer, very detailed!")
assert payload.rating == "like"
assert payload.content == "Great answer, very detailed!"
def test_payload_with_long_content(self) -> None:
"""Test payload with long feedback content."""
long_content = "A" * 1000
payload = MessageFeedbackPayload(content=long_content)
assert payload.content is not None
assert len(payload.content) == 1000
def test_payload_with_unicode_content(self) -> None:
"""Test payload with unicode characters."""
unicode_content = "很好的回答 👍 Отличный ответ"
payload = MessageFeedbackPayload(content=unicode_content)
assert payload.content == unicode_content
class TestFeedbackListQuery:
"""Test suite for FeedbackListQuery Pydantic model."""
def test_query_with_defaults(self) -> None:
"""Test query with default values."""
query = FeedbackListQuery()
assert query.page == 1
assert query.limit == 20
def test_query_with_custom_pagination(self) -> None:
"""Test query with custom page and limit."""
query = FeedbackListQuery(page=3, limit=50)
assert query.page == 3
assert query.limit == 50
def test_query_page_minimum(self) -> None:
"""Test query page minimum validation."""
query = FeedbackListQuery(page=1)
assert query.page == 1
def test_query_rejects_page_below_minimum(self) -> None:
"""Test query rejects page < 1."""
with pytest.raises(ValueError, match="1 validation error for FeedbackListQuery\\\npage"):
FeedbackListQuery(page=0) # pyrefly: ignore[bad-argument-type]
def test_query_limit_boundaries(self) -> None:
"""Test query limit boundaries."""
query_min = FeedbackListQuery(limit=1)
assert query_min.limit == 1
query_max = FeedbackListQuery(limit=101)
assert query_max.limit == 101 # Max is 101
def test_query_rejects_limit_below_minimum(self) -> None:
"""Test query rejects limit < 1."""
with pytest.raises(ValueError, match="1 validation error for FeedbackListQuery\\\nlimit"):
FeedbackListQuery(limit=0) # pyrefly: ignore[bad-argument-type]
def test_query_rejects_limit_above_maximum(self) -> None:
"""Test query rejects limit > 101."""
with pytest.raises(ValueError, match="1 validation error for FeedbackListQuery\\\nlimit"):
FeedbackListQuery(limit=102) # pyrefly: ignore[bad-argument-type]
class TestMessageAppModeValidation:
"""Test app mode validation for message endpoints."""
def test_chat_modes_are_valid_for_message_endpoints(self) -> None:
"""Test that all chat modes are valid."""
valid_modes = {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
for mode in valid_modes:
assert mode in valid_modes
def test_completion_mode_is_invalid_for_message_endpoints(self) -> None:
"""Test that COMPLETION mode is invalid."""
chat_modes = {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
assert AppMode.COMPLETION not in chat_modes
def test_workflow_mode_is_invalid_for_message_endpoints(self) -> None:
"""Test that WORKFLOW mode is invalid."""
chat_modes = {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}
assert AppMode.WORKFLOW not in chat_modes
def test_not_chat_app_error_can_be_raised(self) -> None:
"""Test NotChatAppError can be raised."""
error = NotChatAppError()
assert error is not None
class TestMessageErrorTypes:
"""Test message-related error types."""
def test_message_not_exists_error_can_be_raised(self) -> None:
"""Test MessageNotExistsError can be raised."""
error = MessageNotExistsError()
assert isinstance(error, MessageNotExistsError)
def test_first_message_not_exists_error_can_be_raised(self) -> None:
"""Test FirstMessageNotExistsError can be raised."""
error = FirstMessageNotExistsError()
assert isinstance(error, FirstMessageNotExistsError)
def test_suggested_questions_after_answer_disabled_error_can_be_raised(self) -> None:
"""Test SuggestedQuestionsAfterAnswerDisabledError can be raised."""
error = SuggestedQuestionsAfterAnswerDisabledError()
assert isinstance(error, SuggestedQuestionsAfterAnswerDisabledError)
@@ -0,0 +1,943 @@
import json
import sys
import uuid
from collections.abc import Callable
from datetime import UTC, datetime
from inspect import unwrap
from types import SimpleNamespace
from typing import Literal
from unittest.mock import MagicMock, Mock
import httpx
import pytest
from flask import Flask
from pytest_mock import MockerFixture
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import BadRequest, NotFound
from controllers.service_api.app.error import (
CompletionRequestError,
NotWorkflowAppError,
TriggerWorkflowServiceModeUnavailableError,
WorkflowVersionExecutionNotAllowedError,
)
from controllers.service_api.app.workflow import (
WorkflowAppLogApi,
WorkflowLogQuery,
WorkflowRunApi,
WorkflowRunByIdApi,
WorkflowRunDetailApi,
WorkflowRunPayload,
WorkflowRunResponse,
WorkflowTaskStopApi,
)
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from enums import CloudPlan, DeploymentEdition
from graphon.enums import WorkflowExecutionStatus
from graphon.model_runtime.errors.invoke import InvokeRateLimitError as ProviderInvokeRateLimitError
from libs.helper import dump_response
from models import Account
from models.enums import CreatorUserRole, WorkflowRunTriggeredFrom
from models.model import App, AppMode, EndUser
from models.workflow import WorkflowAppLog, WorkflowAppLogCreatedFrom, WorkflowRun, WorkflowType
from repositories.workflow_app_log_query_repository import WorkflowAppLogQueryRepository
from services.app_generate_service import AppGenerateService
from services.billing_client import transport
from services.billing_service import BillingService
from services.errors.app import (
IsDraftWorkflowError,
WorkflowNotFoundError,
)
from services.errors.app import (
TriggerWorkflowServiceModeUnavailableError as TriggerWorkflowServiceModeUnavailableServiceError,
)
from services.errors.billing import BillingUpstreamInvalidResponseError
from services.errors.llm import InvokeRateLimitError
from services.workflow_app_log_query_service import WorkflowAppLogQueryService
from tests.helpers import billing_builders as builders
"""
Unit tests for Service API Workflow controllers.
Tests coverage for:
- WorkflowRunPayload and WorkflowLogQuery Pydantic models
- Workflow execution error handling
- App mode validation for workflow endpoints
- Workflow stop mechanism validation
Focus on:
- Pydantic model validation
- Error type mappings
- Service method interfaces
"""
def _default_workflow_inputs() -> dict[str, object]:
return {"input": "value"}
def _make_workflow_run(
run_id: str = "run-1",
*,
tenant_id: str = "tenant-1",
app_id: str = "app-1",
workflow_id: str = "wf-1",
inputs: dict[str, object] | None = None,
outputs: dict[str, object] | None = None,
created_at: datetime | None = None,
finished_at: datetime | None = None,
) -> WorkflowRun:
workflow_run = WorkflowRun(
id=run_id,
tenant_id=tenant_id,
app_id=app_id,
workflow_id=workflow_id,
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
version="2026-01-01",
graph=json.dumps({"nodes": [], "edges": []}),
inputs=json.dumps(inputs if inputs is not None else _default_workflow_inputs()),
outputs=json.dumps(outputs if outputs is not None else {"output": "value"}),
status=WorkflowExecutionStatus.SUCCEEDED,
error=None,
elapsed_time=0.1,
total_tokens=10,
total_steps=1,
created_by_role=CreatorUserRole.END_USER,
created_by="end-user-1",
finished_at=finished_at or datetime(2026, 1, 1, tzinfo=UTC),
exceptions_count=0,
)
workflow_run.created_at = created_at or datetime(2026, 1, 1, tzinfo=UTC)
return workflow_run
def _make_workflow_app_log(
*,
tenant_id: str = "tenant-1",
app_id: str = "app-1",
workflow_run_id: str = "log-run-1",
) -> WorkflowAppLog:
log = WorkflowAppLog(
tenant_id=tenant_id,
app_id=app_id,
workflow_id="wf-1",
workflow_run_id=workflow_run_id,
created_from=WorkflowAppLogCreatedFrom.SERVICE_API,
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
)
log.id = "app-log-1"
log.created_at = datetime(2026, 1, 1, 1, 0, 3, tzinfo=UTC)
return log
def _make_app_model(
*,
app_id: str = "app-1",
tenant_id: str = "tenant-1",
mode: AppMode = AppMode.WORKFLOW,
) -> App:
app = App()
app.id = app_id
app.tenant_id = tenant_id
app.mode = mode
return app
def _make_end_user(user_id: str = "end-user-1") -> EndUser:
end_user = EndUser()
end_user.id = user_id
return end_user
def _bind_sqlite_database(
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session: Session,
) -> None:
"""Bind controller- and model-owned database access to the test engine."""
database = SimpleNamespace(engine=sqlite_engine, session=sqlite_session)
monkeypatch.setattr(sys.modules["controllers.service_api.app.workflow"], "db", database)
monkeypatch.setattr(sys.modules["models.workflow"], "db", database)
def _persist_workflow_log(
sqlite_session: Session,
*,
tenant_id: str,
app_id: str,
) -> None:
workflow_run_id = "log-run-1"
account = Account(name="Log Account", email="log-account@example.com")
account.id = "account-1"
sqlite_session.add_all(
[
account,
_make_workflow_run(
run_id=workflow_run_id,
tenant_id=tenant_id,
app_id=app_id,
created_at=datetime(2026, 1, 1, 1, tzinfo=UTC),
finished_at=datetime(2026, 1, 1, 1, 0, 2, tzinfo=UTC),
),
_make_workflow_app_log(
tenant_id=tenant_id,
app_id=app_id,
workflow_run_id=workflow_run_id,
),
]
)
sqlite_session.commit()
def _expected_workflow_log_pagination_payload() -> dict[str, object]:
return {
"page": 1,
"limit": 20,
"total": 1,
"has_more": False,
"data": [
{
"id": "app-log-1",
"workflow_run": {
"id": "log-run-1",
"version": "2026-01-01",
"status": "succeeded",
"triggered_from": "app-run",
"error": None,
"elapsed_time": 0.1,
"total_tokens": 10,
"total_steps": 1,
"created_at": int(datetime(2026, 1, 1, 1).timestamp()),
"finished_at": int(datetime(2026, 1, 1, 1, 0, 2).timestamp()),
"exceptions_count": 0,
},
"details": None,
"created_from": "service-api",
"created_by_role": "account",
"created_by_account": {
"id": "account-1",
"name": "Log Account",
"email": "log-account@example.com",
},
"created_by_end_user": None,
"created_at": int(datetime(2026, 1, 1, 1, 0, 3).timestamp()),
}
],
}
def _stub_workflow_app_logs(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
workflow_app_logs = MagicMock()
workflow_app_logs.list_logs.return_value = _expected_workflow_log_pagination_payload()
services = SimpleNamespace(workflow_app_logs=workflow_app_logs)
monkeypatch.setattr(
sys.modules["controllers.service_api.app.workflow"],
"application_services",
lambda: services,
)
return workflow_app_logs
class TestWorkflowCases:
class TestWorkflowRunPayload:
"""Test suite for WorkflowRunPayload Pydantic model."""
def test_payload_with_required_inputs(self) -> None:
"""Test payload with required inputs field."""
payload = WorkflowRunPayload(inputs={"key": "value"})
assert payload.inputs == {"key": "value"}
assert payload.files is None
assert payload.response_mode is None
def test_payload_with_all_fields(self) -> None:
"""Test payload with all fields populated."""
files = [{"type": "image", "url": "http://example.com/img.png"}]
payload = WorkflowRunPayload(
inputs={"param1": "value1", "param2": 123}, files=files, response_mode="streaming"
)
assert payload.inputs == {"param1": "value1", "param2": 123}
assert payload.files == files
assert payload.response_mode == "streaming"
def test_payload_response_mode_blocking(self) -> None:
"""Test payload with blocking response mode."""
payload = WorkflowRunPayload(inputs={}, response_mode="blocking")
assert payload.response_mode == "blocking"
def test_payload_with_complex_inputs(self) -> None:
"""Test payload with nested complex inputs."""
complex_inputs = {
"config": {"nested": {"value": 123}},
"items": ["item1", "item2"],
"metadata": {"key": "value"},
}
payload = WorkflowRunPayload(inputs=complex_inputs)
assert payload.inputs == complex_inputs
def test_payload_with_empty_inputs(self) -> None:
"""Test payload with empty inputs dict."""
payload = WorkflowRunPayload(inputs={})
assert payload.inputs == {}
def test_payload_with_multiple_files(self) -> None:
"""Test payload with multiple file attachments."""
files = [
{"type": "image", "url": "http://example.com/img1.png"},
{"type": "document", "upload_file_id": "file_123"},
{"type": "audio", "url": "http://example.com/audio.mp3"},
]
payload = WorkflowRunPayload(inputs={}, files=files)
assert payload.files is not None
assert len(payload.files) == 3
class TestWorkflowLogQuery:
"""Test suite for WorkflowLogQuery Pydantic model."""
def test_query_with_defaults(self) -> None:
"""Test query with default values."""
query = WorkflowLogQuery()
assert query.keyword is None
assert query.status is None
assert query.created_at__before is None
assert query.created_at__after is None
assert query.created_by_end_user_session_id is None
assert query.created_by_account is None
assert query.page == 1
assert query.limit == 20
def test_query_with_all_filters(self) -> None:
"""Test query with all filter fields populated."""
query = WorkflowLogQuery(
keyword="search term",
status="succeeded",
created_at__before="2024-01-15T10:00:00Z",
created_at__after="2024-01-01T00:00:00Z",
created_by_end_user_session_id="session_123",
created_by_account="user@example.com",
page=2,
limit=50,
)
assert query.keyword == "search term"
assert query.status == "succeeded"
assert query.created_at__before == "2024-01-15T10:00:00Z"
assert query.created_at__after == "2024-01-01T00:00:00Z"
assert query.created_by_end_user_session_id == "session_123"
assert query.created_by_account == "user@example.com"
assert query.page == 2
assert query.limit == 50
@pytest.mark.parametrize("status", ["succeeded", "failed", "stopped"])
def test_query_valid_status_values(self, status: Literal["succeeded", "failed", "stopped"]) -> None:
"""Test all valid status values."""
query = WorkflowLogQuery(status=status)
assert query.status == status
def test_query_pagination_limits(self) -> None:
"""Test query pagination boundaries."""
query_min_page = WorkflowLogQuery(page=1)
assert query_min_page.page == 1
query_max_page = WorkflowLogQuery(page=99999)
assert query_max_page.page == 99999
query_min_limit = WorkflowLogQuery(limit=1)
assert query_min_limit.limit == 1
query_max_limit = WorkflowLogQuery(limit=100)
assert query_max_limit.limit == 100
def test_query_with_keyword_search(self) -> None:
"""Test query with keyword filter."""
query = WorkflowLogQuery(keyword="workflow execution")
assert query.keyword == "workflow execution"
def test_query_with_date_filters(self) -> None:
"""Test query with before/after date filters."""
query = WorkflowLogQuery(
created_at__before="2024-12-31T23:59:59Z", created_at__after="2024-01-01T00:00:00Z"
)
assert query.created_at__before == "2024-12-31T23:59:59Z"
assert query.created_at__after == "2024-01-01T00:00:00Z"
class TestWorkflowRunResponse:
def test_validates_workflow_run_object_shape_and_clears_paused_outputs(self) -> None:
run = _make_workflow_run(run_id="run-paused")
run.status = WorkflowExecutionStatus.PAUSED
run.outputs = json.dumps({"should": "not leak"})
result = WorkflowRunResponse.model_validate(run, from_attributes=True).model_dump(mode="json")
assert result == {
"id": "run-paused",
"workflow_id": "wf-1",
"status": "paused",
"inputs": '{"input": "value"}',
"outputs": {},
"error": None,
"total_steps": 1,
"total_tokens": 10,
"created_at": 1767225600,
"finished_at": 1767225600,
"elapsed_time": 0.1,
}
class TestWorkflowRunRepository:
"""Test workflow run repository interface."""
@pytest.mark.parametrize("sqlite_session", [(WorkflowRun,)], indirect=True)
def test_workflow_run_repository_get_by_id(self, sqlite_engine: Engine, sqlite_session: Session) -> None:
"""Test repository lookup against committed tenant-scoped state."""
run = _make_workflow_run(run_id=str(uuid.uuid4()))
sqlite_session.add(run)
sqlite_session.commit()
from repositories.factory import DifyAPIRepositoryFactory
repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(
sessionmaker(bind=sqlite_engine, expire_on_commit=False)
)
result = repo.get_workflow_run_by_id(tenant_id="tenant-1", app_id="app-1", run_id=run.id)
assert result is not None
assert result.id == run.id
assert repo.get_workflow_run_by_id(tenant_id="other-tenant", app_id="app-1", run_id=run.id) is None
class TestWorkflowRunDetailApi:
def test_not_workflow_app(self, app: Flask) -> None:
api = WorkflowRunDetailApi()
handler = unwrap(api.get)
app_model = _make_app_model(mode=AppMode.CHAT)
with app.test_request_context("/workflows/run/1", method="GET"):
with pytest.raises(NotWorkflowAppError):
handler(api, app_model=app_model, workflow_run_id="run")
@pytest.mark.parametrize("sqlite_session", [(WorkflowRun,)], indirect=True)
def test_success(
self,
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session: Session,
) -> None:
run = _make_workflow_run(run_id="run", tenant_id="t1", app_id="a1")
sqlite_session.add(run)
sqlite_session.commit()
_bind_sqlite_database(monkeypatch, sqlite_engine, sqlite_session)
api = WorkflowRunDetailApi()
handler = unwrap(api.get)
app_model = _make_app_model(app_id="a1", tenant_id="t1")
result = handler(api, app_model=app_model, workflow_run_id="run")
assert result["id"] == "run"
assert result["workflow_id"] == "wf-1"
assert result["status"] == "succeeded"
class TestWorkflowRunApi:
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_not_workflow_app(self, app: Flask, sqlite_session: Session) -> None:
api = WorkflowRunApi()
handler = unwrap(api.post)
app_model = _make_app_model(mode=AppMode.CHAT)
end_user = _make_end_user()
with app.test_request_context("/workflows/run", method="POST", json={"inputs": {}}):
with pytest.raises(NotWorkflowAppError):
handler(api, session=sqlite_session, app_model=app_model, end_user=end_user)
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
@pytest.mark.parametrize("api_class", [WorkflowRunApi, WorkflowRunByIdApi])
@pytest.mark.parametrize(
("source_error", "http_error", "status_code", "error_code"),
[
pytest.param(InvokeRateLimitError, InvokeRateLimitHttpError, 429, "rate_limit_error", id="cloud-quota"),
pytest.param(
ProviderInvokeRateLimitError, CompletionRequestError, 400, "completion_request_error", id="provider"
),
],
)
def test_maps_rate_limits_by_source(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
sqlite_session: Session,
config_overrides: Callable[..., None],
api_class: type[WorkflowRunApi | WorkflowRunByIdApi],
source_error: type[InvokeRateLimitError | ProviderInvokeRateLimitError],
http_error: type[InvokeRateLimitHttpError | CompletionRequestError],
status_code: int,
error_code: str,
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
mocker.patch.object(BillingService, "get_info", return_value=builders.subscription_info("professional"))
generate = Mock(side_effect=source_error("rate limit reached"))
monkeypatch.setattr(AppGenerateService, "generate", generate)
api = api_class()
handler = unwrap(api.post)
app_model = _make_app_model()
end_user = _make_end_user()
kwargs: dict[str, str] = {"workflow_id": str(uuid.uuid4())} if isinstance(api, WorkflowRunByIdApi) else {}
with app.test_request_context(
"/workflows/run", method="POST", json={"inputs": {}, "response_mode": "blocking"}
):
with pytest.raises(http_error) as exc_info:
handler(api, session=sqlite_session, app_model=app_model, end_user=end_user, **kwargs)
generate.assert_called_once()
assert exc_info.value.code == status_code
assert exc_info.value.error_code == error_code
assert exc_info.value.description == "rate limit reached"
def test_trigger_workflow_returns_stable_unavailable_error(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
Mock(side_effect=TriggerWorkflowServiceModeUnavailableServiceError()),
)
api = WorkflowRunApi()
handler = unwrap(api.post)
with app.test_request_context("/workflows/run", method="POST", json={"inputs": {}}):
with pytest.raises(TriggerWorkflowServiceModeUnavailableError) as exc_info:
handler(
api,
session=sqlite_session,
app_model=_make_app_model(),
end_user=_make_end_user(),
)
assert exc_info.value.code == 403
assert exc_info.value.error_code == "trigger_workflow_service_mode_unavailable"
def test_sandbox_billing_does_not_gate_default_workflow_run(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
sys.modules["controllers.service_api.app.workflow"]
billing_get_info = mocker.patch.object(
BillingService, "get_info", return_value=builders.subscription_info("sandbox")
)
generate = Mock(return_value={"result": "ok"})
monkeypatch.setattr(AppGenerateService, "generate", generate)
api = WorkflowRunApi()
handler = unwrap(api.post)
with app.test_request_context("/workflows/run", method="POST", json={"inputs": {}}):
response = handler(
api,
session=sqlite_session,
app_model=_make_app_model(),
end_user=_make_end_user(),
)
assert response.get_json() == {"result": "ok"}
billing_get_info.assert_not_called()
generate.assert_called_once()
class TestWorkflowRunByIdApi:
def test_missing_billing_plan_cannot_bypass_sandbox_restriction(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, BILLING_API_URL="http://billing/v1")
payload = builders.subscription_info().model_dump()
del payload["subscription"]["plan"]
def unexpected_generation(*_args: object, **_kwargs: object) -> None:
pytest.fail("Invalid billing data must be rejected before workflow execution")
monkeypatch.setattr(AppGenerateService, "generate", unexpected_generation)
api = WorkflowRunByIdApi()
with httpx.Client(transport=httpx.MockTransport(lambda _: httpx.Response(200, json=payload))) as client:
monkeypatch.setattr(transport, "_http_client", client)
with (
app.test_request_context("/workflows/w1/run", method="POST", json={"inputs": {}}),
pytest.raises(BillingUpstreamInvalidResponseError),
):
unwrap(api.post)(
api,
session=sqlite_session,
app_model=_make_app_model(),
end_user=_make_end_user(),
workflow_id="w1",
)
def test_trigger_workflow_version_returns_stable_unavailable_error(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
monkeypatch.setattr(
AppGenerateService,
"generate",
Mock(side_effect=TriggerWorkflowServiceModeUnavailableServiceError()),
)
api = WorkflowRunByIdApi()
handler = unwrap(api.post)
with app.test_request_context("/workflows/w1/run", method="POST", json={"inputs": {}}):
with pytest.raises(TriggerWorkflowServiceModeUnavailableError) as exc_info:
handler(
api,
session=sqlite_session,
app_model=_make_app_model(),
end_user=_make_end_user(),
workflow_id=str(uuid.uuid4()),
)
assert exc_info.value.code == 403
assert exc_info.value.error_code == "trigger_workflow_service_mode_unavailable"
def test_rejects_sandbox_plan_with_upgrade_error(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
sys.modules["controllers.service_api.app.workflow"]
billing_get_info = mocker.patch.object(
BillingService, "get_info", return_value=builders.subscription_info("sandbox")
)
generate = Mock()
monkeypatch.setattr(AppGenerateService, "generate", generate)
api = WorkflowRunByIdApi()
handler = unwrap(api.post)
app_model = _make_app_model()
with app.test_request_context("/workflows/w1/run", method="POST", json={"inputs": {}}):
with pytest.raises(WorkflowVersionExecutionNotAllowedError) as exc_info:
handler(
api,
session=sqlite_session,
app_model=app_model,
end_user=_make_end_user(),
workflow_id="w1",
)
billing_get_info.assert_called_once_with(app_model.tenant_id, exclude_vector_space=True)
generate.assert_not_called()
assert exc_info.value.code == 403
assert exc_info.value.error_code == "workflow_version_execution_not_allowed"
assert exc_info.value.description == (
"Workflow version execution is not available on your current plan. Please upgrade to a paid plan."
)
assert exc_info.value.data == {
"code": "workflow_version_execution_not_allowed",
"message": exc_info.value.description,
"status": 403,
}
@pytest.mark.parametrize(
("deployment_edition", "plan"),
[
(DeploymentEdition.COMMUNITY, CloudPlan.SANDBOX),
(DeploymentEdition.ENTERPRISE, CloudPlan.SANDBOX),
(DeploymentEdition.CLOUD, CloudPlan.PROFESSIONAL),
],
)
def test_allows_execution_outside_enabled_sandbox_plan(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
deployment_edition: DeploymentEdition,
plan: CloudPlan,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=deployment_edition)
billing_get_info = mocker.patch.object(
BillingService, "get_info", return_value=builders.subscription_info(plan)
)
generate = Mock(return_value={"result": "ok"})
monkeypatch.setattr(AppGenerateService, "generate", generate)
api = WorkflowRunByIdApi()
handler = unwrap(api.post)
app_model = _make_app_model()
with app.test_request_context("/workflows/w1/run", method="POST", json={"inputs": {}}):
response = handler(
api,
session=sqlite_session,
app_model=app_model,
end_user=_make_end_user(),
workflow_id="w1",
)
assert response.get_json() == {"result": "ok"}
generate.assert_called_once()
if deployment_edition == DeploymentEdition.CLOUD:
billing_get_info.assert_called_once_with(app_model.tenant_id, exclude_vector_space=True)
else:
billing_get_info.assert_not_called()
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_not_found(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
sys.modules["controllers.service_api.app.workflow"]
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(WorkflowNotFoundError("missing")),
)
api = WorkflowRunByIdApi()
handler = unwrap(api.post)
app_model = _make_app_model()
end_user = _make_end_user()
with app.test_request_context("/workflows/1/run", method="POST", json={"inputs": {}}):
with pytest.raises(NotFound):
handler(api, session=sqlite_session, app_model=app_model, end_user=end_user, workflow_id="w1")
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_draft_workflow(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
sys.modules["controllers.service_api.app.workflow"]
monkeypatch.setattr(
AppGenerateService,
"generate",
lambda *_args, **_kwargs: (_ for _ in ()).throw(IsDraftWorkflowError("draft")),
)
api = WorkflowRunByIdApi()
handler = unwrap(api.post)
app_model = _make_app_model()
end_user = _make_end_user()
with app.test_request_context("/workflows/1/run", method="POST", json={"inputs": {}}):
with pytest.raises(BadRequest):
handler(api, session=sqlite_session, app_model=app_model, end_user=end_user, workflow_id="w1")
class TestWorkflowTaskStopApi:
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.COMPLETION])
def test_wrong_mode(self, app: Flask, mode: AppMode) -> None:
api = WorkflowTaskStopApi()
handler = unwrap(api.post)
app_model = _make_app_model(mode=mode)
end_user = _make_end_user()
with app.test_request_context("/workflows/tasks/1/stop", method="POST"):
with pytest.raises(NotWorkflowAppError):
handler(api, app_model=app_model, end_user=end_user, task_id="t1")
def test_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
stop_mock = Mock()
workflow_module = sys.modules["controllers.service_api.app.workflow"]
monkeypatch.setattr(workflow_module.AppTaskService, "stop_workflow_task", stop_mock)
api = WorkflowTaskStopApi()
handler = unwrap(api.post)
app_model = _make_app_model()
end_user = _make_end_user(user_id="u1")
with app.test_request_context("/workflows/tasks/1/stop", method="POST"):
response = handler(api, app_model=app_model, end_user=end_user, task_id="t1")
assert response == {"result": "success"}
stop_mock.assert_called_once_with(
tenant_id=app_model.tenant_id,
app_id=app_model.id,
task_id="t1",
app_mode=AppMode.WORKFLOW,
owner=None,
)
class TestWorkflowAppLogApi:
def test_success(
self,
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
) -> None:
api = WorkflowAppLogApi()
handler = unwrap(api.get)
app_model = _make_app_model(app_id="a1")
_persist_workflow_log(sqlite_session, tenant_id=app_model.tenant_id, app_id=app_model.id)
workflow_app_logs = WorkflowAppLogQueryService(
logs=WorkflowAppLogQueryRepository(session_factory=sqlite_session_factory),
)
monkeypatch.setattr(
sys.modules["controllers.service_api.app.workflow"],
"application_services",
lambda: SimpleNamespace(workflow_app_logs=workflow_app_logs),
)
with app.test_request_context("/workflows/logs", method="GET"):
response = handler(api, app_model=app_model)
assert response == _expected_workflow_log_pagination_payload()
# =============================================================================
# API Endpoint Tests
#
# ``WorkflowRunDetailApi``, ``WorkflowTaskStopApi``, and
# ``WorkflowAppLogApi`` use ``@validate_app_token`` which preserves
# ``__wrapped__`` via ``functools.wraps``. We call the unwrapped method
# directly to bypass the decorator.
# =============================================================================
@staticmethod
@pytest.fixture
def workflow_app() -> App:
return _make_app_model(app_id=str(uuid.uuid4()), tenant_id=str(uuid.uuid4()))
class TestWorkflowRunDetailApiGet:
"""Test suite for WorkflowRunDetailApi.get() endpoint.
``get`` is wrapped by ``@validate_app_token`` (preserves ``__wrapped__``),
and we call the unwrapped method directly in tests.
"""
@pytest.mark.parametrize("sqlite_session", [(WorkflowRun,)], indirect=True)
def test_get_workflow_run_success(
self,
app: Flask,
workflow_app: App,
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session: Session,
) -> None:
"""Test successful workflow run detail retrieval."""
run = _make_workflow_run(
run_id="run-1",
tenant_id=workflow_app.tenant_id,
app_id=workflow_app.id,
)
sqlite_session.add(run)
sqlite_session.commit()
_bind_sqlite_database(monkeypatch, sqlite_engine, sqlite_session)
from controllers.service_api.app.workflow import WorkflowRunDetailApi
with app.test_request_context(
f"/workflows/run/{run.id}",
method="GET",
):
api = WorkflowRunDetailApi()
result = unwrap(api.get)(api, app_model=workflow_app, workflow_run_id=run.id)
assert result == {
"id": "run-1",
"workflow_id": "wf-1",
"status": "succeeded",
"inputs": '{"input": "value"}',
"outputs": {"output": "value"},
"error": None,
"total_steps": 1,
"total_tokens": 10,
"created_at": int(datetime(2026, 1, 1).timestamp()),
"finished_at": int(datetime(2026, 1, 1).timestamp()),
"elapsed_time": 0.1,
}
def test_get_workflow_run_wrong_app_mode(self, app: Flask) -> None:
"""Test NotWorkflowAppError when app mode is not workflow or advanced_chat."""
from controllers.service_api.app.workflow import WorkflowRunDetailApi
app_model = _make_app_model(mode=AppMode.CHAT)
with app.test_request_context("/workflows/run/run-1", method="GET"):
api = WorkflowRunDetailApi()
with pytest.raises(NotWorkflowAppError):
unwrap(api.get)(api, app_model=app_model, workflow_run_id="run-1")
class TestWorkflowAppLogApiGet:
"""Test suite for WorkflowAppLogApi.get() endpoint.
``get`` is wrapped by ``@validate_app_token``.
"""
def test_get_workflow_logs_success(
self,
app: Flask,
workflow_app: App,
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Test successful workflow log retrieval."""
_stub_workflow_app_logs(monkeypatch)
from controllers.service_api.app.workflow import WorkflowAppLogApi
with app.test_request_context("/workflows/logs?page=1&limit=20", method="GET"):
api = WorkflowAppLogApi()
result = unwrap(api.get)(api, app_model=workflow_app)
assert result == _expected_workflow_log_pagination_payload()
def _workflow_run(status: WorkflowExecutionStatus, outputs: str | None = '{"foo": "bar"}') -> WorkflowRun:
return WorkflowRun(
id="run-id",
workflow_id="workflow-id",
status=status,
inputs="{}",
outputs=outputs,
error=None,
total_steps=1,
total_tokens=2,
elapsed_time=3.5,
)
class TestWorkflowFieldsCases:
@staticmethod
def test_workflow_run_serializer_normalizes_status_enum() -> None:
response = dump_response(WorkflowRunResponse, _workflow_run(WorkflowExecutionStatus.PAUSED))
assert response["status"] == "paused"
@staticmethod
def test_workflow_run_serializer_paused_returns_empty_outputs() -> None:
response = dump_response(WorkflowRunResponse, _workflow_run(WorkflowExecutionStatus.PAUSED))
assert response["outputs"] == {}
@staticmethod
def test_workflow_run_serializer_running_returns_outputs() -> None:
response = dump_response(WorkflowRunResponse, _workflow_run(WorkflowExecutionStatus.RUNNING))
assert response["outputs"] == {"foo": "bar"}
@@ -0,0 +1,231 @@
"""
Shared fixtures for Service API controller tests.
This module provides reusable fixtures for mocking authentication,
database interactions, and common test data patterns used across
Service API controller tests.
"""
from __future__ import annotations
import uuid
from collections.abc import Iterator
from dataclasses import dataclass
from typing import TYPE_CHECKING
import pytest
from flask import Flask
from sqlalchemy import Engine
from sqlalchemy.orm import Session
from core.rag.index_processor.constant.index_type import IndexStructureType
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole, TenantStatus
from models.base import TypeBase
from models.enums import ApiTokenType, AppStatus, DataSourceType, DocumentCreatedFrom, IndexingStatus, SegmentStatus
from models.model import ApiToken, App, AppMode, EndUser, EndUserType
if TYPE_CHECKING:
from models.dataset import ChildChunk, Dataset, Document, DocumentSegment
@dataclass(frozen=True)
class ServiceApiIdentity:
"""Persisted owner identity for service-API authentication tests."""
session: Session
tenant: Tenant
account: Account
membership: TenantAccountJoin
@pytest.fixture
def service_api_identity(sqlite_engine: Engine) -> Iterator[ServiceApiIdentity]:
"""Given an isolated SQLite engine, yield a persisted tenant owner and close its session afterward."""
TypeBase.metadata.create_all(
sqlite_engine,
tables=[TypeBase.metadata.tables[model.__tablename__] for model in (Account, Tenant, TenantAccountJoin)],
)
with Session(sqlite_engine, expire_on_commit=False) as session:
tenant = Tenant(name="Service API Workspace")
tenant.id = str(uuid.uuid4())
account = Account(name="Service API Owner", email=f"owner-{tenant.id}@example.com")
account.id = str(uuid.uuid4())
membership = TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
role=TenantAccountRole.OWNER,
)
account._current_tenant = tenant
session.add_all([tenant, account, membership])
session.commit()
yield ServiceApiIdentity(
session=session,
tenant=tenant,
account=account,
membership=membership,
)
@pytest.fixture
def app() -> Flask:
"""Create Flask test application with proper configuration."""
flask_app = Flask(__name__)
flask_app.config["TESTING"] = True
return flask_app
@pytest.fixture
def mock_tenant_id() -> str:
"""Return a fresh UUID string for an isolated test tenant."""
return str(uuid.uuid4())
@pytest.fixture
def mock_app_id() -> str:
"""Return a fresh UUID string for an isolated test app."""
return str(uuid.uuid4())
@pytest.fixture
def mock_end_user(mock_tenant_id: str) -> EndUser:
"""Create a real EndUser model with required attributes."""
user = EndUser(
id=str(uuid.uuid4()),
external_user_id=f"external_{uuid.uuid4().hex[:8]}",
tenant_id=mock_tenant_id,
app_id=None,
type=EndUserType.SERVICE_API,
name="Service API User",
session_id=str(uuid.uuid4()),
)
return user
@pytest.fixture
def mock_app_model(mock_app_id: str, mock_tenant_id: str) -> App:
"""Create an App model with all required attributes for API testing."""
app = App(
id=mock_app_id,
tenant_id=mock_tenant_id,
name="Test App",
description="A test application",
mode=AppMode.CHAT,
status=AppStatus.NORMAL,
enable_api=True,
)
return app
@pytest.fixture
def mock_tenant(mock_tenant_id: str) -> Tenant:
"""Create a Tenant model."""
tenant = Tenant(name="Service API Tenant", status=TenantStatus.NORMAL)
tenant.id = mock_tenant_id
return tenant
@pytest.fixture
def mock_account() -> Account:
"""Create an Account model."""
account = Account(name="Service API Account", email=f"service-{uuid.uuid4()}@example.com")
account.id = str(uuid.uuid4())
return account
@pytest.fixture
def mock_api_token(mock_app_id: str, mock_tenant_id: str) -> ApiToken:
"""Create a real API token for authentication tests."""
return ApiToken(
app_id=mock_app_id,
tenant_id=mock_tenant_id,
token=f"test_token_{uuid.uuid4().hex[:8]}",
type=ApiTokenType.APP,
)
@pytest.fixture
def mock_dataset_api_token(mock_tenant_id: str) -> ApiToken:
"""Create a real API token for dataset endpoints."""
return ApiToken(
tenant_id=mock_tenant_id,
token=f"dataset_token_{uuid.uuid4().hex[:8]}",
type=ApiTokenType.DATASET,
)
@pytest.fixture
def mock_dataset() -> Dataset:
"""Create a Dataset model."""
from models.dataset import Dataset
dataset = Dataset(
id=str(uuid.uuid4()),
tenant_id=str(uuid.uuid4()),
name="Test Dataset",
indexing_technique="economy",
embedding_model=None,
embedding_model_provider=None,
)
return dataset
@pytest.fixture
def mock_document() -> Document:
"""Return an unpersisted completed Document with its required source and creator fields."""
from models.dataset import Document
document = Document(
id=str(uuid.uuid4()),
dataset_id=str(uuid.uuid4()),
tenant_id=str(uuid.uuid4()),
name="test_document.txt",
position=1,
data_source_type=DataSourceType.UPLOAD_FILE,
batch="test-batch",
created_from=DocumentCreatedFrom.API,
created_by=str(uuid.uuid4()),
indexing_status=IndexingStatus.COMPLETED,
enabled=True,
doc_form=IndexStructureType.PARAGRAPH_INDEX,
)
return document
@pytest.fixture
def mock_segment() -> DocumentSegment:
"""Create a DocumentSegment model."""
from models.dataset import DocumentSegment
segment = DocumentSegment(
tenant_id=str(uuid.uuid4()),
dataset_id=str(uuid.uuid4()),
document_id=str(uuid.uuid4()),
position=1,
content="Test segment content",
word_count=3,
tokens=0,
created_by="account-id",
enabled=True,
status=SegmentStatus.COMPLETED,
)
segment.id = str(uuid.uuid4())
return segment
@pytest.fixture
def mock_child_chunk() -> ChildChunk:
"""Return an unpersisted ChildChunk with valid required fields."""
from models.dataset import ChildChunk
child_chunk = ChildChunk(
tenant_id=str(uuid.uuid4()),
dataset_id="dataset-id",
document_id="document-id",
segment_id=str(uuid.uuid4()),
position=1,
content="Test child chunk content",
word_count=0,
created_by="account-id",
)
child_chunk.id = str(uuid.uuid4())
return child_chunk
@@ -0,0 +1,928 @@
import ast
import io
import uuid
from datetime import UTC, datetime
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import Mock, patch
import pytest
from flask import Flask
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden, NotFound
from controllers.common.errors import (
FilenameNotExistsError,
NoFileUploadedError,
TooManyFilesError,
)
from controllers.common.errors import (
FileTooLargeError as FileTooLargeHTTPError,
)
from controllers.common.errors import (
UnsupportedFileTypeError as UnsupportedFileTypeHTTPError,
)
from controllers.service_api.dataset.error import PipelineRunError
from controllers.service_api.dataset.rag_pipeline import rag_pipeline_workflow as workflow_module
from controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow import (
DatasourceNodeRunApi,
DatasourceNodeRunPayload,
DatasourcePluginsApi,
KnowledgebasePipelineFileUploadApi,
PipelineRunApi,
PipelineUploadFileResponse,
)
from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
from core.app.entities.app_invoke_entities import InvokeFrom
from extensions.storage.storage_type import StorageType
from libs.helper import dump_response
from models.account import Account
from models.dataset import Dataset, Pipeline
from models.enums import CreatorUserRole
from models.model import UploadFile
from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.data_source.credential_repository import SQLAlchemyDatasourceCredentialRepository
from services.errors.file import FileTooLargeError as FileTooLargeServiceError
from services.errors.file import UnsupportedFileTypeError
from services.rag_pipeline.entity.pipeline_service_api_entities import (
DatasourceNodeRunApiEntity,
PipelineRunApiEntity,
)
from services.rag_pipeline.rag_pipeline import RagPipelineService
from tests.helpers.unit.credential_refresh import build_datasource_provider_service
from tests.helpers.unit.model_factories import make_upload_file
"""
Unit tests for Service API RAG Pipeline Workflow controllers.
Tests coverage for:
- DatasourceNodeRunPayload Pydantic model
- PipelineRunApiEntity / DatasourceNodeRunApiEntity model validation
- RAG pipeline service interfaces
- File upload validation for pipelines
- Endpoint tests for DatasourcePluginsApi, DatasourceNodeRunApi,
PipelineRunApi, and KnowledgebasePipelineFileUploadApi
Strategy:
- Endpoint methods on these resources have no billing decorators on the method
itself. ``method_decorators = [validate_dataset_token]`` is only invoked by
Flask-RESTx dispatch, not by direct calls, so we call methods directly.
- Dataset ownership checks run against the shared SQLite fixture; pipeline and
upload responses use real mapped instances while external services stay mocked.
"""
def _persist_dataset(session: Session, *, tenant_id: str, dataset_id: str) -> Dataset:
dataset = Dataset(
id=dataset_id,
tenant_id=tenant_id,
name="Pipeline dataset",
created_by="account-1",
data_source_type=None,
indexing_technique=None,
)
session.add(dataset)
session.commit()
return dataset
def _persist_pipeline(session: Session, *, tenant_id: str) -> Pipeline:
pipeline = Pipeline(tenant_id=tenant_id, name="Knowledge pipeline")
session.add(pipeline)
session.commit()
return pipeline
class TestRagPipelineWorkflowCases:
@staticmethod
@pytest.fixture(autouse=True)
def _bind_database(sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch):
session_proxy = scoped_session(sqlite_session_factory)
monkeypatch.setattr(workflow_module.db, "session", session_proxy)
query = CredentialQueryRepository(session_factory=sqlite_session_factory)
providers = build_datasource_provider_service(
credentials=SQLAlchemyDatasourceCredentialRepository(session_factory=sqlite_session_factory)
)
monkeypatch.setattr(
workflow_module,
"application_services",
lambda: SimpleNamespace(credential_queries=query, data_sources=SimpleNamespace(providers=providers)),
)
yield
session_proxy.remove()
class TestDatasourceNodeRunPayload:
"""Test suite for DatasourceNodeRunPayload Pydantic model."""
def test_payload_with_required_fields(self):
"""Test payload with required fields."""
payload = DatasourceNodeRunPayload(
inputs={"key": "value"}, datasource_type="online_document", is_published=True
)
assert payload.inputs == {"key": "value"}
assert payload.datasource_type == "online_document"
assert payload.is_published is True
assert payload.credential_id is None
def test_payload_with_credential_id(self):
"""Test payload with optional credential_id."""
payload = DatasourceNodeRunPayload(
inputs={"url": "https://example.com"},
datasource_type="online_document",
credential_id="cred_123",
is_published=False,
)
assert payload.credential_id == "cred_123"
assert payload.is_published is False
def test_payload_with_complex_inputs(self):
"""Test payload with complex nested inputs."""
complex_inputs = {
"config": {"url": "https://api.example.com", "headers": {"Authorization": "Bearer token"}},
"parameters": {"limit": 100, "offset": 0},
"options": ["opt1", "opt2"],
}
payload = DatasourceNodeRunPayload(inputs=complex_inputs, datasource_type="api", is_published=True)
assert payload.inputs == complex_inputs
def test_payload_with_empty_inputs(self):
"""Test payload with empty inputs dict."""
payload = DatasourceNodeRunPayload(inputs={}, datasource_type="local_file", is_published=True)
assert payload.inputs == {}
@pytest.mark.parametrize("datasource_type", ["online_document", "local_file", "api", "database", "website"])
def test_payload_common_datasource_types(self, datasource_type):
"""Test payload with common datasource types."""
payload = DatasourceNodeRunPayload(inputs={}, datasource_type=datasource_type, is_published=True)
assert payload.datasource_type == datasource_type
class TestPipelineErrors:
"""Test pipeline-related error types."""
def test_pipeline_run_error_can_be_raised(self):
"""Test PipelineRunError can be raised."""
error = PipelineRunError(description="Pipeline execution failed")
assert error is not None
def test_pipeline_run_error_with_description(self):
"""Test PipelineRunError captures description."""
error = PipelineRunError(description="Timeout during node execution")
# The error should have the description attribute
assert hasattr(error, "description")
class TestFileUploadErrors:
"""Test file upload error types for pipelines."""
def test_no_file_uploaded_error(self):
"""Test NoFileUploadedError can be raised."""
error = NoFileUploadedError()
assert error is not None
def test_too_many_files_error(self):
"""Test TooManyFilesError can be raised."""
error = TooManyFilesError()
assert error is not None
def test_filename_not_exists_error(self):
"""Test FilenameNotExistsError can be raised."""
error = FilenameNotExistsError()
assert error is not None
def test_file_too_large_error(self):
"""Test FileTooLargeError can be raised."""
error = FileTooLargeServiceError("File exceeds size limit")
assert error is not None
def test_unsupported_file_type_error(self):
"""Test UnsupportedFileTypeError can be raised."""
error = UnsupportedFileTypeError()
assert error is not None
class TestRagPipelineService:
"""Test RagPipelineService interface."""
def test_get_datasource_plugins_method_exists(self):
"""Test RagPipelineService.get_datasource_plugins exists."""
assert hasattr(RagPipelineService, "get_datasource_plugins")
def test_get_pipeline_method_exists(self):
"""Test RagPipelineService.get_pipeline exists."""
assert hasattr(RagPipelineService, "get_pipeline")
def test_run_datasource_workflow_node_method_exists(self):
"""Test RagPipelineService.run_datasource_workflow_node exists."""
assert hasattr(RagPipelineService, "run_datasource_workflow_node")
def test_get_pipeline_templates_method_exists(self):
"""Test RagPipelineService.get_pipeline_templates exists."""
assert hasattr(RagPipelineService, "get_pipeline_templates")
def test_get_pipeline_template_detail_method_exists(self):
"""Test RagPipelineService.get_pipeline_template_detail exists."""
assert hasattr(RagPipelineService, "get_pipeline_template_detail")
class TestInvokeFrom:
"""Test InvokeFrom enum for pipeline invocation."""
def test_published_pipeline_invoke_from(self):
"""Test PUBLISHED_PIPELINE InvokeFrom value exists."""
assert hasattr(InvokeFrom, "PUBLISHED_PIPELINE")
def test_debugger_invoke_from(self):
"""Test DEBUGGER InvokeFrom value exists."""
assert hasattr(InvokeFrom, "DEBUGGER")
class TestPipelineResponseModes:
"""Test pipeline response mode patterns."""
def test_streaming_mode(self):
"""Test streaming response mode."""
mode = "streaming"
valid_modes = ["streaming", "blocking"]
assert mode in valid_modes
def test_blocking_mode(self):
"""Test blocking response mode."""
mode = "blocking"
valid_modes = ["streaming", "blocking"]
assert mode in valid_modes
class TestDatasourceTypes:
"""Test common datasource types for pipelines."""
@pytest.mark.parametrize("ds_type", ["online_document", "local_file", "website", "api", "database"])
def test_datasource_type_valid(self, ds_type):
"""Test common datasource types are strings."""
assert isinstance(ds_type, str)
assert len(ds_type) > 0
class TestPipelineFileUploadResponse:
"""Test file upload response structure for pipelines."""
def test_upload_response_fields(self):
"""Test expected fields in upload response."""
expected_fields = ["id", "name", "size", "extension", "mime_type", "created_by", "created_at"]
# Create mock response
mock_response = {
"id": str(uuid.uuid4()),
"name": "document.pdf",
"size": 1024,
"extension": "pdf",
"mime_type": "application/pdf",
"created_by": str(uuid.uuid4()),
"created_at": "2024-01-01T00:00:00Z",
}
for field in expected_fields:
assert field in mock_response
class TestPipelineNodeExecution:
"""Test pipeline node execution patterns."""
def test_node_id_is_string(self):
"""Test node_id is a string identifier."""
node_id = "node_abc123"
assert isinstance(node_id, str)
assert len(node_id) > 0
def test_pipeline_id_is_uuid(self):
"""Test pipeline_id is a valid UUID string."""
pipeline_id = str(uuid.uuid4())
assert len(pipeline_id) == 36
assert "-" in pipeline_id
class TestCredentialHandling:
"""Test credential handling patterns."""
def test_credential_id_is_optional(self):
"""Test credential_id can be None."""
payload = DatasourceNodeRunPayload(
inputs={}, datasource_type="local_file", is_published=True, credential_id=None
)
assert payload.credential_id is None
def test_credential_id_can_be_provided(self):
"""Test credential_id can be set."""
payload = DatasourceNodeRunPayload(
inputs={}, datasource_type="api", is_published=True, credential_id="cred_oauth_123"
)
assert payload.credential_id == "cred_oauth_123"
class TestPublishedVsDraft:
"""Test published vs draft pipeline patterns."""
def test_is_published_true(self):
"""Test is_published=True for published pipelines."""
payload = DatasourceNodeRunPayload(inputs={}, datasource_type="online_document", is_published=True)
assert payload.is_published is True
def test_is_published_false_for_draft(self):
"""Test is_published=False for draft pipelines."""
payload = DatasourceNodeRunPayload(inputs={}, datasource_type="online_document", is_published=False)
assert payload.is_published is False
class TestPipelineInputVariables:
"""Test pipeline input variable patterns."""
def test_inputs_as_dict(self):
"""Test inputs are passed as dictionary."""
inputs = {"url": "https://example.com/doc.pdf", "timeout": 30, "retry": True}
payload = DatasourceNodeRunPayload(inputs=inputs, datasource_type="online_document", is_published=True)
assert payload.inputs["url"] == "https://example.com/doc.pdf"
assert payload.inputs["timeout"] == 30
assert payload.inputs["retry"] is True
def test_inputs_with_list_values(self):
"""Test inputs with list values."""
inputs = {"urls": ["https://example.com/1", "https://example.com/2"], "tags": ["tag1", "tag2", "tag3"]}
payload = DatasourceNodeRunPayload(inputs=inputs, datasource_type="online_document", is_published=True)
assert len(payload.inputs["urls"]) == 2
assert len(payload.inputs["tags"]) == 3
# ---------------------------------------------------------------------------
# PipelineRunApiEntity / DatasourceNodeRunApiEntity Model Tests
# ---------------------------------------------------------------------------
class TestPipelineRunApiEntity:
"""Test PipelineRunApiEntity Pydantic model."""
def test_entity_with_all_fields(self):
"""Test entity with all required fields."""
entity = PipelineRunApiEntity(
inputs={"key": "value"},
datasource_type="online_document",
datasource_info_list=[{"url": "https://example.com"}],
start_node_id="node_1",
is_published=True,
response_mode="streaming",
)
assert entity.datasource_type == "online_document"
assert entity.response_mode == "streaming"
assert entity.is_published is True
def test_entity_blocking_response_mode(self):
"""Test entity with blocking response mode."""
entity = PipelineRunApiEntity(
inputs={},
datasource_type="local_file",
datasource_info_list=[],
start_node_id="node_start",
is_published=False,
response_mode="blocking",
)
assert entity.response_mode == "blocking"
assert entity.is_published is False
def test_entity_missing_required_field(self):
"""Test entity raises on missing required field."""
with pytest.raises(
ValueError, match="4 validation errors for PipelineRunApiEntity\\\ndatasource_info_list"
):
PipelineRunApiEntity.model_validate(
{
"inputs": {},
"datasource_type": "online_document",
# missing datasource_info_list, start_node_id, etc.
}
)
class TestDatasourceNodeRunApiEntity:
"""Test DatasourceNodeRunApiEntity Pydantic model."""
def test_entity_with_all_fields(self):
"""Test entity with all fields."""
entity = DatasourceNodeRunApiEntity(
pipeline_id=str(uuid.uuid4()),
node_id="node_abc",
inputs={"url": "https://example.com"},
datasource_type="website",
is_published=True,
)
assert entity.node_id == "node_abc"
assert entity.credential_id is None
def test_entity_with_credential(self):
"""Test entity with credential_id."""
entity = DatasourceNodeRunApiEntity(
pipeline_id=str(uuid.uuid4()),
node_id="node_xyz",
inputs={},
datasource_type="api",
credential_id="cred_123",
is_published=False,
)
assert entity.credential_id == "cred_123"
# ---------------------------------------------------------------------------
# Endpoint Tests
# ---------------------------------------------------------------------------
class TestDatasourcePluginsApiGet:
"""Tests for DatasourcePluginsApi.get().
The original source delegates directly to ``RagPipelineService`` without
an inline dataset query, so no ``db`` patching is needed.
"""
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
def test_get_plugins_success(self, mock_svc_cls, app: Flask, sqlite_session: Session):
"""Test successful retrieval of datasource plugins."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
datasource_plugins = [
{
"node_id": "node-datasource-1",
"plugin_id": "plugin-a",
"provider_name": "provider-a",
"datasource_type": "online_document",
"title": "Online Docs",
"user_input_variables": [
{"variable": "url", "label": "URL", "type": "text-input", "required": True}
],
"credentials": [
{"id": "cred-1", "name": "Default credential", "type": "oauth2", "is_default": True}
],
}
]
mock_svc_instance = Mock()
mock_svc_instance.get_datasource_plugins.return_value = datasource_plugins
mock_svc_cls.return_value = mock_svc_instance
with app.test_request_context("/datasets/test/pipeline/datasource-plugins?is_published=true"):
api = DatasourcePluginsApi()
response, status = api.get(tenant_id=tenant_id, dataset_id=dataset_id)
assert status == 200
assert response == datasource_plugins
mock_svc_instance.get_datasource_plugins.assert_called_once_with(
tenant_id=tenant_id,
dataset_id=dataset_id,
is_published=True,
credential_query=workflow_module.application_services().credential_queries,
datasource_providers=workflow_module.application_services().data_sources.providers,
)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
def test_get_plugins_parses_false_is_published_query(self, mock_svc_cls, app: Flask, sqlite_session: Session):
"""Test false query string is parsed as boolean False."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
mock_svc_instance = Mock()
mock_svc_instance.get_datasource_plugins.return_value = []
mock_svc_cls.return_value = mock_svc_instance
with app.test_request_context("/datasets/test/pipeline/datasource-plugins?is_published=false"):
api = DatasourcePluginsApi()
response, status = api.get(tenant_id=tenant_id, dataset_id=dataset_id)
assert status == 200
assert response == []
mock_svc_instance.get_datasource_plugins.assert_called_once_with(
tenant_id=tenant_id,
dataset_id=dataset_id,
is_published=False,
credential_query=workflow_module.application_services().credential_queries,
datasource_providers=workflow_module.application_services().data_sources.providers,
)
def test_get_plugins_not_found(self, app: Flask, sqlite_session: Session):
"""Test NotFound when dataset check fails."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id="other-tenant", dataset_id=dataset_id)
with app.test_request_context("/datasets/test/pipeline/datasource-plugins"):
api = DatasourcePluginsApi()
with pytest.raises(NotFound):
api.get(tenant_id=tenant_id, dataset_id=dataset_id)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
def test_get_plugins_empty_list(self, mock_svc_cls, app: Flask, sqlite_session: Session):
"""Test empty plugin list."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
mock_svc_instance = Mock()
mock_svc_instance.get_datasource_plugins.return_value = []
mock_svc_cls.return_value = mock_svc_instance
with app.test_request_context("/datasets/test/pipeline/datasource-plugins"):
api = DatasourcePluginsApi()
response, status = api.get(tenant_id=tenant_id, dataset_id=dataset_id)
assert status == 200
assert response == []
class TestDatasourceNodeRunApiPost:
"""Tests for DatasourceNodeRunApi.post().
The source asserts ``isinstance(current_user, Account)`` and delegates to
``RagPipelineService`` and ``PipelineGenerator``, so we patch those plus
``current_user``. ``post`` is wrapped in ``@model_validate``, which parses
the JSON request body live, so payloads are supplied via
``test_request_context(json=...)`` and validation runs before the dataset
ownership guard.
"""
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.helper")
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.PipelineGenerator")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new_callable=lambda: Account(name="Test Account", email="test@example.com"),
)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
def test_post_success(
self,
mock_svc_cls,
current_account,
mock_gen,
mock_helper,
app: Flask,
sqlite_session: Session,
):
"""Test successful datasource node run."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
node_id = "node_abc"
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
pipeline = _persist_pipeline(sqlite_session, tenant_id=tenant_id)
mock_svc_instance = Mock()
mock_svc_instance.get_pipeline.return_value = pipeline
mock_svc_instance.run_datasource_workflow_node.return_value = iter(["event1"])
mock_svc_cls.return_value = mock_svc_instance
mock_gen.convert_to_event_stream.return_value = iter(["stream_event"])
mock_helper.compact_generate_response.return_value = {"result": "ok"}
with app.test_request_context(
"/datasets/test/pipeline/datasource/nodes/node_abc/run",
method="POST",
json={
"inputs": {"url": "https://example.com"},
"datasource_type": "online_document",
"is_published": True,
},
):
api = DatasourceNodeRunApi()
response = api.post(tenant_id=tenant_id, dataset_id=dataset_id, node_id=node_id)
assert response == {"result": "ok"}
mock_svc_instance.get_pipeline.assert_called_once_with(tenant_id=tenant_id, dataset_id=dataset_id)
mock_svc_instance.get_pipeline.assert_called_once_with(tenant_id=tenant_id, dataset_id=dataset_id)
mock_svc_instance.run_datasource_workflow_node.assert_called_once()
def test_post_not_found(self, app: Flask, sqlite_session: Session):
"""Test NotFound when dataset check fails."""
# `@model_validate` parses the body before the ownership guard, so a
# valid payload is required to reach the NotFound branch.
with app.test_request_context(
"/datasets/test/pipeline/datasource/nodes/n1/run",
method="POST",
json={"inputs": {}, "datasource_type": "online_document", "is_published": True},
):
api = DatasourceNodeRunApi()
with pytest.raises(NotFound):
api.post(tenant_id=str(uuid.uuid4()), dataset_id=str(uuid.uuid4()), node_id="n1")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new="not_account",
)
def test_post_fails_when_current_user_not_account(self, app: Flask, sqlite_session: Session):
"""Test AssertionError when current_user is not an Account instance."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
with app.test_request_context(
"/datasets/test/pipeline/datasource/nodes/n1/run",
method="POST",
json={"inputs": {}, "datasource_type": "local_file", "is_published": True},
):
api = DatasourceNodeRunApi()
with pytest.raises(AssertionError):
api.post(tenant_id=tenant_id, dataset_id=dataset_id, node_id="n1")
class TestPipelineRunApiPost:
"""Tests for PipelineRunApi.post()."""
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.helper")
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.PipelineGenerateService")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new_callable=lambda: Account(name="Test Account", email="test@example.com"),
)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")
def test_post_success_streaming(
self,
mock_ns,
mock_svc_cls,
mock_current_user,
mock_gen_svc,
mock_helper,
app: Flask,
sqlite_session: Session,
pipeline_application: PipelineGenerator,
):
"""Test successful pipeline run with streaming response."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
mock_ns.payload = {
"inputs": {"key": "val"},
"datasource_type": "online_document",
"datasource_info_list": [],
"start_node_id": "node_1",
"is_published": True,
"response_mode": "streaming",
}
pipeline = _persist_pipeline(sqlite_session, tenant_id=tenant_id)
mock_svc_instance = Mock()
mock_svc_instance.get_pipeline.return_value = pipeline
mock_svc_cls.return_value = mock_svc_instance
mock_gen_svc.generate.return_value = {"result": "ok"}
mock_helper.compact_generate_response.return_value = {"result": "ok"}
with app.test_request_context("/datasets/test/pipeline/run", method="POST"):
api = PipelineRunApi()
response = api.post.__wrapped__(api, sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
assert response == {"result": "ok"}
mock_svc_cls.assert_called_once_with(sqlite_session)
mock_gen_svc.generate.assert_called_once()
assert mock_gen_svc.generate.call_args.kwargs["generator"] is pipeline_application
assert mock_gen_svc.generate.call_args.kwargs["session"] is sqlite_session
def test_post_not_found(self, app: Flask, sqlite_session: Session):
"""Test NotFound when dataset check fails."""
with app.test_request_context("/datasets/test/pipeline/run", method="POST"):
api = PipelineRunApi()
with pytest.raises(NotFound):
api.post.__wrapped__(
api,
sqlite_session,
tenant_id=str(uuid.uuid4()),
dataset_id=str(uuid.uuid4()),
)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user", new="not_account")
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")
def test_post_forbidden_non_account_user(self, mock_ns, app: Flask, sqlite_session: Session):
"""Test Forbidden when current_user is not an Account."""
tenant_id = str(uuid.uuid4())
dataset_id = str(uuid.uuid4())
_persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
mock_ns.payload = {
"inputs": {},
"datasource_type": "online_document",
"datasource_info_list": [],
"start_node_id": "node_1",
"is_published": True,
"response_mode": "blocking",
}
with app.test_request_context("/datasets/test/pipeline/run", method="POST"):
api = PipelineRunApi()
with pytest.raises(Forbidden):
api.post.__wrapped__(
api,
sqlite_session,
tenant_id=tenant_id,
dataset_id=dataset_id,
)
class TestFileUploadApiPost:
"""Tests for KnowledgebasePipelineFileUploadApi.post()."""
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FileService")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new_callable=lambda: Account(name="Upload User", email="upload@example.com"),
)
def test_upload_success(self, current_account, mock_file_svc_cls, app: Flask, sqlite_engine):
"""Test successful file upload."""
current_account.id = str(uuid.uuid4())
upload = UploadFile(
tenant_id=str(uuid.uuid4()),
storage_type=StorageType.LOCAL,
key="pipeline/doc.pdf",
name="doc.pdf",
size=1024,
extension="pdf",
mime_type="application/pdf",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=current_account.id,
created_at=datetime(2024, 1, 1, tzinfo=UTC),
used=False,
)
mock_file_svc_instance = Mock()
mock_file_svc_instance.upload_file.return_value = upload
mock_file_svc_cls.return_value = mock_file_svc_instance
file_data = FileStorage(
stream=io.BytesIO(b"fake pdf content"),
filename="doc.pdf",
content_type="application/pdf",
)
with (
patch.object(workflow_module, "db", SimpleNamespace(engine=sqlite_engine)),
app.test_request_context(
"/datasets/pipeline/file-upload",
method="POST",
content_type="multipart/form-data",
data={"file": file_data},
),
):
response, status = KnowledgebasePipelineFileUploadApi().post(tenant_id=str(uuid.uuid4()))
assert status == 201
assert response["name"] == "doc.pdf"
assert response["extension"] == "pdf"
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FeatureService"
".get_knowledge_file_size_limit",
return_value=15,
)
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FileService")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new_callable=lambda: Account(name="Upload User", email="upload@example.com"),
)
def test_upload_file_too_large_returns_http_413(
self, current_account, mock_file_svc_cls, mock_get_limit, app: Flask, sqlite_engine
):
mock_file_svc_cls.return_value.upload_file.side_effect = FileTooLargeServiceError()
file_data = FileStorage(
stream=io.BytesIO(b"oversized content"),
filename="doc.pdf",
content_type="application/pdf",
)
with (
patch.object(workflow_module, "db", SimpleNamespace(engine=sqlite_engine)),
app.test_request_context(
"/datasets/pipeline/file-upload",
method="POST",
content_type="multipart/form-data",
data={"file": file_data},
),
):
with pytest.raises(FileTooLargeHTTPError) as exc_info:
KnowledgebasePipelineFileUploadApi().post(tenant_id="tenant-1")
assert exc_info.value.code == 413
assert exc_info.value.error_code == "file_too_large"
mock_get_limit.assert_called_once_with("tenant-1")
@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FileService")
@patch(
"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",
new_callable=lambda: Account(name="Upload User", email="upload@example.com"),
)
def test_upload_unsupported_file_type_returns_http_415(
self, current_account, mock_file_svc_cls, app: Flask, sqlite_engine
):
# Regression: the service error once shadowed the HTTP error of the same name,
# so this surfaced as a 400 `invalid_param` instead of the documented 415.
mock_file_svc_cls.return_value.upload_file.side_effect = UnsupportedFileTypeError()
file_data = FileStorage(
stream=io.BytesIO(b"binary"),
filename="doc.exe",
content_type="application/octet-stream",
)
with (
patch.object(workflow_module, "db", SimpleNamespace(engine=sqlite_engine)),
patch.object(workflow_module.FeatureService, "get_knowledge_file_size_limit", return_value=15),
app.test_request_context(
"/datasets/pipeline/file-upload",
method="POST",
content_type="multipart/form-data",
data={"file": file_data},
),
):
with pytest.raises(UnsupportedFileTypeHTTPError) as exc_info:
KnowledgebasePipelineFileUploadApi().post(tenant_id="tenant-1")
assert exc_info.value.code == 415
assert exc_info.value.error_code == "unsupported_file_type"
def test_upload_no_file(self, app: Flask):
"""Test error when no file is uploaded."""
with app.test_request_context(
"/datasets/pipeline/file-upload",
method="POST",
content_type="multipart/form-data",
):
api = KnowledgebasePipelineFileUploadApi()
with pytest.raises(NoFileUploadedError):
api.post(tenant_id=str(uuid.uuid4()))
"""
Unit tests for Service API knowledge pipeline file-upload serialization.
"""
def _upload_file(*, created_at: datetime) -> UploadFile:
return make_upload_file(
file_id="file-1",
name="test.pdf",
size=123,
extension="pdf",
mime_type="application/pdf",
created_at=created_at,
)
class TestRagPipelineFileUploadSerializationCases:
@staticmethod
def test_file_upload_created_at_is_isoformat_string():
created_at = datetime(2026, 2, 8, 12, 0, 0, tzinfo=UTC)
upload_file = _upload_file(created_at=created_at)
result = dump_response(PipelineUploadFileResponse, upload_file)
assert result["created_at"] == created_at.isoformat()
@staticmethod
def test_file_upload_created_at_none_serializes_to_null():
upload_file = _upload_file(created_at=datetime(2026, 2, 8, 12, 0, 0, tzinfo=UTC))
upload_file.created_at = None
result = dump_response(PipelineUploadFileResponse, upload_file)
assert result["created_at"] is None
"""
Unit tests for Service API knowledge pipeline route registration.
"""
class TestRagPipelineRouteRegistrationCases:
@staticmethod
def test_rag_pipeline_routes_registered():
api_dir = Path(__file__).resolve().parents[6]
service_api_init = api_dir / "controllers" / "service_api" / "__init__.py"
rag_pipeline_workflow = (
api_dir / "controllers" / "service_api" / "dataset" / "rag_pipeline" / "rag_pipeline_workflow.py"
)
assert service_api_init.exists()
assert rag_pipeline_workflow.exists()
init_tree = ast.parse(service_api_init.read_text(encoding="utf-8"))
import_found = False
for node in ast.walk(init_tree):
if not isinstance(node, ast.ImportFrom):
continue
if node.module != "dataset.rag_pipeline" or node.level != 1:
continue
if any(alias.name == "rag_pipeline_workflow" for alias in node.names):
import_found = True
break
assert import_found, (
"from .dataset.rag_pipeline import rag_pipeline_workflow not found in service_api/__init__.py"
)
workflow_tree = ast.parse(rag_pipeline_workflow.read_text(encoding="utf-8"))
route_paths: set[str] = set()
for node in ast.walk(workflow_tree):
if not isinstance(node, ast.ClassDef):
continue
for decorator in node.decorator_list:
if not isinstance(decorator, ast.Call):
continue
if not isinstance(decorator.func, ast.Attribute):
continue
if decorator.func.attr != "route":
continue
if not decorator.args:
continue
first_arg = decorator.args[0]
if isinstance(first_arg, ast.Constant) and isinstance(first_arg.value, str):
route_paths.add(first_arg.value)
assert "/datasets/<uuid:dataset_id>/pipeline/datasource-plugins" in route_paths
assert "/datasets/<uuid:dataset_id>/pipeline/datasource/nodes/<string:node_id>/run" in route_paths
assert "/datasets/<uuid:dataset_id>/pipeline/run" in route_paths
assert "/datasets/pipeline/file-upload" in route_paths
@@ -0,0 +1,404 @@
"""
Unit tests for Service API HitTesting controller.
Tests coverage for:
- HitTestingPayload Pydantic model validation
- HitTestingApi endpoint (success and error paths via direct method calls)
Strategy:
- ``HitTestingApi.post`` is decorated with ``@cloud_edition_billing_rate_limit_check``
which preserves ``__wrapped__``. We call ``post.__wrapped__(self, ...)`` to skip
the billing decorator and test the business logic directly.
- ``validate_dataset_token`` installs the tenant owner account into Flask-Login's
request context before calling the handler, so direct method-call tests install
the same concrete account on ``g._login_user``.
"""
import uuid
from typing import TypedDict
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask, g
from pydantic import TypeAdapter
from werkzeug.exceptions import Forbidden, NotFound
import services.errors.base
from controllers.service_api.dataset.hit_testing import HitTestingApi, HitTestingPayload
from models.account import Account, Tenant, TenantAccountRole
from models.dataset import Dataset
from services.knowledge.entities.knowledge_entities import RetrievalModel
from tests.helpers.unit.controllers.knowledge_fs_controller_fakes import narrowed
# ---------------------------------------------------------------------------
# HitTestingPayload Model Tests
# ---------------------------------------------------------------------------
def hit_testing_record() -> dict[str, object]:
return {
"segment": {
"id": "segment-1",
"position": 1,
"document_id": "document-1",
"content": "Chunk text",
"sign_content": "Chunk text",
"answer": None,
"word_count": 2,
"tokens": 3,
"keywords": None,
"index_node_id": None,
"index_node_hash": None,
"hit_count": 0,
"enabled": True,
"disabled_at": None,
"disabled_by": None,
"status": "completed",
"created_by": "account-1",
"created_at": 1_700_000_000,
"indexing_at": None,
"completed_at": None,
"error": None,
"stopped_at": None,
"document": {
"id": "document-1",
"data_source_type": "upload_file",
"name": "guide.md",
"doc_type": None,
"doc_metadata": None,
},
},
"child_chunks": None,
"files": None,
"score": 0.9,
}
class _HitRecord(TypedDict):
segment: dict[str, object]
child_chunks: list[object]
files: list[object]
score: float
tsne_position: list[float] | None
summary: str | None
class TestHitTestingPayload:
"""Test suite for HitTestingPayload Pydantic model."""
def test_payload_with_required_query(self) -> None:
"""Test payload with required query field."""
payload = HitTestingPayload(query="test query")
assert payload.query == "test query"
def test_payload_with_all_fields(self) -> None:
"""Test payload with all optional fields."""
retrieval_model_data = {
"search_method": "semantic_search",
"reranking_enable": False,
"score_threshold_enabled": False,
"top_k": 5,
}
payload = HitTestingPayload(
query="test query",
retrieval_model=RetrievalModel.model_validate(retrieval_model_data),
external_retrieval_model={"provider": "openai"},
attachment_ids=["att_1", "att_2"],
)
assert payload.query == "test query"
assert payload.retrieval_model is not None
assert payload.retrieval_model.top_k == 5
assert payload.external_retrieval_model == {"provider": "openai"}
assert payload.attachment_ids == ["att_1", "att_2"]
def test_payload_query_too_long(self) -> None:
"""Test payload rejects query over 250 characters."""
with pytest.raises(ValueError, match="1 validation error for HitTestingPayload\\\nquery"):
HitTestingPayload(query="x" * 251)
def test_payload_query_at_max_length(self) -> None:
"""Test payload accepts query at exactly 250 characters."""
payload = HitTestingPayload(query="x" * 250)
assert len(payload.query) == 250
def test_payload_ignores_unknown_fields_for_compatibility(self) -> None:
"""Top-level fields outside the documented schema remain ignored as before."""
payload = HitTestingPayload.model_validate({"query": "test query", "top_k": 3})
assert payload.model_dump(exclude_none=True) == {"query": "test query"}
# ---------------------------------------------------------------------------
# HitTestingApi Tests
#
# We use ``post.__wrapped__`` to bypass ``@cloud_edition_billing_rate_limit_check``
# and call the underlying method directly.
# ---------------------------------------------------------------------------
class TestHitTestingApiPost:
"""Tests for HitTestingApi.post() via __wrapped__ to skip billing decorator."""
@staticmethod
def _dataset(dataset_id: str, tenant_id: str) -> Dataset:
return Dataset(id=dataset_id, tenant_id=tenant_id, name="Dataset", created_by="account-1")
@staticmethod
def _account(tenant_id: str) -> Account:
account = Account(name="Service API", email="service-api@example.com")
account.id = "account-1"
tenant = Tenant(name="Tenant")
tenant.id = tenant_id
account._current_tenant = tenant
account.role = TenantAccountRole.OWNER
return account
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.HitTestingService")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_success(
self,
mock_dataset_svc: MagicMock,
mock_hit_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The dataset exists and the account is admitted.
Postconditions: The handler returns the query and invokes retrieval.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
mock_dataset = self._dataset(dataset_id, tenant_id)
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_hit_svc.retrieve.return_value = {"query": {"content": "test query"}, "records": list[object]()}
mock_hit_svc.hit_testing_args_check.return_value = None
mock_ns.payload = {"query": "test query"}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
# Skip billing decorator via __wrapped__
response = vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
assert response["query"] == {"content": "test query"}
mock_hit_svc.retrieve.assert_called_once()
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.HitTestingService")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_with_retrieval_model(
self,
mock_dataset_svc: MagicMock,
mock_hit_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The request supplies a valid retrieval model for an accessible dataset.
Postconditions: The handler passes that model to retrieval and returns its response.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
mock_dataset = self._dataset(dataset_id, tenant_id)
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
retrieval_model = {
"search_method": "semantic_search",
"reranking_enable": False,
"score_threshold_enabled": True,
"top_k": 10,
"score_threshold": 0.8,
}
mock_hit_svc.retrieve.return_value = {"query": {"content": "complex query"}, "records": list[object]()}
mock_hit_svc.hit_testing_args_check.return_value = None
mock_ns.payload = {
"query": "complex query",
"retrieval_model": retrieval_model,
"external_retrieval_model": {"provider": "custom"},
}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
response = vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
assert response["query"] == {"content": "complex query"}
call_kwargs = mock_hit_svc.retrieve.call_args
# retrieval_model is serialized via model_dump, verify key fields
passed_retrieval_model = call_kwargs.kwargs.get("retrieval_model")
assert passed_retrieval_model is not None
assert passed_retrieval_model["search_method"] == "semantic_search"
assert passed_retrieval_model["top_k"] == 10
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.HitTestingService")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_preserves_retrieval_model_metadata_filtering_conditions(
self,
mock_dataset_svc: MagicMock,
mock_hit_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The retrieval model includes metadata filters.
Postconditions: The handler preserves those filters in the retrieval request.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
mock_dataset = self._dataset(dataset_id, tenant_id)
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_hit_svc.retrieve.return_value = {"query": {"content": "filtered query"}, "records": list[object]()}
mock_hit_svc.hit_testing_args_check.return_value = None
metadata_filtering_conditions = {
"logical_operator": "and",
"conditions": [
{
"name": "category",
"comparison_operator": "is",
"value": "finance",
}
],
}
mock_ns.payload = {
"query": "filtered query",
"retrieval_model": {
"search_method": "semantic_search",
"reranking_enable": False,
"score_threshold_enabled": False,
"top_k": 4,
"metadata_filtering_conditions": metadata_filtering_conditions,
},
}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
passed_retrieval_model = mock_hit_svc.retrieve.call_args.kwargs.get("retrieval_model")
assert passed_retrieval_model is not None
assert passed_retrieval_model["metadata_filtering_conditions"] == metadata_filtering_conditions
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.HitTestingService")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_prepares_nullable_list_fields(
self,
mock_dataset_svc: MagicMock,
mock_hit_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The retrieval result contains nullable list fields.
Postconditions: The serialized record contains empty lists and preserves its remaining fields.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
mock_dataset = self._dataset(dataset_id, tenant_id)
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_hit_svc.retrieve.return_value = {
"query": {"content": "legacy query"},
"records": [hit_testing_record()],
}
mock_hit_svc.hit_testing_args_check.return_value = None
mock_ns.payload = {"query": "legacy query"}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
response = vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
assert response["query"] == {"content": "legacy query"}
record = TypeAdapter(_HitRecord).validate_python(narrowed(response["records"], list)[0], strict=True)
assert record["segment"]["id"] == "segment-1"
assert record["segment"]["keywords"] == []
assert record["child_chunks"] == []
assert record["files"] == []
assert record["score"] == 0.9
assert record["tsne_position"] is None
assert record["summary"] is None
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The dataset lookup reports a missing dataset.
Postconditions: The handler raises NotFound.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = None
mock_ns.payload = {"query": "test query"}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
with pytest.raises(NotFound):
vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
@patch("controllers.service_api.dataset.hit_testing.service_api_ns")
@patch("controllers.console.datasets.hit_testing_base.DatasetService")
def test_post_no_dataset_permission(
self,
mock_dataset_svc: MagicMock,
mock_ns: MagicMock,
app: Flask,
) -> None:
"""Preconditions: The account has no permission for the dataset.
Postconditions: The handler raises Forbidden.
"""
dataset_id = str(uuid.uuid4())
tenant_id = str(uuid.uuid4())
mock_dataset = self._dataset(dataset_id, tenant_id)
account = self._account(tenant_id)
mock_dataset_svc.get_dataset.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.side_effect = services.errors.base.NoPermissionError("Access denied")
mock_ns.payload = {"query": "test query"}
with app.test_request_context():
# TODO: the service APIs are NOT migrated yet, so we have to do the very dirty hack
g._login_user = account
api = HitTestingApi()
with pytest.raises(Forbidden):
vars(HitTestingApi.post)["__wrapped__"](api, tenant_id, dataset_id)
@@ -0,0 +1,738 @@
"""
Unit tests for Service API Metadata controllers.
Tests coverage for:
- DatasetMetadataCreateServiceApi (post, get)
- DatasetMetadataServiceApi (patch, delete)
- DatasetMetadataBuiltInFieldServiceApi (get)
- DatasetMetadataBuiltInFieldActionServiceApi (post)
- DocumentMetadataEditServiceApi (post)
Decorator strategy:
- ``@cloud_edition_billing_rate_limit_check`` preserves ``__wrapped__``
via ``functools.wraps`` → call the unwrapped method directly.
- Methods without billing decorators → call directly; only patch ``db``,
services, and ``current_user``.
- ``@model_validate`` injects the parsed payload as the first argument after
``self``, so unwrapped calls must pass the validated model explicitly.
"""
import uuid
from inspect import unwrap
from unittest.mock import ANY, MagicMock, Mock, create_autospec, patch
import pytest
from flask import Flask, request
from flask.typing import ResponseReturnValue
from flask_restx import Api, Resource
from sqlalchemy.orm import Session
from werkzeug.exceptions import NotFound
from controllers.common.controller_schemas import MetadataUpdatePayload
from controllers.service_api import api as service_api
from controllers.service_api.dataset import metadata as metadata_module
from controllers.service_api.dataset.metadata import (
DatasetMetadataBuiltInFieldActionServiceApi,
DatasetMetadataBuiltInFieldServiceApi,
DatasetMetadataCreateServiceApi,
DatasetMetadataServiceApi,
DocumentMetadataEditServiceApi,
)
from models.account import Account, Tenant
from models.dataset import Dataset
from models.enums import PermissionEnum
from services.errors.base import NoPermissionError
from services.errors.metadata import MetadataResourceNotFoundError
from services.knowledge.entities.knowledge_entities import MetadataArgs, MetadataOperationData
from services.knowledge.metadata.application import MetadataService
from services.knowledge.resource_scope import DatasetRef
@pytest.mark.parametrize(
("error", "status", "code", "message"),
[
(NoPermissionError("Access denied"), 400, "invalid_param", "Access denied"),
(RuntimeError("backend detail"), 500, "unknown", "Internal Server Error"),
],
)
def test_metadata_permission_error_http_contract(
monkeypatch: pytest.MonkeyPatch,
account: Account,
mock_dataset: Dataset,
sqlite_session: Session,
error: Exception,
status: int,
code: str,
message: str,
) -> None:
monkeypatch.setattr(metadata_module, "current_user", account)
monkeypatch.setattr(
metadata_module.DatasetService,
"get_dataset_for_tenant",
create_autospec(
metadata_module.DatasetService.get_dataset_for_tenant, return_value=mock_dataset, instance=True
),
)
monkeypatch.setattr(
metadata_module.DatasetService,
"check_dataset_permission",
create_autospec(metadata_module.DatasetService.check_dataset_permission, side_effect=error, instance=True),
)
metadata = create_autospec(MetadataService, instance=True)
services = Mock()
services.knowledge.metadata = metadata
monkeypatch.setattr(metadata_module, "application_services", lambda: services)
http_app = Flask(__name__)
http_api = Api(http_app, doc=False)
http_api.error_handlers = service_api.error_handlers.copy()
class Endpoint(Resource):
def post(self) -> ResponseReturnValue:
return unwrap(DatasetMetadataCreateServiceApi.post)(
DatasetMetadataCreateServiceApi(),
MetadataArgs(type="string", name="author"),
sqlite_session,
mock_dataset.tenant_id,
uuid.UUID(mock_dataset.id),
)
http_api.add_resource(Endpoint, "/metadata")
response = http_app.test_client().post("/metadata")
assert response.status_code == status
assert response.json == {"code": code, "message": message, "status": status}
metadata.create_metadata.assert_not_called()
@pytest.fixture
def mock_tenant() -> Tenant:
tenant = Tenant(name="Metadata API Tenant")
tenant.id = str(uuid.uuid4())
return tenant
@pytest.fixture
def account() -> Account:
account = Account(name="Metadata API User", email=f"metadata-api-{uuid.uuid4()}@example.com")
account.id = str(uuid.uuid4())
return account
@pytest.fixture
def mock_dataset(mock_tenant: Tenant, account: Account) -> Dataset:
return Dataset(
id=str(uuid.uuid4()),
tenant_id=mock_tenant.id,
name="Metadata Dataset",
description="",
provider="vendor",
permission=PermissionEnum.ONLY_ME,
indexing_technique="economy",
created_by=account.id,
)
@pytest.fixture(autouse=True)
def _use_current_user(monkeypatch: pytest.MonkeyPatch, account: Account) -> None:
monkeypatch.setattr(metadata_module, "current_user", account)
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# DatasetMetadataCreateServiceApi
# ---------------------------------------------------------------------------
class _UsesSQLiteSession:
session: Session
@pytest.fixture(autouse=True)
def _inject_sqlite_session(self, sqlite_session: Session) -> None:
self.session = sqlite_session
@pytest.mark.parametrize("method", ["patch", "delete"])
def test_metadata_mutation_translates_missing_resource(
method: str, sqlite_session: Session, mock_tenant: Tenant, mock_dataset: Dataset
) -> None:
with (
patch.object(metadata_module, "DatasetService") as datasets,
patch.object(metadata_module, "application_services") as services,
):
datasets.get_dataset_for_tenant.return_value = mock_dataset
metadata = services.return_value.knowledge.metadata
operation = metadata.update_metadata_name if method == "patch" else metadata.delete_metadata
operation.side_effect = MetadataResourceNotFoundError("Metadata not found.")
resource = DatasetMetadataServiceApi()
arguments: dict[str, object] = {
"session": sqlite_session,
"tenant_id": mock_tenant.id,
"dataset_id": mock_dataset.id,
"metadata_id": uuid.uuid4(),
}
if method == "patch":
arguments["payload"] = MetadataUpdatePayload(name="renamed")
endpoint = DatasetMetadataServiceApi.patch if method == "patch" else DatasetMetadataServiceApi.delete
with pytest.raises(NotFound, match="Metadata not found"):
unwrap(endpoint)(resource, **arguments)
class TestDatasetMetadataCreatePost(_UsesSQLiteSession):
"""Tests for DatasetMetadataCreateServiceApi.post().
``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``
which preserves ``__wrapped__``.
"""
@staticmethod
def _call_post(
api: DatasetMetadataCreateServiceApi, session: Session, **kwargs: object
) -> tuple[dict[str, object], int]:
# `post` is wrapped in @model_validate, so the unwrapped view expects the
# validated model where the decorator would have injected it.
metadata_args = MetadataArgs.model_validate(request.get_json() or {})
return unwrap(api.post)(api, metadata_args, session, **kwargs)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_create_metadata_success(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test successful metadata creation."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_metadata = {"id": "meta-1", "type": "string", "name": "Author"}
mock_meta_svc.create_metadata.return_value = mock_metadata
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata",
method="POST",
json={"type": "string", "name": "Author"},
):
api = DatasetMetadataCreateServiceApi()
session = self.session
response, status = self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
assert status == 201
assert response == {"id": "meta-1", "type": "string", "name": "Author"}
mock_meta_svc.create_metadata.assert_called_once()
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_create_metadata_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata",
method="POST",
json={"type": "string", "name": "Author"},
):
api = DatasetMetadataCreateServiceApi()
session = self.session
with pytest.raises(NotFound):
self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
class TestDatasetMetadataCreateGet(_UsesSQLiteSession):
"""Tests for DatasetMetadataCreateServiceApi.get()."""
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_get_metadata_success(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test successful metadata list retrieval."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_meta_svc.get_dataset_metadatas.return_value = {
"doc_metadata": [{"id": "m1", "name": "Author", "type": "string", "count": 0}],
"built_in_field_enabled": False,
}
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata",
method="GET",
):
api = DatasetMetadataCreateServiceApi()
response, status = api.get(
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
assert status == 200
assert response == {
"doc_metadata": [{"id": "m1", "name": "Author", "type": "string", "count": 0}],
"built_in_field_enabled": False,
}
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_get_metadata_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata",
method="GET",
):
api = DatasetMetadataCreateServiceApi()
with pytest.raises(NotFound):
api.get(tenant_id=mock_tenant.id, dataset_id=uuid.UUID(mock_dataset.id))
# ---------------------------------------------------------------------------
# DatasetMetadataServiceApi
# ---------------------------------------------------------------------------
class TestDatasetMetadataServiceApiPatch(_UsesSQLiteSession):
"""Tests for DatasetMetadataServiceApi.patch().
``patch`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
"""
@staticmethod
def _call_patch(
api: DatasetMetadataServiceApi, session: Session, **kwargs: object
) -> tuple[dict[str, object], int]:
payload = MetadataUpdatePayload.model_validate(request.get_json() or {})
return unwrap(api.patch)(api, payload, session, **kwargs)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_update_metadata_name_success(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
account: Account,
) -> None:
"""Test successful metadata name update."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
metadata_id = str(uuid.uuid4())
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_meta_svc.update_metadata_name.return_value = {"id": metadata_id, "type": "string", "name": "New Name"}
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
method="PATCH",
json={"name": "New Name"},
):
api = DatasetMetadataServiceApi()
session = self.session
response, status = self._call_patch(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
metadata_id=metadata_id,
)
assert status == 200
assert response == {"id": metadata_id, "type": "string", "name": "New Name"}
mock_dataset_svc.get_dataset_for_tenant.assert_called_once_with(
mock_dataset.id, mock_tenant.id, session=session
)
mock_meta_svc.update_metadata_name.assert_called_once_with(
DatasetRef(mock_tenant.id, mock_dataset.id), metadata_id, "New Name", actor_id=account.id
)
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_update_metadata_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
metadata_id = str(uuid.uuid4())
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
method="PATCH",
json={"name": "x"},
):
api = DatasetMetadataServiceApi()
session = self.session
with pytest.raises(NotFound):
self._call_patch(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
metadata_id=metadata_id,
)
class TestDatasetMetadataServiceApiDelete(_UsesSQLiteSession):
"""Tests for DatasetMetadataServiceApi.delete().
``delete`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
"""
@staticmethod
def _call_delete(api: DatasetMetadataServiceApi, session: Session, **kwargs: object) -> tuple[str, int]:
return unwrap(api.delete)(api, session, **kwargs)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_delete_metadata_success(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test successful metadata deletion."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
metadata_id = str(uuid.uuid4())
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_meta_svc.delete_metadata.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
method="DELETE",
):
api = DatasetMetadataServiceApi()
session = self.session
response = self._call_delete(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
metadata_id=metadata_id,
)
assert response == ("", 204)
mock_dataset_svc.get_dataset_for_tenant.assert_called_once_with(
mock_dataset.id, mock_tenant.id, session=session
)
mock_meta_svc.delete_metadata.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id), metadata_id)
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_delete_metadata_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
metadata_id = str(uuid.uuid4())
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
method="DELETE",
):
api = DatasetMetadataServiceApi()
session = self.session
with pytest.raises(NotFound):
self._call_delete(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
metadata_id=metadata_id,
)
# ---------------------------------------------------------------------------
# DatasetMetadataBuiltInFieldServiceApi
# ---------------------------------------------------------------------------
class TestDatasetMetadataBuiltInFieldGet(_UsesSQLiteSession):
"""Tests for DatasetMetadataBuiltInFieldServiceApi.get()."""
@patch("controllers.service_api.dataset.metadata.application_services")
def test_get_built_in_fields_success(
self,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test successful built-in fields retrieval."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_meta_svc.get_built_in_fields.return_value = [
{"name": "source", "type": "string"},
]
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/built-in",
method="GET",
):
api = DatasetMetadataBuiltInFieldServiceApi()
response, status = api.get(
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
assert status == 200
assert response == {"fields": [{"name": "source", "type": "string"}]}
# ---------------------------------------------------------------------------
# DatasetMetadataBuiltInFieldActionServiceApi
# ---------------------------------------------------------------------------
class TestDatasetMetadataBuiltInFieldAction(_UsesSQLiteSession):
"""Tests for DatasetMetadataBuiltInFieldActionServiceApi.post().
``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
"""
@staticmethod
def _call_post(
api: DatasetMetadataBuiltInFieldActionServiceApi, session: Session, **kwargs: object
) -> tuple[dict[str, object], int]:
return unwrap(api.post)(api, session, **kwargs)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_enable_built_in_field(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test enabling built-in metadata field."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/built-in/enable",
method="POST",
):
api = DatasetMetadataBuiltInFieldActionServiceApi()
session = self.session
response, status = self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
action="enable",
)
assert status == 200
assert response["result"] == "success"
mock_meta_svc.enable_built_in_field.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id))
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_disable_built_in_field(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test disabling built-in metadata field."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/built-in/disable",
method="POST",
):
api = DatasetMetadataBuiltInFieldActionServiceApi()
session = self.session
response, status = self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
action="disable",
)
assert status == 200
mock_meta_svc.disable_built_in_field.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id))
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_action_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/metadata/built-in/enable",
method="POST",
):
api = DatasetMetadataBuiltInFieldActionServiceApi()
session = self.session
with pytest.raises(NotFound):
self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
action="enable",
)
# ---------------------------------------------------------------------------
# DocumentMetadataEditServiceApi
# ---------------------------------------------------------------------------
class TestDocumentMetadataEditPost(_UsesSQLiteSession):
"""Tests for DocumentMetadataEditServiceApi.post().
``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
"""
@staticmethod
def _call_post(
api: DocumentMetadataEditServiceApi, session: Session, **kwargs: object
) -> tuple[dict[str, object], int]:
metadata_args = MetadataOperationData.model_validate(request.get_json() or {})
return unwrap(api.post)(api, metadata_args, session, **kwargs)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_update_documents_metadata_success(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
account: Account,
) -> None:
"""Test successful documents metadata update."""
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_dataset_svc.check_dataset_permission.return_value = None
mock_meta_svc.update_documents_metadata.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/documents/metadata",
method="POST",
json={"operation_data": []},
):
api = DocumentMetadataEditServiceApi()
session = self.session
response, status = self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
assert status == 200
assert response["result"] == "success"
mock_meta_svc.update_documents_metadata.assert_called_once_with(
DatasetRef(mock_tenant.id, mock_dataset.id),
ANY,
actor_id=account.id,
)
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_update_documents_metadata_dataset_not_found(
self,
mock_dataset_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
"""Test 404 when dataset not found."""
mock_dataset_svc.get_dataset_for_tenant.return_value = None
with app.test_request_context(
f"/datasets/{mock_dataset.id}/documents/metadata",
method="POST",
json={"operation_data": []},
):
api = DocumentMetadataEditServiceApi()
session = self.session
with pytest.raises(NotFound):
self._call_post(
api,
session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
@patch("controllers.service_api.dataset.metadata.application_services")
@patch("controllers.service_api.dataset.metadata.DatasetService")
def test_update_documents_metadata_translates_missing_resource(
self,
mock_dataset_svc: MagicMock,
mock_meta_svc: MagicMock,
app: Flask,
mock_tenant: Tenant,
mock_dataset: Dataset,
) -> None:
mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
mock_meta_svc.update_documents_metadata.side_effect = MetadataResourceNotFoundError("Document not found.")
with app.test_request_context(
f"/datasets/{mock_dataset.id}/documents/metadata",
method="POST",
json={"operation_data": []},
):
api = DocumentMetadataEditServiceApi()
with pytest.raises(NotFound) as exc_info:
self._call_post(
api,
self.session,
tenant_id=mock_tenant.id,
dataset_id=uuid.UUID(mock_dataset.id),
)
assert exc_info.value.description == "Document not found."
@@ -0,0 +1,105 @@
from dataclasses import dataclass
from datetime import UTC, datetime
from inspect import unwrap
from uuid import UUID, uuid4
import pytest
from controllers.service_api.end_user import end_user as controller_module
from controllers.service_api.end_user.end_user import EndUserApi
from controllers.service_api.end_user.error import EndUserNotFoundError
from machinery.context import AppRequestContext
from models.model import App
from services.app_scoped_end_user_query_service import AppScopedEndUserNotFoundError
from services.entities.app_scoped_end_user_entities import AppScopedEndUserRecord
def _request_context(*, tenant_id: str = "workspace-1", app_id: str = "app-1") -> AppRequestContext:
return AppRequestContext(
tenant_id=tenant_id,
app_id=app_id,
)
class EndUserQueryServiceStub:
def __init__(self, result: AppScopedEndUserRecord | Exception) -> None:
self._result = result
self.calls: list[tuple[AppRequestContext, str]] = []
def get_by_id(self, context: AppRequestContext, end_user_id: str) -> AppScopedEndUserRecord:
self.calls.append((context, end_user_id))
if isinstance(self._result, Exception):
raise self._result
return self._result
class ApplicationServicesStub:
def __init__(self, end_user_queries: EndUserQueryServiceStub) -> None:
self.app_scoped_end_users = AppScopedEndUserServicesStub(end_user_queries)
@dataclass(eq=False, repr=False)
class AppScopedEndUserServicesStub:
queries: EndUserQueryServiceStub
class TestEndUserApi:
def test_get_end_user_returns_all_attributes(self, monkeypatch: pytest.MonkeyPatch) -> None:
end_user = AppScopedEndUserRecord(
id=str(uuid4()),
tenant_id=str(uuid4()),
app_id=str(uuid4()),
type="service-api",
external_user_id="external-123",
name="Alice",
is_anonymous=True,
session_id="session-xyz",
created_at=datetime(2024, 1, 1, tzinfo=UTC),
updated_at=datetime(2024, 1, 2, tzinfo=UTC),
)
context = _request_context(tenant_id=end_user.tenant_id, app_id=end_user.app_id)
service = EndUserQueryServiceStub(end_user)
monkeypatch.setattr(
controller_module,
"application_services",
lambda: ApplicationServicesStub(service),
)
result = unwrap(EndUserApi.get)(
EndUserApi(),
app_model=App(id=context.app_id, tenant_id=context.tenant_id),
end_user_id=UUID(end_user.id),
)
assert service.calls == [(context, end_user.id)]
assert result == {
"id": end_user.id,
"tenant_id": end_user.tenant_id,
"app_id": end_user.app_id,
"type": end_user.type,
"external_user_id": end_user.external_user_id,
"name": end_user.name,
"is_anonymous": True,
"session_id": end_user.session_id,
"created_at": "2024-01-01T00:00:00Z",
"updated_at": "2024-01-02T00:00:00Z",
}
def test_get_end_user_maps_application_not_found_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
context = _request_context()
service = EndUserQueryServiceStub(AppScopedEndUserNotFoundError())
monkeypatch.setattr(
controller_module,
"application_services",
lambda: ApplicationServicesStub(service),
)
end_user_id = uuid4()
with pytest.raises(EndUserNotFoundError):
unwrap(EndUserApi.get)(
EndUserApi(),
app_model=App(id=context.app_id, tenant_id=context.tenant_id),
end_user_id=end_user_id,
)
assert service.calls == [(context, str(end_user_id))]
@@ -0,0 +1,719 @@
from __future__ import annotations
from collections.abc import Callable
from typing import Literal, Protocol
import pytest
from flask import Flask
from flask_restx import Resource
from pydantic import BaseModel, ValidationError
from werkzeug.datastructures import FileStorage
from controllers.service_api.knowledge_fs import resources
from controllers.service_api.knowledge_fs.error import (
KnowledgeFSServiceInvalidRequestHTTPError,
KnowledgeFSServiceUpstreamUnavailableHTTPError,
)
from enums import DeploymentEdition
from libs.exception import BaseHTTPException
from services.knowledge_fs.product_dto import (
KnowledgeFSAdmittedQueryRequest,
KnowledgeFSBulkDocumentDeletePayload,
KnowledgeFSBulkJobResponse,
KnowledgeFSCrawlPreviewSelectionPayload,
KnowledgeFSDocumentCompilationJobResponse,
KnowledgeFSDocumentReindexPayload,
KnowledgeFSIdempotencyHeader,
KnowledgeFSLogicalDocumentDeletePayload,
KnowledgeFSQueryCreatePayload,
KnowledgeFSServiceSourceConnectionCreatePayload,
KnowledgeFSServiceSourceCreatePayload,
KnowledgeFSServiceSourceUpdatePayload,
)
from services.knowledge_fs.service_api_authorization import KnowledgeFSServiceApiProfile
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.controllers.knowledge_fs_controller_fakes import (
FakeComponent,
FakeRuntime,
Recorder,
invocation,
narrowed,
)
from tests.unit_tests.conftest import app as app # noqa: PLC0414
_NOW = "2026-09-17T00:00:00Z"
_FAILURE = {
"code": "KNOWLEDGE_FS_RATE_LIMITED",
"category": "rate_limit",
"message": "untrusted provider message",
"retryPolicy": "manual",
}
@pytest.fixture(autouse=True)
def _enabled_knowledge_fs(config_overrides: Callable[..., None]) -> None:
config_overrides(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
KNOWLEDGE_FS_ENABLED=True,
KNOWLEDGE_FS_COMMUNITY_DEV_ENABLED=True,
)
class _ReadResource(Protocol):
def get(self, *args: str) -> object: ...
def _job() -> dict[str, object]:
return {
"id": "job-1",
"knowledgeSpaceId": "space-1",
"checkpoint": "requested",
"runState": "queued",
"targetId": "document-1",
"targetType": "logical_document",
"createdAt": _NOW,
"updatedAt": _NOW,
}
def _workflow() -> dict[str, object]:
return {
"id": "run-1",
"knowledgeSpaceId": "space-1",
"sourceId": "source-1",
"kind": "source-sync",
"state": "queued",
"checkpoint": "queued",
"executionAttempts": 0,
"maxExecutionAttempts": 3,
"progressCompleted": 0,
"progressFailed": 0,
"progressSkipped": 0,
"createdAt": _NOW,
"updatedAt": _NOW,
}
@pytest.fixture
def runtime(monkeypatch: pytest.MonkeyPatch) -> FakeRuntime:
value = FakeRuntime(facade=FakeComponent(execute_service=Recorder()))
profile = KnowledgeFSServiceApiProfile(
tenant_id="tenant-1",
control_space_id="control-1",
api_token_id="token-1",
principal_id="principal-1",
knowledge_space_id="space-1",
knowledge_space_revision=1,
membership_epoch=1,
space_acl_epoch=1,
external_access_epoch=1,
content_policy_revision=1,
)
monkeypatch.setattr(resources, "_runtime", lambda: value)
monkeypatch.setattr(resources, "_profile", lambda *_args, **_kwargs: profile)
return value
@pytest.mark.parametrize("bad", [" leading-key", "trailing-key ", "newline\nkey", "tab\tkey", "unicode-键", "nul\0key"])
def test_idempotency_header_rejects_invalid_wire_values(bad: str) -> None:
with pytest.raises(ValidationError):
KnowledgeFSIdempotencyHeader.model_validate({"Idempotency-Key": bad})
def test_utf8_budget_is_identical_for_admission_and_stream() -> None:
within = "汉" * 5461 + "a"
assert len(within.encode()) == 16384
assert KnowledgeFSQueryCreatePayload(query=within).query == within
assert KnowledgeFSAdmittedQueryRequest(query=within, knowledgeSpaceId="space-1").query == within
for model, extra in [
(KnowledgeFSQueryCreatePayload, dict[str, str]()),
(KnowledgeFSAdmittedQueryRequest, {"knowledgeSpaceId": "space-1"}),
]:
with pytest.raises(ValidationError):
model.model_validate({"query": within + "a", **extra})
def test_public_batches_bound_manifest_before_remote_calls() -> None:
documents = [{"documentId": str(index), "expectedRevision": 1} for index in range(101)]
KnowledgeFSBulkDocumentDeletePayload.model_validate({"documents": documents[:100]})
with pytest.raises(ValidationError):
KnowledgeFSBulkDocumentDeletePayload.model_validate({"documents": documents})
with pytest.raises(ValidationError):
KnowledgeFSDocumentReindexPayload.model_validate({"documentIds": [str(index) for index in range(101)]})
@pytest.mark.parametrize(
"payload", [{"selection": {}}, {"syncPolicy": {}}, {"metadata": {"syncPolicy": {"everyHours": 24}}}]
)
def test_service_source_update_does_not_advertise_console_only_fields(payload: dict[str, object]) -> None:
with pytest.raises(ValidationError):
KnowledgeFSServiceSourceUpdatePayload.model_validate({"name": "edited", **payload})
def test_service_sources_retain_managed_credentials_and_scope_boundaries() -> None:
source = {"name": "source", "type": "web", "uri": "https://example.com"}
for extra in [{"credentials": {"secret": "not-allowed"}}, {"permissionScope": ["scope-a"]}]:
with pytest.raises(ValidationError):
KnowledgeFSServiceSourceCreatePayload.model_validate({**source, **extra})
assert KnowledgeFSServiceSourceCreatePayload.model_validate(source).permission_scope == []
with pytest.raises(ValidationError):
KnowledgeFSServiceSourceConnectionCreatePayload.model_validate(
{"name": "binding", "providerId": "plugin-daemon-website", "credentials": {"apiKey": "secret"}}
)
def test_compilation_and_bulk_failures_survive_safe_serialization() -> None:
compilation = KnowledgeFSDocumentCompilationJobResponse.model_validate(
{
"id": "job-1",
"knowledgeSpaceId": "space-1",
"documentAssetId": "asset-1",
"stage": "failed",
"createdAt": 1,
"updatedAt": 2,
"version": 1,
"failure": _FAILURE,
}
).model_dump(mode="json")
assert compilation["failure"]["code"] == "KNOWLEDGE_FS_RATE_LIMITED"
assert "untrusted" not in compilation["failure"]["message"]
bulk = KnowledgeFSBulkJobResponse.model_validate(
{
"id": "bulk-1",
"knowledgeSpaceId": "space-1",
"createdAt": _NOW,
"updatedAt": _NOW,
"type": "document_reindex",
"status": "failed",
"totalItems": 1,
"completedItems": 0,
"canceledItems": 0,
"failedItems": 1,
"failedItemIds": ["document-1"],
"failures": [
{
"documentId": "document-1",
"jobId": "job-1",
"errorCode": "KNOWLEDGE_FS_RATE_LIMITED",
"errorMessage": "Safe error",
"failure": _FAILURE,
}
],
}
).model_dump(mode="json")
assert bulk["failures"][0]["job_id"] == "job-1"
assert bulk["failures"][0]["failure"]["code"] == "KNOWLEDGE_FS_RATE_LIMITED"
def test_logical_read_exposes_current_cas_and_pagination(runtime: FakeRuntime) -> None:
raw = {
"id": "doc-1",
"knowledgeSpaceId": "space-1",
"active": None,
"rowVersion": 7,
"title": "Document",
"status": "pending",
"userMetadata": {"team": "docs"},
"createdAt": _NOW,
"updatedAt": _NOW,
}
runtime.facade.execute_service.return_value = {"items": [raw], "nextCursor": "next"}
with Flask(__name__).test_request_context("/?limit=17&cursor=prev"):
result = resources.KnowledgeFSServiceLogicalDocumentsApi().get("control-1")
assert isinstance(result, dict)
documents = result["data"]
assert isinstance(documents, list)
document = documents[0]
assert isinstance(document, dict)
assert document["row_version"] == 7
assert document["id"] == "doc-1"
assert runtime.facade.execute_service.last_call.kwargs["query"] == (("limit", "17"), ("cursor", "prev"))
def test_logical_delete_uses_row_version_and_public_deletion_status(
runtime: FakeRuntime, monkeypatch: pytest.MonkeyPatch
) -> None:
apply_config_overrides(monkeypatch, SERVICE_API_URL="https://api.example/v1")
runtime.facade.execute_service.return_value = {
"job": _job(),
"statusUrl": "http://internal/deletion-jobs/job-1",
}
with Flask(__name__).test_request_context(
"/",
method="DELETE",
json={"expectedRevision": 0},
headers={"Idempotency-Key": "logical-delete-1"},
):
result, status, headers = resources.KnowledgeFSServiceLogicalDocumentApi().delete("control-1", "document-1")
assert status == 202
assert isinstance(result, dict)
job = result["job"]
assert isinstance(job, dict)
assert job["target_type"] == "logical_document"
assert headers["Location"] == "https://api.example/v1/knowledge-fs/spaces/control-1/deletion-jobs/job-1"
assert result["status_url"] == headers["Location"]
kwargs = runtime.facade.execute_service.last_call.kwargs
assert kwargs["operation_id"] == "deleteLogicalDocument"
assert kwargs["resource_id"] == "document-1"
assert kwargs["path_parameters"] == (("documentId", "document-1"),)
assert kwargs["headers"] == (("Idempotency-Key", "logical-delete-1"),)
assert isinstance(kwargs["payload"], KnowledgeFSLogicalDocumentDeletePayload)
assert kwargs["payload"].expected_revision == 0
def test_deletion_links_and_partial_batch_results_stay_on_public_origin(
runtime: FakeRuntime, monkeypatch: pytest.MonkeyPatch
) -> None:
apply_config_overrides(monkeypatch, SERVICE_API_URL="https://api.example/v1")
accepted = {"documentId": "document-1", "job": _job(), "statusUrl": "http://internal/deletion-jobs/job-1"}
runtime.facade.execute_service.return_value = {
"items": [accepted],
"total": 2,
"batchId": "batch-1",
"statusUrl": "http://internal/batches/batch-1",
"results": [
{**accepted, "status": "accepted"},
{
"documentId": "document-2",
"status": "rejected",
"error": {"code": "CONFLICT", "message": "Safe", "retryable": False},
},
],
}
with Flask(__name__).test_request_context(
"/",
method="DELETE",
json={"documents": [{"documentId": "document-1", "expectedRevision": 1}]},
headers={"Idempotency-Key": "delete-once"},
):
result, status, headers = resources.KnowledgeFSServiceBulkDocumentsApi().delete("control-1")
assert status == 202
assert headers["Location"] == "https://api.example/v1/knowledge-fs/spaces/control-1/deletion-batches/batch-1"
assert isinstance(result, dict)
results = result["results"]
assert isinstance(results, list)
rejected_result = results[1]
assert isinstance(rejected_result, dict)
assert rejected_result["status"] == "rejected"
accepted_result = results[0]
assert isinstance(accepted_result, dict)
assert accepted_result["status_url"] == "https://api.example/v1/knowledge-fs/spaces/control-1/deletion-jobs/job-1"
assert "internal" not in str(result)
@pytest.mark.parametrize("kind", ["pages", "files"])
def test_legacy_source_import_adapts_coordinates_and_admits_durable_workflow(runtime: FakeRuntime, kind: str) -> None:
runtime.facade.execute_service.return_value = _workflow()
if kind == "pages":
payload = {"pages": [{"workspaceId": "ws-1", "pageId": "page-1", "type": "page"}]}
resource = resources.KnowledgeFSServiceSourcePageImportApi()
coordinate = '["ws-1","page-1"]'
else:
payload = {"files": [{"bucket": "bucket-1", "id": "file-1", "name": "file.txt"}]}
resource = resources.KnowledgeFSServiceSourceFileImportApi()
coordinate = '["bucket-1","file-1"]'
with Flask(__name__).test_request_context(
"/", method="POST", json=payload, headers={"Idempotency-Key": "import-once"}
):
result, status = resource.post("control-1", "source-1")
assert status == 202
assert isinstance(result, dict)
assert result["id"] == "run-1"
kwargs = runtime.facade.execute_service.last_call.kwargs
assert kwargs["operation_id"] == "importSourceWorkflow"
assert kwargs["headers"] == (("Idempotency-Key", "import-once"),)
forwarded = narrowed(kwargs["payload"], BaseModel).model_dump(mode="json", by_alias=True)
assert forwarded["items"][0]["providerItemId"] == coordinate
def test_malformed_upstream_is_502_and_invalid_input_is_400_without_input_echo(runtime: FakeRuntime) -> None:
runtime.facade.execute_service.return_value = dict[str, object]()
with Flask(__name__).test_request_context("/"):
with pytest.raises(KnowledgeFSServiceUpstreamUnavailableHTTPError):
resources.KnowledgeFSServiceLogicalDocumentApi().get("control-1", "doc-1")
runtime.facade.execute_service.calls.clear()
with Flask(__name__).test_request_context("/?limit=private-invalid-value"):
with pytest.raises(KnowledgeFSServiceInvalidRequestHTTPError) as caught:
resources.KnowledgeFSServiceLogicalDocumentsApi().get("control-1")
assert "private-invalid-value" not in str(caught.value.data)
assert runtime.facade.execute_service.calls == []
def test_resume_binds_original_task_and_processing_history_preserves_superseded(runtime: FakeRuntime) -> None:
runtime.facade.execute_service.return_value = {
"items": [
{
"id": "attempt-1",
"documentId": "doc-1",
"documentRevision": 1,
"knowledgeSpaceId": "space-1",
"state": "superseded",
"stage": "queued",
"progressPercent": 0,
"createdAt": _NOW,
"updatedAt": _NOW,
}
]
}
with Flask(__name__).test_request_context("/"):
response = resources.KnowledgeFSServiceDocumentProcessingTasksApi().get("control-1", "doc-1")
assert isinstance(response, dict)
tasks = response["data"]
assert isinstance(tasks, list)
task = tasks[0]
assert isinstance(task, dict)
assert task["state"] == "superseded"
assert runtime.facade.execute_service.last_call.kwargs["resource_id"] == "doc-1"
runtime.facade.execute_service.return_value = {
"id": "task-1",
"knowledgeSpaceId": "space-1",
"query": "q",
"cost": dict[str, object](),
"metadata": dict[str, object](),
"stage": "retrieving",
"createdAt": 1,
"updatedAt": 2,
}
with Flask(__name__).test_request_context("/", method="POST"):
response = resources.KnowledgeFSServiceResearchTaskResumeApi().post("control-1", "task-1")
assert isinstance(response, dict)
assert response["id"] == "task-1"
assert runtime.facade.execute_service.last_call.kwargs["operation_id"] == "resumeResearchTask"
assert runtime.facade.execute_service.last_call.kwargs["resource_id"] == "task-1"
@pytest.mark.parametrize("status", [503, 504])
def test_service_preserves_temporary_failure_status_and_safe_violations(status: Literal[503, 504]) -> None:
from services.knowledge_fs.errors import KnowledgeFSProductRequestRejectedError
@resources._service_api_errors
def rejected() -> None:
raise KnowledgeFSProductRequestRejectedError(
status_code=status,
violations=[{"field": ["query"], "type": "too_long"}],
)
with pytest.raises(BaseHTTPException) as error:
rejected()
assert error.value.code == status
assert error.value.data is not None
assert error.value.data["violations"] == [{"field": ["query"], "type": "too_long"}]
@pytest.mark.usefixtures("runtime")
def test_service_image_upload_uses_authenticated_profile_and_typed_response(monkeypatch: pytest.MonkeyPatch) -> None:
import io
upload = Recorder({"upload_file_id": "image-1", "byte_size": 8, "mime_type": "image/png"})
monkeypatch.setattr(resources, "upload_service_query_image", upload)
with Flask(__name__).test_request_context("/", method="POST", data={"file": (io.BytesIO(b"fakepng"), "image.png")}):
response, status = resources.KnowledgeFSServiceQueryImagesApi().post("control-1")
assert status == 201
assert response == {"upload_file_id": "image-1", "byte_size": 8, "mime_type": "image/png"}
assert narrowed(upload.last_call.kwargs["profile"], KnowledgeFSServiceApiProfile).tenant_id == "tenant-1"
assert narrowed(upload.last_call.kwargs["file"], FileStorage).filename == "image.png"
def test_image_admission_checks_ownership_before_issuing_a_capability(
runtime: FakeRuntime, monkeypatch: pytest.MonkeyPatch
) -> None:
from services.knowledge_fs.errors import KnowledgeFSProductRequestRejectedError
runtime.broker = FakeComponent(issue_service=Recorder())
validator = Recorder(raises=KnowledgeFSProductRequestRejectedError(status_code=422))
monkeypatch.setattr(resources, "validate_service_query_image_references", validator)
with Flask(__name__).test_request_context(
"/",
method="POST",
json={"queryImages": [{"uploadFileId": "b3d672a0-f379-4c3a-ad89-6eac80aa3efd"}]},
):
with pytest.raises(BaseHTTPException) as error:
resources.KnowledgeFSServiceQueryAdmissionApi().post("control-1")
assert error.value.code == 422
assert runtime.broker.issue_service.calls == []
assert len(validator.calls) == 1
def test_atomic_crawl_edit_rejects_inline_document_content() -> None:
from services.knowledge_fs.product_dto import KnowledgeFSCrawlImportPayload
payload = {
"sourceUrls": ["https://example.com/a"],
"pages": [{"sourceUrl": "https://example.com/a", "content": "document"}],
}
assert KnowledgeFSCrawlImportPayload.model_validate(payload).pages is not None
with pytest.raises(ValidationError):
KnowledgeFSCrawlImportPayload.model_validate(
{
**payload,
"sourceUpdate": {"expectedVersion": 3},
"desiredSyncPolicy": {"enabled": False, "mode": "manual"},
}
)
@pytest.mark.parametrize(
("controller", "arguments", "operation", "resource_id", "path_parameters"),
[
(
resources.KnowledgeFSServiceDeletionJobApi,
("control-1", "job-1"),
"getDeletionJob",
"job-1",
(("jobId", "job-1"),),
),
(
resources.KnowledgeFSServiceSettingsMigrationApi,
("control-1", "migration-1"),
"getProfileMigration",
None,
(("migrationId", "migration-1"),),
),
(
resources.KnowledgeFSServiceSourceSyncPolicyApi,
("control-1", "source-1"),
"getSourceSyncPolicy",
"source-1",
(("sourceId", "source-1"),),
),
(
resources.KnowledgeFSServiceSourceWorkflowApi,
("control-1", "run-1"),
"getSourceWorkflow",
"run-1",
(("runId", "run-1"),),
),
(
resources.KnowledgeFSServiceDocumentProcessingTaskApi,
("control-1", "document-1", "task-1"),
"getDocumentProcessingTask",
"task-1",
(("documentId", "document-1"), ("taskId", "task-1")),
),
],
)
def test_recovery_reads_keep_the_authorized_space_and_child_resource_binding(
runtime: FakeRuntime,
monkeypatch: pytest.MonkeyPatch,
controller: Callable[[], _ReadResource],
arguments: tuple[str, ...],
operation: str,
resource_id: str | None,
path_parameters: tuple[tuple[str, str], ...],
) -> None:
profile = object()
authorize = Recorder(profile)
monkeypatch.setattr(resources, "_profile", authorize)
monkeypatch.setattr(resources, "_dump_response", lambda _schema, raw: raw)
upstream = {"id": resource_id}
runtime.facade.execute_service.return_value = upstream
with Flask(__name__).test_request_context("/", method="GET"):
assert controller().get(*arguments) is upstream
assert authorize.calls == [invocation(runtime, operation_id=operation, control_space_id="control-1")]
call = runtime.facade.execute_service.last_call.kwargs
assert call["profile"] is profile
assert call["operation_id"] == operation
assert call["resource_id"] == resource_id
assert call["path_parameters"] == path_parameters
def test_source_workflow_history_keeps_source_filter_and_bounded_pagination(
runtime: FakeRuntime, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setattr(resources, "_dump_response", lambda _schema, raw: raw)
with Flask(__name__).test_request_context("/?source_id=source-1&cursor=next-page&limit=25"):
resources.KnowledgeFSServiceSourceWorkflowsApi().get("control-1")
call = runtime.facade.execute_service.last_call.kwargs
assert call["operation_id"] == "listSourceWorkflows"
query = call["query"]
assert isinstance(query, tuple)
assert dict(query) == {"sourceId": "source-1", "cursor": "next-page", "limit": "25"}
def test_preview_selection_is_a_durable_idempotent_import_admission(runtime: FakeRuntime) -> None:
runtime.facade.execute_service.return_value = _workflow()
with Flask(__name__).test_request_context(
"/",
method="POST",
json={"pageIds": ["page-1"]},
headers={"Idempotency-Key": "selection-request-1"},
):
result, status = resources.KnowledgeFSServiceCrawlPreviewSelectionApi().post("control-1", "run-1")
assert status == 202
assert isinstance(result, dict)
assert result["id"] == "run-1"
call = runtime.facade.execute_service.last_call.kwargs
assert call["operation_id"] == "selectCrawlPreviewPages"
assert call["resource_id"] == "run-1"
assert call["headers"] == (("Idempotency-Key", "selection-request-1"),)
assert narrowed(call["payload"], KnowledgeFSCrawlPreviewSelectionPayload).page_ids == ["page-1"]
@pytest.mark.parametrize(
("controller", "method", "arguments", "operation", "body", "resource_id", "path_parameters", "requires_key"),
[
(
resources.KnowledgeFSServiceSourceSyncApi,
resources.KnowledgeFSServiceSourceSyncApi.post,
("control-1", "source-1"),
"syncSource",
None,
"source-1",
(("sourceId", "source-1"),),
True,
),
(
resources.KnowledgeFSServiceSourceCrawlPreviewApi,
resources.KnowledgeFSServiceSourceCrawlPreviewApi.post,
("control-1", "source-1"),
"previewSourceCrawl",
None,
"source-1",
(("sourceId", "source-1"),),
True,
),
(
resources.KnowledgeFSServiceSourceCrawlImportApi,
resources.KnowledgeFSServiceSourceCrawlImportApi.post,
("control-1", "source-1"),
"importSelectedSourceCrawl",
{"sourceUrls": ["https://example.com/a"]},
"source-1",
(("sourceId", "source-1"),),
True,
),
(
resources.KnowledgeFSServiceSourceWorkflowImportApi,
resources.KnowledgeFSServiceSourceWorkflowImportApi.post,
("control-1", "source-1"),
"importSourceWorkflow",
{
"kind": "online-drive-import",
"items": [{"id": "file-1", "name": "file.pdf", "providerItemId": "provider-1"}],
},
"source-1",
(("sourceId", "source-1"),),
True,
),
(
resources.KnowledgeFSServiceSourceSyncPolicyApi,
resources.KnowledgeFSServiceSourceSyncPolicyApi.put,
("control-1", "source-1"),
"updateSourceSyncPolicy",
{"expectedRevision": 3, "expectedSourceVersion": 4, "enabled": False, "mode": "manual"},
"source-1",
(("sourceId", "source-1"),),
False,
),
(
resources.KnowledgeFSServiceSourceConnectionsApi,
resources.KnowledgeFSServiceSourceConnectionsApi.get,
("control-1",),
"listSourceConnections",
None,
None,
(),
False,
),
(
resources.KnowledgeFSServiceSourceConnectionsApi,
resources.KnowledgeFSServiceSourceConnectionsApi.post,
("control-1",),
"createSourceConnection",
{
"name": "managed binding",
"providerId": "plugin-daemon-website",
"configuration": {"credentialId": "credential-1"},
},
None,
(),
False,
),
(
resources.KnowledgeFSServiceSourceConnectionRefreshApi,
resources.KnowledgeFSServiceSourceConnectionRefreshApi.post,
("control-1", "connection-1"),
"refreshSourceConnection",
{"expectedVersion": 3},
None,
(("connectionId", "connection-1"),),
False,
),
(
resources.KnowledgeFSServiceSourceWorkflowCancelApi,
resources.KnowledgeFSServiceSourceWorkflowCancelApi.post,
("control-1", "run-1"),
"cancelSourceWorkflow",
{"reason": "source selection changed"},
"run-1",
(("runId", "run-1"),),
False,
),
(
resources.KnowledgeFSServiceSourceWorkflowRetryApi,
resources.KnowledgeFSServiceSourceWorkflowRetryApi.post,
("control-1", "run-1"),
"retrySourceWorkflow",
None,
"run-1",
(("runId", "run-1"),),
False,
),
(
resources.KnowledgeFSServiceCrawlPreviewPagesApi,
resources.KnowledgeFSServiceCrawlPreviewPagesApi.get,
("control-1", "run-1"),
"listCrawlPreviewPages",
None,
"run-1",
(("runId", "run-1"),),
False,
),
(
resources.KnowledgeFSServiceSourceProvidersApi,
resources.KnowledgeFSServiceSourceProvidersApi.get,
("control-1",),
"listSourceProviders",
None,
None,
(),
False,
),
],
)
def test_durable_source_contracts_bind_the_original_profile_and_resource(
runtime: FakeRuntime,
monkeypatch: pytest.MonkeyPatch,
controller: type[Resource],
method: Callable[..., object],
arguments: tuple[str, ...],
operation: str,
body: dict[str, object] | None,
resource_id: str | None,
path_parameters: tuple[tuple[str, str], ...],
requires_key: bool,
) -> None:
profile = object()
authorize = Recorder(profile)
monkeypatch.setattr(resources, "_profile", authorize)
monkeypatch.setattr(resources, "_dump_response", lambda _schema, raw: raw)
with Flask(__name__).test_request_context(
"/",
method=method.__name__.upper(),
json=body,
headers={"Idempotency-Key": "source-command-1"},
):
method(controller(), *arguments)
assert authorize.calls == [invocation(runtime, operation_id=operation, control_space_id="control-1")]
call = runtime.facade.execute_service.last_call.kwargs
assert call["profile"] is profile
assert call["resource_id"] == resource_id
assert call["path_parameters"] == path_parameters
if requires_key:
assert call["headers"] == (("Idempotency-Key", "source-command-1"),)
if body is not None:
forwarded = narrowed(call["payload"], BaseModel).model_dump(by_alias=True, exclude_none=True)
for field, value in body.items():
assert forwarded[field] == value
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,81 @@
"""
Unit tests for Service API Index endpoint
"""
from unittest.mock import patch
import pytest
from flask import Flask
from controllers.service_api import bp as service_api_bp
from controllers.service_api import index as index_module
from controllers.service_api.index import IndexApi
def _get_index_response(app: Flask, version: str) -> dict[str, str]:
with patch.object(index_module.dify_config.project, "version", version):
with app.test_request_context("/", method="GET"):
index_api = IndexApi()
return index_api.get()
class TestIndexApi:
"""Test suite for IndexApi resource."""
def test_get_returns_api_info(self, app: Flask) -> None:
"""Test that GET returns API metadata with correct structure."""
# Act
response = _get_index_response(app, "1.0.0-test")
# Assert
assert response["welcome"] == "Dify OpenAPI"
assert response["api_version"] == "v1"
assert response["server_version"] == "1.0.0-test"
def test_get_response_has_required_fields(self, app: Flask) -> None:
"""Test that response contains all required fields."""
# Act
response = _get_index_response(app, "1.11.4")
# Assert
assert "welcome" in response
assert "api_version" in response
assert "server_version" in response
assert isinstance(response["welcome"], str)
assert isinstance(response["api_version"], str)
assert isinstance(response["server_version"], str)
@pytest.mark.parametrize("version", ["0.0.1", "1.0.0", "2.0.0-beta", "1.11.4"])
def test_get_returns_correct_version(self, app: Flask, version: str) -> None:
"""Test that server_version matches config version."""
# Act
response = _get_index_response(app, version)
# Assert
assert response["server_version"] == version
def test_root_route_returns_public_api_info(self) -> None:
"""Exercise the registered blueprint so Flask-RESTX cannot shadow the resource."""
app = Flask(__name__)
app.config["TESTING"] = True
app.register_blueprint(service_api_bp)
with patch.object(index_module.dify_config.project, "version", "1.0.0-route-test"):
response = app.test_client().get("/v1/")
assert response.status_code == 200
assert response.get_json() == {
"welcome": "Dify OpenAPI",
"api_version": "v1",
"server_version": "1.0.0-route-test",
}
root_rules = [rule for rule in app.url_map.iter_rules() if rule.rule == "/v1/"]
assert [rule.endpoint for rule in root_rules] == ["service_api.root"]
def test_datasource_credentials_route_is_not_registered(self) -> None:
app = Flask(__name__)
app.config["TESTING"] = True
app.register_blueprint(service_api_bp)
assert not any(rule.rule == "/v1/datasource-credentials" for rule in app.url_map.iter_rules())
assert app.test_client().get("/v1/datasource-credentials").status_code == 404
File diff suppressed because it is too large. Load diff