POST /api/v1/chats/{chat_id}/messages now requires the header, checked
at the HTTP boundary (1-128 of [A-Za-z0-9._:-], else 400). The handler
keeps the lab 2 order under the chat row lock: membership, then text,
then the receipt for (chat, sender, key) younger than
IDEMPOTENCY_TTL_SECONDS. A receipt with the same fingerprint replays
the stored message, a different one is 409 conflict; without a
receipt one statement inserts the message, the key row and the chat
mark, so both commit or neither does. Concurrent retries wait on the
same row lock and then read the committed receipt. The fingerprint is
SHA-256 of the canonical JSON of the parsed body, so layout does not
matter, and only 201 answers are ever stored.
A lock timeout now counts as a dependency failure and answers 503
instead of 500, so a retry with the same key is safe.
Own tests cover replay, a different layout of the same JSON, conflict,
missing and malformed keys, rejected attempts that leave the key free,
scope by user and chat, revalidation after logout and for outsiders,
expiry, and eight concurrent retries through two app instances
sharing one PostgreSQL. Every earlier message post sends a fresh key.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
243 lines
8.2 KiB
Python
243 lines
8.2 KiB
Python
import ast
|
|
import re
|
|
from pathlib import Path
|
|
|
|
SOURCE = Path(__file__).resolve().parents[2] / "src" / "messenger"
|
|
IDENTITY = "messenger.identity"
|
|
MESSAGING = "messenger.messaging"
|
|
|
|
|
|
def imports_of(path: Path) -> list[str]:
|
|
tree = ast.parse(path.read_text(), filename=str(path))
|
|
found: list[str] = []
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.ImportFrom) and node.module:
|
|
found.append(node.module)
|
|
elif isinstance(node, ast.Import):
|
|
found.extend(alias.name for alias in node.names)
|
|
return found
|
|
|
|
|
|
def modules_under(*parts: str) -> list[Path]:
|
|
root = SOURCE.joinpath(*parts)
|
|
return [path for path in root.rglob("*.py") if path.name != "__init__.py"]
|
|
|
|
|
|
def test_identity_does_not_know_about_messaging() -> None:
|
|
offenders = {
|
|
str(path.relative_to(SOURCE)): [m for m in imports_of(path) if m.startswith(MESSAGING)]
|
|
for path in modules_under("identity")
|
|
}
|
|
assert not {k: v for k, v in offenders.items() if v}
|
|
|
|
|
|
def test_messaging_touches_identity_only_through_events() -> None:
|
|
allowed = f"{IDENTITY}.domain.events"
|
|
offenders: dict[str, list[str]] = {}
|
|
for path in modules_under("messaging"):
|
|
borrowed = [
|
|
module
|
|
for module in imports_of(path)
|
|
if module.startswith(IDENTITY) and module != allowed
|
|
]
|
|
if borrowed:
|
|
offenders[str(path.relative_to(SOURCE))] = borrowed
|
|
assert not offenders
|
|
|
|
|
|
def test_domains_do_not_import_infrastructure() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for zone in ("identity", "messaging", "shared"):
|
|
for layer in ("domain", "application"):
|
|
for path in modules_under(zone, layer):
|
|
borrowed = [m for m in imports_of(path) if ".infrastructure" in m]
|
|
if borrowed:
|
|
offenders[str(path.relative_to(SOURCE))] = borrowed
|
|
assert not offenders
|
|
|
|
|
|
def test_core_layers_do_not_import_pydantic() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for zone in ("identity", "messaging", "shared"):
|
|
for layer in ("domain", "application"):
|
|
for path in modules_under(zone, layer):
|
|
borrowed = [m for m in imports_of(path) if m.split(".")[0] == "pydantic"]
|
|
if borrowed:
|
|
offenders[str(path.relative_to(SOURCE))] = borrowed
|
|
assert not offenders, "схемы pydantic живут на границе: в entrypoints/ и config.py"
|
|
|
|
|
|
def test_shared_knows_nothing_about_zones() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for path in modules_under("shared"):
|
|
borrowed = [
|
|
module
|
|
for module in imports_of(path)
|
|
if module.startswith(IDENTITY) or module.startswith(MESSAGING)
|
|
]
|
|
if borrowed:
|
|
offenders[str(path.relative_to(SOURCE))] = borrowed
|
|
assert not offenders
|
|
|
|
|
|
TRANSPORT = ("fastapi", "starlette", "uvicorn", "gunicorn")
|
|
|
|
|
|
def test_shared_core_is_free_of_transport() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for layer in ("domain", "application", "infrastructure"):
|
|
for path in modules_under("shared", layer):
|
|
borrowed = [module for module in imports_of(path) if module.split(".")[0] in TRANSPORT]
|
|
if borrowed:
|
|
offenders[str(path.relative_to(SOURCE))] = borrowed
|
|
assert not offenders, "ядро shared обязано жить без веб-фреймворка"
|
|
|
|
|
|
def test_shared_core_holds_only_platform() -> None:
|
|
names = {
|
|
path.name
|
|
for layer in ("domain", "application", "infrastructure")
|
|
for path in modules_under("shared", layer)
|
|
}
|
|
assert names == {
|
|
"errors.py",
|
|
"events.py",
|
|
"commands.py",
|
|
"messagebus.py",
|
|
"ports.py",
|
|
"clock.py",
|
|
"ids.py",
|
|
"logging.py",
|
|
"postgres.py",
|
|
}
|
|
|
|
|
|
def test_shared_entrypoints_hold_only_transport() -> None:
|
|
names = {path.name for path in modules_under("shared", "entrypoints")}
|
|
assert names == {
|
|
"actor.py",
|
|
"config.py",
|
|
"errors.py",
|
|
"health.py",
|
|
"ioc.py",
|
|
"pipeline.py",
|
|
"schemas.py",
|
|
}
|
|
|
|
|
|
def test_every_zone_owns_its_errors_events_and_commands() -> None:
|
|
for zone in ("identity", "messaging"):
|
|
assert (SOURCE / zone / "domain" / "errors.py").is_file()
|
|
assert (SOURCE / zone / "domain" / "events.py").is_file()
|
|
assert (SOURCE / zone / "application" / "commands.py").is_file()
|
|
|
|
|
|
def test_every_zone_owns_its_http_layer() -> None:
|
|
for zone in ("identity", "messaging"):
|
|
for part in ("http.py", "ioc.py", "errors.py", "journal.py"):
|
|
assert (SOURCE / zone / "entrypoints" / part).is_file(), f"{zone}: нет {part}"
|
|
|
|
|
|
def test_only_main_knows_both_zones() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for path in SOURCE.rglob("*.py"):
|
|
relative = path.relative_to(SOURCE)
|
|
if path.name in {"__init__.py", "main.py"} or relative.parts[0] in {
|
|
"identity",
|
|
"messaging",
|
|
}:
|
|
continue
|
|
borrowed = [
|
|
module
|
|
for module in imports_of(path)
|
|
if module.startswith(IDENTITY) or module.startswith(MESSAGING)
|
|
]
|
|
if borrowed:
|
|
offenders[str(relative)] = borrowed
|
|
assert not offenders
|
|
|
|
|
|
def test_application_has_no_separate_entrypoints_root() -> None:
|
|
assert not (SOURCE / "entrypoints").exists()
|
|
assert (SOURCE / "main.py").is_file()
|
|
|
|
|
|
ZONE_WORDS = (
|
|
"username",
|
|
"display_name",
|
|
"chat",
|
|
"member",
|
|
"history",
|
|
"cursor",
|
|
"sender",
|
|
"message_id",
|
|
"message_text",
|
|
)
|
|
|
|
|
|
def test_shared_source_mentions_no_domain_vocabulary() -> None:
|
|
offenders: dict[str, list[str]] = {}
|
|
for path in modules_under("shared"):
|
|
source = path.read_text().lower()
|
|
hits = sorted({word for word in ZONE_WORDS if word in source})
|
|
if hits:
|
|
offenders[str(path.relative_to(SOURCE))] = hits
|
|
assert not offenders
|
|
|
|
|
|
def test_shared_declares_no_concrete_commands_or_events() -> None:
|
|
for path in modules_under("shared"):
|
|
tree = ast.parse(path.read_text(), filename=str(path))
|
|
declared = [n.name for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]
|
|
concrete = [
|
|
name
|
|
for name in declared
|
|
if name not in {"Command", "DomainEvent", "DomainError"}
|
|
and (name.endswith("Event") or name in {"RegisterUser", "CreateChat", "PostMessage"})
|
|
]
|
|
assert not concrete, f"{path.name}: {concrete}"
|
|
|
|
|
|
def test_shared_has_no_test_doubles() -> None:
|
|
for path in modules_under("shared"):
|
|
source = path.read_text()
|
|
for marker in ("Frozen", "Fake", "Stub", "Null", "Dummy"):
|
|
assert marker not in source, f"{path.name} содержит подделку {marker}"
|
|
|
|
|
|
def test_zone_errors_do_not_leak_transport_codes() -> None:
|
|
for zone in ("identity", "messaging", "shared"):
|
|
source = (SOURCE / zone / "domain" / "errors.py").read_text()
|
|
assert "http_status" not in source
|
|
assert "invalid_request" not in source
|
|
assert "404" not in source
|
|
|
|
|
|
IDENTITY_TABLES = ("users", "sessions")
|
|
MESSAGING_TABLES = ("chats", "chat_members", "messages", "idempotency_keys")
|
|
|
|
|
|
def sql_tables(zone: str, tables: tuple[str, ...]) -> set[str]:
|
|
words: set[str] = set()
|
|
for path in modules_under(zone):
|
|
tree = ast.parse(path.read_text(), filename=str(path))
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.Constant) and isinstance(node.value, str):
|
|
words.update(re.findall(r"\b(?:FROM|JOIN|INTO|UPDATE)\s+(\w+)", node.value))
|
|
return words & set(tables)
|
|
|
|
|
|
def test_sql_of_each_zone_reads_only_its_tables() -> None:
|
|
assert sql_tables("messaging", IDENTITY_TABLES) == set()
|
|
assert sql_tables("identity", MESSAGING_TABLES) == set()
|
|
assert sql_tables("messaging", MESSAGING_TABLES) == set(MESSAGING_TABLES)
|
|
assert sql_tables("identity", IDENTITY_TABLES) == set(IDENTITY_TABLES)
|
|
|
|
|
|
def test_messaging_does_not_import_identity_at_all() -> None:
|
|
borrowed = {
|
|
str(path.relative_to(SOURCE)): [m for m in imports_of(path) if m.startswith(IDENTITY)]
|
|
for path in modules_under("messaging")
|
|
}
|
|
assert not {key: value for key, value in borrowed.items() if value}
|