Files
2026-10-30 12:32:42 +03:00

229 lines
7.7 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_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")
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}