Merge pull request #30 from George-Ogden/typed-marks

Typed Marks

Author: George-Ogden

.github/workflows/test.yaml

@@ -25,4 +25,4 @@ jobs:
     with:
       python-versions: "['3.13']"
       timeout-minutes: 10
-      pytest-flags: -vv tests
+      pytest-flags: -vv tests -n auto

mypy_pytest_plugin/error_codes.py

@@ -120,6 +120,12 @@
     category="Pytest",
 )
 
+UNKNOWN_MARK: Final[ErrorCode] = ErrorCode(
+    "unknown-mark",
+    "Mark name is not recognized as a pre-defined or user-defined mark.",
+    category="Pytest",
+)
+
 ITERABLE_SEQUENCE: Final[ErrorCode] = ErrorCode(
     "iterable-sequence",
     """"Sequence" passed into a function expecting "Iterable" in a test.""",

mypy_pytest_plugin/fixture.py

@@ -23,6 +23,7 @@
 from .error_codes import DUPLICATE_FIXTURE, INVALID_FIXTURE_SCOPE, MARKED_FIXTURE, REQUEST_KEYWORD
 from .fullname import Fullname
 from .test_argument import TestArgument
+from .types_module import TYPES_MODULE
 
 FixtureScope = enum.IntEnum(
     "FixtureScope", ["function", "class", "module", "package", "session", "unknown"]
@@ -93,6 +94,20 @@ def name(self) -> str:
     def module_name(self) -> Fullname:
         return self.fullname.module_name
 
+    def as_fixture_type(self, *, decorator: Decorator, checker: TypeChecker) -> Type:
+        assert decorator.func.type is not None
+        return checker.named_generic_type(
+            f"{TYPES_MODULE}.FixtureType",
+            [
+                LiteralType(self.scope, fallback=checker.named_type("builtins.object")),
+                decorator.func.type,
+                LiteralType(
+                    decorator.func.is_generator, fallback=checker.named_type("builtins.object")
+                ),
+                LiteralType(decorator.fullname, fallback=checker.named_type("builtins.object")),
+            ],
+        )
+
 
 @dataclass(frozen=True, slots=True)
 class FixtureParser:

mypy_pytest_plugin/mark_checker.py

@@ -0,0 +1,52 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+import functools
+import itertools
+
+from mypy.checker import TypeChecker
+from mypy.nodes import MemberExpr
+from mypy.subtypes import is_same_type
+
+from .error_codes import UNKNOWN_MARK
+from .pytest_config_manager import PytestConfigManager
+
+
+@dataclass(frozen=True)
+class MarkChecker:
+    checker: TypeChecker
+
+    def check_attribute(self, expr: MemberExpr) -> None:
+        if is_same_type(
+            self.checker.lookup_type(expr.expr), self.checker.named_type("pytest.MarkGenerator")
+        ) and not self.is_valid_mark(expr.name):
+            error_msg = f"Invalid mark name {expr.name!r}."
+            note_prefix = f"Expected a predefined mark (one of {self.predefined_names!r}) or "
+            if self.user_defined_names:
+                note_suffix = f"a user defined mark (one of {self.user_defined_names!r})."
+            else:
+                note_suffix = "see https://docs.pytest.org/en/stable/how-to/mark.html for how to register marks."
+            self.checker.fail(error_msg, context=expr, code=UNKNOWN_MARK)
+            self.checker.note(note_prefix + note_suffix, context=expr, code=UNKNOWN_MARK)
+
+    def is_valid_mark(self, name: str) -> bool:
+        return not name.startswith("_") and (name in self._mark_names_index)
+
+    @functools.cached_property
+    def _mark_names_index(self) -> set[str]:
+        return set(itertools.chain(self.predefined_names, self.user_defined_names))
+
+    @functools.cached_property
+    def predefined_names(self) -> Sequence[str]:
+        return [
+            name
+            for name in self.checker.named_type("pytest.MarkGenerator").type.names
+            if not name.startswith("_")
+        ]
+
+    @functools.cached_property
+    def user_defined_names(self) -> list[str]:
+        return [
+            name
+            for line in PytestConfigManager.markers()
+            if (name := line.split(":")[0].split("(")[0].strip()) and not name.startswith("_")
+        ]

mypy_pytest_plugin/mark_checker_test.py

@@ -0,0 +1,36 @@
+from .mark_checker import MarkChecker
+from .test_utils import parse
+
+
+def _mark_name_test_body(name: str, valid: bool) -> None:
+    pytest_source_mock = """
+    from typing import Any
+
+    class MarkGenerator:
+        skip: Any
+        parametrize: Any
+        def __getattr__(self, name: str) -> Any:
+            raise NotImplementedError()
+        def _config(self) -> None: ...
+    """
+    parse_result = parse(pytest_source_mock, module_name="pytest")
+    parse_result.accept_all()
+
+    mark_checker = MarkChecker(parse_result.checker)
+    assert mark_checker.is_valid_mark(name) == valid
+
+
+def test_mark_name_starts_with_underscore() -> None:
+    _mark_name_test_body("_parametrize", False)
+
+
+def test_mark_name_valid() -> None:
+    _mark_name_test_body("parametrize", True)
+
+
+def test_mark_name_not_predefined() -> None:
+    _mark_name_test_body("invalid", False)
+
+
+def test_mark_name_user_defined() -> None:
+    _mark_name_test_body("used_for_testing", True)

mypy_pytest_plugin/plugin.py

@@ -3,25 +3,18 @@
 from typing import cast
 
 from mypy.checker import TypeChecker
-from mypy.nodes import CallExpr, Decorator, Expression, MypyFile
+from mypy.nodes import CallExpr, Decorator, Expression, MemberExpr, MypyFile
 from mypy.options import Options
-from mypy.plugin import (
-    FunctionContext,
-    MethodContext,
-    Plugin,
-)
-from mypy.types import (
-    CallableType,
-    LiteralType,
-    Type,
-)
+from mypy.plugin import AttributeContext, FunctionContext, MethodContext, Plugin
+from mypy.types import CallableType, Type
 
 from .defer import DeferralError
 from .excluded_test_checker import ExcludedTestChecker
 from .fixture import Fixture
 from .fixture_manager import FixtureManager
 from .fullname import Fullname
 from .iterable_sequence_checker import IterableSequenceChecker
+from .mark_checker import MarkChecker
 from .mock_call_checker import FunctionMockCallChecker, MethodMockCallChecker
 from .test_body_ranges import TestBodyRanges
 from .test_info import TestInfo
@@ -65,6 +58,23 @@ def module_to_dep(cls, module: str | Fullname) -> tuple[int, str, int]:
             module = str(module)
         return (10, module, -1)
 
+    def get_attribute_hook(self, fullname: str) -> Callable[[AttributeContext], Type] | None:
+        if fullname.startswith("_pytest.mark.structures.MarkGenerator"):
+            return self.check_mark
+        return None
+
+    @classmethod
+    def check_mark(cls, ctx: AttributeContext) -> Type:
+        if ctx.api.path == "test_samples/mark_test.py":
+            ...
+        if (
+            not ctx.is_lvalue
+            and isinstance(checker := ctx.api, TypeChecker)
+            and isinstance(expr := ctx.context, MemberExpr)
+        ):
+            MarkChecker(checker).check_attribute(expr)
+        return ctx.default_attr_type
+
     def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         if fullname.startswith("unittest.mock"):
             return functools.partial(FunctionMockCallChecker.check_mock_calls, fullname=fullname)
@@ -126,7 +136,7 @@ def _check_pytest_structure(cls, ctx: MethodContext | FunctionContext) -> Type:
             cls._update_return_type(ctx.default_return_type, ctx.api)
             if not Fixture.is_fixture_and_mark(ctx.context, checker=ctx.api):
                 if fixture := Fixture.from_decorator(ctx.context, checker=ctx.api):
-                    return cls._fixture_type(fixture, decorator=ctx.context, checker=ctx.api)
+                    return fixture.as_fixture_type(decorator=ctx.context, checker=ctx.api)
                 ignored_testnames = ExcludedTestChecker.ignored_test_names(
                     ctx.api.tree.defs, ctx.api
                 )
@@ -136,27 +146,6 @@ def _check_pytest_structure(cls, ctx: MethodContext | FunctionContext) -> Type:
                     cls._check_decorators(ctx.context, ctx.api)
         return ctx.default_return_type
 
-    @classmethod
-    def _check_decorators(cls, node: Decorator, checker: TypeChecker) -> None:
-        test_info = TestInfo.from_fn_def(node, checker=checker)
-        if test_info is not None:
-            test_info.check()
-
-    @classmethod
-    def _fixture_type(cls, fixture: Fixture, *, decorator: Decorator, checker: TypeChecker) -> Type:
-        assert decorator.func.type is not None
-        return checker.named_generic_type(
-            f"{TYPES_MODULE}.FixtureType",
-            [
-                LiteralType(fixture.scope, fallback=checker.named_type("builtins.object")),
-                decorator.func.type,
-                LiteralType(
-                    decorator.func.is_generator, fallback=checker.named_type("builtins.object")
-                ),
-                LiteralType(decorator.fullname, fallback=checker.named_type("builtins.object")),
-            ],
-        )
-
     @classmethod
     def _update_return_type(cls, return_type: Type, checker: TypeChecker) -> None:
         if (
@@ -165,6 +154,12 @@ def _update_return_type(cls, return_type: Type, checker: TypeChecker) -> None:
         ):
             return_type.fallback = checker.named_type(f"{TYPES_MODULE}.Testable")
 
+    @classmethod
+    def _check_decorators(cls, node: Decorator, checker: TypeChecker) -> None:
+        test_info = TestInfo.from_fn_def(node, checker=checker)
+        if test_info is not None:
+            test_info.check()
+
 
 def plugin(version: str) -> type[PytestPlugin]:
     return PytestPlugin

mypy_pytest_plugin/pytest_config_manager.py

@@ -0,0 +1,32 @@
+import functools
+
+import _pytest.config
+from pytest import Config, Session  # noqa: PT013
+
+
+class PytestConfigManager:
+    @classmethod
+    @functools.cache
+    def session(cls) -> Session:
+        config = _pytest.config.get_config()
+        config.parse(["-s", "--noconftest"])
+        return Session.from_config(config)
+
+    @classmethod
+    def config(cls) -> Config:
+        return cls.session().config
+
+    @classmethod
+    @functools.cache
+    def file_patterns(cls) -> list[str]:
+        return cls.config().getini("python_files")
+
+    @classmethod
+    @functools.cache
+    def fn_patterns(cls) -> list[str]:
+        return cls.config().getini("python_functions")
+
+    @classmethod
+    @functools.cache
+    def markers(cls) -> list[str]:
+        return cls.config().getini("markers")

mypy_pytest_plugin/test_name_checker.py

@@ -3,10 +3,10 @@
 import functools
 from pathlib import Path
 
-import _pytest.config
-from _pytest.main import Session
 from _pytest.pathlib import fnmatch_ex
 
+from .pytest_config_manager import PytestConfigManager
+
 
 class TestNameChecker:
     @classmethod
@@ -25,23 +25,6 @@ def _path_from_sections(cls, sections: MutableSequence[str]) -> Path:
             sections[-1] += ".py"
         return Path(*sections)
 
-    @classmethod
-    @functools.cache
-    def _session(cls) -> Session:
-        config = _pytest.config.get_config()
-        config.parse(["-s", "--noconftest"])
-        return Session.from_config(config)
-
-    @classmethod
-    @functools.cache
-    def _file_patterns(cls) -> list[str]:
-        return cls._session().config.getini("python_files")
-
-    @classmethod
-    @functools.cache
-    def _fn_patterns(cls) -> list[str]:
-        return cls._session().config.getini("python_functions")
-
     @classmethod
     @functools.cache
     def is_test_file_name(cls, name: str) -> bool:
@@ -51,11 +34,11 @@ def is_test_file_name(cls, name: str) -> bool:
     @classmethod
     @functools.cache
     def is_test_path(cls, path: Path) -> bool:
-        return any(fnmatch_ex(pattern, path) for pattern in cls._file_patterns())
+        return any(fnmatch_ex(pattern, path) for pattern in PytestConfigManager.file_patterns())
 
     @classmethod
     def is_test_fn_name(cls, fn_name: str) -> bool:
         return any(
             fn_name.startswith(pattern) or fnmatch.fnmatch(pattern, fn_name)
-            for pattern in cls._fn_patterns()
+            for pattern in PytestConfigManager.fn_patterns()
         )

mypy_pytest_plugin/test_utils.py

@@ -101,7 +101,8 @@ def parse_multiple(modules: Sequence[tuple[str, str]], *, header: bool = False)
     ]
 
     options = mypy.options.Options()
-    options.incremental = False
+    options.show_traceback = True
+    options.incremental = True
     options.show_traceback = True
     options.preserve_asts = True
     options.disallow_untyped_defs = False
@@ -159,8 +160,7 @@ def parse_multiple(modules: Sequence[tuple[str, str]], *, header: bool = False)
 
 
 @functools.lru_cache(maxsize=1)
-def parse(code: str, *, header: bool = True) -> ParseResult:
-    module_name = "test_module"
+def parse(code: str, *, header: bool = True, module_name: str = "test_module") -> ParseResult:
     parse_result = parse_multiple([(module_name, code)], header=header)
     return parse_result.single(module_name)
 

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mypy-pytest-plugin"
 requires-python = ">=3.12,<3.15"
-version = "0.7.2"
+version = "0.8.0"
 dynamic = ["dependencies"]
 
 [tool.setuptools]
@@ -54,3 +54,4 @@ python_files = "*_test.py"
 addopts = '--capture=sys --timeout 60 --timeout-method=thread'
 norecursedirs = ["test_samples"]
 pythonpath = ["."]
+markers = ["used_for_testing: used to verify config in mark attribute tests"]