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

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

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

No files matched your search

@@ -0,0 +1,257 @@
"""Conversation commands through real Web admission and SQLite transactions."""
from dataclasses import dataclass
from http import HTTPStatus
from typing import Literal
from uuid import uuid4
import pytest
from sqlalchemy import event, select, update
from sqlalchemy.orm import Session
from werkzeug.test import TestResponse
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from controllers.web.conversation import ConversationApi, ConversationPinApi, ConversationUnPinApi
from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType
from models.enums import ConversationFromSource, CreatorUserRole
from models.model import AppMode, Conversation, EndUser
from models.web import PinnedConversation
from repositories.conversation_repository import ConversationRepository
from services.conversation_command_service import ConversationCommandService
from tests.e2e_tests.contracts.controllers.web import test_conversation_rename as rename_tests
from tests.e2e_tests.contracts.controllers.web.test_conversation_rename import _Harness as RenameHarness
rename_harness = rename_tests.harness
@dataclass(frozen=True)
class _Services:
conversation_commands: ConversationCommandService
@dataclass(frozen=True)
class _Harness:
source: RenameHarness
cleanups: list[tuple[str, str, tuple[str, ...]]]
def request(self, action: str, *, conversation_id: str | None = None) -> TestResponse:
path = f"/conversations/{conversation_id or self.source.conversation.id}"
return self.source.app.test_client().open(
path if action == "delete" else f"{path}/{action}",
method="DELETE" if action == "delete" else "PATCH",
headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.source.passport},
)
def assert_not_deleted(self) -> None:
with self.source.factory() as session:
stored = session.get(Conversation, self.source.conversation.id)
assert stored is not None
assert not stored.is_deleted
assert self.cleanups == []
@pytest.fixture
def harness(rename_harness: RenameHarness) -> _Harness:
cleanups: list[tuple[str, str, tuple[str, ...]]] = []
def enqueue_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:
# Observe the real external boundary: committed state must be visible on
# another connection, with neither admission nor command transactions open.
rename_harness.assert_closed()
with rename_harness.factory() as session:
stored = session.get(Conversation, conversation_id)
assert stored is not None
assert stored.is_deleted
for workspace_id in retired_workspace_ids:
workspace = session.get(AgentWorkspace, workspace_id)
assert workspace is not None
assert workspace.status == AgentWorkingResourceStatus.RETIRED
assert workspace.active_guard is None
assert workspace.retired_at is not None
cleanups.append((tenant_id, conversation_id, retired_workspace_ids))
rename_harness.app.extensions["application_services"] = _Services(
conversation_commands=ConversationCommandService(
conversations=ConversationRepository(session_factory=rename_harness.repository_factory),
enqueue_delete_cleanup=enqueue_cleanup,
)
)
rename_harness.api.add_resource(ConversationApi, "/conversations/<uuid:c_id>")
rename_harness.api.add_resource(ConversationPinApi, "/conversations/<uuid:c_id>/pin")
rename_harness.api.add_resource(ConversationUnPinApi, "/conversations/<uuid:c_id>/unpin")
return _Harness(rename_harness, cleanups)
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_delete_commits_retirement_before_cleanup_and_returns_empty_204(harness: _Harness, mode: AppMode) -> None:
source = harness.source
rename_tests._publish_mode(source, mode)
with source.factory.begin() as session:
workspace = AgentWorkspace(
id=str(uuid4()),
tenant_id=source.target.tenant_id,
app_id=source.target.id,
owner_type=AgentWorkspaceOwnerType.CONVERSATION,
owner_id=source.conversation.id,
owner_scope_key="chatflow-node",
backend_workspace_ref="backend-workspace",
status=AgentWorkingResourceStatus.ACTIVE,
active_guard=1,
)
session.add(workspace)
response = harness.request("delete")
assert response.status_code == HTTPStatus.NO_CONTENT
assert response.data == b""
assert response.headers["Content-Type"] == "application/json"
assert harness.cleanups == [(source.target.tenant_id, source.conversation.id, (workspace.id,))]
assert source.repository_sessions
source.assert_closed()
repeated = harness.request("delete")
assert repeated.status_code == HTTPStatus.NOT_FOUND
assert repeated.json is not None
assert repeated.json["code"] == "conversation_not_found"
assert len(harness.cleanups) == 1
source.assert_closed()
@pytest.mark.parametrize("action", ["delete", "pin"])
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])
def test_commands_cannot_target_conversations_outside_end_user_scope(
harness: _Harness, action: str, field: str
) -> None:
source = harness.source
value: str | bool
if field == "is_deleted":
value = True
elif field == "from_source":
value = ConversationFromSource.CONSOLE
elif field == "from_account_id":
# Account and EndUser IDs are independent namespaces, even if equal.
value = source.end_user.id
else:
value = str(uuid4())
with source.factory.begin() as session:
session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))
response = harness.request(action)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.json is not None
assert response.json["code"] == "conversation_not_found"
assert harness.cleanups == []
with source.factory() as session:
stored = session.get(Conversation, source.conversation.id)
assert stored is not None
assert stored.is_deleted is (field == "is_deleted")
assert session.scalars(select(PinnedConversation)).all() == []
source.assert_closed()
@pytest.mark.parametrize("action", ["delete", "pin", "unpin"])
@pytest.mark.parametrize("field", ["tenant_id", "app_id"])
def test_commands_reject_end_user_outside_app_owner_scope(
harness: _Harness, action: str, field: Literal["tenant_id", "app_id"]
) -> None:
source = harness.source
with source.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == source.end_user.id).values({field: str(uuid4())}))
response = harness.request(action)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.json is not None
assert response.json["code"] == "not_found"
harness.assert_not_deleted()
source.assert_closed()
def test_pin_and_unpin_are_idempotent_and_isolate_actor_role(harness: _Harness) -> None:
source = harness.source
with source.factory.begin() as session:
other_pins = [
PinnedConversation(
app_id=source.target.id,
conversation_id=source.conversation.id,
created_by_role=role,
created_by=actor_id,
)
for role, actor_id in [
(CreatorUserRole.ACCOUNT, source.end_user.id),
(CreatorUserRole.END_USER, str(uuid4())),
]
]
session.add_all(other_pins)
for _ in range(2):
response = harness.request("pin")
assert response.status_code == HTTPStatus.OK
assert response.headers["Content-Type"] == "application/json"
assert response.json is not None
assert response.json == {"result": "success"}
source.assert_closed()
with source.factory() as session:
pins = session.scalars(select(PinnedConversation)).all()
own_pins = [
pin
for pin in pins
if pin.created_by_role == CreatorUserRole.END_USER and pin.created_by == source.end_user.id
]
assert len(pins) == 3
assert len(own_pins) == 1
assert own_pins[0].app_id == source.target.id
assert own_pins[0].conversation_id == source.conversation.id
for _ in range(2):
response = harness.request("unpin")
assert response.status_code == HTTPStatus.OK
assert response.json is not None
assert response.json == {"result": "success"}
source.assert_closed()
with source.factory() as session:
assert set(session.scalars(select(PinnedConversation.id))) == {pin.id for pin in other_pins}
harness.assert_not_deleted()
@pytest.mark.parametrize("action", ["delete", "pin", "unpin"])
def test_unknown_conversation_preserves_existing_decoy(harness: _Harness, action: str) -> None:
response = harness.request(action, conversation_id=str(uuid4()))
if action == "unpin":
assert response.status_code == HTTPStatus.OK
assert response.json is not None
assert response.json == {"result": "success"}
else:
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.json is not None
assert response.json["code"] == "conversation_not_found"
harness.assert_not_deleted()
harness.source.assert_closed()
@pytest.mark.parametrize("action", ["delete", "pin", "unpin"])
@pytest.mark.parametrize("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
def test_non_chat_mode_is_rejected_before_command_transaction(harness: _Harness, action: str, mode: AppMode) -> None:
source = harness.source
rename_tests._publish_mode(source, mode)
response = harness.request(action)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.json is not None
assert response.json["code"] == "not_chat_app"
assert source.repository_sessions == []
harness.assert_not_deleted()
source.assert_closed()
def test_failed_delete_commit_rolls_back_without_publishing_cleanup(harness: _Harness) -> None:
def reject_commit(_session: Session) -> None:
raise RuntimeError("Database commit failed")
source = harness.source
event.listen(source.repository_factory, "before_commit", reject_commit)
try:
response = harness.request("delete")
finally:
event.remove(source.repository_factory, "before_commit", reject_commit)
assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
harness.assert_not_deleted()
source.assert_closed()
@@ -0,0 +1,297 @@
"""Conversation lists through real Web admission, queries, and SQLite reads."""
from collections.abc import Callable, Mapping
from dataclasses import dataclass
from datetime import timedelta
from http import HTTPStatus
from uuid import uuid4
import pytest
from pydantic import JsonValue
from sqlalchemy import Engine, event, update
from sqlalchemy.orm import Session, SessionTransaction
from werkzeug.test import TestResponse
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from controllers.web.conversation import ConversationListApi
from graphon.file import File, FileTransferMethod, FileType
from models.enums import ConversationFromSource, CreatorUserRole, InvokeFrom
from models.model import App, AppMode, Conversation, EndUser
from models.utils.file_input_compat import restore_input_files
from models.web import PinnedConversation
from repositories.conversation_repository import ConversationRepository
from services.conversation_query_service import ConversationQueryService
from services.entities.conversation_entities import ConversationSort
from services.message_query_adapters import MessageFileResolver
from tests.e2e_tests.contracts.controllers.web import test_conversation_rename as rename_tests
from tests.e2e_tests.contracts.controllers.web.test_conversation_rename import _Harness as RenameHarness
from tests.helpers.unit.model_factories import make_conversation
rename_harness = rename_tests.harness
@dataclass(frozen=True)
class _Services:
conversation_queries: ConversationQueryService
@dataclass(frozen=True)
class _Harness:
source: RenameHarness
restored_inputs: list[dict[str, JsonValue | File | list[File]]]
def get(self, query: Mapping[str, str | int] | None = None) -> TestResponse:
return self.source.app.test_client().get(
"/conversations",
query_string=query,
headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.source.passport},
)
@pytest.fixture
def harness(rename_harness: RenameHarness) -> _Harness:
restored_inputs: list[dict[str, JsonValue | File | list[File]]] = []
def restore(
*,
inputs: Mapping[str, JsonValue | File | list[File]],
tenant_resolver: Callable[[], str],
) -> dict[str, JsonValue | File | list[File]]:
# Exercise the real restoration, observing its transaction boundary.
rename_harness.assert_closed()
restored = restore_input_files(inputs=inputs, tenant_resolver=tenant_resolver)
restored_inputs.append(restored)
return restored
rename_harness.app.extensions["application_services"] = _Services(
conversation_queries=ConversationQueryService(
files=MessageFileResolver(),
conversations=ConversationRepository(session_factory=rename_harness.repository_factory),
restore_inputs=restore,
)
)
rename_harness.api.add_resource(ConversationListApi, "/conversations")
return _Harness(rename_harness, restored_inputs)
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_list_preserves_wire_contract_and_restores_inputs_after_session_close(harness: _Harness, mode: AppMode) -> None:
source = harness.source
rename_tests._publish_mode(source, mode)
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.headers["Content-Type"] == "application/json"
assert response.get_json() == {
"limit": 20,
"has_more": False,
"data": [
{
"id": source.conversation.id,
"name": "Original title",
"inputs": {"text": "", "list": [], "zero": 0, "flag": False, "null": None},
"status": "normal",
"introduction": None,
"created_at": int(source.conversation.created_at.timestamp()),
"updated_at": int(source.conversation.updated_at.timestamp()),
}
],
}
assert len(harness.restored_inputs) == 1
assert source.repository_sessions
source.assert_closed()
@pytest.mark.parametrize("sort_by", ["created_at", "-created_at", "updated_at", "-updated_at"])
def test_sort_and_cursor_return_the_next_page(harness: _Harness, sort_by: ConversationSort) -> None:
source = harness.source
newest = make_conversation(
conversation_id=str(uuid4()),
app_id=source.target.id,
from_source=ConversationFromSource.API,
from_end_user_id=source.end_user.id,
inputs={},
)
newest.created_at = source.conversation.created_at + timedelta(days=1)
newest.updated_at = source.conversation.updated_at + timedelta(days=1)
newest.invoke_from = InvokeFrom.WEB_APP
with source.factory.begin() as session:
session.add(newest)
ordered_ids = [source.conversation.id, newest.id]
if sort_by.startswith("-"):
ordered_ids.reverse()
first = harness.get({"sort_by": sort_by, "limit": 1, "last_id": ""})
assert first.status_code == HTTPStatus.OK
assert first.get_json()["has_more"] is True
assert [item["id"] for item in first.get_json()["data"]] == ordered_ids[:1]
second = harness.get({"sort_by": sort_by, "limit": 1, "last_id": ordered_ids[0]})
assert second.status_code == HTTPStatus.OK
assert second.get_json()["has_more"] is False
assert [item["id"] for item in second.get_json()["data"]] == ordered_ids[1:]
last = harness.get({"sort_by": sort_by, "last_id": ordered_ids[1]})
assert last.get_json() == {"limit": 20, "has_more": False, "data": []}
source.assert_closed()
@pytest.mark.parametrize(
"field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted", "invoke_from"]
)
def test_list_and_cursor_cannot_expose_other_owners_or_invocation_sources(harness: _Harness, field: str) -> None:
source = harness.source
value: str | bool
if field == "is_deleted":
value = True
elif field == "from_source":
value = ConversationFromSource.CONSOLE
elif field == "invoke_from":
value = InvokeFrom.SERVICE_API.value
else:
value = str(uuid4())
with source.factory.begin() as session:
session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {"limit": 20, "has_more": False, "data": []}
cursor = harness.get({"last_id": source.conversation.id})
assert cursor.status_code == HTTPStatus.NOT_FOUND
assert cursor.get_json()["code"] == "conversation_cursor_not_found"
source.assert_closed()
@pytest.mark.parametrize("pinned", [True, False])
def test_pin_filter_is_scoped_to_app_actor_and_role(harness: _Harness, pinned: bool) -> None:
source = harness.source
with source.factory.begin() as session:
session.add(
PinnedConversation(
app_id=source.target.id,
conversation_id=source.conversation.id,
created_by_role=CreatorUserRole.END_USER,
created_by=source.end_user.id,
)
)
response = harness.get({"pinned": str(pinned).lower()})
assert response.status_code == HTTPStatus.OK
assert [item["id"] for item in response.get_json()["data"]] == ([source.conversation.id] if pinned else [])
source.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "created_by", "created_by_role"])
def test_another_owner_pin_does_not_hide_the_unpinned_conversation(harness: _Harness, field: str) -> None:
source = harness.source
pin = PinnedConversation(
app_id=source.target.id,
conversation_id=source.conversation.id,
created_by_role=CreatorUserRole.END_USER,
created_by=source.end_user.id,
)
if field == "created_by_role":
pin.created_by_role = CreatorUserRole.ACCOUNT
elif field == "created_by":
pin.created_by = str(uuid4())
else:
pin.app_id = str(uuid4())
with source.factory.begin() as session:
session.add(pin)
response = harness.get({"pinned": "false"})
assert response.status_code == HTTPStatus.OK
assert [item["id"] for item in response.get_json()["data"]] == [source.conversation.id]
# Existing behavior: a requested pinned list with no pins is empty even
# when a cursor is supplied; it does not first try to resolve that cursor.
empty = harness.get({"pinned": "true", "last_id": str(uuid4())})
assert empty.status_code == HTTPStatus.OK
assert empty.get_json() == {"limit": 20, "has_more": False, "data": []}
source.assert_closed()
@pytest.mark.parametrize("query", [{"limit": "0"}, {"limit": "101"}, {"last_id": "invalid"}, {"sort_by": "name"}])
def test_invalid_query_preserves_400_before_querying(harness: _Harness, query: dict[str, str]) -> None:
response = harness.get(query)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "invalid_param"
assert not harness.source.repository_sessions
harness.source.assert_closed()
@pytest.mark.parametrize("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
def test_non_chat_mode_is_rejected_before_querying(harness: _Harness, mode: AppMode) -> None:
source = harness.source
rename_tests._publish_mode(source, mode)
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "not_chat_app"
assert not source.repository_sessions
source.assert_closed()
@pytest.mark.parametrize("field", ["tenant_id", "app_id"])
def test_end_user_outside_app_owner_scope_is_rejected(harness: _Harness, field: str) -> None:
source = harness.source
with source.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == source.end_user.id).values({field: str(uuid4())}))
response = harness.get()
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
source.assert_closed()
@pytest.mark.parametrize("change_app_too", [False, True], ids=["end-user-workspace", "app-workspace"])
def test_workspace_change_after_admission_returns_conversation_not_found(
harness: _Harness, sqlite_engine: Engine, change_app_too: bool
) -> None:
source = harness.source
owner_changed = False
def change_owner(session: Session, _transaction: SessionTransaction) -> None:
nonlocal owner_changed
assert session in source.admission_sessions
assert not source.repository_sessions
# Change persisted ownership after passport resolution has closed its transaction.
new_tenant_id = str(uuid4())
with Session(sqlite_engine) as writer, writer.begin():
writer.execute(update(EndUser).where(EndUser.id == source.end_user.id).values(tenant_id=new_tenant_id))
if change_app_too:
writer.execute(update(App).where(App.id == source.target.id).values(tenant_id=new_tenant_id))
owner_changed = True
event.listen(source.factory, "after_transaction_end", change_owner, once=True)
try:
response = harness.get()
finally:
event.remove(source.factory, "after_transaction_end", change_owner)
assert owner_changed
assert source.repository_sessions
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json() == {
"code": "conversation_not_found",
"message": "The conversation was not found for this user and app.",
"status": HTTPStatus.NOT_FOUND,
}
assert harness.restored_inputs == []
source.assert_closed()
def test_remote_file_input_keeps_its_existing_wire_shape(harness: _Harness) -> None:
source = harness.source
file = File(
file_id=str(uuid4()),
file_type=FileType.DOCUMENT,
transfer_method=FileTransferMethod.REMOTE_URL,
remote_url="https://example.com/document.pdf",
filename="document.pdf",
extension=".pdf",
mime_type="application/pdf",
size=12,
)
with source.factory.begin() as session:
conversation = session.get(Conversation, source.conversation.id)
assert conversation is not None
conversation.inputs = {"document": file, "documents": [file]}
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.get_json()["data"][0]["inputs"] == {
"document": dict(file.to_dict()),
"documents": [dict(file.to_dict())],
}
source.assert_closed()
@@ -0,0 +1,384 @@
"""Rename through real Web admission, application service, and SQLite persistence."""
from collections.abc import Callable, Iterator
from dataclasses import dataclass
from datetime import datetime
from decimal import Decimal
from http import HTTPStatus
from typing import Literal
from uuid import uuid4
import pytest
from flask import Flask
from pydantic import JsonValue
from sqlalchemy import Connection, Engine, delete, event, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from controllers.web.conversation import ConversationRenameApi
from core.errors.error import ProviderTokenNotInitError
from enums import DeploymentEdition
from extensions.ext_database import db
from graphon.file import File, FileTransferMethod, FileType
from libs.external_api import ExternalApi
from libs.passport import PassportService
from models.agent import (
Agent,
AgentConfigRevision,
AgentConfigRevisionOperation,
AgentConfigSnapshot,
AgentScope,
AgentSource,
)
from models.agent_config_entities import AgentSoulConfig
from models.enums import ConversationFromSource, CustomizeTokenStrategy
from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, Site
from models.workflow import WorkflowType
from repositories.conversation_repository import ConversationRepository
from services.conversation_name_generator import DefaultModelConversationNameGenerator
from services.conversation_name_service import ConversationNameService
from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message, make_workflow
from tests.helpers.unit.services.tracing_ports import untraced_scopes
_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
_UPDATED_AT = datetime(2026, 1, 3, 3, 4, 5)
_INPUTS: dict[str, JsonValue] = {"text": "", "list": [], "zero": 0, "flag": False, "null": None}
@dataclass
class _Services:
conversation_names: ConversationNameService
@dataclass(frozen=True)
class _Harness:
app: Flask
target: App
end_user: EndUser
conversation: Conversation
factory: sessionmaker[Session]
repository_factory: sessionmaker[Session]
api: ExternalApi
passport: str
admission_sessions: list[Session]
repository_sessions: list[Session]
provider_sessions: list[Session]
def post(self, body: dict[str, object]) -> TestResponse:
return self.app.test_client().post(
f"/conversations/{self.conversation.id}/name",
json=body,
headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.passport},
)
def assert_closed(self) -> None:
sessions = self.admission_sessions + self.repository_sessions + self.provider_sessions
assert sessions
assert all(not session.in_transaction() and not session.identity_map for session in sessions)
def assert_name(self, name: str) -> None:
with self.factory() as session:
conversation = session.get(Conversation, self.conversation.id)
assert conversation is not None
assert conversation.name == name
@pytest.fixture
def harness(
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session_factory: sessionmaker[Session],
) -> Iterator[_Harness]:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="conversation-rename-test-secret-key")
target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()))
end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)
site = Site(
app_id=target.id,
title="Public app",
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.UUID,
code="public-app",
)
conversation = make_conversation(
conversation_id=str(uuid4()),
app_id=target.id,
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
inputs=_INPUTS,
name="Original title",
)
conversation.created_at = _CREATED_AT
conversation.updated_at = _UPDATED_AT
message = make_message(
message_id=str(uuid4()),
app_id=target.id,
conversation_id=conversation.id,
inputs={},
message={},
query="How does it work?",
answer="Like this.",
message_unit_price=Decimal(0),
answer_unit_price=Decimal(0),
currency="USD",
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
with sqlite_session_factory.begin() as session:
config = AppModelConfig(app_id=target.id)
session.add_all([target, end_user, site, conversation, message, config])
session.flush()
target.app_model_config_id = config.id
repository_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
admission_sessions: list[Session] = []
repository_sessions: list[Session] = []
provider_sessions: list[Session] = []
def track_admission(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
admission_sessions.append(session)
def track_repository(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
# Admission and provider lookup must release their transactions before
# rename starts its own read/write transaction.
assert all(not item.in_transaction() for item in admission_sessions + provider_sessions)
repository_sessions.append(session)
def track_provider(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
assert all(not item.in_transaction() for item in admission_sessions + repository_sessions)
provider_sessions.append(session)
event.listen(sqlite_session_factory, "after_begin", track_admission)
event.listen(repository_factory, "after_begin", track_repository)
passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
event.listen(db.session.session_factory, "after_begin", track_provider)
app.extensions["application_services"] = _Services(
ConversationNameService(
conversations=ConversationRepository(session_factory=repository_factory),
generate_name=DefaultModelConversationNameGenerator(trace_scopes=untraced_scopes()),
)
)
api = ExternalApi(app)
api.add_resource(ConversationRenameApi, "/conversations/<uuid:c_id>/name")
yield _Harness(
app,
target,
end_user,
conversation,
sqlite_session_factory,
repository_factory,
api,
passport,
admission_sessions,
repository_sessions,
provider_sessions,
)
event.remove(sqlite_session_factory, "after_begin", track_admission)
event.remove(repository_factory, "after_begin", track_repository)
event.remove(db.session.session_factory, "after_begin", track_provider)
with app.app_context():
db.session.remove()
db.engine.dispose()
def _publish_mode(harness: _Harness, mode: AppMode) -> None:
with harness.factory.begin() as session:
target = session.get(App, harness.target.id)
assert target is not None
target.mode = mode
if mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:
workflow = make_workflow(
tenant_id=target.tenant_id,
app_id=target.id,
workflow_type=WorkflowType.CHAT if mode == AppMode.ADVANCED_CHAT else WorkflowType.WORKFLOW,
version="published",
)
session.add(workflow)
session.flush()
target.workflow_id = workflow.id
elif mode == AppMode.AGENT:
agent = Agent(
tenant_id=target.tenant_id,
app_id=target.id,
name="Published agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
)
session.add(agent)
session.flush()
snapshot = AgentConfigSnapshot(
tenant_id=target.tenant_id,
agent_id=agent.id,
version=1,
config_snapshot=AgentSoulConfig(),
)
session.add(snapshot)
session.flush()
agent.active_config_snapshot_id = snapshot.id
session.add(
AgentConfigRevision(
tenant_id=target.tenant_id,
agent_id=agent.id,
current_snapshot_id=snapshot.id,
revision=1,
operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
)
)
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_manual_rename_persists_name_and_preserves_response_contract(harness: _Harness, mode: AppMode) -> None:
_publish_mode(harness, mode)
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.OK
assert response.headers["Content-Type"] == "application/json"
body = response.get_json()
assert body == {
"id": harness.conversation.id,
"name": "Manual title",
"inputs": _INPUTS,
"status": "normal",
"introduction": None,
"created_at": int(_CREATED_AT.timestamp()),
"updated_at": body["updated_at"],
}
assert isinstance(body["updated_at"], int)
assert body["updated_at"] > int(_UPDATED_AT.timestamp())
harness.assert_name("Manual title")
assert harness.repository_sessions
harness.assert_closed()
@pytest.mark.parametrize("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
def test_non_chat_mode_is_rejected_before_repository(harness: _Harness, mode: AppMode) -> None:
_publish_mode(harness, mode)
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "not_chat_app"
assert not harness.repository_sessions
harness.assert_name("Original title")
harness.assert_closed()
@pytest.mark.parametrize("body", [{}, {"name": None}, {"name": ""}, {"name": " "}, {"name": []}])
def test_invalid_manual_payload_is_rejected_without_writing(harness: _Harness, body: dict[str, object]) -> None:
response = harness.post(body)
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
assert response.get_json()["code"] == "unprocessable_entity"
assert not harness.repository_sessions
harness.assert_name("Original title")
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])
def test_conversation_outside_end_user_scope_is_not_renamed(harness: _Harness, field: str) -> None:
value: str | bool
if field == "is_deleted":
value = True
elif field == "from_source":
value = ConversationFromSource.CONSOLE
else:
value = str(uuid4())
with harness.factory.begin() as session:
session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values({field: value}))
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "conversation_not_found"
assert response.get_json()["message"] == "The conversation was not found for this user and app."
harness.assert_name("Original title")
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "tenant_id"])
def test_end_user_outside_app_owner_scope_is_rejected(harness: _Harness, field: Literal["app_id", "tenant_id"]) -> None:
with harness.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
assert not harness.repository_sessions
harness.assert_name("Original title")
harness.assert_closed()
def test_auto_rename_preserves_existing_name_when_real_provider_lookup_fails(
harness: _Harness, caplog: pytest.LogCaptureFixture
) -> None:
response = harness.post({"auto_generate": True, "name": "Ignored manual title"})
assert response.status_code == HTTPStatus.OK
assert response.get_json()["name"] == "Original title"
assert response.get_json()["updated_at"] == int(_UPDATED_AT.timestamp())
failures = [
record.exc_info[1]
for record in caplog.records
if record.name == "services.conversation_name_service" and record.exc_info is not None
]
assert len(failures) == 1
assert isinstance(failures[0], ProviderTokenNotInitError)
assert str(failures[0]) == "Default model not found for llm"
harness.assert_name("Original title")
harness.assert_closed()
def test_auto_rename_without_first_message_returns_specific_not_found(harness: _Harness) -> None:
with harness.factory.begin() as session:
session.execute(delete(Message).where(Message.conversation_id == harness.conversation.id))
response = harness.post({"auto_generate": True})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "conversation_first_message_not_found"
assert response.get_json()["message"] == "The conversation has no message from which to generate a name."
harness.assert_name("Original title")
harness.assert_closed()
def test_restored_remote_input_file_keeps_existing_wire_shape(harness: _Harness) -> None:
file = File(
file_id=str(uuid4()),
file_type=FileType.DOCUMENT,
transfer_method=FileTransferMethod.REMOTE_URL,
remote_url="https://example.com/document.pdf",
filename="document.pdf",
extension=".pdf",
mime_type="application/pdf",
size=12,
)
with harness.factory.begin() as session:
conversation = session.get(Conversation, harness.conversation.id)
assert conversation is not None
conversation.inputs = {"document": file}
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.OK
assert response.get_json()["inputs"] == {"document": dict(file.to_dict())}
harness.assert_name("Manual title")
harness.assert_closed()
@pytest.mark.parametrize("passport", ["missing", "invalid"])
def test_web_admission_rejects_missing_or_invalid_passport(harness: _Harness, passport: str) -> None:
headers = {HEADER_NAME_APP_CODE: "public-app"}
if passport == "invalid":
headers[HEADER_NAME_PASSPORT] = "invalid-passport"
response = harness.app.test_client().post(
f"/conversations/{harness.conversation.id}/name", json={"name": "Manual title"}, headers=headers
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
assert response.get_json()["code"] == "unauthorized"
assert response.get_json()["message"] == ("App token is missing." if passport == "missing" else "Invalid token.")
assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
assert not harness.repository_sessions
harness.assert_name("Original title")
def test_web_admission_rejects_disabled_site_before_rename(harness: _Harness) -> None:
with harness.factory.begin() as session:
session.execute(update(App).where(App.id == harness.target.id).values(enable_site=False))
response = harness.post({"name": "Manual title"})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "app_not_found"
assert response.get_json()["message"] == "App not found."
assert not harness.repository_sessions
harness.assert_name("Original title")
harness.assert_closed()
@@ -0,0 +1,225 @@
"""Web feedback through real passport admission, services, and SQLite writes."""
from collections.abc import Callable, Iterator
from dataclasses import dataclass
from decimal import Decimal
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Flask
from redis import Redis
from sqlalchemy import Connection, Engine, event, select, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from controllers.web.message import MessageFeedbackApi, MessageListApi
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from libs.external_api import ExternalApi
from libs.passport import PassportService
from models.enums import ConversationFromSource, CustomizeTokenStrategy, FeedbackFromSource, FeedbackRating
from models.model import App, AppModelConfig, EndUser, Message, MessageFeedback, Site
from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message
@dataclass(frozen=True)
class _Harness:
app: Flask
target: App
end_user: EndUser
message: Message
factory: sessionmaker[Session]
sessions: list[Session]
headers: dict[str, str]
def post(self, payload: dict[str, object], *, message_id: str | None = None) -> TestResponse:
return self.app.test_client().post(
f"/messages/{message_id or self.message.id}/feedbacks", json=payload, headers=self.headers
)
def feedbacks(self) -> list[MessageFeedback]:
with self.factory() as session:
return list(session.scalars(select(MessageFeedback)).all())
def assert_closed(self) -> None:
assert self.sessions
assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)
@pytest.fixture
def harness(
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session_factory: sessionmaker[Session],
) -> Iterator[_Harness]:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="feedback-passport-test-key-32-bytes")
target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()))
end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)
config = AppModelConfig(app_id=target.id)
target.app_model_config_id = config.id
conversation = make_conversation(
conversation_id=str(uuid4()),
inputs={},
app_id=target.id,
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
message = make_message(
message_id=str(uuid4()),
inputs={},
message={},
query="question",
answer="answer",
message_unit_price=Decimal(0),
answer_unit_price=Decimal(0),
currency="USD",
app_id=target.id,
conversation_id=conversation.id,
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
site = Site(
app_id=target.id,
title="Feedback app",
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.UUID,
code="feedback-app",
)
with sqlite_session_factory.begin() as session:
session.add_all([target, config, end_user, conversation, message, site])
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
sessions: list[Session] = []
def track(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
assert all(not previous.in_transaction() for previous in sessions if previous is not session)
sessions.append(session)
event.listen(sqlite_session_factory, "after_begin", track)
event.listen(factory, "after_begin", track)
event.listen(db.session.session_factory, "after_begin", track)
redis_client = Redis()
redis = RedisClientWrapper()
redis.initialize(redis_client)
app.extensions["application_services"] = build_application_services(
database_client=factory, deployment_edition=DeploymentEdition.COMMUNITY, initialization_password="", redis=redis
)
api = ExternalApi(app)
api.add_resource(MessageFeedbackApi, "/messages/<uuid:message_id>/feedbacks")
api.add_resource(MessageListApi, "/messages")
passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})
yield _Harness(
app,
target,
end_user,
message,
sqlite_session_factory,
sessions,
{HEADER_NAME_APP_CODE: "feedback-app", HEADER_NAME_PASSPORT: passport},
)
event.remove(sqlite_session_factory, "after_begin", track)
event.remove(factory, "after_begin", track)
event.remove(db.session.session_factory, "after_begin", track)
redis_client.close()
with app.app_context():
db.session.remove()
db.engine.dispose()
def test_create_update_and_revoke_user_feedback(harness: _Harness) -> None:
created = harness.post({"rating": "like", "content": "有帮助"})
assert created.status_code == HTTPStatus.OK
assert created.get_json() == {"result": "success"}
assert created.headers["Content-Type"] == "application/json"
[feedback] = harness.feedbacks()
assert feedback.app_id == harness.target.id
assert feedback.conversation_id == harness.message.conversation_id
assert feedback.message_id == harness.message.id
assert feedback.from_end_user_id == harness.end_user.id
assert feedback.from_account_id is None
assert feedback.from_source == FeedbackFromSource.USER
assert feedback.rating == FeedbackRating.LIKE
assert feedback.content == "有帮助"
feedback_id = feedback.id
updated = harness.post({"rating": "dislike", "content": ""})
assert updated.status_code == HTTPStatus.OK
[feedback] = harness.feedbacks()
assert feedback.id == feedback_id
assert feedback.rating == FeedbackRating.DISLIKE
assert feedback.content == ""
revoked = harness.post({"rating": None})
assert revoked.status_code == HTTPStatus.OK
assert revoked.get_json() == {"result": "success"}
assert harness.feedbacks() == []
harness.assert_closed()
@pytest.mark.parametrize("payload", [{}, {"rating": None, "content": "comment only"}])
def test_revoke_without_feedback_has_specific_error(harness: _Harness, payload: dict[str, object]) -> None:
response = harness.post(payload)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "message_feedback_rating_required"
assert harness.feedbacks() == []
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])
def test_message_ownership_is_enforced(harness: _Harness, field: str) -> None:
value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())
with harness.factory.begin() as session:
session.execute(update(Message).where(Message.id == harness.message.id).values({field: value}))
response = harness.post({"rating": "like"})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
assert harness.feedbacks() == []
harness.assert_closed()
def test_missing_message_returns_not_found(harness: _Harness) -> None:
response = harness.post({"rating": "like"}, message_id=str(uuid4()))
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["message"] == "Message Not Exists."
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "tenant_id"])
def test_corrupt_end_user_scope_cannot_write_feedback(harness: _Harness, field: str) -> None:
with harness.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))
response = harness.post({"rating": "like"})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
assert harness.feedbacks() == []
def test_invalid_rating_is_rejected_without_persistence(harness: _Harness) -> None:
response = harness.post({"rating": "neutral"})
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
assert response.get_json()["code"] == "unprocessable_entity"
assert harness.feedbacks() == []
def test_revoking_user_feedback_preserves_admin_feedback(harness: _Harness) -> None:
with harness.factory.begin() as session:
session.add(
MessageFeedback(
app_id=harness.target.id,
conversation_id=harness.message.conversation_id,
message_id=harness.message.id,
rating=FeedbackRating.LIKE,
from_source=FeedbackFromSource.ADMIN,
from_account_id=str(uuid4()),
)
)
assert harness.post({"rating": "dislike"}).status_code == HTTPStatus.OK
assert harness.post({"rating": None}).status_code == HTTPStatus.OK
[remaining] = harness.feedbacks()
assert remaining.from_source == FeedbackFromSource.ADMIN
@@ -0,0 +1,346 @@
"""Web message history through real passport admission and detached SQLite reads."""
import json
from collections.abc import Callable, Iterator
from datetime import datetime, timedelta
from decimal import Decimal
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread
from typing import override
from uuid import uuid4
import pytest
from sqlalchemy import delete, event, update
from sqlalchemy.orm import Session
from werkzeug.test import TestResponse
from core.helper import http_client_pooling
from graphon.file import FileTransferMethod, FileType
from models.enums import (
ConversationFromSource,
CreatorUserRole,
FeedbackFromSource,
FeedbackRating,
MessageFileBelongsTo,
)
from models.model import App, AppMode, Conversation, EndUser, Message, MessageAgentThought, MessageFeedback, MessageFile
from models.workflow import Workflow
from tests.e2e_tests.contracts.controllers.web.test_message_feedback import _Harness
from tests.e2e_tests.contracts.controllers.web.test_message_feedback import harness as admission_harness
from tests.helpers.unit.model_factories import make_message
harness = admission_harness
@pytest.fixture
def remote_files(
harness: _Harness, config_overrides: Callable[..., None], monkeypatch: pytest.MonkeyPatch
) -> Iterator[tuple[str, list[tuple[str, str, bool]]]]:
config_overrides(SSRF_PROXY_HTTP_URL="", SSRF_PROXY_HTTPS_URL="", SSRF_PROXY_ALL_URL="")
requests: list[tuple[str, str, bool]] = []
class Handler(BaseHTTPRequestHandler):
@override
def log_message(self, format: str, *args: object) -> None:
pass
def do_HEAD(self) -> None:
requests.append((self.command, self.path, any(session.in_transaction() for session in harness.sessions)))
self.send_response(HTTPStatus.OK)
self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", "42")
self.send_header("Content-Disposition", "attachment; filename*=UTF-8''downloaded%20image.png")
self.end_headers()
http_pool = http_client_pooling.HttpClientPoolFactory()
monkeypatch.setattr(http_client_pooling, "_factory", http_pool)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)
thread.start()
try:
yield f"http://127.0.0.1:{server.server_port}", requests
finally:
server.shutdown()
server.server_close()
thread.join()
http_pool.close_all()
def _get(harness: _Harness, **query: object) -> TestResponse:
return harness.app.test_client().get(
"/messages",
query_string={"conversation_id": harness.message.conversation_id, **query},
headers=harness.headers,
)
def test_message_list_preserves_wire_shape_and_loaded_relationships(
harness: _Harness, remote_files: tuple[str, list[tuple[str, str, bool]]]
) -> None:
remote_url, requests = remote_files
created_at = datetime(2024, 1, 1, 12)
thought = MessageAgentThought(
message_id=harness.message.id,
message_chain_id=str(uuid4()),
position=1,
created_by_role=CreatorUserRole.END_USER,
created_by=harness.end_user.id,
thought="thinking",
tool="search",
tool_labels_str='{"search": "Search"}',
message_files='["file-a"]',
)
thought.created_at = created_at
attachment = MessageFile(
message_id=harness.message.id,
type=FileType.IMAGE,
transfer_method=FileTransferMethod.REMOTE_URL,
created_by_role=CreatorUserRole.END_USER,
created_by=harness.end_user.id,
belongs_to=MessageFileBelongsTo.USER,
url=f"{remote_url}/user-image.png",
)
assistant_attachment = MessageFile(
message_id=harness.message.id,
type=FileType.IMAGE,
transfer_method=FileTransferMethod.REMOTE_URL,
created_by_role=CreatorUserRole.END_USER,
created_by=harness.end_user.id,
belongs_to=MessageFileBelongsTo.ASSISTANT,
url=f"{remote_url}/assistant-image.png",
)
resource_id = str(uuid4())
metadata = {
"custom": "metadata",
"retriever_resources": [{"id": resource_id, "message_id": harness.message.id, "position": 1}],
}
with harness.factory.begin() as session:
session.execute(
update(Message)
.where(Message.id == harness.message.id)
.values(
{
Message._inputs: {"text": "hello", "nested": {"value": [1, None]}},
Message.message_metadata: json.dumps(metadata),
Message.created_at: created_at,
Message.message_tokens: 3,
Message.answer_tokens: 5,
Message.total_price: Decimal("0.0012"),
Message.provider_response_latency: 0.25,
}
)
)
session.add_all(
[
thought,
attachment,
assistant_attachment,
MessageFeedback(
app_id=harness.target.id,
conversation_id=harness.message.conversation_id,
message_id=harness.message.id,
rating=FeedbackRating.LIKE,
from_source=FeedbackFromSource.USER,
from_end_user_id=harness.end_user.id,
),
]
)
commits: list[Session] = []
def record_commit(session: Session) -> None:
commits.append(session)
event.listen(Session, "before_commit", record_commit)
try:
response = _get(harness)
finally:
event.remove(Session, "before_commit", record_commit)
assert response.status_code == HTTPStatus.OK
assert not commits
assert sorted(requests) == [("HEAD", "/assistant-image.png", False), ("HEAD", "/user-image.png", False)]
assert response.headers["Content-Type"] == "application/json"
body = response.get_json()
assert body["limit"] == 20
assert body["has_more"] is False
[item] = body["data"]
assert set(item) == {
"id",
"conversation_id",
"parent_message_id",
"inputs",
"query",
"answer",
"feedback",
"retriever_resources",
"created_at",
"agent_thoughts",
"message_files",
"message_tokens",
"answer_tokens",
"provider_response_latency",
"total_price",
"currency",
"status",
"error",
"extra_contents",
"total_tokens",
"metadata",
}
assert item["id"] == harness.message.id
assert item["conversation_id"] == harness.message.conversation_id
assert item["parent_message_id"] is None
assert item["inputs"] == {"text": "hello", "nested": {"value": [1, None]}}
assert item["query"] == "question"
assert item["answer"] == "answer"
assert item["feedback"] == {"rating": "like"}
assert item["metadata"] == metadata
assert item["retriever_resources"][0]["id"] == resource_id
assert item["created_at"] == int(created_at.timestamp())
assert item["message_tokens"] == 3
assert item["answer_tokens"] == 5
assert item["total_tokens"] == 8
assert Decimal(item["total_price"]) == Decimal("0.0012")
assert item["provider_response_latency"] == 0.25
assert item["currency"] == "USD"
assert item["status"] == "normal"
assert item["error"] is None
assert item["extra_contents"] == []
[actual_thought] = item["agent_thoughts"]
assert actual_thought["id"] == thought.id
assert actual_thought["chain_id"] == thought.message_chain_id
assert actual_thought["tool_labels"] == {"search": "Search"}
assert actual_thought["files"] == ["file-a"]
assert actual_thought["created_at"] == int(created_at.timestamp())
assert len(item["message_files"]) == 2
actual_files = {file["id"]: file for file in item["message_files"]}
for expected in (attachment, assistant_attachment):
actual_file = actual_files[expected.id]
assert expected.belongs_to is not None
assert actual_file["url"] == expected.url
assert actual_file["transfer_method"] == "remote_url"
assert actual_file["type"] == "image"
assert actual_file["belongs_to"] == expected.belongs_to.value
assert actual_file["filename"] == "downloaded image.png"
assert actual_file["mime_type"] == "image/png"
assert actual_file["size"] == 42
harness.assert_closed()
def test_pagination_returns_latest_slice_in_ascending_order(harness: _Harness) -> None:
created_at = datetime(2024, 1, 1)
messages = [
make_message(
message_id=str(uuid4()),
app_id=harness.target.id,
conversation_id=harness.message.conversation_id,
inputs={},
query=f"question-{index}",
message={},
answer=f"answer-{index}",
message_unit_price=Decimal(0),
answer_unit_price=Decimal(0),
currency="USD",
from_source=ConversationFromSource.API,
from_end_user_id=harness.end_user.id,
created_at=created_at + timedelta(seconds=index),
)
for index in (1, 2)
]
with harness.factory.begin() as session:
session.execute(update(Message).where(Message.id == harness.message.id).values(created_at=created_at))
session.add_all(messages)
response = _get(harness, limit=2)
assert response.status_code == HTTPStatus.OK
body = response.get_json()
assert body["limit"] == 2
assert body["has_more"] is True
assert [item["id"] for item in body["data"]] == [message.id for message in messages]
previous = _get(harness, first_id=messages[0].id, limit=2).get_json()
assert previous["has_more"] is False
assert [item["id"] for item in previous["data"]] == [harness.message.id]
assert _get(harness, first_id=harness.message.id, limit=2).get_json() == {"limit": 2, "has_more": False, "data": []}
harness.assert_closed()
def test_empty_conversation_keeps_pagination_shape(harness: _Harness) -> None:
with harness.factory.begin() as session:
session.execute(delete(Message).where(Message.id == harness.message.id))
assert _get(harness, limit=100).get_json() == {"limit": 100, "has_more": False, "data": []}
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])
def test_conversation_ownership_is_enforced(harness: _Harness, field: str) -> None:
value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())
with harness.factory.begin() as session:
session.execute(
update(Conversation).where(Conversation.id == harness.message.conversation_id).values({field: value})
)
response = _get(harness)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
assert response.get_json()["message"] == "Conversation Not Exists."
harness.assert_closed()
@pytest.mark.parametrize("query", [{"conversation_id": str(uuid4())}, {"first_id": str(uuid4())}])
def test_missing_conversation_or_cursor_has_precise_error(harness: _Harness, query: dict[str, str]) -> None:
response = _get(harness, **query)
assert response.status_code == HTTPStatus.NOT_FOUND
expected = "Conversation Not Exists." if "conversation_id" in query else "First Message Not Exists."
assert response.get_json()["message"] == expected
harness.assert_closed()
@pytest.mark.parametrize("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
def test_non_chat_app_is_rejected(harness: _Harness, mode: AppMode) -> None:
with harness.factory.begin() as session:
session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))
if mode == AppMode.WORKFLOW:
workflow = Workflow.new(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
type="workflow",
version="published",
graph="{}",
features="{}",
created_by=str(uuid4()),
environment_variables=[],
conversation_variables=[],
rag_pipeline_variables=[],
)
session.add(workflow)
session.flush()
session.execute(update(App).where(App.id == harness.target.id).values(workflow_id=workflow.id))
response = _get(harness)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "not_chat_app"
harness.assert_closed()
@pytest.mark.parametrize("query", [{"limit": 0}, {"limit": 101}, {"conversation_id": "bad"}, {"first_id": "bad"}])
def test_invalid_query_is_rejected(harness: _Harness, query: dict[str, object]) -> None:
response = _get(harness, **query)
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
assert response.get_json()["code"] == "unprocessable_entity"
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "tenant_id"])
def test_corrupt_end_user_scope_is_rejected(harness: _Harness, field: str) -> None:
with harness.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))
response = _get(harness)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
harness.assert_closed()
def test_missing_passport_is_rejected(harness: _Harness) -> None:
response = harness.app.test_client().get(
"/messages", query_string={"conversation_id": harness.message.conversation_id}
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
assert response.get_json()["code"] == "unauthorized"
@@ -0,0 +1,415 @@
"""Web more-like-this through real JWT, services, generator, and SQLite.
Persisted invalid provider metadata triggers model preparation failure without a
model server. Successful generation belongs to runtime integration coverage.
"""
import json
from collections.abc import Callable, Iterator
from dataclasses import dataclass
from decimal import Decimal
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Flask
from redis import Redis
from sqlalchemy import Connection, Engine, delete, event, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
import controllers.web.message as module
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from libs.external_api import ExternalApi
from libs.passport import PassportService
from models.agent import (
Agent,
AgentConfigRevision,
AgentConfigRevisionOperation,
AgentConfigSnapshot,
AgentScope,
AgentSource,
)
from models.agent_config_entities import AgentSoulConfig
from models.enums import ConversationFromSource, CustomizeTokenStrategy
from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, Site
from models.provider import Provider
from models.workflow import Workflow
from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message
@dataclass(frozen=True)
class _Harness:
app: Flask
target: App
end_user: EndUser
message: Message
current_config: AppModelConfig
historical_config: AppModelConfig
factory: sessionmaker[Session]
sessions: list[Session]
query_sessions: list[Session]
passport: str
@property
def headers(self) -> dict[str, str]:
return {HEADER_NAME_APP_CODE: "more-like-this-app", HEADER_NAME_PASSPORT: self.passport}
def url(self, *, query: str = "response_mode=blocking") -> str:
return f"/messages/{self.message.id}/more-like-this?{query}"
def get(self, *, query: str = "response_mode=blocking") -> TestResponse:
return self.app.test_client().get(self.url(query=query), headers=self.headers)
def assert_closed(self, *, caller: Session | None = None) -> None:
assert self.sessions
assert all(
not session.in_transaction() and not session.identity_map
for session in self.sessions
if session is not caller
)
@pytest.fixture
def harness(
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session_factory: sessionmaker[Session],
) -> Iterator[_Harness]:
config_overrides(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="more-like-this-http-test-key-at-least-32-bytes"
)
target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()), mode=AppMode.COMPLETION)
end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)
current_config = AppModelConfig(app_id=target.id, more_like_this='{"enabled":true}', pre_prompt="New prompt")
historical_config = AppModelConfig(
app_id=target.id,
more_like_this='{"enabled":false}',
pre_prompt="Historical prompt",
model=json.dumps(
{
"provider": "openai",
"name": "historical-model",
"mode": "completion",
"completion_params": {"temperature": 0.2},
}
),
)
site = Site(
app_id=target.id,
title="Completion app",
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.UUID,
code="more-like-this-app",
)
conversation = make_conversation(
conversation_id=str(uuid4()),
app_id=target.id,
mode=AppMode.COMPLETION,
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
inputs={"topic": "Earlier topic"},
)
message = make_message(
message_id=str(uuid4()),
app_id=target.id,
conversation_id=conversation.id,
inputs={"topic": "Earlier topic"},
message={},
query="Original query",
answer="Original answer",
message_unit_price=Decimal(0),
answer_unit_price=Decimal(0),
currency="USD",
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
with sqlite_session_factory.begin() as session:
# A real stored provider ID fails validation before plugin discovery.
provider = Provider(tenant_id=target.tenant_id, provider_name="invalid/provider", is_valid=True)
session.add_all([target, end_user, current_config, historical_config, site, conversation, message, provider])
session.flush()
target.app_model_config_id = current_config.id
conversation.app_model_config_id = historical_config.id
admission_factory = sqlite_session_factory
query_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
sessions: list[Session] = []
query_sessions: list[Session] = []
def track(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
sessions.append(session)
def track_query(session: Session, transaction: SessionTransaction, connection: Connection) -> None:
query_sessions.append(session)
track(session, transaction, connection)
event.listen(admission_factory, "after_begin", track)
event.listen(query_factory, "after_begin", track_query)
passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
event.listen(db.session.session_factory, "after_begin", track)
redis_client = Redis()
redis = RedisClientWrapper()
redis.initialize(redis_client)
app.extensions["application_services"] = build_application_services(
database_client=query_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis,
)
api = ExternalApi(app)
api.add_resource(module.MessageMoreLikeThisApi, "/messages/<uuid:message_id>/more-like-this")
yield _Harness(
app,
target,
end_user,
message,
current_config,
historical_config,
sqlite_session_factory,
sessions,
query_sessions,
passport,
)
event.remove(admission_factory, "after_begin", track)
event.remove(query_factory, "after_begin", track_query)
event.remove(db.session.session_factory, "after_begin", track)
redis_client.close()
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("response_mode", ["blocking", "streaming"])
def test_stored_provider_error_propagates_through_the_real_generator(harness: _Harness, response_mode: str) -> None:
response = harness.get(query=f"response_mode={response_mode}")
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json() == {
"code": "invalid_param",
"message": "Invalid plugin id invalid/provider",
"status": HTTPStatus.BAD_REQUEST,
}
assert response.headers["Content-Type"] == "application/json"
with harness.factory() as session:
persisted = session.get(AppModelConfig, harness.historical_config.id)
assert persisted is not None
assert persisted.model_dict["completion_params"]["temperature"] == 0.2
harness.assert_closed()
def test_real_preparation_failure_preserves_caller_session_and_pending_edits(harness: _Harness) -> None:
with harness.app.app_context():
caller = db.session()
app_model = caller.get(App, harness.target.id)
assert app_model is not None
app_model.name = "Uncommitted caller change"
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["message"] == "Invalid plugin id invalid/provider"
assert db.session() is caller
assert caller.in_transaction()
assert app_model in caller.dirty
harness.assert_closed(caller=caller)
with harness.factory() as session:
persisted = session.get(App, harness.target.id)
assert persisted is not None
assert persisted.name == harness.target.name
@pytest.mark.parametrize("query", ["", "response_mode=invalid"])
def test_invalid_response_mode_is_rejected_before_source_queries(harness: _Harness, query: str) -> None:
response = harness.get(query=query)
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
assert response.get_json()["code"] == "unprocessable_entity"
assert harness.query_sessions == []
harness.assert_closed()
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT, AppMode.WORKFLOW])
def test_non_completion_app_is_rejected_before_source_queries(harness: _Harness, mode: AppMode) -> None:
with harness.factory.begin() as session:
session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))
if mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:
workflow = Workflow.new(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
type="chat" if mode == AppMode.ADVANCED_CHAT else "workflow",
version="published",
graph="{}",
features="{}",
created_by=str(uuid4()),
environment_variables=[],
conversation_variables=[],
rag_pipeline_variables=[],
)
session.add(workflow)
session.flush()
session.execute(update(App).where(App.id == harness.target.id).values(workflow_id=workflow.id))
elif mode == AppMode.AGENT:
agent = Agent(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
name="Published agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
)
session.add(agent)
session.flush()
snapshot = AgentConfigSnapshot(
tenant_id=agent.tenant_id,
agent_id=agent.id,
version=1,
config_snapshot=AgentSoulConfig(),
)
session.add(snapshot)
session.flush()
agent.active_config_snapshot_id = snapshot.id
session.add(
AgentConfigRevision(
tenant_id=agent.tenant_id,
agent_id=agent.id,
current_snapshot_id=snapshot.id,
revision=1,
operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
)
)
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "not_completion_app"
assert harness.query_sessions == []
@pytest.mark.parametrize("feature", [None, "", "{}", '{"enabled":false}'])
def test_disabled_current_feature_wins_over_corrupt_historical_configuration(
harness: _Harness, feature: str | None
) -> None:
with harness.factory.begin() as session:
session.execute(
update(AppModelConfig).where(AppModelConfig.id == harness.current_config.id).values(more_like_this=feature)
)
session.execute(
update(AppModelConfig).where(AppModelConfig.id == harness.historical_config.id).values(model="broken-json")
)
response = harness.get()
assert response.status_code == HTTPStatus.FORBIDDEN
assert response.get_json()["code"] == "app_more_like_this_disabled"
harness.assert_closed()
@pytest.mark.parametrize(
("current", "field", "value"),
[
(True, "more_like_this", '{"secret":"private-config-value"'),
(True, "more_like_this", '["private-config-value"]'),
(False, "model", '{"secret":"private-config-value"'),
(False, "model", '["private-config-value"]'),
(False, "model", '{"completion_params":["private-config-value"]}'),
(False, "model", None),
],
ids=["feature-json", "feature-shape", "model-json", "model-shape", "parameter-shape", "missing-model"],
)
def test_corrupt_persisted_configuration_returns_app_unavailable(
harness: _Harness, current: bool, field: str, value: str | None
) -> None:
"""None represents a missing model payload in an existing configuration row."""
config_id = harness.current_config.id if current else harness.historical_config.id
with harness.factory.begin() as session:
session.execute(update(AppModelConfig).where(AppModelConfig.id == config_id).values({field: value}))
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json() == {
"code": "app_unavailable",
"message": "App unavailable, please check your app configurations.",
"status": HTTPStatus.BAD_REQUEST,
}
assert b"private-config-value" not in response.data
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])
def test_message_ownership_is_enforced_through_http(harness: _Harness, field: str) -> None:
value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())
with harness.factory.begin() as session:
session.execute(update(Message).where(Message.id == harness.message.id).values({field: value}))
response = harness.get()
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "tenant_id"])
def test_foreign_end_user_is_rejected_at_jwt_admission(harness: _Harness, field: str) -> None:
with harness.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))
response = harness.get()
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "not_found"
assert harness.query_sessions == []
harness.assert_closed()
@pytest.mark.parametrize("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])
def test_foreign_conversation_cannot_supply_historical_config(harness: _Harness, field: str) -> None:
value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())
with harness.factory.begin() as session:
session.execute(
update(Conversation).where(Conversation.id == harness.message.conversation_id).values({field: value})
)
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "app_unavailable"
harness.assert_closed()
@pytest.mark.parametrize("resource", ["conversation", "historical_config", "foreign_config"])
def test_missing_or_foreign_history_is_app_unavailable(harness: _Harness, resource: str) -> None:
with harness.factory.begin() as session:
if resource == "conversation":
session.execute(delete(Conversation).where(Conversation.id == harness.message.conversation_id))
elif resource == "historical_config":
session.execute(delete(AppModelConfig).where(AppModelConfig.id == harness.historical_config.id))
else:
session.execute(
update(AppModelConfig)
.where(AppModelConfig.id == harness.historical_config.id)
.values(app_id=str(uuid4()))
)
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "app_unavailable"
harness.assert_closed()
def test_incomplete_historical_model_reaches_generic_error_without_exposing_configuration(
harness: _Harness, caplog: pytest.LogCaptureFixture
) -> None:
# The persisted model is an object, but it lacks the provider field required
# by the real completion configuration converter.
with harness.factory.begin() as session:
session.execute(
update(AppModelConfig)
.where(AppModelConfig.id == harness.historical_config.id)
.values(model=json.dumps({"name": "private-model-name", "completion_params": {}}))
)
response = harness.get()
assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
assert response.get_json()["code"] == "internal_server_error"
assert b"private-model-name" not in response.data
failures = [
record.exc_info[1]
for record in caplog.records
if record.name == "controllers.web.message" and record.exc_info is not None
]
assert len(failures) == 1
assert isinstance(failures[0], KeyError)
assert failures[0].args == ("provider",)
harness.assert_closed()
@@ -0,0 +1,437 @@
"""Web suggested questions through HTTP, real admission, and SQLite ownership queries."""
import json
from collections.abc import Callable, Iterator
from dataclasses import dataclass
from decimal import Decimal
from http import HTTPStatus
from typing import Literal
from uuid import uuid4
import pytest
from flask import Flask
from sqlalchemy import Connection, Engine, delete, event, select, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
import controllers.web.message as message_controller
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
from enums import DeploymentEdition
from extensions.ext_database import db
from graphon.model_runtime.entities.model_entities import ModelType
from libs.external_api import ExternalApi
from libs.passport import PassportService
from models.agent import (
Agent,
AgentConfigRevision,
AgentConfigRevisionOperation,
AgentConfigSnapshot,
AgentScope,
AgentSource,
)
from models.agent_config_entities import AgentSoulConfig
from models.enums import ConversationFromSource, CustomizeTokenStrategy
from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, Site
from models.provider import Provider, TenantDefaultModel
from models.workflow import Workflow
from repositories.message_repository import MessageRepository
from services.message_suggested_questions_generator import SuggestedQuestionsGenerator
from services.message_suggested_questions_queries import SuggestedQuestionsQuery
from services.message_suggested_questions_service import (
MessageSuggestedQuestions,
MessageSuggestedQuestionsService,
)
from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message
from tests.helpers.unit.services.tracing_ports import untraced_scopes
@dataclass
class _Services:
message_suggested_questions: MessageSuggestedQuestions
@dataclass(frozen=True)
class _Harness:
app: Flask
target: App
end_user: EndUser
message: Message
factory: sessionmaker[Session]
admission_factory: sessionmaker[Session]
passport: str
sessions: list[Session]
def get(self) -> TestResponse:
return self.app.test_client().get(
f"/messages/{self.message.id}/suggested-questions",
headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.passport},
)
def assert_closed(self, *, caller: Session | None = None) -> None:
assert self.sessions
assert all(
not session.in_transaction() and not session.identity_map
for session in self.sessions
if session is not caller
)
@pytest.fixture
def harness(
_empty_model_provider_daemon: None,
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session_factory: sessionmaker[Session],
) -> Iterator[_Harness]:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="suggested-questions-test-secret-key")
target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()))
end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)
config = AppModelConfig(
app_id=target.id,
suggested_questions_after_answer=json.dumps({"enabled": True, "prompt": "Ask concise questions"}),
)
site = Site(
app_id=target.id,
title="Public app",
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.UUID,
code="public-app",
)
conversation = make_conversation(
conversation_id=str(uuid4()),
app_id=target.id,
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
inputs={},
)
message = make_message(
message_id=str(uuid4()),
app_id=target.id,
conversation_id=conversation.id,
inputs={},
message={},
query="How does it work?",
answer="Like this.",
message_unit_price=Decimal(0),
answer_unit_price=Decimal(0),
currency="USD",
from_source=ConversationFromSource.API,
from_end_user_id=end_user.id,
)
with sqlite_session_factory.begin() as session:
# The real provider lookup rejects this stored ID before plugin discovery.
# Generation remains best-effort and must return an empty list.
provider = Provider(tenant_id=target.tenant_id, provider_name="invalid/provider", is_valid=True)
session.add(
TenantDefaultModel(
tenant_id=target.tenant_id,
provider_name="invalid/provider",
model_name="invalid-model",
model_type=ModelType.LLM,
)
)
session.add_all([target, end_user, config, site, conversation, message, provider])
session.flush()
target.app_model_config_id = config.id
conversation.app_model_config_id = config.id
read_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
admission_factory = sqlite_session_factory
sessions: list[Session] = []
def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
sessions.append(session)
admission_sessions: list[Session] = []
def track_admission(session: Session, transaction: SessionTransaction, connection: Connection) -> None:
admission_sessions.append(session)
track_session(session, transaction, connection)
event.listen(admission_factory, "after_begin", track_admission)
event.listen(read_factory, "after_begin", track_session)
passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
event.listen(db.session.session_factory, "after_begin", track_session)
queries = SuggestedQuestionsQuery(
session_factory=read_factory, repository=MessageRepository(session_factory=read_factory)
)
services = _Services(
MessageSuggestedQuestionsService(
queries=queries, generator=SuggestedQuestionsGenerator(trace_scopes=untraced_scopes())
)
)
app.extensions["application_services"] = services
api = ExternalApi(app)
api.add_resource(message_controller.MessageSuggestedQuestionApi, "/messages/<uuid:message_id>/suggested-questions")
yield _Harness(
app,
target,
end_user,
message,
sqlite_session_factory,
admission_factory,
passport,
sessions,
)
event.remove(admission_factory, "after_begin", track_admission)
event.remove(read_factory, "after_begin", track_session)
event.remove(db.session.session_factory, "after_begin", track_session)
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_chat_modes_return_empty_questions_when_stored_provider_config_is_invalid(
harness: _Harness,
mode: AppMode,
caplog: pytest.LogCaptureFixture,
) -> None:
with harness.factory.begin() as session:
session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))
if mode == AppMode.ADVANCED_CHAT:
workflow = Workflow.new(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
type="chat",
version="published",
graph="{}",
features='{"suggested_questions_after_answer":{"enabled":true}}',
created_by=str(uuid4()),
environment_variables=[],
conversation_variables=[],
rag_pipeline_variables=[],
)
session.add(workflow)
session.flush()
app_model = session.get(App, harness.target.id)
assert app_model is not None
app_model.workflow_id = workflow.id
elif mode == AppMode.AGENT:
agent = Agent(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
name="Agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
)
session.add(agent)
session.flush()
snapshot = AgentConfigSnapshot(
tenant_id=agent.tenant_id,
agent_id=agent.id,
version=1,
config_snapshot=AgentSoulConfig.model_validate(
{"app_features": {"suggested_questions_after_answer": {"enabled": True}}}
),
)
session.add(snapshot)
session.flush()
agent.active_config_snapshot_id = snapshot.id
session.add(
AgentConfigRevision(
tenant_id=agent.tenant_id,
agent_id=agent.id,
current_snapshot_id=snapshot.id,
revision=1,
operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
)
)
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.headers["Content-Type"] == "application/json"
assert response.get_json() == {"data": []}
failures = [
record.exc_info[1]
for record in caplog.records
if record.name == "services.message_suggested_questions_generator" and record.exc_info is not None
]
assert len(failures) == 1
assert isinstance(failures[0], ValueError)
assert str(failures[0]) == "Invalid provider: invalid/provider"
harness.assert_closed()
@pytest.mark.parametrize("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
def test_non_chat_app_is_rejected_before_shared_capability(harness: _Harness, mode: AppMode) -> None:
with harness.factory.begin() as session:
session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))
if mode == AppMode.WORKFLOW:
workflow = Workflow.new(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
type="workflow",
version="published",
graph="{}",
features="{}",
created_by=str(uuid4()),
environment_variables=[],
conversation_variables=[],
rag_pipeline_variables=[],
)
session.add(workflow)
session.flush()
session.execute(update(App).where(App.id == harness.target.id).values(workflow_id=workflow.id))
response = harness.get()
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.get_json()["code"] == "not_chat_app"
harness.assert_closed()
@pytest.mark.parametrize(
("resource", "status", "code", "message"),
[
("agent_version", 404, "app_not_found", "App not found"),
("message", 404, "not_found", "Message not found"),
("conversation", 404, "not_found", "Conversation not found"),
("disabled", 403, "app_suggested_questions_after_answer_disabled", "disabled"),
],
)
def test_resource_errors_keep_specific_http_codes(
harness: _Harness,
resource: Literal["agent_version", "message", "conversation", "disabled"],
status: int,
code: str,
message: str,
) -> None:
with harness.factory.begin() as session:
if resource == "message":
session.execute(delete(Message).where(Message.id == harness.message.id))
elif resource == "conversation":
session.execute(delete(Conversation).where(Conversation.id == harness.message.conversation_id))
elif resource == "disabled":
session.execute(
update(AppModelConfig)
.where(AppModelConfig.app_id == harness.target.id)
.values(suggested_questions_after_answer='{"enabled":false}')
)
else:
session.execute(update(App).where(App.id == harness.target.id).values(mode=AppMode.AGENT))
session.add(
Agent(
tenant_id=harness.target.tenant_id,
app_id=harness.target.id,
name="Broken agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
active_config_snapshot_id=str(uuid4()),
)
)
response = harness.get()
assert response.status_code == status
assert response.headers["Content-Type"] == "application/json"
body = response.get_json()
assert body["code"] == code
assert body["status"] == status
assert message in body["message"]
harness.assert_closed()
@pytest.mark.parametrize(
("resource", "status", "code", "message"),
[
("end_user", 404, "not_found", "End user not found"),
(
"app_mode",
400,
"app_unavailable",
"App unavailable, please check your app configurations.",
),
],
)
def test_resource_changes_after_admission_keep_specific_errors(
harness: _Harness,
resource: Literal["end_user", "app_mode"],
status: int,
code: str,
message: str,
) -> None:
# Change persisted state after the real admission transaction ends; the
# application service and repository must reject the now-stale reference.
def change_resource(_session: Session, _transaction: SessionTransaction) -> None:
with harness.factory.begin() as session:
if resource == "end_user":
session.execute(delete(EndUser).where(EndUser.id == harness.end_user.id))
else:
session.execute(update(App).where(App.id == harness.target.id).values(mode=AppMode.WORKFLOW))
event.listen(harness.admission_factory, "after_transaction_end", change_resource, once=True)
try:
response = harness.get()
finally:
event.remove(harness.admission_factory, "after_transaction_end", change_resource)
assert response.status_code == status
assert response.get_json()["code"] == code
assert response.get_json()["message"] == message
harness.assert_closed()
def test_model_resolution_failure_preserves_caller_session_and_pending_edits(harness: _Harness) -> None:
with harness.app.app_context():
caller = db.session()
app_model = caller.get(App, harness.target.id)
assert app_model is not None
app_model.name = "Uncommitted caller change"
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {"data": []}
assert db.session() is caller
assert caller.in_transaction()
assert app_model in caller.dirty
harness.assert_closed(caller=caller)
with harness.factory() as session:
persisted = session.get(App, harness.target.id)
assert persisted is not None
assert persisted.name == harness.target.name
@pytest.mark.parametrize("field_name", ["tenant_id", "app_id"])
def test_admission_rejects_end_user_from_another_owner(
harness: _Harness,
field_name: Literal["tenant_id", "app_id"],
) -> None:
with harness.factory.begin() as session:
session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field_name: str(uuid4())}))
response = harness.get()
assert response.status_code == HTTPStatus.NOT_FOUND
# Passport admission rejects the owner mismatch before the message service.
assert response.get_json()["code"] == "not_found"
harness.assert_closed()
@pytest.mark.parametrize("model", [Message, Conversation])
@pytest.mark.parametrize("field_name", ["app_id", "from_end_user_id", "from_source"])
def test_real_runtime_rejects_message_or_conversation_outside_actor_scope(
harness: _Harness,
model: type[Message] | type[Conversation],
field_name: Literal["app_id", "from_end_user_id", "from_source"],
) -> None:
record_id = harness.message.id if model is Message else harness.message.conversation_id
value = ConversationFromSource.CONSOLE if field_name == "from_source" else str(uuid4())
with harness.factory.begin() as session:
session.execute(update(model).where(model.id == record_id).values({field_name: value}))
response = harness.get()
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["message"] == ("Message not found" if model is Message else "Conversation not found")
harness.assert_closed()
def test_missing_saved_default_returns_empty_questions_without_creating_a_default(harness: _Harness) -> None:
with harness.factory.begin() as session:
session.execute(delete(TenantDefaultModel).where(TenantDefaultModel.tenant_id == harness.target.tenant_id))
response = harness.get()
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {"data": []}
with harness.factory() as session:
assert (
session.scalar(
select(TenantDefaultModel.id).where(TenantDefaultModel.tenant_id == harness.target.tenant_id)
)
is None
)
harness.assert_closed()