Add chat data models + migration (conversations, messages, reports)
docs/planning/social.md US-4, task 6: conversations, conversation_participants, messages (DM + world/room chat), and message_reports, following app/models/social.py's conventions (native enums, explicit index/constraint names, CASCADE FKs where appropriate). Delete behavior, chosen per-relationship: - conversations.user_a_id/user_b_id -> CASCADE: a DM is meaningless with one of its two participants gone, so it cascades away entirely (participants + messages with it). - messages.sender_id -> SET NULL: world/room chat history and reported messages must survive the sender's account being deleted, matching the existing actor-reference convention (WorldChunk.updated_by_id, WorldChunkRevision.actor_id). - messages.world_id/room_id -> CASCADE: chat scoped to a world/room has no meaning once that world/room is gone (mirrors WorldChunk). - message_reports.message_id -> SET NULL (not CASCADE): a moderation report must outlive the message it's about, mirroring WorldChunkRevision's audit-trail-survives-deletion precedent. - message_reports.reporter_id/moderator_id -> SET NULL: audit-actor references, same reasoning. Models + migration only, no endpoints, no text filtering (sibling tasks). Verified: migration upgrade/downgrade/upgrade round-trip against a real Postgres with schema inspected via \d against spec; new model tests cover DM creation, pair uniqueness + ordering check constraint, world/room messages, report defaults, and cascade behavior for both conversation-deletion and sender-deletion; full backend suite (160 tests) passes with no regressions. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Y2FESCaMXeJpC9gSctiEeD
This commit is contained in:
@@ -45,6 +45,11 @@ TEST_TABLES = (
|
||||
# Social graph (app/models/social.py) -- all three FK users with
|
||||
# ON DELETE CASCADE, but list explicitly for clarity/consistency.
|
||||
"friendships", "follows", "blocks",
|
||||
# Chat (app/models/chat.py). message_reports.message_id is ON DELETE SET
|
||||
# NULL (not CASCADE, deliberately -- see chat.py), so it wouldn't be
|
||||
# reached by cascading a truncate of messages/conversations; list it
|
||||
# explicitly along with the rest for clarity/consistency.
|
||||
"message_reports", "messages", "conversation_participants", "conversations",
|
||||
"sessions", "refresh_tokens", "users",
|
||||
)
|
||||
|
||||
|
||||
@@ -0,0 +1,344 @@
|
||||
"""Model-level tests for chat: conversations, messages, message reports.
|
||||
|
||||
app/models/chat.py / alembic/versions/0008_add_chat_tables.py
|
||||
(docs/planning/social.md US-4). This is the models+migration task only --
|
||||
there are no API endpoints yet (sibling tasks own filtering, rate limiting,
|
||||
and the routers), so these tests exercise the ORM models and the real
|
||||
Postgres constraints directly rather than going through HTTP.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from sqlalchemy import delete, select
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
||||
from sqlalchemy.pool import NullPool
|
||||
|
||||
from app.config import settings
|
||||
from app.main import app
|
||||
from app.models.chat import (
|
||||
Conversation,
|
||||
ConversationParticipant,
|
||||
Message,
|
||||
MessageReport,
|
||||
ReportStatus,
|
||||
)
|
||||
from app.models.user import User
|
||||
from app.models.world import World
|
||||
|
||||
|
||||
def _register(client: TestClient, username: str) -> int:
|
||||
resp = client.post(
|
||||
"/api/auth/register",
|
||||
json={
|
||||
"username": username,
|
||||
"email": f"{username}@example.com",
|
||||
"password": "secret123",
|
||||
"date_of_birth": "1990-01-01",
|
||||
},
|
||||
)
|
||||
assert resp.status_code == 201, resp.text
|
||||
headers = {"Authorization": f"Bearer {resp.json()['access_token']}"}
|
||||
me = client.get("/api/users/me", headers=headers)
|
||||
assert me.status_code == 200, me.text
|
||||
return me.json()["id"]
|
||||
|
||||
|
||||
def _session_factory():
|
||||
engine = create_async_engine(settings.DATABASE_URL, poolclass=NullPool)
|
||||
return engine, async_sessionmaker(engine, expire_on_commit=False)
|
||||
|
||||
|
||||
class TestConversationCreation:
|
||||
async def test_create_conversation_with_participants_and_messages(self):
|
||||
client = TestClient(app)
|
||||
a = _register(client, "chat_conv_a")
|
||||
b = _register(client, "chat_conv_b")
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
lo, hi = sorted((a, b))
|
||||
async with factory() as session:
|
||||
convo = Conversation(user_a_id=lo, user_b_id=hi)
|
||||
session.add(convo)
|
||||
await session.flush()
|
||||
session.add_all(
|
||||
[
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=a),
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=b),
|
||||
]
|
||||
)
|
||||
session.add(
|
||||
Message(sender_id=a, conversation_id=convo.id, body="hi there")
|
||||
)
|
||||
await session.commit()
|
||||
convo_id = convo.id
|
||||
|
||||
async with factory() as session:
|
||||
participants = (
|
||||
await session.execute(
|
||||
select(ConversationParticipant).where(
|
||||
ConversationParticipant.conversation_id == convo_id
|
||||
)
|
||||
)
|
||||
).scalars().all()
|
||||
messages = (
|
||||
await session.execute(
|
||||
select(Message).where(Message.conversation_id == convo_id)
|
||||
)
|
||||
).scalars().all()
|
||||
assert len(participants) == 2
|
||||
assert len(messages) == 1
|
||||
assert messages[0].sender_id == a
|
||||
assert messages[0].filtered is False
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
async def test_duplicate_pair_rejected(self):
|
||||
client = TestClient(app)
|
||||
a = _register(client, "chat_uq_a")
|
||||
b = _register(client, "chat_uq_b")
|
||||
lo, hi = sorted((a, b))
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
session.add(Conversation(user_a_id=lo, user_b_id=hi))
|
||||
await session.commit()
|
||||
|
||||
async with factory() as session:
|
||||
session.add(Conversation(user_a_id=lo, user_b_id=hi))
|
||||
with pytest.raises(IntegrityError):
|
||||
await session.commit()
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
async def test_unordered_pair_rejected_by_check_constraint(self):
|
||||
client = TestClient(app)
|
||||
a = _register(client, "chat_ck_a")
|
||||
b = _register(client, "chat_ck_b")
|
||||
lo, hi = sorted((a, b))
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
# Reversed order violates ck_conversations_ordered_pair.
|
||||
session.add(Conversation(user_a_id=hi, user_b_id=lo))
|
||||
with pytest.raises(IntegrityError):
|
||||
await session.commit()
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
class TestWorldRoomChat:
|
||||
async def test_world_message_has_null_conversation(self):
|
||||
client = TestClient(app)
|
||||
owner = _register(client, "chat_world_owner")
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
world = World(name="Chat Test World", owner_id=owner)
|
||||
session.add(world)
|
||||
await session.flush()
|
||||
msg = Message(sender_id=owner, world_id=world.id, body="hello world")
|
||||
session.add(msg)
|
||||
await session.commit()
|
||||
world_id = world.id
|
||||
|
||||
async with factory() as session:
|
||||
rows = (
|
||||
await session.execute(
|
||||
select(Message).where(Message.world_id == world_id)
|
||||
)
|
||||
).scalars().all()
|
||||
assert len(rows) == 1
|
||||
assert rows[0].conversation_id is None
|
||||
assert rows[0].room_id is None
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
class TestMessageReports:
|
||||
async def test_create_report_defaults_to_open(self):
|
||||
client = TestClient(app)
|
||||
sender = _register(client, "chat_rpt_sender")
|
||||
reporter = _register(client, "chat_rpt_reporter")
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
world = World(name="Report World", owner_id=sender)
|
||||
session.add(world)
|
||||
await session.flush()
|
||||
msg = Message(sender_id=sender, world_id=world.id, body="bad words")
|
||||
session.add(msg)
|
||||
await session.flush()
|
||||
report = MessageReport(
|
||||
message_id=msg.id, reporter_id=reporter, reason="spam"
|
||||
)
|
||||
session.add(report)
|
||||
await session.commit()
|
||||
report_id = report.id
|
||||
|
||||
async with factory() as session:
|
||||
report = await session.get(MessageReport, report_id)
|
||||
assert report.status == ReportStatus.OPEN
|
||||
assert report.moderator_id is None
|
||||
assert report.resolved_at is None
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
|
||||
class TestCascadeDelete:
|
||||
async def test_deleting_conversation_deletes_participants_and_messages(self):
|
||||
client = TestClient(app)
|
||||
a = _register(client, "chat_cd_conv_a")
|
||||
b = _register(client, "chat_cd_conv_b")
|
||||
lo, hi = sorted((a, b))
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
convo = Conversation(user_a_id=lo, user_b_id=hi)
|
||||
session.add(convo)
|
||||
await session.flush()
|
||||
session.add_all(
|
||||
[
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=a),
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=b),
|
||||
]
|
||||
)
|
||||
session.add(Message(sender_id=a, conversation_id=convo.id, body="bye"))
|
||||
await session.commit()
|
||||
convo_id = convo.id
|
||||
|
||||
async with factory() as session:
|
||||
# Core delete against the conversations table directly, so
|
||||
# the real ON DELETE CASCADE does the work (not the ORM).
|
||||
await session.execute(
|
||||
delete(Conversation).where(Conversation.id == convo_id)
|
||||
)
|
||||
await session.commit()
|
||||
|
||||
async with factory() as session:
|
||||
participants = (
|
||||
await session.execute(
|
||||
select(ConversationParticipant).where(
|
||||
ConversationParticipant.conversation_id == convo_id
|
||||
)
|
||||
)
|
||||
).scalars().all()
|
||||
messages = (
|
||||
await session.execute(
|
||||
select(Message).where(Message.conversation_id == convo_id)
|
||||
)
|
||||
).scalars().all()
|
||||
assert participants == []
|
||||
assert messages == []
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
async def test_deleting_user_removes_conversation_but_keeps_report_and_message_id_null(self):
|
||||
"""Deleting a conversation participant cascades away the whole DM
|
||||
(conversation + participants + messages -- there's no third party
|
||||
left to care about the history). Deleting the sender of a
|
||||
world-chat message, by contrast, must NOT delete the message or its
|
||||
report -- sender_id is SET NULL and message_reports.message_id
|
||||
follows the message (also SET NULL, never CASCADE) so the audit
|
||||
trail survives account deletion."""
|
||||
client = TestClient(app)
|
||||
a = _register(client, "chat_cd_user_a")
|
||||
b = _register(client, "chat_cd_user_b")
|
||||
reporter = _register(client, "chat_cd_user_reporter")
|
||||
lo, hi = sorted((a, b))
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
convo = Conversation(user_a_id=lo, user_b_id=hi)
|
||||
session.add(convo)
|
||||
await session.flush()
|
||||
session.add_all(
|
||||
[
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=a),
|
||||
ConversationParticipant(conversation_id=convo.id, user_id=b),
|
||||
]
|
||||
)
|
||||
session.add(Message(sender_id=a, conversation_id=convo.id, body="dm"))
|
||||
|
||||
world = World(name="Sender Delete World", owner_id=b)
|
||||
session.add(world)
|
||||
await session.flush()
|
||||
world_msg = Message(sender_id=a, world_id=world.id, body="world chat")
|
||||
session.add(world_msg)
|
||||
await session.flush()
|
||||
report = MessageReport(
|
||||
message_id=world_msg.id, reporter_id=reporter, reason="rude"
|
||||
)
|
||||
session.add(report)
|
||||
await session.commit()
|
||||
convo_id = convo.id
|
||||
world_msg_id = world_msg.id
|
||||
report_id = report.id
|
||||
|
||||
async with factory() as session:
|
||||
# Delete `a`: participant in the DM (cascades the whole
|
||||
# conversation) and sender of the world message (SET NULL).
|
||||
await session.execute(delete(User).where(User.id == a))
|
||||
await session.commit()
|
||||
|
||||
async with factory() as session:
|
||||
convo_row = await session.get(Conversation, convo_id)
|
||||
dm_messages = (
|
||||
await session.execute(
|
||||
select(Message).where(Message.conversation_id == convo_id)
|
||||
)
|
||||
).scalars().all()
|
||||
world_msg = await session.get(Message, world_msg_id)
|
||||
report = await session.get(MessageReport, report_id)
|
||||
|
||||
assert convo_row is None
|
||||
assert dm_messages == []
|
||||
# World message survives with sender_id nulled out.
|
||||
assert world_msg is not None
|
||||
assert world_msg.sender_id is None
|
||||
assert world_msg.body == "world chat"
|
||||
# Report still points at the surviving message.
|
||||
assert report is not None
|
||||
assert report.message_id == world_msg_id
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
async def test_deleting_message_nulls_report_message_id(self):
|
||||
client = TestClient(app)
|
||||
sender = _register(client, "chat_cd_msg_sender")
|
||||
reporter = _register(client, "chat_cd_msg_reporter")
|
||||
|
||||
engine, factory = _session_factory()
|
||||
try:
|
||||
async with factory() as session:
|
||||
world = World(name="Msg Delete World", owner_id=sender)
|
||||
session.add(world)
|
||||
await session.flush()
|
||||
msg = Message(sender_id=sender, world_id=world.id, body="to be removed")
|
||||
session.add(msg)
|
||||
await session.flush()
|
||||
report = MessageReport(
|
||||
message_id=msg.id, reporter_id=reporter, reason="spam"
|
||||
)
|
||||
session.add(report)
|
||||
await session.commit()
|
||||
msg_id = msg.id
|
||||
report_id = report.id
|
||||
|
||||
async with factory() as session:
|
||||
await session.execute(delete(Message).where(Message.id == msg_id))
|
||||
await session.commit()
|
||||
|
||||
async with factory() as session:
|
||||
report = await session.get(MessageReport, report_id)
|
||||
assert report is not None
|
||||
assert report.message_id is None
|
||||
finally:
|
||||
await engine.dispose()
|
||||
Reference in New Issue
Block a user