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