pytest-orm-boundaries 0.3.0__tar.gz → 0.3.1__tar.gz

{pytest_orm_boundaries-0.3.0 → pytest_orm_boundaries-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-orm-boundaries
-Version: 0.3.0
+Version: 0.3.1
 Summary: Pytest plugin that fails tests when ORM queries cross DDD aggregate boundaries (Django supported today).
 Keywords: django,pytest,plugin,orm,ddd,aggregate,boundaries,architecture
 Author: Evgeniia Chibisova

{pytest_orm_boundaries-0.3.0 → pytest_orm_boundaries-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "pytest-orm-boundaries"
-version = "0.3.0"
+version = "0.3.1"
 description = "Pytest plugin that fails tests when ORM queries cross DDD aggregate boundaries (Django supported today)."
 readme = "README.md"
 requires-python = ">=3.11"

{pytest_orm_boundaries-0.3.0 → pytest_orm_boundaries-0.3.1}/src/pytest_orm_boundaries/build_report.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
     from pytest_orm_boundaries.guard import ViolationRecord
 
-MAX_TESTS_SHOWN = 20
+MAX_TESTS_SHOWN = 5
 
 
 def report_violations(
@@ -22,8 +22,8 @@ def report_violations(
     violations: list[ViolationRecord],
     verbose: bool = False,
 ) -> None:
-    """Print one grouped entry per offending place: where the query crosses a
-    boundary, the offending line of code, and which tests reached it.
+    """Print one grouped entry per offending call place: which aggregates the
+    query crossed, the models it joined, and which tests reached it.
     """
     if not violations:
         return
@@ -58,23 +58,26 @@ def _write_violation(
 ) -> None:
     terminalreporter.write_line("")
     terminalreporter.write_line(f"{violation.file}:{violation.line_number}", bold=True)
-    if violation.line_code:
-        terminalreporter.write_line(f"    code: {violation.line_code}")
-    terminalreporter.write_line(f"    crosses: {violation.crossed}")
+    aggregates = " ↔ ".join(violation.crossed_aggregates)
+    terminalreporter.write_line(
+        f"    crossed aggregates: {aggregates}", yellow=True, bold=True
+    )
+    models = ", ".join(violation.joined_models)
+    terminalreporter.write_line(f"    models: {models}")
 
     tests = sorted(violation.tests)
     if not tests:
-        terminalreporter.write_line("    affected tests: (none captured)")
+        terminalreporter.write_line("    tests affected: (none captured)", light=True)
         return
 
     shown = tests if verbose else tests[:MAX_TESTS_SHOWN]
-    terminalreporter.write_line(f"    affected tests ({len(tests)}):")
+    terminalreporter.write_line(f"    {len(tests)} test(s) affected:", light=True)
     for nodeid in shown:
-        terminalreporter.write_line(f"      {nodeid}")
+        terminalreporter.write_line(f"      {nodeid}", light=True)
     hidden = len(tests) - len(shown)
     if hidden:
         terminalreporter.write_line(
-            f"      ... +{hidden} more (run with -v to list all)"
+            f"      ... +{hidden} more (-v to list all)", light=True
         )
 
 

{pytest_orm_boundaries-0.3.0 → pytest_orm_boundaries-0.3.1}/src/pytest_orm_boundaries/guard.py

@@ -5,7 +5,6 @@ interception that records crossings.
 from __future__ import annotations
 
 import functools
-import linecache
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -35,8 +34,8 @@ class ViolationRecord:
 
     file: str
     line_number: int
-    line_code: str
-    crossed: str
+    crossed_aggregates: tuple[str, ...]  # ("order", "payment")
+    joined_models: tuple[str, ...]  # ("order.Invoice", "payrolls.IncomePayment")
     tests: set[str] = field(default_factory=set)
 
 
@@ -55,7 +54,7 @@ class BoundaryGuard:
         self._root = Path(root)
         self._original_execute_sql: Callable[..., Any] | None = None
         self._current_test: str | None = None
-        self._violations: dict[tuple[str, int, str], ViolationRecord] = {}
+        self._violations: dict[tuple[str, int, tuple[str, ...]], ViolationRecord] = {}
 
     def install(self) -> None:
         from django.db.models.sql.compiler import SQLCompiler
@@ -80,7 +79,11 @@ class BoundaryGuard:
 
     @property
     def violations(self) -> list[ViolationRecord]:
-        return sorted(self._violations.values(), key=lambda v: (v.file, v.line_number))
+        """Recorded crossings, most-affecting first (then by call place)."""
+        return sorted(
+            self._violations.values(),
+            key=lambda v: (-len(v.tests), v.file, v.line_number),
+        )
 
     def find_stale_patterns(self) -> list[str]:
         return self._ignore_tracker.find_stale_patterns()
@@ -99,8 +102,8 @@ class BoundaryGuard:
             self._ignore_tracker.mark_seen(file_paths=file_paths)
 
         labels = self._read_labels(query=query)
-        crossed = self._find_crossing(labels=labels)
-        if crossed is None:
+        crossing = self._find_crossing(labels=labels)
+        if crossing is None:
             return
 
         if file_paths is not None and self._ignore_tracker.has_ignore_for(
@@ -111,7 +114,9 @@ class BoundaryGuard:
 
         if frames is None:
             frames = find_in_project_frames(root=self._root)
-        self._record_violation(call_place=frames[0] if frames else None, crossed=crossed)
+        self._record_violation(
+            call_place=frames[0] if frames else None, crossing=crossing
+        )
 
     def _read_labels(self, *, query: Query) -> list[str]:
         """Model labels of the tables the query actually reads.
@@ -127,38 +132,45 @@ class BoundaryGuard:
             and query.alias_refcount.get(alias, 0) > 0
         ]
 
-    def _find_crossing(self, *, labels: Iterable[str]) -> str | None:
-        """Return the crossed aggregate names ("order, payment") if the query
-        crosses a boundary, else None."""
-        aggregates = {
-            aggregate
+    def _find_crossing(
+        self, *, labels: Iterable[str]
+    ) -> tuple[tuple[str, ...], tuple[str, ...]] | None:
+        """Return ``(crossed aggregate names, joined model labels)`` if the query
+        crosses a boundary, else None.
+
+        e.g. ``(("order", "payment"), ("order.Invoice", "payrolls.IncomePayment"))``.
+        """
+        aggregate_by_label = {
+            label: aggregate
             for label in labels
             if (aggregate := self._aggregates_config.get(label.lower())) is not None
         }
+        aggregates = set(aggregate_by_label.values())
         if len(aggregates) <= 1:
             return None
-        return ", ".join(sorted(aggregates))
+        return tuple(sorted(aggregates)), tuple(sorted(aggregate_by_label.keys()))
 
-    def _record_violation(self, *, call_place: tuple[str, int] | None, crossed: str) -> None:
+    def _record_violation(
+        self,
+        *,
+        call_place: tuple[str, int] | None,
+        crossing: tuple[tuple[str, ...], tuple[str, ...]],
+    ) -> None:
+        crossed_aggregates, joined_models = crossing
         file, line = call_place if call_place is not None else ("<unknown>", 0)
-        key = (file, line, crossed)
+        key = (file, line, crossed_aggregates)
         record = self._violations.get(key)
         if record is None:
-            line_code = self._read_line_code(file=file, line=line)
             record = ViolationRecord(
-                file=file, line_number=line, line_code=line_code, crossed=crossed
+                file=file,
+                line_number=line,
+                crossed_aggregates=crossed_aggregates,
+                joined_models=joined_models,
             )
             self._violations[key] = record
         if self._current_test is not None:
             record.tests.add(self._current_test)
 
-    def _read_line_code(self, *, file: str, line: int) -> str:
-        """The offending line of code, stripped - or "" if it can't be read."""
-        if line <= 0 or file == "<unknown>":
-            return ""
-        absolute_path = str(self._root / file)
-        return linecache.getline(absolute_path, line).strip()
-
     @staticmethod
     def _extract_file_paths(frames: Iterable[tuple[str, int]]) -> set[str]:
         return {path for path, _ in frames}