pytest-eo 0.5.1__py3-none-any.whl

pytest_eo/plugin.py

@@ -0,0 +1,45 @@
+"""The pytest plugin: ``pytest --eo`` adds one test item per aggregated tool."""
+
+from pathlib import Path
+
+import pytest
+
+from pytest_eo.eo_item import EoItem
+from pytest_eo.eo_table import EoTable
+from pytest_eo.project import Project
+from pytest_eo.strict import Strict
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register ``--eo``."""
+    parser.getgroup("eo").addoption(
+        "--eo",
+        action="store_true",
+        default=False,
+        help=(
+            "also run the strict style gate (ruff, ruff format, mypy --strict)"
+        ),
+    )
+
+
+def pytest_collection_modifyitems(
+    session: pytest.Session,
+    config: pytest.Config,
+    items: list[pytest.Item],
+) -> None:
+    """Append one item per tool when ``--eo`` is given."""
+    if not config.getoption("--eo"):
+        return
+    root = Path(config.rootpath)
+    items.extend(
+        EoItem.from_parent(
+            session,
+            name=check.name(),
+            nodeid=f"eo::{check.name()}",
+            check=check,
+        )
+        for check in Strict(
+            Project(EoTable(root / "pyproject.toml"), root),
+            root,
+        ).checks()
+    )

pytest_eo/printout.py

@@ -0,0 +1,18 @@
+"""What a finished tool left behind, as the checks see it."""
+
+from collections.abc import Iterable
+from typing import Protocol
+
+from pytest_eo.tool_failed_error import ToolFailedError
+
+
+class Printout(Iterable[str], Protocol):
+    """The lines a finished tool printed, and how it exited."""
+
+    def exited(self, statuses: tuple[int, ...]) -> bool:
+        """Tell whether the tool exited with one of the statuses."""
+        ...
+
+    def failure(self, reason: str) -> ToolFailedError:
+        """Build the error of a tool that failed, with what it complained."""
+        ...

pytest_eo/profile.py

@@ -0,0 +1,13 @@
+"""A set of checks to run over a project."""
+
+from typing import Protocol
+
+from pytest_eo.check import Check
+
+
+class Profile(Protocol):
+    """A set of checks to run over a project."""
+
+    def checks(self) -> tuple[Check, ...]:
+        """Build the checks; nothing runs until ``violations()`` is called."""
+        ...

pytest_eo/project.py

@@ -0,0 +1,37 @@
+"""The project under check and its settings."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.layout import Layout
+from pytest_eo.table import Table
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Project(Layout):
+    """A directory checked as its settings say, or as its layout suggests."""
+
+    _table: Table
+    _root: Path
+
+    @override
+    def paths(self) -> tuple[str, ...]:
+        """Directories to check: the configured ones or existing src/tests."""
+        return (
+            self._table.strings("paths")
+            or tuple(
+                name
+                for name in ("src", "tests")
+                if (self._root / name).is_dir()
+            )
+            or (".",)
+        )
+
+    @override
+    def excludes(self) -> tuple[str, ...]:
+        """Glob patterns to skip, as configured."""
+        return self._table.strings("exclude")

pytest_eo/project_files.py

