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}