Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

refactor: isolate saved message persistence (#41857)

非法操作c592610ed361
diff --git a/api/controllers/console/explore/saved_message.py b/api/controllers/console/explore/saved_message.py
index 7facb7fd530..07b40a20e80 100644
--- a/api/controllers/console/explore/saved_message.py
+++ b/api/controllers/console/explore/saved_message.py
@@ -1,6 +1,5 @@
from uuid import UUID
-from pydantic import TypeAdapter
from werkzeug.exceptions import NotFound
from controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQuery
@@ -9,64 +8,71 @@ from controllers.console import console_ns
from controllers.console.app.error import AppUnavailableError
from controllers.console.explore.error import NotCompletionAppError
from controllers.console.explore.wraps import InstalledAppResource
-from controllers.console.wraps import model_validate, with_current_user
-from extensions.ext_database import db
-from fields.conversation_fields import MessageResponseSource, ResultResponse
-from fields.message_fields import SavedMessageInfiniteScrollPagination, SavedMessageItem
-from models import Account
+from controllers.console.wraps import model_validate, with_current_user_id
+from extensions.ext_application_services import application_services
+from fields.conversation_fields import ResultResponse
+from fields.message_fields import SavedMessageInfiniteScrollPagination
+from libs.helper import dump_response
from models.model import InstalledApp
+from services.app_definition_query_service import AppDefinitionUnavailableError
from services.errors.message import MessageNotExistsError
-from services.saved_message_service import SavedMessageService
+from services.saved_message_service import SavedMessageActor
register_schema_models(console_ns, SavedMessageListQuery, SavedMessageCreatePayload)
register_response_schema_models(console_ns, ResultResponse, SavedMessageInfiniteScrollPagination)
+def _require_completion_app(installed_app: InstalledApp) -> str:
+ app_id = installed_app.app_id
+ try:
+ mode = application_services().app_definitions.get_mode(app_id)
+ except AppDefinitionUnavailableError:
+ raise AppUnavailableError() from None
+
+ if mode != "completion":
+ raise NotCompletionAppError()
+ return app_id
+
+
@console_ns.route("/installed-apps/<uuid:installed_app_id>/saved-messages", endpoint="installed_app_saved_messages")
class SavedMessageListApi(InstalledAppResource):
@console_ns.doc(params=query_params_from_model(SavedMessageListQuery))
@console_ns.response(200, "Success", console_ns.models[SavedMessageInfiniteScrollPagination.__name__])
- @with_current_user
+ @with_current_user_id
@model_validate(SavedMessageListQuery)
- def get(self, req_data: SavedMessageListQuery, current_user: Account, installed_app: InstalledApp):
- session = db.session()
- app_model = installed_app.app_with_session(session=session)
- if app_model is None:
- raise AppUnavailableError()
- if app_model.mode != "completion":
- raise NotCompletionAppError()
-
- pagination = SavedMessageService.pagination_by_last_id(
- app_model,
- current_user,
- str(req_data.last_id) if req_data.last_id else None,
- req_data.limit,
- session=session,
+ def get(
+ self,
+ req_data: SavedMessageListQuery,
+ current_user_id: str,
+ installed_app: InstalledApp,
+ ) -> dict[str, object]:
+ app_id = _require_completion_app(installed_app)
+ pagination = application_services().saved_messages.pagination_by_last_id(
+ app_id=app_id,
+ actor=SavedMessageActor.account(current_user_id),
+ last_id=str(req_data.last_id) if req_data.last_id else None,
+ limit=req_data.limit,
)
- adapter = TypeAdapter(SavedMessageItem)
- items = [
- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)
- for message in pagination.data
- ]
- return SavedMessageInfiniteScrollPagination(
- limit=pagination.limit,
- has_more=pagination.has_more,
- data=items,
- ).model_dump(mode="json")
+ return dump_response(SavedMessageInfiniteScrollPagination, pagination)
@console_ns.expect(console_ns.models[SavedMessageCreatePayload.__name__])
@console_ns.response(200, "Success", console_ns.models[ResultResponse.__name__])
- @with_current_user
+ @with_current_user_id
@model_validate(SavedMessageCreatePayload)
- def post(self, req_data: SavedMessageCreatePayload, current_user: Account, installed_app: InstalledApp):
- app_model = installed_app.app_with_session(session=db.session())
- if app_model is None:
- raise AppUnavailableError()
- if app_model.mode != "completion":
- raise NotCompletionAppError()
+ def post(
+ self,
+ req_data: SavedMessageCreatePayload,
+ current_user_id: str,
+ installed_app: InstalledApp,
+ ) -> dict[str, object]:
+ app_id = _require_completion_app(installed_app)
try:
- SavedMessageService.save(app_model, current_user, str(req_data.message_id), session=db.session())
+ application_services().saved_messages.save(
+ app_id=app_id,
+ actor=SavedMessageActor.account(current_user_id),
+ message_id=str(req_data.message_id),
+ )
except MessageNotExistsError:
raise NotFound("Message Not Exists.")
@@ -78,17 +84,18 @@ class SavedMessageListApi(InstalledAppResource):
)
class SavedMessageApi(InstalledAppResource):
@console_ns.response(204, "Saved message deleted successfully")
- @with_current_user
- def delete(self, current_user: Account, installed_app: InstalledApp, message_id: UUID):
- app_model = installed_app.app_with_session(session=db.session())
- if app_model is None:
- raise AppUnavailableError()
-
- message_id_str = str(message_id)
-
- if app_model.mode != "completion":
- raise NotCompletionAppError()
-
- SavedMessageService.delete(app_model, current_user, message_id_str, session=db.session())
+ @with_current_user_id
+ def delete(
+ self,
+ current_user_id: str,
+ installed_app: InstalledApp,
+ message_id: UUID,
+ ) -> tuple[str, int]:
+ app_id = _require_completion_app(installed_app)
+ application_services().saved_messages.delete(
+ app_id=app_id,
+ actor=SavedMessageActor.account(current_user_id),
+ message_id=str(message_id),
+ )
return "", 204
diff --git a/api/controllers/web/saved_message.py b/api/controllers/web/saved_message.py
index eed4aed5ed6..6549a8e2148 100644
--- a/api/controllers/web/saved_message.py
+++ b/api/controllers/web/saved_message.py
@@ -1,21 +1,20 @@
from uuid import UUID
-from pydantic import TypeAdapter
-from sqlalchemy.orm import Session
from werkzeug.exceptions import NotFound
from controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQuery
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
-from controllers.console.app.wraps import with_session
from controllers.console.wraps import model_validate
from controllers.web import web_ns
from controllers.web.error import NotCompletionAppError
from controllers.web.wraps import WebApiResource
-from fields.conversation_fields import MessageResponseSource, ResultResponse
-from fields.message_fields import SavedMessageInfiniteScrollPagination, SavedMessageItem
+from extensions.ext_application_services import application_services
+from fields.conversation_fields import ResultResponse
+from fields.message_fields import SavedMessageInfiniteScrollPagination
+from libs.helper import dump_response
from models.model import App, EndUser
from services.errors.message import MessageNotExistsError
-from services.saved_message_service import SavedMessageService
+from services.saved_message_service import SavedMessageActor
register_schema_models(web_ns, SavedMessageListQuery, SavedMessageCreatePayload)
register_response_schema_models(web_ns, ResultResponse, SavedMessageInfiniteScrollPagination)
@@ -37,23 +36,18 @@ class SavedMessageListApi(WebApiResource):
}
)
@web_ns.response(200, "Success", web_ns.models[SavedMessageInfiniteScrollPagination.__name__])
- @with_session(write=False)
@model_validate(SavedMessageListQuery)
- def get(self, query: SavedMessageListQuery, session: Session, app_model: App, end_user: EndUser):
+ def get(self, query: SavedMessageListQuery, app_model: App, end_user: EndUser) -> dict[str, object]:
if app_model.mode != "completion":
raise NotCompletionAppError()
- pagination = SavedMessageService.pagination_by_last_id(
- app_model, end_user, query.last_id, query.limit, session=session
+ pagination = application_services().saved_messages.pagination_by_last_id(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ last_id=query.last_id,
+ limit=query.limit,
)
- adapter = TypeAdapter(SavedMessageItem)
- items = [
- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)
- for message in pagination.data
- ]
- return SavedMessageInfiniteScrollPagination(
- limit=pagination.limit, has_more=pagination.has_more, data=items
- ).model_dump(mode="json")
+ return dump_response(SavedMessageInfiniteScrollPagination, pagination)
@web_ns.doc("Save Message")
@web_ns.doc(description="Save a specific message for later reference.")
@@ -74,14 +68,17 @@ class SavedMessageListApi(WebApiResource):
)
@web_ns.response(200, "Message saved successfully", web_ns.models[ResultResponse.__name__])
@web_ns.expect(web_ns.models[SavedMessageCreatePayload.__name__])
- @with_session
@model_validate(SavedMessageCreatePayload)
- def post(self, payload: SavedMessageCreatePayload, session: Session, app_model: App, end_user: EndUser):
+ def post(self, payload: SavedMessageCreatePayload, app_model: App, end_user: EndUser) -> dict[str, object]:
if app_model.mode != "completion":
raise NotCompletionAppError()
try:
- SavedMessageService.save(app_model, end_user, payload.message_id, session=session)
+ application_services().saved_messages.save(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ message_id=payload.message_id,
+ )
except MessageNotExistsError:
raise NotFound("Message Not Exists.")
@@ -104,13 +101,16 @@ class SavedMessageApi(WebApiResource):
}
)
@web_ns.response(204, "Message removed successfully")
- @with_session
- def delete(self, session: Session, app_model: App, end_user: EndUser, message_id: UUID):
+ def delete(self, app_model: App, end_user: EndUser, message_id: UUID) -> tuple[str, int]:
message_id_str = str(message_id)
if app_model.mode != "completion":
raise NotCompletionAppError()
- SavedMessageService.delete(app_model, end_user, message_id_str, session=session)
+ application_services().saved_messages.delete(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ message_id=message_id_str,
+ )
return "", 204
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index 9695f44427b..095e8b3c761 100644
--- a/api/extensions/ext_application_services.py
+++ b/api/extensions/ext_application_services.py
@@ -58,6 +58,7 @@ from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessToke
from repositories.oauth_server_repository import RedisOAuthServerTokenRepository, SQLAlchemyOAuthServerRepository
from repositories.plugin_file_upload_repository import SQLAlchemyPluginFileUploadOwnerRepository
from repositories.recommended_app_catalog_repository import DatabaseRecommendedAppCatalogRepository
+from repositories.saved_message_repository import SQLAlchemySavedMessageRepository
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
from repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepository
from repositories.tag_repository import TagRepository
@@ -197,6 +198,7 @@ from services.retention.workflow_run.archive_download_adapters import (
)
from services.retention.workflow_run.archive_download_task_cache import WorkflowRunArchiveDownloadTaskCache
from services.retention.workflow_run.archive_log_service import WorkflowRunArchiveService
+from services.saved_message_service import SavedMessageService
from services.schema_definition_service import SchemaDefinitionService
from services.setup_adapters import RedisSetupLock, RegisterServiceAccountProvisioner
from services.setup_service import SetupService
@@ -311,6 +313,7 @@ class ApplicationServices:
partner_tenant_bindings: PartnerTenantBindingService
recommended_app_queries: RecommendedAppQueryService
remote_files: RemoteFileService
+ saved_messages: SavedMessageService
app_tasks: AppTaskControlService
trial_app_access: TrialAppAccessService
app_audio: AppAudio
@@ -760,6 +763,9 @@ def build_application_services(
),
recommended_app_queries=recommended_app_queries,
remote_files=remote_file_service,
+ saved_messages=SavedMessageService(
+ saved_messages=SQLAlchemySavedMessageRepository(session_factory=database_client),
+ ),
app_tasks=AppTaskControlService(redis_client=redis),
trial_app_access=TrialAppAccessService(apps=trial_apps),
app_audio=AppAudioRuntime(session_factory=database_client),
diff --git a/api/repositories/app_definition_query_repository.py b/api/repositories/app_definition_query_repository.py
index eeaecd55d32..03114a08d46 100644
--- a/api/repositories/app_definition_query_repository.py
+++ b/api/repositories/app_definition_query_repository.py
@@ -81,6 +81,12 @@ class AppDefinitionQueryRepository(AppDefinitionQuery):
def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
self._session_factory = session_factory
+ @override
+ def get_mode(self, app_id: str) -> str | None:
+ with self._session_factory() as session:
+ mode = session.scalar(select(App.mode).where(App.id == app_id).limit(1))
+ return mode.value if mode is not None else None
+
@override
def get_published_parameter_config(
self,
diff --git a/api/repositories/saved_message_repository.py b/api/repositories/saved_message_repository.py
new file mode 100644
index 00000000000..e27048c4676
--- /dev/null
+++ b/api/repositories/saved_message_repository.py
@@ -0,0 +1,155 @@
+from typing import cast, override
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session, sessionmaker
+
+from models.enums import CreatorUserRole
+from models.model import Message
+from models.web import SavedMessage
+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError
+from services.saved_message_service import (
+ SavedMessageActor,
+ SavedMessageFeedback,
+ SavedMessageFileRecord,
+ SavedMessageInputValue,
+ SavedMessagePage,
+ SavedMessageRecord,
+ SavedMessageStore,
+)
+
+
+class SQLAlchemySavedMessageRepository(SavedMessageStore):
+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
+ self._session_factory = session_factory
+
+ @override
+ def pagination_by_last_id(
+ self,
+ *,
+ app_id: str,
+ actor: SavedMessageActor,
+ last_id: str | None,
+ limit: int,
+ ) -> SavedMessagePage:
+ with self._session_factory() as session:
+ message_ids = session.scalars(
+ select(SavedMessage.message_id)
+ .where(
+ SavedMessage.app_id == app_id,
+ SavedMessage.created_by_role == actor.role,
+ SavedMessage.created_by == actor.id,
+ )
+ .order_by(SavedMessage.created_at.desc())
+ ).all()
+ if not message_ids:
+ return SavedMessagePage(limit=limit, has_more=False, data=())
+
+ stmt = select(Message).where(Message.id.in_(message_ids))
+ fetch_limit = limit + 1
+ if last_id:
+ last_message = session.scalar(stmt.where(Message.id == last_id).limit(1))
+ if last_message is None:
+ raise LastMessageNotExistsError("The last_id cursor does not belong to the current saved messages.")
+ stmt = stmt.where(Message.created_at < last_message.created_at, Message.id != last_message.id)
+
+ messages = list(session.scalars(stmt.order_by(Message.created_at.desc()).limit(fetch_limit)).all())
+ has_more = len(messages) > limit
+ if has_more:
+ messages = messages[:limit]
+
+ return SavedMessagePage(
+ limit=limit,
+ has_more=has_more,
+ data=tuple(self._to_record(message=message, session=session) for message in messages),
+ )
+
+ @override
+ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:
+ with self._session_factory() as session:
+ saved_message = session.scalar(
+ select(SavedMessage)
+ .where(
+ SavedMessage.app_id == app_id,
+ SavedMessage.message_id == message_id,
+ SavedMessage.created_by_role == actor.role,
+ SavedMessage.created_by == actor.id,
+ )
+ .limit(1)
+ )
+ if saved_message is not None:
+ return
+
+ message = session.scalar(
+ select(Message)
+ .where(
+ Message.id == message_id,
+ Message.app_id == app_id,
+ Message.from_source == ("console" if actor.role == "account" else "api"),
+ Message.from_end_user_id == (actor.id if actor.role == "end_user" else None),
+ Message.from_account_id == (actor.id if actor.role == "account" else None),
+ )
+ .limit(1)
+ )
+ if message is None:
+ raise MessageNotExistsError()
+
+ session.add(
+ SavedMessage(
+ app_id=app_id,
+ message_id=message.id,
+ created_by_role=CreatorUserRole(actor.role),
+ created_by=actor.id,
+ )
+ )
+ session.commit()
+
+ @override
+ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:
+ with self._session_factory() as session:
+ saved_message = session.scalar(
+ select(SavedMessage)
+ .where(
+ SavedMessage.app_id == app_id,
+ SavedMessage.message_id == message_id,
+ SavedMessage.created_by_role == actor.role,
+ SavedMessage.created_by == actor.id,
+ )
+ .limit(1)
+ )
+ if saved_message is None:
+ return
+
+ session.delete(saved_message)
+ session.commit()
+
+ @staticmethod
+ def _to_record(*, message: Message, session: Session) -> SavedMessageRecord:
+ inputs = cast(dict[str, SavedMessageInputValue], message.inputs_with_session(session=session))
+ message_files = SQLAlchemySavedMessageRepository._message_files(message=message, session=session)
+ feedback = message.user_feedback_with_session(session=session)
+ return SavedMessageRecord(
+ id=message.id,
+ inputs=inputs,
+ query=message.query,
+ answer=message.answer,
+ message_files=message_files,
+ user_feedback=SavedMessageFeedback(rating=feedback.rating.value) if feedback is not None else None,
+ created_at=message.created_at,
+ )
+
+ @staticmethod
+ def _message_files(*, message: Message, session: Session) -> list[SavedMessageFileRecord]:
+ return [
+ SavedMessageFileRecord(
+ id=file["id"],
+ filename=cast(str, file["filename"]),
+ type=file["type"],
+ url=file.get("url"),
+ mime_type=file.get("mime_type"),
+ size=file.get("size"),
+ transfer_method=file["transfer_method"],
+ belongs_to=file.get("belongs_to"),
+ upload_file_id=file.get("upload_file_id"),
+ )
+ for file in message.message_files_with_session(session=session)
+ ]
diff --git a/api/services/app_definition_query_service.py b/api/services/app_definition_query_service.py
index 6815911b119..327428d2518 100644
--- a/api/services/app_definition_query_service.py
+++ b/api/services/app_definition_query_service.py
@@ -47,6 +47,8 @@ class AppSiteConfiguration(NamedTuple):
class AppDefinitionQuery(Protocol):
+ def get_mode(self, app_id: str) -> str | None: ...
+
def get_published_parameter_config(
self,
app_id: str,
@@ -82,6 +84,12 @@ class AppDefinitionQueryService:
self._definitions = definitions
self._builtin_icon_url_prefix = builtin_icon_url_prefix
+ def get_mode(self, app_id: str) -> str:
+ mode = self._definitions.get_mode(app_id)
+ if mode is None:
+ raise AppDefinitionUnavailableError("App not found")
+ return mode
+
def get_parameters(self, app_id: str) -> AppParametersDict:
config = self._definitions.get_published_parameter_config(app_id)
return self._map_parameters(config)
diff --git a/api/services/saved_message_service.py b/api/services/saved_message_service.py
index 6165d74333f..db094d7f8a9 100644
--- a/api/services/saved_message_service.py
+++ b/api/services/saved_message_service.py
@@ -1,88 +1,97 @@
-from sqlalchemy import select
-from sqlalchemy.orm import Session
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Literal, NamedTuple, Protocol
-from libs.infinite_scroll_pagination import InfiniteScrollPagination
-from models import Account
-from models.enums import CreatorUserRole
-from models.model import App, EndUser
-from models.web import SavedMessage
-from services.message_service import MessageService
+from pydantic import JsonValue
+from graphon.file import File
+
+type SavedMessageActorRole = Literal["account", "end_user"]
+type SavedMessageInputValue = JsonValue | File | list[File]
+
+
+@dataclass(frozen=True, slots=True)
+class SavedMessageActor:
+ id: str
+ role: SavedMessageActorRole
-class SavedMessageService:
@classmethod
- def pagination_by_last_id(
- cls, app_model: App, user: Account | EndUser | None, last_id: str | None, limit: int, *, session: Session
- ) -> InfiniteScrollPagination:
- if not user:
- raise ValueError("User is required")
- saved_messages = session.scalars(
- select(SavedMessage)
- .where(
- SavedMessage.app_id == app_model.id,
- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),
- SavedMessage.created_by == user.id,
- )
- .order_by(SavedMessage.created_at.desc())
- ).all()
- message_ids = [sm.message_id for sm in saved_messages]
-
- return MessageService.pagination_by_last_id(
- app_model=app_model,
- user=user,
- last_id=last_id,
- limit=limit,
- include_ids=message_ids,
- session=session,
- )
+ def account(cls, account_id: str) -> "SavedMessageActor":
+ return cls(id=account_id, role="account")
@classmethod
- def save(cls, app_model: App, user: Account | EndUser | None, message_id: str, *, session: Session):
- if not user:
- return
- saved_message = session.scalar(
- select(SavedMessage)
- .where(
- SavedMessage.app_id == app_model.id,
- SavedMessage.message_id == message_id,
- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),
- SavedMessage.created_by == user.id,
- )
- .limit(1)
- )
+ def end_user(cls, end_user_id: str) -> "SavedMessageActor":
+ return cls(id=end_user_id, role="end_user")
- if saved_message:
- return
- message = MessageService.get_message(app_model=app_model, user=user, message_id=message_id, session=session)
+class SavedMessageFeedback(NamedTuple):
+ rating: str | None
- saved_message = SavedMessage(
- app_id=app_model.id,
- message_id=message.id,
- created_by_role=CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USER,
- created_by=user.id,
- )
- session.add(saved_message)
- session.commit()
+class SavedMessageFileRecord(NamedTuple):
+ id: str
+ filename: str
+ type: str
+ url: str | None
+ mime_type: str | None
+ size: int | None
+ transfer_method: str
+ belongs_to: str | None
+ upload_file_id: str | None
- @classmethod
- def delete(cls, app_model: App, user: Account | EndUser | None, message_id: str, *, session: Session):
- if not user:
- return
- saved_message = session.scalar(
- select(SavedMessage)
- .where(
- SavedMessage.app_id == app_model.id,
- SavedMessage.message_id == message_id,
- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),
- SavedMessage.created_by == user.id,
- )
- .limit(1)
+
+class SavedMessageRecord(NamedTuple):
+ id: str
+ inputs: dict[str, SavedMessageInputValue]
+ query: str
+ answer: str
+ message_files: list[SavedMessageFileRecord]
+ user_feedback: SavedMessageFeedback | None
+ created_at: datetime | None
+
+
+class SavedMessagePage(NamedTuple):
+ limit: int
+ has_more: bool
+ data: tuple[SavedMessageRecord, ...]
+
+
+class SavedMessageStore(Protocol):
+ def pagination_by_last_id(
+ self,
+ *,
+ app_id: str,
+ actor: SavedMessageActor,
+ last_id: str | None,
+ limit: int,
+ ) -> SavedMessagePage: ...
+
+ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None: ...
+
+ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None: ...
+
+
+class SavedMessageService:
+ def __init__(self, *, saved_messages: SavedMessageStore) -> None:
+ self._saved_messages = saved_messages
+
+ def pagination_by_last_id(
+ self,
+ *,
+ app_id: str,
+ actor: SavedMessageActor,
+ last_id: str | None,
+ limit: int,
+ ) -> SavedMessagePage:
+ return self._saved_messages.pagination_by_last_id(
+ app_id=app_id,
+ actor=actor,
+ last_id=last_id,
+ limit=limit,
)
- if not saved_message:
- return
+ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:
+ self._saved_messages.save(app_id=app_id, actor=actor, message_id=message_id)
- session.delete(saved_message)
- session.commit()
+ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:
+ self._saved_messages.delete(app_id=app_id, actor=actor, message_id=message_id)
diff --git a/api/tests/test_containers_integration_tests/pyrefly.toml b/api/tests/test_containers_integration_tests/pyrefly.toml
index 7c0feb1323f..b86dc8e10ae 100644
--- a/api/tests/test_containers_integration_tests/pyrefly.toml
+++ b/api/tests/test_containers_integration_tests/pyrefly.toml
@@ -88,7 +88,6 @@ project-excludes = [
"services/test_model_load_balancing_service.py",
"services/test_model_provider_service.py",
"services/test_restore_archived_workflow_run.py",
- "services/test_saved_message_service.py",
"services/test_schedule_service.py",
"services/test_web_conversation_service.py",
"services/test_webapp_auth_service.py",
diff --git a/api/tests/test_containers_integration_tests/services/test_saved_message_service.py b/api/tests/test_containers_integration_tests/services/test_saved_message_service.py
deleted file mode 100644
index a55ed6c9532..00000000000
--- a/api/tests/test_containers_integration_tests/services/test_saved_message_service.py
+++ /dev/null
@@ -1,651 +0,0 @@
-from unittest.mock import ANY, patch
-
-import pytest
-from faker import Faker
-from sqlalchemy.orm import Session
-
-from models import App, CreatorUserRole
-from models.enums import ConversationFromSource, EndUserType
-from models.model import EndUser, Message
-from models.web import SavedMessage
-from services.app_service import AppService, CreateAppParams
-from services.saved_message_service import SavedMessageService
-from tests.test_containers_integration_tests.helpers import generate_valid_password
-
-
-class TestSavedMessageService:
- """Integration tests for SavedMessageService using testcontainers."""
-
- @pytest.fixture
- def mock_external_service_dependencies(self):
- """Mock setup for external service dependencies."""
- with (
- patch("services.account_service.SystemFeatureService") as mock_account_feature_service,
- patch("services.app_service.ModelManager.for_tenant") as mock_model_manager,
- patch("services.saved_message_service.MessageService") as mock_message_service,
- ):
- # Setup default mock returns
- mock_account_feature_service.is_registration_allowed.return_value = True
-
- # Mock ModelManager for app creation
- mock_model_instance = mock_model_manager.return_value
- mock_model_instance.get_default_model_instance.return_value = None
- mock_model_instance.get_default_provider_model_name.return_value = ("openai", "gpt-3.5-turbo")
-
- # Mock MessageService
- mock_message_service.get_message.return_value = None
- mock_message_service.pagination_by_last_id.return_value = None
-
- yield {
- "account_feature_service": mock_account_feature_service,
- "model_manager": mock_model_manager,
- "message_service": mock_message_service,
- }
-
- def _create_test_app_and_account(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """
- Helper method to create a test app and account for testing.
-
- Args:
- db_session_with_containers: Database session from testcontainers infrastructure
- mock_external_service_dependencies: Mock dependencies
-
- Returns:
- tuple: (app, account) - Created app and account instances
- """
- fake = Faker()
-
- # Setup mocks for account creation
- mock_external_service_dependencies["account_feature_service"].is_registration_allowed.return_value = True
-
- # Create account and tenant first
- from services.account_service import AccountService, TenantService
-
- account = AccountService.create_account(
- email=fake.email(),
- name=fake.name(),
- interface_language="en-US",
- password=generate_valid_password(fake),
- session=db_session_with_containers,
- )
- TenantService.create_owner_tenant_if_not_exist(account, name=fake.company(), session=db_session_with_containers)
- tenant = account.current_tenant
-
- # Create app with realistic data
- app_args = CreateAppParams(
- name=fake.company(),
- description=fake.text(max_nb_chars=100),
- mode="chat",
- icon_type="emoji",
- icon="🤖",
- icon_background="#FF6B6B",
- api_rph=100,
- api_rpm=10,
- )
-
- app_service = AppService()
- app = app_service.create_app(tenant.id, app_args, account, session=db_session_with_containers)
-
- return app, account
-
- def _create_test_end_user(self, db_session_with_containers: Session, app: App):
- """
- Helper method to create a test end user for testing.
-
- Args:
- db_session_with_containers: Database session from testcontainers infrastructure
- app: App instance to associate the end user with
-
- Returns:
- EndUser: Created end user instance
- """
- fake = Faker()
-
- end_user = EndUser(
- tenant_id=app.tenant_id,
- app_id=app.id,
- external_user_id=fake.uuid4(),
- name=fake.name(),
- type=EndUserType.BROWSER,
- session_id=fake.uuid4(),
- is_anonymous=False,
- )
-
- db_session_with_containers.add(end_user)
- db_session_with_containers.commit()
-
- return end_user
-
- def _create_test_message(self, db_session_with_containers: Session, app: App, user):
- """
- Helper method to create a test message for testing.
-
- Args:
- db_session_with_containers: Database session from testcontainers infrastructure
- app: App instance to associate the message with
- user: User instance (Account or EndUser) to associate the message with
-
- Returns:
- Message: Created message instance
- """
- fake = Faker()
-
- # Create a simple conversation first
- from models.model import Conversation
-
- is_account = hasattr(user, "current_tenant")
- from_source = ConversationFromSource.CONSOLE if is_account else ConversationFromSource.API
-
- conversation = Conversation(
- app_id=app.id,
- from_source=from_source,
- from_end_user_id=user.id if not is_account else None,
- from_account_id=user.id if is_account else None,
- name=fake.sentence(nb_words=3),
- inputs={},
- status="normal",
- mode="chat",
- )
-
- db_session_with_containers.add(conversation)
- db_session_with_containers.commit()
-
- # Create message
- message = Message(
- app_id=app.id,
- conversation_id=conversation.id,
- from_source=from_source,
- from_end_user_id=user.id if not is_account else None,
- from_account_id=user.id if is_account else None,
- inputs={},
- query=fake.sentence(nb_words=5),
- message=fake.text(max_nb_chars=100),
- answer=fake.text(max_nb_chars=200),
- message_tokens=50,
- answer_tokens=100,
- message_unit_price=0.001,
- answer_unit_price=0.002,
- total_price=0.003,
- currency="USD",
- status="normal",
- )
-
- db_session_with_containers.add(message)
- db_session_with_containers.commit()
-
- return message
-
- def test_pagination_by_last_id_success_with_account_user(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test successful pagination by last ID with account user.
-
- This test verifies:
- - Proper pagination with account user
- - Correct filtering by app_id and user
- - Proper role identification for account users
- - MessageService integration
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create test messages
- message1 = self._create_test_message(db_session_with_containers, app, account)
- message2 = self._create_test_message(db_session_with_containers, app, account)
-
- # Create saved messages
- saved_message1 = SavedMessage(
- app_id=app.id,
- message_id=message1.id,
- created_by_role=CreatorUserRole.ACCOUNT,
- created_by=account.id,
- )
- saved_message2 = SavedMessage(
- app_id=app.id,
- message_id=message2.id,
- created_by_role=CreatorUserRole.ACCOUNT,
- created_by=account.id,
- )
-
- db_session_with_containers.add_all([saved_message1, saved_message2])
- db_session_with_containers.commit()
-
- # Mock MessageService.pagination_by_last_id return value
- from libs.infinite_scroll_pagination import InfiniteScrollPagination
-
- mock_pagination = InfiniteScrollPagination(data=[message1, message2], limit=10, has_more=False)
- mock_external_service_dependencies["message_service"].pagination_by_last_id.return_value = mock_pagination
-
- # Act: Execute the method under test
- result = SavedMessageService.pagination_by_last_id(
- app_model=app, user=account, last_id=None, limit=10, session=db_session_with_containers
- )
-
- # Assert: Verify the expected outcomes
- assert result is not None
- assert result.data == [message1, message2]
- assert result.limit == 10
- assert result.has_more is False
-
- # Verify MessageService was called with correct parameters
- # Sort the IDs to handle database query order variations
- expected_include_ids = sorted([message1.id, message2.id])
- actual_call = mock_external_service_dependencies["message_service"].pagination_by_last_id.call_args
- actual_include_ids = sorted(actual_call.kwargs.get("include_ids", []))
-
- assert actual_call.kwargs["app_model"] == app
- assert actual_call.kwargs["user"] == account
- assert actual_call.kwargs["last_id"] is None
- assert actual_call.kwargs["limit"] == 10
- assert actual_include_ids == expected_include_ids
-
- # Verify database state
- db_session_with_containers.refresh(saved_message1)
- db_session_with_containers.refresh(saved_message2)
- assert saved_message1.id is not None
- assert saved_message2.id is not None
- assert saved_message1.created_by_role == "account"
- assert saved_message2.created_by_role == "account"
-
- def test_pagination_by_last_id_success_with_end_user(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test successful pagination by last ID with end user.
-
- This test verifies:
- - Proper pagination with end user
- - Correct filtering by app_id and user
- - Proper role identification for end users
- - MessageService integration
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- end_user = self._create_test_end_user(db_session_with_containers, app)
-
- # Create test messages
- message1 = self._create_test_message(db_session_with_containers, app, end_user)
- message2 = self._create_test_message(db_session_with_containers, app, end_user)
-
- # Create saved messages
- saved_message1 = SavedMessage(
- app_id=app.id,
- message_id=message1.id,
- created_by_role=CreatorUserRole.END_USER,
- created_by=end_user.id,
- )
- saved_message2 = SavedMessage(
- app_id=app.id,
- message_id=message2.id,
- created_by_role=CreatorUserRole.END_USER,
- created_by=end_user.id,
- )
-
- db_session_with_containers.add_all([saved_message1, saved_message2])
- db_session_with_containers.commit()
-
- # Mock MessageService.pagination_by_last_id return value
- from libs.infinite_scroll_pagination import InfiniteScrollPagination
-
- mock_pagination = InfiniteScrollPagination(data=[message1, message2], limit=5, has_more=True)
- mock_external_service_dependencies["message_service"].pagination_by_last_id.return_value = mock_pagination
-
- # Act: Execute the method under test
- result = SavedMessageService.pagination_by_last_id(
- app_model=app, user=end_user, last_id="test_last_id", limit=5, session=db_session_with_containers
- )
-
- # Assert: Verify the expected outcomes
- assert result is not None
- assert result.data == [message1, message2]
- assert result.limit == 5
- assert result.has_more is True
-
- # Verify MessageService was called with correct parameters
- # Sort the IDs to handle database query order variations
- expected_include_ids = sorted([message1.id, message2.id])
- actual_call = mock_external_service_dependencies["message_service"].pagination_by_last_id.call_args
- actual_include_ids = sorted(actual_call.kwargs.get("include_ids", []))
-
- assert actual_call.kwargs["app_model"] == app
- assert actual_call.kwargs["user"] == end_user
- assert actual_call.kwargs["last_id"] == "test_last_id"
- assert actual_call.kwargs["limit"] == 5
- assert actual_include_ids == expected_include_ids
-
- # Verify database state
- db_session_with_containers.refresh(saved_message1)
- db_session_with_containers.refresh(saved_message2)
- assert saved_message1.id is not None
- assert saved_message2.id is not None
- assert saved_message1.created_by_role == "end_user"
- assert saved_message2.created_by_role == "end_user"
-
- def test_save_success_with_new_message(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test successful save of a new message.
-
- This test verifies:
- - Proper creation of new saved message
- - Correct database state after save
- - Proper relationship establishment
- - MessageService integration for message retrieval
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- message = self._create_test_message(db_session_with_containers, app, account)
-
- # Mock MessageService.get_message return value
- mock_external_service_dependencies["message_service"].get_message.return_value = message
-
- # Act: Execute the method under test
- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)
-
- # Assert: Verify the expected outcomes
- # Check if saved message was created in database
-
- saved_message = (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- SavedMessage.created_by_role == "account",
- SavedMessage.created_by == account.id,
- )
- .first()
- )
-
- assert saved_message is not None
- assert saved_message.app_id == app.id
- assert saved_message.message_id == message.id
- assert saved_message.created_by_role == "account"
- assert saved_message.created_by == account.id
- assert saved_message.created_at is not None
-
- # Verify MessageService.get_message was called
- mock_external_service_dependencies["message_service"].get_message.assert_called_once_with(
- app_model=app, user=account, message_id=message.id, session=ANY
- )
-
- # Verify database state
- db_session_with_containers.refresh(saved_message)
- assert saved_message.id is not None
-
- def test_pagination_by_last_id_error_no_user(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test error handling when no user is provided.
-
- This test verifies:
- - Proper error handling for missing user
- - ValueError is raised when user is None
- - No database operations are performed
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Act & Assert: Verify proper error handling
- with pytest.raises(ValueError) as exc_info:
- SavedMessageService.pagination_by_last_id(
- app_model=app, user=None, last_id=None, limit=10, session=db_session_with_containers
- )
-
- assert "User is required" in str(exc_info.value)
-
- def test_save_error_no_user(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """
- Test error handling when saving message with no user.
-
- This test verifies:
- - Method returns early when user is None
- - No database operations are performed
- - No exceptions are raised
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- message = self._create_test_message(db_session_with_containers, app, account)
-
- # Act: Execute the method under test with None user
- result = SavedMessageService.save(
- app_model=app, user=None, message_id=message.id, session=db_session_with_containers
- )
-
- # Assert: Verify the expected outcomes
- assert result is None
-
- # Verify no saved message was created
-
- saved_message = (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- )
- .first()
- )
-
- assert saved_message is None
-
- def test_delete_success_existing_message(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test successful deletion of an existing saved message.
-
- This test verifies:
- - Proper deletion of existing saved message
- - Correct database state after deletion
- - No errors during deletion process
- """
- # Arrange: Create test data
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- message = self._create_test_message(db_session_with_containers, app, account)
-
- # Create a saved message first
- saved_message = SavedMessage(
- app_id=app.id,
- message_id=message.id,
- created_by_role=CreatorUserRole.ACCOUNT,
- created_by=account.id,
- )
-
- db_session_with_containers.add(saved_message)
- db_session_with_containers.commit()
-
- # Verify saved message exists
- assert (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- SavedMessage.created_by_role == "account",
- SavedMessage.created_by == account.id,
- )
- .first()
- is not None
- )
-
- # Act: Execute the method under test
- SavedMessageService.delete(
- app_model=app, user=account, message_id=message.id, session=db_session_with_containers
- )
-
- # Assert: Verify the expected outcomes
- # Check if saved message was deleted from database
- deleted_saved_message = (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- SavedMessage.created_by_role == "account",
- SavedMessage.created_by == account.id,
- )
- .first()
- )
-
- assert deleted_saved_message is None
-
- # Verify database state
- db_session_with_containers.commit()
- # The message should still exist, only the saved_message should be deleted
- assert db_session_with_containers.query(Message).where(Message.id == message.id).first() is not None
-
- def test_save_for_end_user(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """Test saving a message for an EndUser."""
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- end_user = self._create_test_end_user(db_session_with_containers, app)
- message = self._create_test_message(db_session_with_containers, app, end_user)
-
- mock_external_service_dependencies["message_service"].get_message.return_value = message
-
- SavedMessageService.save(
- app_model=app, user=end_user, message_id=message.id, session=db_session_with_containers
- )
-
- saved = (
- db_session_with_containers.query(SavedMessage)
- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)
- .first()
- )
- assert saved is not None
- assert saved.created_by == end_user.id
- assert saved.created_by_role == "end_user"
-
- def test_save_duplicate_is_idempotent(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """Test that saving an already-saved message does not create a duplicate."""
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- message = self._create_test_message(db_session_with_containers, app, account)
-
- mock_external_service_dependencies["message_service"].get_message.return_value = message
-
- # Save once
- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)
- # Save again
- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)
-
- count = (
- db_session_with_containers.query(SavedMessage)
- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)
- .count()
- )
- assert count == 1
-
- def test_delete_without_user_does_nothing(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """Test that deleting without a user is a no-op."""
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- message = self._create_test_message(db_session_with_containers, app, account)
-
- # Pre-create a saved message
- saved = SavedMessage(
- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.ACCOUNT, created_by=account.id
- )
- db_session_with_containers.add(saved)
- db_session_with_containers.commit()
-
- SavedMessageService.delete(app_model=app, user=None, message_id=message.id, session=db_session_with_containers)
-
- # Should still exist
- assert (
- db_session_with_containers.query(SavedMessage)
- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)
- .first()
- is not None
- )
-
- def test_delete_non_existent_does_nothing(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """Test that deleting a non-existent saved message is a no-op."""
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Should not raise — use a valid UUID that doesn't exist in DB
- from uuid import uuid4
-
- SavedMessageService.delete(
- app_model=app, user=account, message_id=str(uuid4()), session=db_session_with_containers
- )
-
- def test_delete_for_end_user(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """Test deleting a saved message for an EndUser."""
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
- end_user = self._create_test_end_user(db_session_with_containers, app)
- message = self._create_test_message(db_session_with_containers, app, end_user)
-
- saved = SavedMessage(
- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.END_USER, created_by=end_user.id
- )
- db_session_with_containers.add(saved)
- db_session_with_containers.commit()
-
- SavedMessageService.delete(
- app_model=app, user=end_user, message_id=message.id, session=db_session_with_containers
- )
-
- assert (
- db_session_with_containers.query(SavedMessage)
- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)
- .first()
- is None
- )
-
- def test_delete_only_affects_own_saved_messages(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """Test that delete only removes the requesting user's saved message."""
- app, account1 = self._create_test_app_and_account(
- db_session_with_containers, mock_external_service_dependencies
- )
- end_user = self._create_test_end_user(db_session_with_containers, app)
- message = self._create_test_message(db_session_with_containers, app, account1)
-
- # Both users save the same message
- saved_account = SavedMessage(
- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.ACCOUNT, created_by=account1.id
- )
- saved_end_user = SavedMessage(
- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.END_USER, created_by=end_user.id
- )
- db_session_with_containers.add_all([saved_account, saved_end_user])
- db_session_with_containers.commit()
-
- # Delete only account1's saved message
- SavedMessageService.delete(
- app_model=app, user=account1, message_id=message.id, session=db_session_with_containers
- )
-
- # Account's saved message should be gone
- assert (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- SavedMessage.created_by == account1.id,
- )
- .first()
- is None
- )
- # End user's saved message should still exist
- assert (
- db_session_with_containers.query(SavedMessage)
- .where(
- SavedMessage.app_id == app.id,
- SavedMessage.message_id == message.id,
- SavedMessage.created_by == end_user.id,
- )
- .first()
- is not None
- )
diff --git a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py b/api/tests/unit_tests/controllers/console/explore/test_saved_message.py
index a55500690be..6b5e91c49ab 100644
--- a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py
+++ b/api/tests/unit_tests/controllers/console/explore/test_saved_message.py
@@ -1,253 +1,316 @@
-from decimal import Decimal
+from collections.abc import Generator
+from dataclasses import dataclass
+from datetime import UTC, datetime
from inspect import unwrap
-from unittest.mock import MagicMock, PropertyMock, patch
+from unittest.mock import MagicMock, patch
from uuid import uuid4
import pytest
from flask import Flask
-from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.exceptions import NotFound
import controllers.console.explore.saved_message as module
+from controllers.console.app.error import AppUnavailableError
from controllers.console.explore.error import NotCompletionAppError
-from models import Account
-from models.enums import ConversationFromSource, FeedbackFromSource, FeedbackRating
-from models.model import App, AppMode, InstalledApp, Message, MessageFeedback
-from services.errors.message import MessageNotExistsError
-
-
-def make_message(session: Session, *, app_id: str, account_id: str) -> Message:
- message = Message(
- id=str(uuid4()),
- app_id=app_id,
- conversation_id=str(uuid4()),
- query="hello",
- message={"role": "user", "content": "hello"},
- answer="world",
- message_tokens=1,
- message_unit_price=Decimal(0),
- answer_tokens=1,
- answer_unit_price=Decimal(0),
- provider_response_latency=0,
- currency="USD",
- from_source=ConversationFromSource.API,
- from_account_id=account_id,
- app_mode=AppMode.COMPLETION,
- )
- message._inputs = {}
- message.status = "normal"
- session.add(message)
- session.flush()
- session.add(
- MessageFeedback(
- app_id=app_id,
- conversation_id=message.conversation_id,
- message_id=message.id,
- rating=FeedbackRating.LIKE,
- from_source=FeedbackFromSource.USER,
- from_account_id=account_id,
- )
- )
- session.flush()
- return message
-
-
-def make_installed_app(session: Session, mode: AppMode | str) -> InstalledApp:
- app_model = App(
- tenant_id="owner-tenant",
- name="Explore App",
- mode=AppMode.value_of(mode),
- enable_site=True,
- enable_api=False,
- )
- session.add(app_model)
- session.flush()
- installed_app = InstalledApp(
- tenant_id="viewer-tenant",
- app_id=app_model.id,
- app_owner_tenant_id=app_model.tenant_id,
+from controllers.console.explore.wraps import InstalledAppResource
+from graphon.file import File, FileTransferMethod, FileType
+from models.model import InstalledApp
+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError
+from services.saved_message_service import (
+ SavedMessageActor,
+ SavedMessageFeedback,
+ SavedMessageFileRecord,
+ SavedMessagePage,
+ SavedMessageRecord,
+)
+
+_INPUT_FILE_URL = "https://example.com/input.pdf"
+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
+_ACCOUNT_ID = "11111111-1111-4111-8111-111111111111"
+_WORKSPACE_ID = "22222222-2222-4222-8222-222222222222"
+
+
+@dataclass(frozen=True)
+class _ApplicationServiceMocks:
+ app_definitions: MagicMock
+ saved_messages: MagicMock
+
+
+def _installed_app() -> InstalledApp:
+ return InstalledApp(
+ tenant_id=_WORKSPACE_ID,
+ app_id="33333333-3333-4333-8333-333333333333",
+ app_owner_tenant_id="44444444-4444-4444-8444-444444444444",
position=0,
is_pinned=False,
last_used_at=None,
)
- session.add(installed_app)
- session.commit()
- return installed_app
-def payload_patch():
- def _patch(payload):
- return patch.object(
- type(module.console_ns),
- "payload",
- new_callable=PropertyMock,
- return_value=payload,
- )
+def _record() -> SavedMessageRecord:
+ input_file = File(
+ file_id="66666666-6666-4666-8666-666666666666",
+ file_type=FileType.DOCUMENT,
+ transfer_method=FileTransferMethod.REMOTE_URL,
+ remote_url=_INPUT_FILE_URL,
+ filename="input.pdf",
+ extension=".pdf",
+ mime_type="application/pdf",
+ size=12,
+ )
+ return SavedMessageRecord(
+ id="55555555-5555-4555-8555-555555555555",
+ inputs={"topic": "hello", "document": input_file},
+ query="hello",
+ answer="world",
+ message_files=[
+ SavedMessageFileRecord(
+ id="77777777-7777-4777-8777-777777777777",
+ filename="attachment.pdf",
+ type="document",
+ url="https://example.com/attachment.pdf",
+ mime_type="application/pdf",
+ size=34,
+ transfer_method="remote_url",
+ belongs_to="user",
+ upload_file_id="88888888-8888-4888-8888-888888888888",
+ )
+ ],
+ user_feedback=SavedMessageFeedback(rating="like"),
+ created_at=_CREATED_AT,
+ )
- return _patch
+def _expected_record() -> dict[str, object]:
+ return {
+ "id": "55555555-5555-4555-8555-555555555555",
+ "inputs": {
+ "topic": "hello",
+ "document": {
+ "dify_model_identity": "__dify__file__",
+ "id": "66666666-6666-4666-8666-666666666666",
+ "type": "document",
+ "transfer_method": "remote_url",
+ "remote_url": _INPUT_FILE_URL,
+ "reference": None,
+ "filename": "input.pdf",
+ "extension": ".pdf",
+ "mime_type": "application/pdf",
+ "size": 12,
+ "related_id": None,
+ "url": _INPUT_FILE_URL,
+ },
+ },
+ "query": "hello",
+ "answer": "world",
+ "message_files": [
+ {
+ "id": "77777777-7777-4777-8777-777777777777",
+ "filename": "attachment.pdf",
+ "type": "document",
+ "url": "https://example.com/attachment.pdf",
+ "mime_type": "application/pdf",
+ "size": 34,
+ "transfer_method": "remote_url",
+ "belongs_to": "user",
+ "upload_file_id": "88888888-8888-4888-8888-888888888888",
+ }
+ ],
+ "feedback": {"rating": "like"},
+ "created_at": 1767323045,
+ }
-class _UsesSQLiteSession:
- sqlite_session: Session
- account: Account
- @pytest.fixture(autouse=True)
- def _bind_database(
- self,
- sqlite_session: Session,
- sqlite_session_factory: sessionmaker[Session],
- monkeypatch: pytest.MonkeyPatch,
+def services() -> Generator[_ApplicationServiceMocks]:
+ service_mocks = _ApplicationServiceMocks(
+ app_definitions=MagicMock(),
+ saved_messages=MagicMock(),
+ )
+ service_mocks.app_definitions.get_mode.return_value = "completion"
+ with patch.object(
+ module,
+ "application_services",
+ return_value=service_mocks,
):
- self.sqlite_session = sqlite_session
- self.account = Account(name="User", email="[email protected]")
- self.sqlite_session.add(self.account)
- self.sqlite_session.commit()
- session_proxy = scoped_session(sqlite_session_factory)
- monkeypatch.setattr(module.db, "session", session_proxy)
- yield
- session_proxy.remove()
+ yield service_mocks
-class TestSavedMessageListApi(_UsesSQLiteSession):
- def test_get_success(self, app: Flask):
- api = module.SavedMessageListApi()
- method = unwrap(api.get)
+def test_saved_message_resources_use_installed_app_admission() -> None:
+ assert issubclass(module.SavedMessageListApi, InstalledAppResource)
+ assert issubclass(module.SavedMessageApi, InstalledAppResource)
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)
- pagination = MagicMock(
+class TestSavedMessageListApi:
+ def test_get_success(self, app: Flask, services: _ApplicationServiceMocks) -> None:
+ installed_app = _installed_app()
+ services.saved_messages.pagination_by_last_id.return_value = SavedMessagePage(
limit=20,
has_more=False,
- data=[
- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),
- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),
- ],
+ data=(_record(),),
)
- self.sqlite_session.commit()
with (
app.test_request_context("/", query_string={}),
- patch.object(
- module.SavedMessageService,
- "pagination_by_last_id",
- return_value=pagination,
- ) as pagination_mock,
+ patch.object(File, "generate_url", return_value=_INPUT_FILE_URL),
):
- result = method(api, module.SavedMessageListQuery.model_validate({}), self.account, installed_app)
-
- pagination_mock.assert_called_once()
- assert pagination_mock.call_args.args[1] is self.account
- assert result["limit"] == 20
- assert result["has_more"] is False
- assert len(result["data"]) == 2
-
- def test_get_with_query_params(self, app: Flask):
- api = module.SavedMessageListApi()
- method = unwrap(api.get)
-
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)
-
- pagination = MagicMock(
- limit=50,
- has_more=True,
- data=[
- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),
- ],
+ result = unwrap(module.SavedMessageListApi().get)(
+ module.SavedMessageListApi(),
+ module.SavedMessageListQuery.model_validate({}),
+ _ACCOUNT_ID,
+ installed_app,
+ )
+
+ services.app_definitions.get_mode.assert_called_once_with(installed_app.app_id)
+ services.saved_messages.pagination_by_last_id.assert_called_once_with(
+ app_id=installed_app.app_id,
+ actor=SavedMessageActor.account(_ACCOUNT_ID),
+ last_id=None,
+ limit=20,
)
- self.sqlite_session.commit()
-
+ assert result == {
+ "limit": 20,
+ "has_more": False,
+ "data": [_expected_record()],
+ }
+
+ def test_get_forwards_query(self, app: Flask, services: _ApplicationServiceMocks) -> None:
+ installed_app = _installed_app()
last_id = str(uuid4())
- query = module.SavedMessageListQuery.model_validate({"last_id": last_id, "limit": 50})
-
- with (
- app.test_request_context("/", query_string={"last_id": last_id, "limit": "50"}),
- patch.object(
- module.SavedMessageService,
- "pagination_by_last_id",
- return_value=pagination,
- ) as pagination_mock,
- ):
- result = method(api, query, self.account, installed_app)
-
- pagination_mock.assert_called_once()
- assert pagination_mock.call_args.args[1] is self.account
- assert pagination_mock.call_args.args[2] == last_id
- assert pagination_mock.call_args.args[3] == 50
- assert result["limit"] == 50
- assert result["has_more"] is True
+ services.saved_messages.pagination_by_last_id.return_value = SavedMessagePage(limit=50, has_more=True, data=())
+
+ with app.test_request_context("/", query_string={"last_id": last_id, "limit": "50"}):
+ result = unwrap(module.SavedMessageListApi().get)(
+ module.SavedMessageListApi(),
+ module.SavedMessageListQuery.model_validate({"last_id": last_id, "limit": "50"}),
+ _ACCOUNT_ID,
+ installed_app,
+ )
+
+ services.saved_messages.pagination_by_last_id.assert_called_once_with(
+ app_id=installed_app.app_id,
+ actor=SavedMessageActor.account(_ACCOUNT_ID),
+ last_id=last_id,
+ limit=50,
+ )
- def test_get_not_completion_app(self):
- api = module.SavedMessageListApi()
- method = unwrap(api.get)
+ assert result == {"limit": 50, "has_more": True, "data": []}
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.CHAT)
+ @pytest.mark.parametrize("query_string", [{"limit": "0"}, {"limit": "101"}, {"last_id": "invalid-uuid"}])
+ def test_get_rejects_invalid_query(self, services: _ApplicationServiceMocks, query_string: dict[str, str]) -> None:
+ http_app = Flask(__name__)
- with pytest.raises(NotCompletionAppError):
- method(api, module.SavedMessageListQuery.model_validate({}), self.account, installed_app)
+ @http_app.get("/saved-messages")
+ def get_saved_messages() -> dict[str, object]:
+ return module.SavedMessageListApi().get(_installed_app())
- def test_post_success(self, app: Flask, payload_patch):
- api = module.SavedMessageListApi()
- method = unwrap(api.post)
+ with patch(
+ "controllers.console.wraps.current_account_with_tenant",
+ return_value=(MagicMock(id=_ACCOUNT_ID), _WORKSPACE_ID),
+ ):
+ response = http_app.test_client().get("/saved-messages", query_string=query_string)
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)
+ assert response.status_code == 422
+ services.app_definitions.get_mode.assert_not_called()
+ services.saved_messages.pagination_by_last_id.assert_not_called()
- payload = {"message_id": str(uuid4())}
+ def test_get_preserves_invalid_last_id_context(self, app: Flask, services: _ApplicationServiceMocks) -> None:
+ installed_app = _installed_app()
+ last_id = str(uuid4())
+ description = "The last_id cursor does not belong to the current saved messages."
+ services.saved_messages.pagination_by_last_id.side_effect = LastMessageNotExistsError(description)
with (
- app.test_request_context("/", json=payload),
- payload_patch(payload),
- patch.object(module.SavedMessageService, "save") as save_mock,
+ app.test_request_context("/", query_string={"last_id": last_id}),
+ pytest.raises(LastMessageNotExistsError, match="last_id") as raised,
):
- result = method(api, module.SavedMessageCreatePayload.model_validate(payload), self.account, installed_app)
+ unwrap(module.SavedMessageListApi().get)(
+ module.SavedMessageListApi(),
+ module.SavedMessageListQuery.model_validate({"last_id": last_id}),
+ _ACCOUNT_ID,
+ installed_app,
+ )
+
+ assert raised.value.description == description
+
+ def test_get_rejects_missing_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:
+ services.app_definitions.get_mode.side_effect = module.AppDefinitionUnavailableError
+
+ with app.test_request_context("/"), pytest.raises(AppUnavailableError):
+ unwrap(module.SavedMessageListApi().get)(
+ module.SavedMessageListApi(),
+ module.SavedMessageListQuery.model_validate({}),
+ _ACCOUNT_ID,
+ _installed_app(),
+ )
+
+ def test_get_rejects_non_completion_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:
+ services.app_definitions.get_mode.return_value = "chat"
+
+ with app.test_request_context("/"), pytest.raises(NotCompletionAppError):
+ unwrap(module.SavedMessageListApi().get)(
+ module.SavedMessageListApi(),
+ module.SavedMessageListQuery.model_validate({}),
+ _ACCOUNT_ID,
+ _installed_app(),
+ )
+
+ def test_post_success(self, services: _ApplicationServiceMocks) -> None:
+ installed_app = _installed_app()
+ message_id = str(uuid4())
+
+ result = unwrap(module.SavedMessageListApi().post)(
+ module.SavedMessageListApi(),
+ module.SavedMessageCreatePayload.model_validate({"message_id": message_id}),
+ _ACCOUNT_ID,
+ installed_app,
+ )
- save_mock.assert_called_once()
- assert save_mock.call_args.args[1] is self.account
+ services.saved_messages.save.assert_called_once_with(
+ app_id=installed_app.app_id,
+ actor=SavedMessageActor.account(_ACCOUNT_ID),
+ message_id=message_id,
+ )
assert result == {"result": "success"}
- def test_post_message_not_exists(self, app: Flask, payload_patch):
- api = module.SavedMessageListApi()
- method = unwrap(api.post)
-
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)
-
- payload = {"message_id": str(uuid4())}
-
- with (
- app.test_request_context("/", json=payload),
- payload_patch(payload),
- patch.object(
- module.SavedMessageService,
- "save",
- side_effect=MessageNotExistsError(),
- ),
- ):
- with pytest.raises(NotFound):
- method(api, module.SavedMessageCreatePayload.model_validate(payload), self.account, installed_app)
+ def test_post_maps_missing_message_to_not_found(self, services: _ApplicationServiceMocks) -> None:
+ services.saved_messages.save.side_effect = MessageNotExistsError()
+ with pytest.raises(NotFound, match="Message Not Exists"):
+ unwrap(module.SavedMessageListApi().post)(
+ module.SavedMessageListApi(),
+ module.SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())}),
+ _ACCOUNT_ID,
+ _installed_app(),
+ )
-class TestSavedMessageApi(_UsesSQLiteSession):
- def test_delete_success(self):
- api = module.SavedMessageApi()
- method = unwrap(api.delete)
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)
+class TestSavedMessageApi:
+ def test_delete_success(self, services: _ApplicationServiceMocks) -> None:
+ installed_app = _installed_app()
+ message_id = uuid4()
- with (
- patch.object(module.SavedMessageService, "delete") as delete_mock,
- ):
- result, status = method(api, self.account, installed_app, str(uuid4()))
-
- delete_mock.assert_called_once()
- assert delete_mock.call_args.args[1] is self.account
- assert status == 204
- assert result == ""
+ result = unwrap(module.SavedMessageApi().delete)(
+ module.SavedMessageApi(),
+ _ACCOUNT_ID,
+ installed_app,
+ message_id,
+ )
- def test_delete_not_completion_app(self):
- api = module.SavedMessageApi()
- method = unwrap(api.delete)
+ services.saved_messages.delete.assert_called_once_with(
+ app_id=installed_app.app_id,
+ actor=SavedMessageActor.account(_ACCOUNT_ID),
+ message_id=str(message_id),
+ )
+ assert result == ("", 204)
- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.CHAT)
+ def test_delete_rejects_non_completion_app(self, services: _ApplicationServiceMocks) -> None:
+ services.app_definitions.get_mode.return_value = "chat"
with pytest.raises(NotCompletionAppError):
- method(api, self.account, installed_app, str(uuid4()))
+ unwrap(module.SavedMessageApi().delete)(
+ module.SavedMessageApi(),
+ _ACCOUNT_ID,
+ _installed_app(),
+ uuid4(),
+ )
diff --git a/api/tests/unit_tests/controllers/web/test_saved_message.py b/api/tests/unit_tests/controllers/web/test_saved_message.py
index 11ef11da686..6e2f3def794 100644
--- a/api/tests/unit_tests/controllers/web/test_saved_message.py
+++ b/api/tests/unit_tests/controllers/web/test_saved_message.py
@@ -1,8 +1,6 @@
-"""Unit tests for controllers.web.saved_message endpoints."""
-
-from __future__ import annotations
-
-import inspect
+from collections.abc import Generator
+from datetime import UTC, datetime
+from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
from uuid import uuid4
@@ -11,13 +9,24 @@ import pytest
from flask import Flask
from werkzeug.exceptions import NotFound
+import controllers.web.saved_message as module
from controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQuery
from controllers.web.error import NotCompletionAppError
-from controllers.web.saved_message import SavedMessageApi, SavedMessageListApi
+from graphon.file import File, FileTransferMethod, FileType
from models.model import App, AppMode, EndUser
-from services.errors.message import MessageNotExistsError
+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError
+from services.saved_message_service import (
+ SavedMessageActor,
+ SavedMessageFeedback,
+ SavedMessageFileRecord,
+ SavedMessagePage,
+ SavedMessageRecord,
+)
from tests.unit_tests.model_factories import make_end_user
+_INPUT_FILE_URL = "https://example.com/input.pdf"
+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
+
def _completion_app() -> App:
return App(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)
@@ -31,78 +40,198 @@ def _end_user() -> EndUser:
return make_end_user(end_user_id="eu-1")
-# The @with_session and @model_validate decorators wrap the handler; tests call
-# the undecorated function so they can pass the validated pydantic payload and a
-# stub session directly and skip the flask request-parsing step.
-_list_get = inspect.unwrap(SavedMessageListApi.get)
-_list_post = inspect.unwrap(SavedMessageListApi.post)
+def _record() -> SavedMessageRecord:
+ input_file = File(
+ file_id="66666666-6666-4666-8666-666666666666",
+ file_type=FileType.DOCUMENT,
+ transfer_method=FileTransferMethod.REMOTE_URL,
+ remote_url=_INPUT_FILE_URL,
+ filename="input.pdf",
+ extension=".pdf",
+ mime_type="application/pdf",
+ size=12,
+ )
+ return SavedMessageRecord(
+ id="55555555-5555-4555-8555-555555555555",
+ inputs={"topic": "hello", "document": input_file},
+ query="hello",
+ answer="world",
+ message_files=[
+ SavedMessageFileRecord(
+ id="77777777-7777-4777-8777-777777777777",
+ filename="attachment.pdf",
+ type="document",
+ url="https://example.com/attachment.pdf",
+ mime_type="application/pdf",
+ size=34,
+ transfer_method="remote_url",
+ belongs_to="user",
+ upload_file_id="88888888-8888-4888-8888-888888888888",
+ )
+ ],
+ user_feedback=SavedMessageFeedback(rating="like"),
+ created_at=_CREATED_AT,
+ )
+
+
+def _expected_record() -> dict[str, object]:
+ return {
+ "id": "55555555-5555-4555-8555-555555555555",
+ "inputs": {
+ "topic": "hello",
+ "document": {
+ "dify_model_identity": "__dify__file__",
+ "id": "66666666-6666-4666-8666-666666666666",
+ "type": "document",
+ "transfer_method": "remote_url",
+ "remote_url": _INPUT_FILE_URL,
+ "reference": None,
+ "filename": "input.pdf",
+ "extension": ".pdf",
+ "mime_type": "application/pdf",
+ "size": 12,
+ "related_id": None,
+ "url": _INPUT_FILE_URL,
+ },
+ },
+ "query": "hello",
+ "answer": "world",
+ "message_files": [
+ {
+ "id": "77777777-7777-4777-8777-777777777777",
+ "filename": "attachment.pdf",
+ "type": "document",
+ "url": "https://example.com/attachment.pdf",
+ "mime_type": "application/pdf",
+ "size": 34,
+ "transfer_method": "remote_url",
+ "belongs_to": "user",
+ "upload_file_id": "88888888-8888-4888-8888-888888888888",
+ }
+ ],
+ "feedback": {"rating": "like"},
+ "created_at": 1767323045,
+ }
+
+
+def saved_messages() -> Generator[MagicMock]:
+ service = MagicMock()
+ with patch.object(
+ module,
+ "application_services",
+ return_value=SimpleNamespace(saved_messages=service),
+ ):
+ yield service
+
+
+_list_get = unwrap(module.SavedMessageListApi.get)
+_list_post = unwrap(module.SavedMessageListApi.post)
-# ---------------------------------------------------------------------------
-# SavedMessageListApi (GET)
-# ---------------------------------------------------------------------------
class TestSavedMessageListApiGet:
- def test_non_completion_mode_raises(self, app: Flask) -> None:
+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:
query = SavedMessageListQuery.model_validate({})
- with app.test_request_context("/saved-messages"):
- with pytest.raises(NotCompletionAppError):
- _list_get(SavedMessageListApi(), query, MagicMock(), _chat_app(), _end_user())
-
- @patch("controllers.web.saved_message.SavedMessageService.pagination_by_last_id")
- def test_happy_path(self, mock_paginate: MagicMock, app: Flask) -> None:
- mock_paginate.return_value = SimpleNamespace(limit=20, has_more=False, data=[])
- query = SavedMessageListQuery.model_validate({"limit": 20})
+ with app.test_request_context("/saved-messages"), pytest.raises(NotCompletionAppError):
+ _list_get(module.SavedMessageListApi(), query, _chat_app(), _end_user())
- with app.test_request_context("/saved-messages?limit=20"):
- result = _list_get(SavedMessageListApi(), query, MagicMock(), _completion_app(), _end_user())
+ saved_messages.pagination_by_last_id.assert_not_called()
- assert result["limit"] == 20
- assert result["has_more"] is False
+ def test_happy_path(self, app: Flask, saved_messages: MagicMock) -> None:
+ saved_messages.pagination_by_last_id.return_value = SavedMessagePage(
+ limit=20,
+ has_more=False,
+ data=(_record(),),
+ )
+ query = SavedMessageListQuery.model_validate({"limit": 20})
+ app_model = _completion_app()
+ end_user = _end_user()
+
+ with (
+ app.test_request_context("/saved-messages?limit=20"),
+ patch.object(File, "generate_url", return_value=_INPUT_FILE_URL),
+ ):
+ result = _list_get(module.SavedMessageListApi(), query, app_model, end_user)
+
+ saved_messages.pagination_by_last_id.assert_called_once_with(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ last_id=None,
+ limit=20,
+ )
+ assert result == {"limit": 20, "has_more": False, "data": [_expected_record()]}
+
+ def test_invalid_last_id_preserves_error_context(self, app: Flask, saved_messages: MagicMock) -> None:
+ last_id = str(uuid4())
+ description = "The last_id cursor does not belong to the current saved messages."
+ saved_messages.pagination_by_last_id.side_effect = LastMessageNotExistsError(description)
+ query = SavedMessageListQuery.model_validate({"last_id": last_id})
+
+ with (
+ app.test_request_context(f"/saved-messages?last_id={last_id}"),
+ pytest.raises(LastMessageNotExistsError, match="last_id") as raised,
+ ):
+ _list_get(module.SavedMessageListApi(), query, _completion_app(), _end_user())
+
+ assert raised.value.description == description
-# ---------------------------------------------------------------------------
-# SavedMessageListApi (POST)
-# ---------------------------------------------------------------------------
class TestSavedMessageListApiPost:
- def test_non_completion_mode_raises(self, app: Flask) -> None:
+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:
payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})
- with app.test_request_context("/saved-messages", method="POST"):
- with pytest.raises(NotCompletionAppError):
- _list_post(SavedMessageListApi(), payload, MagicMock(), _chat_app(), _end_user())
+ with app.test_request_context("/saved-messages", method="POST"), pytest.raises(NotCompletionAppError):
+ _list_post(module.SavedMessageListApi(), payload, _chat_app(), _end_user())
- @patch("controllers.web.saved_message.SavedMessageService.save")
- def test_save_success(self, mock_save: MagicMock, app: Flask) -> None:
- payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})
+ saved_messages.save.assert_not_called()
+
+ def test_save_success(self, app: Flask, saved_messages: MagicMock) -> None:
+ message_id = str(uuid4())
+ payload = SavedMessageCreatePayload.model_validate({"message_id": message_id})
+ app_model = _completion_app()
+ end_user = _end_user()
with app.test_request_context("/saved-messages", method="POST"):
- result = _list_post(SavedMessageListApi(), payload, MagicMock(), _completion_app(), _end_user())
+ result = _list_post(module.SavedMessageListApi(), payload, app_model, end_user)
- assert result["result"] == "success"
+ saved_messages.save.assert_called_once_with(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ message_id=message_id,
+ )
+ assert result == {"result": "success"}
- @patch("controllers.web.saved_message.SavedMessageService.save", side_effect=MessageNotExistsError())
- def test_save_not_found(self, mock_save: MagicMock, app: Flask) -> None:
+ def test_save_not_found(self, app: Flask, saved_messages: MagicMock) -> None:
+ saved_messages.save.side_effect = MessageNotExistsError()
payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})
- with app.test_request_context("/saved-messages", method="POST"):
- with pytest.raises(NotFound, match="Message Not Exists"):
- _list_post(SavedMessageListApi(), payload, MagicMock(), _completion_app(), _end_user())
+ with (
+ app.test_request_context("/saved-messages", method="POST"),
+ pytest.raises(NotFound, match="Message Not Exists"),
+ ):
+ _list_post(module.SavedMessageListApi(), payload, _completion_app(), _end_user())
-# ---------------------------------------------------------------------------
-# SavedMessageApi (DELETE)
-# ---------------------------------------------------------------------------
class TestSavedMessageApi:
- def test_non_completion_mode_raises(self, app: Flask) -> None:
- msg_id = uuid4()
- with app.test_request_context(f"/saved-messages/{msg_id}", method="DELETE"):
- with pytest.raises(NotCompletionAppError):
- SavedMessageApi().delete(_chat_app(), _end_user(), msg_id)
-
- @patch("controllers.web.saved_message.SavedMessageService.delete")
- def test_delete_success(self, mock_delete: MagicMock, app: Flask) -> None:
- msg_id = uuid4()
- with app.test_request_context(f"/saved-messages/{msg_id}", method="DELETE"):
- result, status = SavedMessageApi().delete(_completion_app(), _end_user(), msg_id)
-
- assert status == 204
- assert result == ""
+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:
+ message_id = uuid4()
+ with (
+ app.test_request_context(f"/saved-messages/{message_id}", method="DELETE"),
+ pytest.raises(NotCompletionAppError),
+ ):
+ module.SavedMessageApi().delete(_chat_app(), _end_user(), message_id)
+
+ saved_messages.delete.assert_not_called()
+
+ def test_delete_success(self, app: Flask, saved_messages: MagicMock) -> None:
+ message_id = uuid4()
+ app_model = _completion_app()
+ end_user = _end_user()
+ with app.test_request_context(f"/saved-messages/{message_id}", method="DELETE"):
+ result = module.SavedMessageApi().delete(app_model, end_user, message_id)
+
+ saved_messages.delete.assert_called_once_with(
+ app_id=app_model.id,
+ actor=SavedMessageActor.end_user(end_user.id),
+ message_id=str(message_id),
+ )
+ assert result == ("", 204)
diff --git a/api/tests/unit_tests/repositories/test_app_definition_query_repository.py b/api/tests/unit_tests/repositories/test_app_definition_query_repository.py
index cc9c851bddf..a4888797492 100644
--- a/api/tests/unit_tests/repositories/test_app_definition_query_repository.py
+++ b/api/tests/unit_tests/repositories/test_app_definition_query_repository.py
@@ -53,6 +53,21 @@ def _persist_app(
return app
+def test_get_mode_returns_none_for_missing_app(sqlite_session_factory: sessionmaker[Session]) -> None:
+ repository = AppDefinitionQueryRepository(session_factory=sqlite_session_factory)
+
+ assert repository.get_mode(_APP_ID) is None
+
+
+def test_get_mode_returns_app_mode(sqlite_session_factory: sessionmaker[Session]) -> None:
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session, mode=AppMode.COMPLETION)
+
+ repository = AppDefinitionQueryRepository(session_factory=sqlite_session_factory)
+
+ assert repository.get_mode(_APP_ID) == AppMode.COMPLETION.value
+
+
def test_get_published_parameter_config_returns_none_for_missing_app(
sqlite_session_factory: sessionmaker[Session],
) -> None:
diff --git a/api/tests/unit_tests/repositories/test_saved_message_repository.py b/api/tests/unit_tests/repositories/test_saved_message_repository.py
new file mode 100644
index 00000000000..30201dcac61
--- /dev/null
+++ b/api/tests/unit_tests/repositories/test_saved_message_repository.py
@@ -0,0 +1,311 @@
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session, sessionmaker
+
+from models.enums import (
+ ConversationFromSource,
+ CreatorUserRole,
+ FeedbackFromSource,
+ FeedbackRating,
+)
+from models.model import App, AppMode, Message, MessageFeedback
+from models.web import SavedMessage
+from repositories.saved_message_repository import SQLAlchemySavedMessageRepository
+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError
+from services.saved_message_service import SavedMessageActor
+
+_APP_ID = "11111111-1111-4111-8111-111111111111"
+_OTHER_APP_ID = "22222222-2222-4222-8222-222222222222"
+_ACCOUNT_ID = "33333333-3333-4333-8333-333333333333"
+_END_USER_ID = "44444444-4444-4444-8444-444444444444"
+_OTHER_ACCOUNT_ID = "66666666-6666-4666-8666-666666666666"
+
+
+def _persist_app(session: Session, *, app_id: str = _APP_ID, mode: AppMode = AppMode.COMPLETION) -> App:
+ app = App(
+ id=app_id,
+ tenant_id="55555555-5555-4555-8555-555555555555",
+ name="Saved message app",
+ description="",
+ mode=mode,
+ icon_type=None,
+ icon=None,
+ icon_background=None,
+ enable_site=True,
+ enable_api=True,
+ is_public=True,
+ max_active_requests=None,
+ )
+ session.add(app)
+ session.flush()
+ return app
+
+
+def _persist_message(
+ session: Session,
+ *,
+ app_id: str = _APP_ID,
+ actor: SavedMessageActor,
+ created_at: datetime,
+ feedback: FeedbackRating | None = None,
+) -> Message:
+ message = Message(
+ id=str(uuid4()),
+ app_id=app_id,
+ conversation_id=str(uuid4()),
+ query="hello",
+ message={"role": "user", "content": "hello"},
+ answer="world",
+ message_tokens=1,
+ message_unit_price=Decimal(0),
+ answer_tokens=1,
+ answer_unit_price=Decimal(0),
+ provider_response_latency=0,
+ currency="USD",
+ from_source=(ConversationFromSource.CONSOLE if actor.role == "account" else ConversationFromSource.API),
+ from_end_user_id=actor.id if actor.role == "end_user" else None,
+ from_account_id=actor.id if actor.role == "account" else None,
+ app_mode=AppMode.COMPLETION,
+ )
+ message._inputs = {"topic": "test"}
+ message.created_at = created_at
+ session.add(message)
+ session.flush()
+ if feedback is not None:
+ session.add(
+ MessageFeedback(
+ app_id=app_id,
+ conversation_id=message.conversation_id,
+ message_id=message.id,
+ rating=feedback,
+ from_source=FeedbackFromSource.USER,
+ from_account_id=actor.id if actor.role == "account" else None,
+ from_end_user_id=actor.id if actor.role == "end_user" else None,
+ )
+ )
+ return message
+
+
+def _save_message(session: Session, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:
+ session.add(
+ SavedMessage(
+ app_id=app_id,
+ message_id=message_id,
+ created_by_role=CreatorUserRole(actor.role),
+ created_by=actor.id,
+ )
+ )
+ session.flush()
+
+
+def _repository(session_factory: sessionmaker[Session]) -> SQLAlchemySavedMessageRepository:
+ return SQLAlchemySavedMessageRepository(session_factory=session_factory)
+
+
+def test_list_returns_detached_records(
+ sqlite_session_factory: sessionmaker[Session],
+) -> None:
+ account = SavedMessageActor.account(_ACCOUNT_ID)
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ oldest = _persist_message(session, actor=account, created_at=datetime(2026, 1, 1))
+ middle = _persist_message(session, actor=account, created_at=datetime(2026, 1, 2))
+ newest = _persist_message(
+ session,
+ actor=account,
+ created_at=datetime(2026, 1, 3),
+ feedback=FeedbackRating.LIKE,
+ )
+ for message in (oldest, middle, newest):
+ _save_message(session, app_id=_APP_ID, actor=account, message_id=message.id)
+
+ result = _repository(sqlite_session_factory).pagination_by_last_id(
+ app_id=_APP_ID,
+ actor=account,
+ last_id=None,
+ limit=2,
+ )
+
+ assert result.limit == 2
+ assert result.has_more is True
+ assert [record.id for record in result.data] == [newest.id, middle.id]
+ assert result.data[0].inputs == {"topic": "test"}
+ assert result.data[0].message_files == []
+ assert result.data[0].user_feedback is not None
+ assert result.data[0].user_feedback.rating == FeedbackRating.LIKE.value
+
+
+ ("saved_app_id", "saved_actor"),
+ [
+ pytest.param(_OTHER_APP_ID, SavedMessageActor.account(_ACCOUNT_ID), id="app-id"),
+ pytest.param(_APP_ID, SavedMessageActor.end_user(_ACCOUNT_ID), id="actor-role"),
+ pytest.param(_APP_ID, SavedMessageActor.account(_OTHER_ACCOUNT_ID), id="actor-id"),
+ ],
+)
+def test_list_excludes_saved_messages_outside_actor_scope(
+ sqlite_session_factory: sessionmaker[Session],
+ saved_app_id: str,
+ saved_actor: SavedMessageActor,
+) -> None:
+ actor = SavedMessageActor.account(_ACCOUNT_ID)
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ if saved_app_id != _APP_ID:
+ _persist_app(session, app_id=saved_app_id)
+ owned = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))
+ out_of_scope = _persist_message(
+ session,
+ app_id=saved_app_id,
+ actor=saved_actor,
+ created_at=datetime(2026, 1, 2),
+ )
+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=owned.id)
+ _save_message(session, app_id=saved_app_id, actor=saved_actor, message_id=out_of_scope.id)
+
+ result = _repository(sqlite_session_factory).pagination_by_last_id(
+ app_id=_APP_ID,
+ actor=actor,
+ last_id=None,
+ limit=20,
+ )
+
+ assert [record.id for record in result.data] == [owned.id]
+
+
+def test_list_paginates_after_last_id(sqlite_session_factory: sessionmaker[Session]) -> None:
+ actor = SavedMessageActor.account(_ACCOUNT_ID)
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ oldest = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))
+ middle = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 2))
+ newest = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 3))
+ for message in (oldest, middle, newest):
+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=message.id)
+
+ result = _repository(sqlite_session_factory).pagination_by_last_id(
+ app_id=_APP_ID,
+ actor=actor,
+ last_id=middle.id,
+ limit=20,
+ )
+
+ assert result.has_more is False
+ assert [record.id for record in result.data] == [oldest.id]
+
+
+def test_list_rejects_last_id_outside_saved_set(sqlite_session_factory: sessionmaker[Session]) -> None:
+ actor = SavedMessageActor.account(_ACCOUNT_ID)
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ saved = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))
+ not_saved = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 2))
+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=saved.id)
+
+ with pytest.raises(
+ LastMessageNotExistsError,
+ match=r"^The last_id cursor does not belong to the current saved messages\.$",
+ ):
+ _repository(sqlite_session_factory).pagination_by_last_id(
+ app_id=_APP_ID,
+ actor=actor,
+ last_id=not_saved.id,
+ limit=20,
+ )
+
+
+def test_list_with_no_saved_messages_ignores_last_id(sqlite_session_factory: sessionmaker[Session]) -> None:
+ result = _repository(sqlite_session_factory).pagination_by_last_id(
+ app_id=_APP_ID,
+ actor=SavedMessageActor.account(_ACCOUNT_ID),
+ last_id=str(uuid4()),
+ limit=20,
+ )
+
+ assert result.data == ()
+ assert result.has_more is False
+
+
+ "actor",
+ [
+ pytest.param(SavedMessageActor.account(_ACCOUNT_ID), id="account"),
+ pytest.param(SavedMessageActor.end_user(_END_USER_ID), id="end-user"),
+ ],
+)
+def test_saved_message_lifecycle_is_actor_scoped_and_idempotent(
+ sqlite_session_factory: sessionmaker[Session],
+ actor: SavedMessageActor,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ message = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))
+
+ repository = _repository(sqlite_session_factory)
+ repository.save(app_id=_APP_ID, actor=actor, message_id=message.id)
+ repository.save(app_id=_APP_ID, actor=actor, message_id=message.id)
+
+ with sqlite_session_factory() as session:
+ rows = session.scalars(select(SavedMessage)).all()
+ assert [(row.created_by_role, row.created_by) for row in rows] == [(CreatorUserRole(actor.role), actor.id)]
+
+ result = repository.pagination_by_last_id(app_id=_APP_ID, actor=actor, last_id=None, limit=20)
+ assert [record.id for record in result.data] == [message.id]
+
+ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)
+ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)
+
+ with sqlite_session_factory() as session:
+ count = session.scalar(select(func.count()).select_from(SavedMessage))
+ assert count == 0
+
+
+def test_save_rejects_message_owned_by_another_actor(sqlite_session_factory: sessionmaker[Session]) -> None:
+ owner = SavedMessageActor.account(_ACCOUNT_ID)
+ other = SavedMessageActor.account(str(uuid4()))
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ message = _persist_message(session, actor=owner, created_at=datetime(2026, 1, 1))
+
+ with pytest.raises(MessageNotExistsError):
+ _repository(sqlite_session_factory).save(app_id=_APP_ID, actor=other, message_id=message.id)
+
+
+ ("saved_app_id", "saved_actor"),
+ [
+ pytest.param(_OTHER_APP_ID, SavedMessageActor.account(_ACCOUNT_ID), id="app-id"),
+ pytest.param(_APP_ID, SavedMessageActor.end_user(_ACCOUNT_ID), id="actor-role"),
+ pytest.param(_APP_ID, SavedMessageActor.account(_OTHER_ACCOUNT_ID), id="actor-id"),
+ ],
+)
+def test_delete_preserves_saved_messages_outside_actor_scope(
+ sqlite_session_factory: sessionmaker[Session],
+ saved_app_id: str,
+ saved_actor: SavedMessageActor,
+) -> None:
+ actor = SavedMessageActor.account(_ACCOUNT_ID)
+ with sqlite_session_factory.begin() as session:
+ _persist_app(session)
+ if saved_app_id != _APP_ID:
+ _persist_app(session, app_id=saved_app_id)
+ message = _persist_message(
+ session,
+ app_id=saved_app_id,
+ actor=saved_actor,
+ created_at=datetime(2026, 1, 1),
+ )
+ _save_message(session, app_id=saved_app_id, actor=saved_actor, message_id=message.id)
+
+ repository = _repository(sqlite_session_factory)
+ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)
+
+ with sqlite_session_factory() as session:
+ rows = session.scalars(select(SavedMessage)).all()
+ assert [(row.app_id, row.created_by_role, row.created_by) for row in rows] == [
+ (saved_app_id, CreatorUserRole(saved_actor.role), saved_actor.id)
+ ]
diff --git a/api/tests/unit_tests/services/test_app_definition_query_service.py b/api/tests/unit_tests/services/test_app_definition_query_service.py
index 4a5d69bb15b..9987d4e50d3 100644
--- a/api/tests/unit_tests/services/test_app_definition_query_service.py
+++ b/api/tests/unit_tests/services/test_app_definition_query_service.py
@@ -28,6 +28,22 @@ def _service() -> tuple[AppDefinitionQueryService, MagicMock]:
)
+def test_get_mode_returns_repository_value() -> None:
+ service, definitions = _service()
+ definitions.get_mode.return_value = "completion"
+
+ assert service.get_mode("app-1") == "completion"
+ definitions.get_mode.assert_called_once_with("app-1")
+
+
+def test_get_mode_rejects_missing_app() -> None:
+ service, definitions = _service()
+ definitions.get_mode.return_value = None
+
+ with pytest.raises(AppDefinitionUnavailableError, match="App not found"):
+ service.get_mode("missing")
+
+
def test_get_parameters_maps_published_config() -> None:
service, definitions = _service()
config = AppParameterConfig(