@@ -0,0 +1,39 @@
+"""Python files under the checked paths of a project."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.excludes import Excludes
+from pytest_eo.files import Files
+from pytest_eo.layout import Layout
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class ProjectFiles(Files):
+    """Python files under the checked paths of a layout, minus its excludes."""
+
+    _layout: Layout
+    _root: Path
+
+    @override
+    def files(self) -> tuple[Path, ...]:
+        """Sorted ``*.py`` files under the checked paths, minus excludes."""
+        found = (
+            file
+            for path in self._layout.paths()
+            for file in (self._root / path).rglob("*.py")
+        )
+        excludes = Excludes(self._layout.excludes())
+        return tuple(
+            sorted(
+                {
+                    file
+                    for file in found
+                    if file.relative_to(self._root).as_posix() not in excludes
+                },
+            ),
+        )

pytest_eo/python_module.py

@@ -0,0 +1,36 @@
+"""Running a Python module: the only place that touches subprocesses."""
+
+import subprocess  # ruff: ignore[suspicious-subprocess-import] - the only module that runs external tools
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.command import Command
+from pytest_eo.output import Output
+from pytest_eo.printout import Printout
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class PythonModule(Command):
+    """``python -m <module> <args>`` in the interpreter that runs pytest."""
+
+    _module: str
+    _args: tuple[str, ...]
+    _cwd: Path
+
+    @override
+    def run(self) -> Printout:
+        """Run the module and capture its output."""
+        argv = (sys.executable, "-m", self._module, *self._args)
+        done = subprocess.run(  # ruff: ignore[subprocess-without-shell-equals-true] - argv is built from fixed tool names
+            argv,
+            capture_output=True,
+            text=True,
+            check=False,
+            cwd=self._cwd,
+        )
+        return Output(done.stdout, done.stderr, done.returncode)

pytest_eo/raising.py

@@ -0,0 +1,27 @@
+"""Whether a statement expects an exception."""
+
+import ast
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.callee import Callee
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Raising(ast.NodeVisitor):  # noqa: ENC100 - a visitor holds no state, ast dispatches on the node
+    """Whether a statement is a block under ``pytest.raises`` alone."""
+
+    @override
+    def generic_visit(self, node: ast.AST) -> bool:
+        """Expect no exception from any other statement."""
+        return False
+
+    @override
+    def visit_With(self, node: ast.With) -> bool:
+        """Expect an exception from a block under ``pytest.raises`` alone."""
+        return tuple(
+            Callee().visit(item.context_expr) for item in node.items
+        ) == ("pytest.raises",)

pytest_eo/remark.py

@@ -0,0 +1,25 @@
+"""A comment of a source file, as the suppression checks see one."""
+
+import re
+from collections.abc import Iterator
+from typing import Protocol
+
+from pytest_eo.place import Place
+
+
+class Remark(Protocol):
+    """A comment that finds patterns in its own text."""
+
+    def matches(
+        self,
+        pattern: re.Pattern[str],
+    ) -> Iterator[tuple[Place, re.Match[str]]]:
+        """Yield every match of the pattern, with where it stands."""
+        ...
+
+    def heading(
+        self,
+        pattern: re.Pattern[str],
+    ) -> Iterator[tuple[Place, re.Match[str]]]:
+        """Yield the matches only when the comment stands above all code."""
+        ...

pytest_eo/ruff_check.py

@@ -0,0 +1,50 @@
+"""``ruff check`` as a source of violations."""
+
+import json
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.check import Check
+from pytest_eo.command import Command
+from pytest_eo.place import Place
+from pytest_eo.tool_failed_error import ToolFailedError
+from pytest_eo.verified import Verified
+from pytest_eo.violation import Violation
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class RuffCheck(Check):
+    """``ruff check`` with the locked configuration."""
+
+    _command: Command
+
+    @override
+    def name(self) -> str:
+        """Short name shown in the pytest report."""
+        return "ruff"
+
+    @override
+    def violations(self) -> tuple[Violation, ...]:
+        """Parse the JSON report of ``ruff check``."""
+        output = Verified(self._command, self.name(), (0, 1)).run()
+        try:
+            items = json.loads("\n".join(output) or "[]")
+        except json.JSONDecodeError as error:
+            message = f"ruff printed invalid JSON: {error}"
+            raise ToolFailedError(message) from error
+        return tuple(
+            Violation(
+                self.name(),
+                item["code"] or "syntax",
+                Place(
+                    item["filename"],
+                    item["location"]["row"],
+                    item["location"]["column"],
+                ),
+                item["message"],
+            )
+            for item in items
+        )

pytest_eo/ruff_format_check.py

@@ -0,0 +1,46 @@
+"""``ruff format --check`` as a source of violations."""
+
+import re
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.check import Check
+from pytest_eo.command import Command
+from pytest_eo.place import Place
+from pytest_eo.verified import Verified
+from pytest_eo.violation import Violation
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class RuffFormatCheck(Check):
+    """``ruff format --check``: files that the formatter would change."""
+
+    _command: Command
+
+    @override
+    def name(self) -> str:
+        """Short name shown in the pytest report."""
+        return "ruff-format"
+
+    @override
+    def violations(self) -> tuple[Violation, ...]:
+        """Parse the concise report of ``ruff format --check``."""
+        output = Verified(self._command, self.name(), (0, 1)).run()
+        pattern = re.compile(
+            r"^(?P<path>.+?):(?P<line>\d+):(?P<col>\d+): "
+            r"(?P<code>\w+): (?P<msg>.+)$"
+        )
+        found = (pattern.match(line) for line in output)
+        return tuple(
+            Violation(
+                self.name(),
+                match["code"],
+                Place(match["path"], int(match["line"]), int(match["col"])),
+                match["msg"],
+            )
+            for match in found
+            if match
+        )

pytest_eo/rule.py

@@ -0,0 +1,12 @@
+"""A rule over one parsed module, as this package sees one."""
+
+from collections.abc import Iterator
+from typing import Protocol
+
+
+class Rule(Protocol):
+    """One rule, such as one of Angry Tests, over a parsed module."""
+
+    def problems(self) -> Iterator[tuple[int, int, str]]:
+        """Yield the line, column and message of every break of the rule."""
+        ...

pytest_eo/shared.py

@@ -0,0 +1,35 @@
+"""Whether a statement of a module shares a value between its tests."""
+
+import ast
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Shared(ast.NodeVisitor):  # noqa: ENC100 - a visitor holds no state, ast dispatches on the node
+    """Whether a statement assigns a module value besides ``pytest_plugins``."""
+
+    @override
+    def generic_visit(self, node: ast.AST) -> bool:
+        """Share nothing through a statement that assigns nothing."""
+        return False
+
+    @override
+    def visit_Assign(self, node: ast.Assign) -> bool:
+        """Share the value unless it is the list of plugins."""
+        return tuple(ast.unparse(target) for target in node.targets) != (
+            "pytest_plugins",
+        )
+
+    @override
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> bool:
+        """Share the annotated value unless it is the list of plugins."""
+        return ast.unparse(node.target) != "pytest_plugins"
+
+    @override
+    def visit_AugAssign(self, node: ast.AugAssign) -> bool:
+        """Share the value that a module changes in place."""
+        return True

pytest_eo/span.py

@@ -0,0 +1,28 @@
+"""The rows that a function takes in its file."""
+
+import ast
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Span(ast.NodeVisitor):  # noqa: ENC100 - a visitor holds no state, ast dispatches on the node
+    """The rows of a function, from ``def`` to its last line, and none else."""
+
+    @override
+    def generic_visit(self, node: ast.AST) -> range:
+        """Span no rows of a node that isnt a function."""
+        return range(0)
+
+    @override
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> range:
+        """Span the rows of a function."""
+        return range(node.lineno, (node.end_lineno or node.lineno) + 1)
+
+    @override
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> range:
+        """Span the rows of a coroutine."""
+        return range(node.lineno, (node.end_lineno or node.lineno) + 1)

pytest_eo/strict.py

@@ -0,0 +1,112 @@
+"""The locked profile: which tools run, with which bundled configuration."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.bundled import Bundled
+from pytest_eo.check import Check
+from pytest_eo.flake_check import FlakeCheck
+from pytest_eo.layout import Layout
+from pytest_eo.mypy_check import MypyCheck
+from pytest_eo.profile import Profile
+from pytest_eo.project_files import ProjectFiles
+from pytest_eo.python_module import PythonModule
+from pytest_eo.ruff_check import RuffCheck
+from pytest_eo.ruff_format_check import RuffFormatCheck
+from pytest_eo.suppression_check import SuppressionCheck
+
+# The rule a suppression may never name, by code or by name: the ban on mocks.
+UNSUPPRESSIBLE = ("TID251", "banned-api")
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Strict(Profile):
+    """ruff, ruff format, ``mypy --strict``, pyeo and suppressions."""
+
+    _layout: Layout
+    _root: Path
+
+    @override
+    def checks(self) -> tuple[Check, ...]:
+        """Build the checks; nothing runs until ``violations()`` is called."""
+        root = self._root
+        paths = self._layout.paths()
+        skipped = tuple(
+            arg
+            for pattern in self._layout.excludes()
+            for arg in ("--extend-exclude", pattern)
+        )
+        ruff_config = ("--config", str(Bundled("ruff.toml")), *skipped)
+        flake_skipped = (
+            ("--extend-exclude", ",".join(self._layout.excludes()))
+            if self._layout.excludes()
+            else ()
+        )
+        mypy_skipped = tuple(
+            arg
+            for pattern in self._layout.excludes()
+            for arg in ("--exclude", pattern)
+        )
+        return (
+            RuffCheck(
+                PythonModule(
+                    "ruff",
+                    (
+                        "check",
+                        "--output-format",
+                        "json",
+                        "--no-cache",
+                        *ruff_config,
+                        *paths,
+                    ),
+                    root,
+                ),
+            ),
+            RuffFormatCheck(
+                PythonModule(
+                    "ruff",
+                    (
+                        "format",
+                        "--check",
+                        "--output-format",
+                        "concise",
+                        "--no-cache",
+                        *ruff_config,
+                        *paths,
+                    ),
+                    root,
+                ),
+            ),
+            MypyCheck(
+                PythonModule(
+                    "mypy",
+                    (
+                        "--strict",
+                        "--config-file",
+                        str(Bundled("mypy.ini")),
+                        "--output",
+                        "json",
+                        *mypy_skipped,
+                        *paths,
+                    ),
+                    root,
+                ),
+            ),
+            FlakeCheck(
+                PythonModule(
+                    "flake8",
+                    (
+                        "--config",
+                        str(Bundled("flake8.ini")),
+                        *flake_skipped,
+                        *paths,
+                    ),
+                    root,
+                ),
+            ),
+            SuppressionCheck(ProjectFiles(self._layout, root), UNSUPPRESSIBLE),
+        )

