Merge pull request #46 from George-Ogden/autouse-fixtures

Autouse Fixtures

Author: George-Ogden

README.md

@@ -56,6 +56,7 @@ See the [Mypy docs](https://mypy.readthedocs.io/en/stable/extending_mypy.html#co
 The Mypy plugin system is fairly limited, so this can only check marked functions.
 If you're using parametrized testing, that's fine as you `pytest.mark.parametrize`.
 If not, [add a `typed` mark](https://docs.pytest.org/en/stable/how-to/mark.html#registering-marks) then mark any remaining tests you want to check.
+The order of the error messages is unclear, but this isn't an issue if you're using a plugin.
 
 ```python
 import random

mypy_pytest_plugin/argmapper.py

@@ -74,3 +74,13 @@ def _named_arg_overloaded_mapping(
     @classmethod
     def _merge_mappings(cls, this: ArgMap, that: ArgMap) -> ArgMap:
         return {key: expr for key, expr in this.items() if that.get(key, None) is expr}
+
+    @classmethod
+    def named_arg(cls, call: CallExpr, name: str) -> Expression | None:
+        expressions = [
+            arg for arg_name, arg in zip(call.arg_names, call.args, strict=True) if arg_name == name
+        ]
+        match expressions:
+            case [expression]:
+                return expression
+        return None

mypy_pytest_plugin/argnames_parser.py

@@ -20,12 +20,16 @@
     UNREADABLE_ARGNAME,
     UNREADABLE_ARGNAMES,
 )
+from .utils import cache_by_id
 
 
 @dataclass(frozen=True)
 class ArgnamesParser(CheckerWrapper):
     checker: TypeChecker
 
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "parse_names", cache_by_id(self.parse_names))
+
     def parse_names(self, expression: Expression) -> str | list[str] | None:
         match expression:
             case StrExpr():

mypy_pytest_plugin/checker_wrapper.py

@@ -17,8 +17,8 @@ class CheckerWrapper(abc.ABC):
     @abc.abstractmethod
     def __init__(self) -> None: ...
 
-    def fail(self, msg: str, *, context: Context, code: ErrorCode) -> None:
-        self.checker.fail(msg, context=context, code=code)
+    def fail(self, msg: str, *, context: Context, code: ErrorCode, file: None | str = None) -> None:
+        self.checker.msg.fail(msg, context=context, code=code, file=file)
 
     def note(self, msg: str, *, context: Context, code: ErrorCode | None) -> None:
         self.checker.note(msg, context=context, code=code)

mypy_pytest_plugin/decorator_wrapper.py

@@ -1,5 +1,6 @@
 from collections.abc import Sequence
 from dataclasses import dataclass
+import functools
 from typing import Self, TypeGuard
 
 from mypy.checker import TypeChecker
@@ -38,7 +39,7 @@ def _is_parametrized_decorator_expr(
             )
         return False
 
-    @property
+    @functools.cached_property
     def arg_names_and_arg_values(self) -> tuple[Expression, Expression] | None:
         name_mapping = ArgMapper.named_arg_mapping(self.call, self.checker)
         try:
@@ -50,3 +51,10 @@ def arg_names_and_arg_values(self) -> tuple[Expression, Expression] | None:
                 code=UNREADABLE_ARGNAMES_ARGVALUES,
             )
             return None
+
+    @property
+    def arg_names(self) -> Expression | None:
+        if self.arg_names_and_arg_values is None:
+            return None
+        arg_names, _arg_values = self.arg_names_and_arg_values
+        return arg_names

mypy_pytest_plugin/defer.py

@@ -1 +1,14 @@
-class DeferralError(Exception): ...
+from dataclasses import dataclass
+import enum
+
+
+class DeferralReason(enum.IntEnum):
+    # cannot compute value until another node has been processed
+    REQUIRED_WAIT = enum.auto()
+    # requires other nodes in the file to be processed to ensure correctness
+    SPECULATIVE_WAIT = enum.auto()
+
+
+@dataclass(eq=False)
+class DeferralError(Exception):
+    cause: DeferralReason

mypy_pytest_plugin/error_codes.py

@@ -24,10 +24,6 @@
     "duplicate-argname", "Pytest parametrize contains duplicate argnames.", category="Pytest"
 )
 
-REPEATED_ARGNAME: Final[ErrorCode] = ErrorCode(
-    "repeated-argname", "Pytest parametrizations contain repeated argname.", category="Pytest"
-)
-
 
 REPEATED_FIXTURE_ARGNAME: Final[ErrorCode] = ErrorCode(
     "repeated-fixture-argname",
@@ -89,6 +85,12 @@
     "Do not use `pytest.mark` with `pytest.fixture`.",
     category="Pytest",
 )
+INVALID_FIXTURE_AUTOUSE: Final[ErrorCode] = ErrorCode(
+    "invalid-fixture-autouse",
+    "Use literal value when setting autouse of a Pytest fixture.",
+    category="Pytest",
+)
+
 
 INVALID_FIXTURE_SCOPE: Final[ErrorCode] = ErrorCode(
     "invalid-fixture-scope",

mypy_pytest_plugin/excluded_test_checker.py

@@ -12,7 +12,7 @@
 from mypy.subtypes import is_same_type
 from mypy.types import LiteralType
 
-from .defer import DeferralError
+from .defer import DeferralError, DeferralReason
 
 
 class ExcludedTestChecker:
@@ -46,7 +46,7 @@ def _identify_non_test_assignment_names(
     ) -> Iterable[str]:
         rvalue_type = checker.lookup_type_or_none(assignment.rvalue)
         if rvalue_type is None:
-            raise DeferralError()
+            raise DeferralError(DeferralReason.REQUIRED_WAIT)
         if is_same_type(rvalue_type, LiteralType(False, checker.named_type("builtins.bool"))):
             for lvalue in assignment.lvalues:
                 assignment_target = cls._test_assignment_target(lvalue)

mypy_pytest_plugin/fixture.py

@@ -6,7 +6,16 @@
 from typing import ClassVar, Final, Self, cast
 
 from mypy.checker import TypeChecker
-from mypy.nodes import CallExpr, Context, Decorator, Expression, FuncDef
+from mypy.nodes import (
+    GDEF,
+    CallExpr,
+    Context,
+    Decorator,
+    Expression,
+    FuncDef,
+    SymbolTableNode,
+    Var,
+)
 from mypy.subtypes import is_subtype
 from mypy.types import (
     AnyType,
@@ -17,14 +26,23 @@
     Type,
     TypeOfAny,
     TypeVarLikeType,
+    UnionType,
 )
 
+from .argmapper import ArgMapper
 from .checker_wrapper import CheckerWrapper
-from .defer import DeferralError
-from .error_codes import DUPLICATE_FIXTURE, INVALID_FIXTURE_SCOPE, MARKED_FIXTURE, REQUEST_KEYWORD
+from .defer import DeferralError, DeferralReason
+from .error_codes import (
+    DUPLICATE_FIXTURE,
+    INVALID_FIXTURE_AUTOUSE,
+    INVALID_FIXTURE_SCOPE,
+    MARKED_FIXTURE,
+    REQUEST_KEYWORD,
+)
 from .fullname import Fullname
 from .test_argument import TestArgument
 from .types_module import TYPES_MODULE
+from .utils import strict_cast, strict_not_none
 
 FixtureScope = enum.IntEnum(
     "FixtureScope", ["function", "class", "module", "package", "session", "unknown"]
@@ -34,11 +52,13 @@
 
 @dataclass(frozen=True, slots=True, kw_only=True)
 class Fixture:
+    AUTOUSE_NAME: ClassVar[str] = "__autouse__"
     fullname: Fullname
     file: str
     return_type: Type
     arguments: Sequence[TestArgument]
     scope: FixtureScope
+    autouse: bool
     type_variables: Sequence[TypeVarLikeType]
     context: Context
 
@@ -54,13 +74,15 @@ def from_type(
         scope: FixtureScope,
         file: str,
         is_generator: bool,
+        autouse: bool,
         fullname: str,
     ) -> Self:
         func = type.definition
         assert isinstance(func, FuncDef | None)
         if isinstance(func, FuncDef):
-            arguments = TestArgument.from_fn_def(func, checker=None, source="fixture")
-            assert arguments is not None
+            arguments = strict_not_none(
+                TestArgument.from_fn_def(func, checker=None, source="fixture")
+            )
             context: Context = func
         else:
             arguments = TestArgument.from_type(type)
@@ -71,6 +93,7 @@ def from_type(
             return_type=FixtureParser.fixture_return_type(type.ret_type, is_generator=is_generator),
             arguments=arguments,
             scope=scope,
+            autouse=autouse,
             context=context,
             type_variables=type.variables,
         )
@@ -97,6 +120,8 @@ def module_name(self) -> Fullname:
 
     def as_fixture_type(self, *, decorator: Decorator, checker: TypeChecker) -> Type:
         assert decorator.func.type is not None
+        if self.autouse:
+            self.save_to_autouse(checker)
         return checker.named_generic_type(
             f"{TYPES_MODULE}.FixtureType",
             [
@@ -106,9 +131,37 @@ def as_fixture_type(self, *, decorator: Decorator, checker: TypeChecker) -> Type
                     decorator.func.is_generator, fallback=checker.named_type("builtins.object")
                 ),
                 LiteralType(decorator.fullname, fallback=checker.named_type("builtins.object")),
+                LiteralType(self.autouse, fallback=checker.named_type("builtins.object")),
             ],
         )
 
+    def save_to_autouse(self, checker: TypeChecker) -> None:
+        if str(self.module_name) in checker.modules:
+            node = checker.modules[str(self.module_name)].names.setdefault(
+                self.AUTOUSE_NAME,
+                SymbolTableNode(
+                    GDEF,
+                    Var(
+                        self.AUTOUSE_NAME,
+                        UnionType([]),
+                    ),
+                    implicit=True,
+                    module_hidden=True,
+                    plugin_generated=True,
+                ),
+            )
+            literal_type = LiteralType(
+                self.name,
+                fallback=checker.named_type("builtins.str"),
+            )
+            assert isinstance(node.node, Var)
+            assert isinstance(node.type, UnionType)
+            if not any(
+                strict_cast(LiteralType, item).value == literal_type.value
+                for item in node.type.items
+            ):
+                node.type.items.append(literal_type)
+
 
 @dataclass(frozen=True, slots=True)
 class FixtureParser(CheckerWrapper):
@@ -134,6 +187,7 @@ def from_decorator(self, decorator: Decorator) -> Fixture | None:
             ),
             arguments=arguments,
             scope=self._fixture_scope_from_decorator(fixture_decorator),
+            autouse=self._fixture_autouse_from_decorator(fixture_decorator),
             context=decorator.func,
             type_variables=type_.variables,
         )
@@ -210,7 +264,7 @@ def _warn_extra_decorator(self, decorator: Expression) -> None:
     def _is_fixture_decorator(self, decorator: Expression) -> bool:
         decorator_type = self.checker.lookup_type_or_none(decorator)
         if decorator_type is None:
-            raise DeferralError()
+            raise DeferralError(DeferralReason.REQUIRED_WAIT)
         return self._is_fixture_type(decorator_type) or (
             isinstance(decorator_type, Overloaded)
             and any(self._is_fixture_type(overload.ret_type) for overload in decorator_type.items)
@@ -229,12 +283,9 @@ def _fixture_scope_from_decorator(self, decorator: Expression) -> FixtureScope:
         return DEFAULT_SCOPE
 
     def _fixture_scope_from_call(self, call: CallExpr) -> FixtureScope:
-        scope_expressions = [
-            arg for name, arg in zip(call.arg_names, call.args, strict=True) if name == "scope"
-        ]
-        if not scope_expressions:
+        scope_expression = ArgMapper.named_arg(call, "scope")
+        if scope_expression is None:
             return DEFAULT_SCOPE
-        [scope_expression] = scope_expressions
         return self._fixture_scope_from_type(
             self.checker.lookup_type(scope_expression), context=scope_expression
         )
@@ -250,6 +301,39 @@ def _fixture_scope_from_type(self, type_: Type, context: Context) -> FixtureScop
 
         return FixtureScope.unknown
 
+    def _fixture_autouse_from_decorator(self, decorator: Expression) -> bool:
+        if isinstance(decorator, CallExpr):
+            return self._fixture_autouse_from_call(decorator)
+        return False
+
+    def _fixture_autouse_from_call(self, call: CallExpr) -> bool:
+        autouse_expression = ArgMapper.named_arg(call, "autouse")
+        if autouse_expression is None:
+            return False
+        return self._fixture_autouse_from_type(
+            self.checker.lookup_type(autouse_expression), context=autouse_expression
+        )
+
+    def _fixture_autouse_from_type(self, type_: Type, context: Context) -> bool:
+        for value in [True, False]:
+            if is_subtype(
+                type_, LiteralType(value, fallback=self.checker.named_type("builtins.bool"))
+            ):
+                return value
+        if isinstance(type_, LiteralType) and isinstance(type_.value, bool):
+            return type_.value
+        self.fail(
+            """Invalid type for "autouse". This fixture will be not be applied automatically when type checking.""",
+            context=context,
+            code=INVALID_FIXTURE_AUTOUSE,
+        )
+        self.note(
+            "Use `autouse=True` directly.",
+            context=context,
+            code=INVALID_FIXTURE_AUTOUSE,
+        )
+        return False
+
     def is_request_name(self, decorator: Decorator) -> bool:
         if is_request_name := decorator.name == "request":
             self.fail(