Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
"""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()