pytest_eo/style_violations_error.py

@@ -0,0 +1,15 @@
+"""The error an item raises when its tool found violations."""
+
+from typing import final
+
+from typing_extensions import override
+
+
+@final
+class StyleViolationsError(Exception):  # noqa: ENC100 - an exception keeps its message in args
+    """Raised by an item when its tool found violations; its args are them."""
+
+    @override
+    def __str__(self) -> str:
+        """Show one violation per line."""
+        return "\n".join(str(item) for item in self.args)

pytest_eo/suppression_check.py

@@ -0,0 +1,44 @@
+"""Suppression comments: each one gives a reason, and some codes allow none."""
+
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+from pytest_eo.check import Check
+from pytest_eo.comments import Comments
+from pytest_eo.files import Files
+from pytest_eo.narrow_suppressions import NarrowSuppressions
+from pytest_eo.violation import Violation
+from pytest_eo.wide_suppressions import WideSuppressions
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class SuppressionCheck(Check):
+    """Suppressions without a reason, of a forbidden rule, or wider than a line.
+
+    It reads ``# noqa: CODE`` and ``# ruff: ignore[CODE-OR-NAME]``, and
+    refuses the file-wide and range forms of ruff, flake8 and mypy outright.
+    """
+
+    _sources: Files
+    _forbidden: tuple[str, ...]
+
+    @override
+    def name(self) -> str:
+        """Short name shown in the pytest report."""
+        return "suppressions"
+
+    @override
+    def violations(self) -> tuple[Violation, ...]:
+        """Read the comments of every file, never running a tool."""
+        return tuple(
+            found
+            for file in self._sources.files()
+            for comment in Comments(file)
+            for found in (
+                *NarrowSuppressions(self.name(), comment, self._forbidden),
+                *WideSuppressions(self.name(), comment),
+            )
+        )

