Sending a message used to be BEGIN, a SELECT ... FOR UPDATE of the chat with its members, a lookup of the idempotency key, the insert CTE and COMMIT. Three of those round trips ran under the chat row lock, and each one waited for the replica's event loop, so under load the lock holders sat idle in transaction while everyone else queued behind them. The new MessageLog port has one PostgreSQL adapter that does it all in a single statement with an implicit transaction: lock the chat row joined with the sender's membership, stamp the message with the later of the replica clock and the last message plus one microsecond, claim the key (overwriting it only if it has expired), insert the message only when the key was claimed, and move last_message_at. The foreign key from the key to the message is checked at the end of the statement, so the key may be written first. When the key is already taken the adapter reads the stored result with a second statement outside the lock, which also covers a concurrent duplicate that waited for the first one; the handler then replays it or answers 409 as before. The chat aggregate no longer takes part in posting, so its post, membership and last_message_at members and their unit tests are gone; Message.posted() builds the event. An invalid text is still answered 404 for an outsider: only then the handler reads the membership. A new API test pins the clock rule against a real database: a lagging replica clock gets the last stamp plus one microsecond, a clock ahead is kept. The concurrency, same-key race, expiry and access tests pass unchanged. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
163 lines
5.2 KiB
Python
163 lines
5.2 KiB
Python
from dataclasses import fields
|
|
from datetime import UTC, datetime, timedelta
|
|
from itertools import pairwise
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
from messenger.identity.domain.errors import InvalidUserData
|
|
from messenger.identity.domain.models import Session, User, token_digest
|
|
from messenger.identity.domain.values import DisplayName, Password, Username
|
|
from messenger.messaging.domain.errors import (
|
|
IdempotencyConflict,
|
|
InvalidChatData,
|
|
InvalidMessageText,
|
|
)
|
|
from messenger.messaging.domain.models import Chat, Message, Receipt
|
|
from messenger.messaging.domain.values import MessageText
|
|
from messenger.shared.infrastructure.clock import MonotonicUtcClock
|
|
|
|
MOMENT = datetime(2026, 1, 1, tzinfo=UTC)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"raw", ["ab", "a" * 33, "Alice", "alice-01", "алиса", "", "a b", "alice\n", "alice\r\n"]
|
|
)
|
|
def test_username_rejects_invalid(raw: str) -> None:
|
|
with pytest.raises(InvalidUserData):
|
|
Username(raw)
|
|
|
|
|
|
@pytest.mark.parametrize("raw", ["abc", "a_b_9", "a" * 32])
|
|
def test_username_accepts_valid(raw: str) -> None:
|
|
assert Username(raw).value == raw
|
|
|
|
|
|
@pytest.mark.parametrize("raw", ["", " ", "\t\n", "x" * 101])
|
|
def test_display_name_rejects_invalid(raw: str) -> None:
|
|
with pytest.raises(InvalidUserData):
|
|
DisplayName(raw)
|
|
|
|
|
|
@pytest.mark.parametrize("raw", ["", " " * 20, "x" * 11, "x" * 129, "\t" * 12])
|
|
def test_password_rejects_invalid(raw: str) -> None:
|
|
with pytest.raises(InvalidUserData):
|
|
Password(raw)
|
|
|
|
|
|
@pytest.mark.parametrize("raw", ["x" * 12, "п" * 128, "пароль:с:двоеточием", "👋" * 12])
|
|
def test_password_counts_code_points(raw: str) -> None:
|
|
assert Password(raw).value == raw
|
|
|
|
|
|
def test_password_is_not_printed() -> None:
|
|
assert "секретный-пароль" not in repr(Password("секретный-пароль"))
|
|
|
|
|
|
def test_session_token_is_opaque_and_stored_as_digest() -> None:
|
|
user_id = uuid4()
|
|
token, session = Session.issue(user_id=user_id, issued_at=MOMENT, ttl=timedelta(hours=1))
|
|
assert len(token) >= 43
|
|
assert str(user_id) not in token
|
|
assert session.token_hash == token_digest(token)
|
|
assert len(session.token_hash) == 32
|
|
assert session.expires_at == MOMENT + timedelta(hours=1)
|
|
assert token not in repr(session)
|
|
|
|
|
|
def test_session_tokens_are_unique() -> None:
|
|
tokens = {
|
|
Session.issue(user_id=uuid4(), issued_at=MOMENT, ttl=timedelta(seconds=1))[0]
|
|
for _ in range(1000)
|
|
}
|
|
assert len(tokens) == 1000
|
|
|
|
|
|
def test_message_text_counts_code_points_not_bytes() -> None:
|
|
emoji = "👋" * 4000
|
|
assert len(MessageText(emoji).value) == 4000
|
|
with pytest.raises(InvalidMessageText):
|
|
MessageText("👋" * 4001)
|
|
|
|
|
|
def test_message_text_rejects_blank() -> None:
|
|
for raw in ("", " ", "\n\t "):
|
|
with pytest.raises(InvalidMessageText):
|
|
MessageText(raw)
|
|
|
|
|
|
def test_chat_requires_creator_in_members() -> None:
|
|
members = [uuid4(), uuid4()]
|
|
with pytest.raises(InvalidChatData):
|
|
Chat.create(
|
|
chat_id=uuid4(),
|
|
title="Чат",
|
|
member_ids=members,
|
|
creator_id=uuid4(),
|
|
created_at=MOMENT,
|
|
)
|
|
|
|
|
|
def test_chat_rejects_duplicate_members() -> None:
|
|
same = uuid4()
|
|
with pytest.raises(InvalidChatData):
|
|
Chat.create(
|
|
chat_id=uuid4(),
|
|
title="Чат",
|
|
member_ids=[same, same],
|
|
creator_id=same,
|
|
created_at=MOMENT,
|
|
)
|
|
|
|
|
|
def test_chat_rejects_more_than_hundred_members() -> None:
|
|
members = [uuid4() for _ in range(101)]
|
|
with pytest.raises(InvalidChatData):
|
|
Chat.create(
|
|
chat_id=uuid4(),
|
|
title="Чат",
|
|
member_ids=members,
|
|
creator_id=members[0],
|
|
created_at=MOMENT,
|
|
)
|
|
|
|
|
|
def test_receipt_replays_only_the_same_request() -> None:
|
|
message = Message(uuid4(), uuid4(), uuid4(), MessageText("раз"), MOMENT)
|
|
receipt = Receipt("key-1", b"a" * 32, message)
|
|
assert receipt.replay(b"a" * 32) is message
|
|
with pytest.raises(IdempotencyConflict):
|
|
receipt.replay(b"b" * 32)
|
|
|
|
|
|
def test_posted_message_describes_itself() -> None:
|
|
message = Message(uuid4(), uuid4(), uuid4(), MessageText("пять"), MOMENT)
|
|
event = message.posted()
|
|
assert (event.message_id, event.chat_id, event.sender_id) == (
|
|
message.id,
|
|
message.chat_id,
|
|
message.sender_id,
|
|
)
|
|
assert (event.text_length, event.created_at, event.name) == (4, MOMENT, "message.posted")
|
|
|
|
|
|
def test_user_registration_emits_event() -> None:
|
|
user, event = User.register(
|
|
user_id=uuid4(),
|
|
username=Username("alice_01"),
|
|
display_name=DisplayName("Алиса"),
|
|
password_hash="$argon2id$v=19$m=19456,t=2,p=1$c2FsdA$aGFzaA",
|
|
registered_at=MOMENT,
|
|
)
|
|
assert event.name == "user.registered"
|
|
assert {field.name for field in fields(event)} == {"name", "user_id", "registered_at"}
|
|
assert user.created_at == MOMENT
|
|
assert "argon2id" not in repr(user)
|
|
|
|
|
|
def test_clock_is_strictly_increasing() -> None:
|
|
clock = MonotonicUtcClock()
|
|
stamps = [clock.now() for _ in range(1000)]
|
|
assert all(later > earlier for earlier, later in pairwise(stamps))
|
|
assert all(stamp.tzinfo is UTC for stamp in stamps)
|