Merge pull request #59 from George-Ogden/usefixtures

Support `pytest.mark.usefixtures`

Author: George-Ogden

.mirror.lock

@@ -1,5 +1,5 @@
 # DANGER: EDIT AT YOUR OWN RISK. Track this file in version control so that others can sync files correctly.
-- commit: 26f0c34dacfaf7ad3d790b9b8a005daf242960b2
+- commit: 6b9433e75ab272c0e3cefb8ed56a4144c10986cf
   files:
   - .github/python-release.yaml
   - .github/python-test.yaml

.pre-commit-config.yaml

@@ -6,7 +6,7 @@ ci:
 
 repos:
   - repo: https://github.com/George-Ogden/mirror-rorrim/
-    rev: v0.4.4
+    rev: v0.4.5
     hooks:
       - id: mirror-check
         fail_fast: true

mypy_pytest_plugin/argmapper_test.py

@@ -15,9 +15,7 @@ def _named_arg_mapping_test_body(defs: str, expected_keys: list[str]) -> None:
 
     raw_arg_map = ArgMapper.named_arg_mapping(call, parse_result.checker)
 
-    def dump_arg_map(
-        arg_map: dict[str, Expression],
-    ) -> dict[str, tuple[type, dict[str, Any]]]:
+    def dump_arg_map(arg_map: dict[str, Expression]) -> dict[str, tuple[type, dict[str, Any]]]:
         return {key: (dump_expr(expr)) for key, expr in arg_map.items()}
 
     assert dump_arg_map(raw_arg_map) == dump_arg_map(

mypy_pytest_plugin/argnames_parser.py

@@ -1,32 +1,23 @@
 from collections import Counter
 from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import cast
+from typing import cast, override
 
-from mypy.checker import TypeChecker
-from mypy.nodes import (
-    Context,
-    Expression,
-    ListExpr,
-    StrExpr,
-    TupleExpr,
-)
+from mypy.nodes import Context, Expression, ListExpr, StrExpr, TupleExpr
 
-from .checker_wrapper import CheckerWrapper
 from .error_codes import (
     DUPLICATE_ARGNAME,
     INVALID_ARGNAME,
     REQUEST_KEYWORD,
     UNREADABLE_ARGNAME,
     UNREADABLE_ARGNAMES,
 )
+from .names_parser import NamesParser
 from .utils import cache_by_id
 
 
 @dataclass(frozen=True)
-class ArgnamesParser(CheckerWrapper):
-    checker: TypeChecker
-
+class ArgnamesParser(NamesParser):
     def __post_init__(self) -> None:
         object.__setattr__(self, "parse_names", cache_by_id(self.parse_names))
 
@@ -37,29 +28,17 @@ def parse_names(self, expression: Expression) -> str | list[str] | None:
             case ListExpr() | TupleExpr():
                 argnames = self.parse_names_sequence(expression)
             case _:
-                self.fail(
-                    "Unable to identify argnames. (Use a comma-separated string, list of strings or tuple of strings).",
-                    context=expression,
-                    code=UNREADABLE_ARGNAMES,
-                )
+                self._fail_unreadable_argnames(expression)
                 return None
         argnames = self._check_duplicate_argnames(argnames, expression)
         return argnames
 
-    def _check_valid_identifier(self, name: str, context: StrExpr) -> bool:
-        if not (valid_identifier := name.isidentifier()):
-            self.fail(
-                f"Invalid identifier {name!r}.",
-                context=context,
-                code=INVALID_ARGNAME,
-            )
-        elif not (valid_identifier := (name != "request")):
-            self.fail(
-                f"{name!r} is not allowed as an argname; it is a reserved word in Pytest.",
-                context=context,
-                code=REQUEST_KEYWORD,
-            )
-        return valid_identifier
+    def _fail_unreadable_argnames(self, context: Context) -> None:
+        self.fail(
+            "Unable to identify argnames. (Use a comma-separated string, list of strings or tuple of strings).",
+            context=context,
+            code=UNREADABLE_ARGNAMES,
+        )
 
     def parse_names_string(self, expression: StrExpr) -> str | list[str] | None:
         individual_names = [name.strip() for name in expression.value.split(",")]
@@ -71,21 +50,8 @@ def parse_names_string(self, expression: StrExpr) -> str | list[str] | None:
             return name
         return filtered_names
 
-    def _parse_name(self, expression: Expression) -> str | None:
-        if isinstance(expression, StrExpr):
-            name = expression.value
-            if self._check_valid_identifier(name, expression):
-                return name
-        else:
-            self.fail(
-                "Unable to read identifier. (Use a sequence of strings instead.)",
-                context=expression,
-                code=UNREADABLE_ARGNAME,
-            )
-        return None
-
     def parse_names_sequence(self, expr: TupleExpr | ListExpr) -> list[str] | None:
-        names = [self._parse_name(item) for item in expr.items]
+        names = [self.parse_name(item) for item in expr.items]
         if all([isinstance(name, str) for name in names]):
             return cast(list[str], names)
         return None
@@ -109,8 +75,30 @@ def _check_duplicate_argnames_sequence(
 
     def _warn_duplicate_argnames(self, duplicates: Iterable[str], context: Context) -> None:
         for argname in duplicates:
-            self.fail(
-                f"Duplicated argname {argname!r}.",
-                context=context,
-                code=DUPLICATE_ARGNAME,
-            )
+            self.fail(f"Duplicated argname {argname!r}.", context=context, code=DUPLICATE_ARGNAME)
+
+    @override
+    def _fail_invalid_identifier(self, name: str, context: Context) -> None:
+        self.fail(
+            f"Invalid identifier {name!r} for argname.", context=context, code=INVALID_ARGNAME
+        )
+
+    @override
+    def _fail_keyword_identifier(self, name: str, context: Context) -> None:
+        self.fail(f"Keyword {name!r} used as an argname.", context=context, code=INVALID_ARGNAME)
+
+    @override
+    def _fail_unreadable_identifier(self, context: Context) -> None:
+        self.fail(
+            "Unable to read argname. (Use string literals instead.)",
+            context=context,
+            code=UNREADABLE_ARGNAME,
+        )
+
+    @override
+    def _fail_request_identifier(self, name: str, context: Context) -> None:
+        self.fail(
+            f"{name!r} is not allowed as an argname; it is a reserved word in Pytest.",
+            context=context,
+            code=REQUEST_KEYWORD,
+        )

mypy_pytest_plugin/argnames_parser_test.py

@@ -1,17 +1,10 @@
 from collections.abc import Callable
 from typing import cast
 
-from mypy.nodes import (
-    Expression,
-)
+from mypy.nodes import Expression
 
 from .argnames_parser import ArgnamesParser
-from .test_utils import (
-    check_error_messages,
-    default_argnames_parser,
-    get_error_messages,
-    parse,
-)
+from .test_utils import check_error_messages, default_argnames_parser, get_error_messages, parse
 
 
 def _argnames_parser_parse_names_custom_test_body[T: Expression](
@@ -22,6 +15,7 @@ def _argnames_parser_parse_names_custom_test_body[T: Expression](
 ) -> None:
     source = f"names = {source}"
     parse_result = parse(source)
+    parse_result.accept_all()
     checker = parse_result.checker
 
     names_node = cast(T, parse_result.defs["names"])
@@ -94,10 +88,7 @@ def test_argnames_parser_parse_names_string_with_reserved_name() -> None:
 
 
 def _argnames_parser_parse_names_sequence_test_body(
-    source: str,
-    names: list[str] | None,
-    *,
-    errors: list[str] | None = None,
+    source: str, names: list[str] | None, *, errors: list[str] | None = None
 ) -> None:
     _argnames_parser_parse_names_custom_test_body(
         source, names, errors, ArgnamesParser.parse_names_sequence
@@ -149,6 +140,12 @@ def test_argnames_parser_parse_names_sequence_one_invalid() -> None:
     )
 
 
+def test_argnames_parser_parse_names_sequence_multiple_keywords() -> None:
+    _argnames_parser_parse_names_sequence_test_body(
+        "('if', 'it', 'is')", None, errors=["invalid-argname", "invalid-argname"]
+    )
+
+
 def test_argnames_parser_parse_names_sequence_one_undeterminable() -> None:
     _argnames_parser_parse_names_sequence_test_body(
         "('a', 'ab'.upper(), 'c')", None, errors=["unreadable-argname"]
@@ -162,10 +159,7 @@ def test_argnames_parser_parse_names_sequence_with_reserved_name() -> None:
 
 
 def _argnames_parser_parse_names_test_body(
-    source: str,
-    names: list[str] | str | None,
-    *,
-    errors: list[str] | None = None,
+    source: str, names: list[str] | str | None, *, errors: list[str] | None = None
 ) -> None:
     _argnames_parser_parse_names_custom_test_body(source, names, errors, ArgnamesParser.parse_names)
 

mypy_pytest_plugin/checker_wrapper.py

@@ -39,10 +39,7 @@ def named_type(self, fullname: Fullname) -> Instance:
         )
 
     def lookup_fullname_type(
-        self,
-        fullname: Fullname,
-        *,
-        context: Context | None = None,
+        self, fullname: Fullname, *, context: Context | None = None
     ) -> Type | None:
         result = self.lookup_fullname(
             fullname, context=context, predicate=lambda node: hasattr(node, "type")
@@ -77,10 +74,7 @@ def lookup_fullname(
         context: Context | None = None,
         predicate: None | Callable[[Any], bool] = None,
     ) -> tuple[MypyFile, Any] | None:
-        module_name, target = (
-            Fullname(()),
-            fullname,
-        )
+        module_name, target = (Fullname(()), fullname)
         while target:
             module_name = module_name.push_back(target.head)
             target = target.pop_front()

mypy_pytest_plugin/checker_wrapper_test.py

@@ -169,16 +169,4 @@ class x:
 
 
 def test_lookup_fullname_many_nested_modules_exists_as_module() -> None:
-    _lookup_fullname_type_test_body(
-        [
-            (
-                "test_module",
-                "",
-            ),
-            (
-                "test_module.x",
-                "",
-            ),
-        ],
-        "test_module.x",
-    )
+    _lookup_fullname_type_test_body([("test_module", ""), ("test_module.x", "")], "test_module.x")

mypy_pytest_plugin/conftest.py

@@ -1,12 +1,9 @@
-from .test_argument import TestArgumentParser
 from .test_body_ranges import TestBodyRanges
 from .test_case import TestCase
-from .test_info import TestArgument, TestInfo
+from .test_info import TestInfo
 from .test_signature import TestSignature
 
 TestSignature.__test__ = False  # type: ignore
 TestCase.__test__ = False  # type: ignore
 TestInfo.__test__ = False  # type: ignore
-TestArgument.__test__ = False  # type: ignore
-TestArgumentParser.__test__ = False  # type: ignore
 TestBodyRanges.__test__ = False  # type: ignore

mypy_pytest_plugin/error_codes.py

@@ -25,6 +25,19 @@
 )
 
 
+INVALID_USEFIXTURES: Final[ErrorCode] = ErrorCode(
+    "invalid-usefixtures-name",
+    "Invalid Python identifier used with `pytest.mark.usefixtures`.",
+    category="Pytest",
+)
+
+UNREADABLE_USEFIXTURES: Final[ErrorCode] = ErrorCode(
+    "unreadable-usefixtures-name",
+    "Unable to parse fixture name from `pytest.mark.usefixtures`.",
+    category="Pytest",
+)
+
+
 REPEATED_FIXTURE_ARGNAME: Final[ErrorCode] = ErrorCode(
     "repeated-fixture-argname",
     "Pytest parametrization contains an argument that is shadowed by a fixture.",
@@ -36,9 +49,7 @@
 )
 
 UNREADABLE_ARGNAMES_ARGVALUES: Final[ErrorCode] = ErrorCode(
-    "unreadable-argnames-argvalues",
-    "Unable to read argnames or argvalues.",
-    category="Pytest",
+    "unreadable-argnames-argvalues", "Unable to read argnames or argvalues.", category="Pytest"
 )
 
 
@@ -75,15 +86,11 @@
 )
 
 DUPLICATE_FIXTURE: Final[ErrorCode] = ErrorCode(
-    "duplicate-fixture",
-    "Only one use of `pytest.fixture` is allowed per test.",
-    category="Pytest",
+    "duplicate-fixture", "Only one use of `pytest.fixture` is allowed per test.", category="Pytest"
 )
 
 MARKED_FIXTURE: Final[ErrorCode] = ErrorCode(
-    "marked-fixture",
-    "Do not use `pytest.mark` with `pytest.fixture`.",
-    category="Pytest",
+    "marked-fixture", "Do not use `pytest.mark` with `pytest.fixture`.", category="Pytest"
 )
 INVALID_FIXTURE_AUTOUSE: Final[ErrorCode] = ErrorCode(
     "invalid-fixture-autouse",
@@ -117,9 +124,7 @@
 )
 
 REQUEST_KEYWORD: Final[ErrorCode] = ErrorCode(
-    "request-keyword",
-    """"request" is a reserved word in Pytest.""",
-    category="Pytest",
+    "request-keyword", """"request" is a reserved word in Pytest.""", category="Pytest"
 )
 
 UNKNOWN_MARK: Final[ErrorCode] = ErrorCode(
@@ -135,9 +140,7 @@
 )
 
 TEST_RETURN_TYPE: Final[ErrorCode] = ErrorCode(
-    "test-return-type",
-    "Tests must return `None`.",
-    category="robust-testing",
+    "test-return-type", "Tests must return `None`.", category="robust-testing"
 )
 
 ITERABLE_SEQUENCE: Final[ErrorCode] = ErrorCode(

mypy_pytest_plugin/excluded_test_checker.py

@@ -3,13 +3,7 @@
 import itertools
 
 from mypy.checker import TypeChecker
-from mypy.nodes import (
-    AssignmentStmt,
-    Expression,
-    MemberExpr,
-    NameExpr,
-    Statement,
-)
+from mypy.nodes import AssignmentStmt, Expression, MemberExpr, NameExpr, Statement
 from mypy.subtypes import is_same_type
 from mypy.types import LiteralType
 
@@ -35,7 +29,7 @@ def ignored_test_names(self, defs: Sequence[Statement]) -> set[str]:
 
     def _ignored_test_names_from_statements(self, statements: Sequence[Statement]) -> set[str]:
         return self._ignored_test_names_from_assignments(
-            [statement for statement in statements if isinstance(statement, AssignmentStmt)],
+            [statement for statement in statements if isinstance(statement, AssignmentStmt)]
         )
 
     def _ignored_test_names_from_assignments(