pytest_eo/table.py

@@ -0,0 +1,11 @@
+"""Settings of the gate, as this package sees them."""
+
+from typing import Protocol
+
+
+class Table(Protocol):
+    """Settings a project gives the gate, by key."""
+
+    def strings(self, key: str) -> tuple[str, ...]:
+        """Return the strings listed under the key, or none without them."""
+        ...

pytest_eo/text.py

@@ -0,0 +1,28 @@
+"""The words of a message as the source spells them."""
+
+import ast
+from dataclasses import dataclass
+from typing import final
+
+from typing_extensions import override
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class Text(ast.NodeVisitor):  # noqa: ENC100 - a visitor holds no state, ast dispatches on the node
+    """The literal words of an expression, and nothing for computed ones."""
+
+    @override
+    def generic_visit(self, node: ast.AST) -> str:
+        """Read nothing from a value only known at run time."""
+        return ""
+
+    @override
+    def visit_Constant(self, node: ast.Constant) -> str:
+        """Read a literal as it is written."""
+        return str(node.value)
+
+    @override
+    def visit_JoinedStr(self, node: ast.JoinedStr) -> str:
+        """Read the literal parts of a formatted string."""
+        return " ".join(self.visit(part) for part in node.values)

pytest_eo/tool_failed_error.py

@@ -0,0 +1,15 @@
+"""The error of a tool that crashed or printed nonsense."""
+
+from typing import final
+
+from typing_extensions import override
+
+
+@final
+class ToolFailedError(RuntimeError):  # noqa: ENC100 - an exception keeps its message in args
+    """A tool crashed or printed something we cannot understand."""
+
+    @override
+    def __str__(self) -> str:
+        """Show the message as a failure of the tool, not of the code."""
+        return f"tool failure: {super().__str__()}"