chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
60158935f4
commit
6519682885
15831 files changed
+3063428
No files matched your search
+257
@@ -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()
|
||||
+297
@@ -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()
|
||||
+384
@@ -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()
|
||||
+225
@@ -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"
|
||||
+415
@@ -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()
|
||||
+437
@@ -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()
|
||||
Reference in new issue
Block a user