Merge pull request #26 from George-Ogden/broken-cache

Continue working when cache valued result is missing

Author: George-Ogden

mypy_pytest_plugin/fixture.py

@@ -38,29 +38,39 @@ class Fixture:
     arguments: Sequence[TestArgument]
     scope: FixtureScope
     type_variables: Sequence[TypeVarLikeType]
-    context: FuncDef
+    context: Context
 
     @classmethod
     def from_decorator(cls, decorator: Decorator, checker: TypeChecker) -> Fixture | None:
         return FixtureParser(checker).from_decorator(decorator)
 
     @classmethod
-    def from_type(cls, type: CallableType, *, scope: FixtureScope, file: str) -> Self:
+    def from_type(
+        cls,
+        type: CallableType,
+        *,
+        scope: FixtureScope,
+        file: str,
+        is_generator: bool,
+        fullname: str,
+    ) -> Self:
         func = type.definition
-        assert isinstance(func, FuncDef)
-        assert isinstance(func.type, CallableType)
-        arguments = TestArgument.from_fn_def(func, checker=None, source="fixture")
-        assert arguments is not None
+        assert isinstance(func, FuncDef | None)
+        if isinstance(func, FuncDef):
+            arguments = TestArgument.from_fn_def(func, checker=None, source="fixture")
+            assert arguments is not None
+            context: Context = func
+        else:
+            arguments = TestArgument.from_type(type)
+            context = Context()
         return cls(
-            fullname=Fullname.from_string(func.fullname),
+            fullname=Fullname.from_string(fullname),
             file=file,
-            return_type=FixtureParser.fixture_return_type(
-                func.type.ret_type, is_generator=func.is_generator
-            ),
+            return_type=FixtureParser.fixture_return_type(type.ret_type, is_generator=is_generator),
             arguments=arguments,
             scope=scope,
-            context=func,
-            type_variables=func.type.variables,
+            context=context,
+            type_variables=type.variables,
         )
 
     @classmethod

mypy_pytest_plugin/fixture_manager.py

@@ -8,7 +8,7 @@
 from _pytest.fixtures import FixtureManager as PytestFixtureManager
 from _pytest.main import Session
 from mypy.checker import TypeChecker
-from mypy.nodes import FuncDef, MypyFile
+from mypy.nodes import MypyFile
 from mypy.types import CallableType, Instance, LiteralType
 from pytest import FixtureDef  # noqa: PT013
 
@@ -121,12 +121,17 @@ def _module_lookup(self, module: MypyFile, request_name: str) -> Fixture | None:
             and isinstance(type_ := decorator.type, Instance)
             and type_.type.fullname == f"{TYPES_MODULE}.fixture_type.FixtureType"
         ):
-            [scope, signature] = type_.args
+            [scope, signature, is_generator, fullname] = type_.args
             assert isinstance(scope, LiteralType)
             assert isinstance(signature, CallableType)
-            assert isinstance(signature.definition, FuncDef)
+            assert isinstance(is_generator, LiteralType)
+            assert isinstance(fullname, LiteralType)
             return Fixture.from_type(
-                signature, scope=cast(FixtureScope, scope.value), file=module.path
+                signature,
+                scope=cast(FixtureScope, scope.value),
+                file=module.path,
+                is_generator=cast(bool, is_generator.value),
+                fullname=cast(str, fullname.value),
             )
         return None
 

mypy_pytest_plugin/fixture_test.py

@@ -1,8 +1,9 @@
 from mypy.nodes import Decorator
 from mypy.subtypes import is_same_type
+from mypy.types import CallableType
 import pytest
 
-from .fixture import Fixture, FixtureParser
+from .fixture import Fixture, FixtureParser, FixtureScope
 from .test_utils import check_error_messages, get_error_messages, parse
 
 
@@ -247,6 +248,55 @@ def fixture(x, y):
     )
 
 
+def _fixture_from_type_test_body(defs: str) -> None:
+    parse_result = parse(defs)
+    fixture_node = parse_result.defs["fixture"]
+    assert isinstance(fixture_node, Decorator)
+
+    checker = parse_result.checker
+    parse_result.accept_all()
+
+    fixture_type = fixture_node.func.type
+    assert isinstance(fixture_type, CallableType)
+    fixture_type.definition = None
+
+    fixture = Fixture.from_type(
+        fixture_type,
+        scope=FixtureScope.module,
+        file="",
+        is_generator=False,
+        fullname="test_module.fullname",
+    )
+    assert fixture is not None
+
+    messages = get_error_messages(checker)
+    assert not checker.errors.is_errors(), messages
+
+
+def test_fixture_from_types_no_args() -> None:
+    _fixture_from_type_test_body(
+        """
+        import pytest
+
+        @pytest.fixture
+        def fixture() -> None:
+            ...
+        """
+    )
+
+
+def test_fixture_from_type_some_args() -> None:
+    _fixture_from_type_test_body(
+        """
+        import pytest
+
+        @pytest.fixture
+        def fixture(x: int, y: bool) -> None:
+            ...
+        """
+    )
+
+
 def fixture_return_type_test_body(defs: str, is_generator: bool) -> None:
     parse_result = parse(defs)
     original_type = parse_result.types["original"]

mypy_pytest_plugin/plugin.py

@@ -150,6 +150,10 @@ def _fixture_type(cls, fixture: Fixture, *, decorator: Decorator, checker: TypeC
             [
                 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")),
             ],
         )
 

mypy_pytest_plugin/test_argument.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Literal
+from typing import Literal, Self
 
 from mypy.checker import TypeChecker
 from mypy.errorcodes import ErrorCode
@@ -15,7 +15,15 @@
     TypeInfo,
 )
 from mypy.subtypes import is_subtype
-from mypy.types import AnyType, CallableType, Instance, Type, TypeOfAny, TypeVarLikeType
+from mypy.types import (
+    AnyType,
+    CallableType,
+    FormalArgument,
+    Instance,
+    Type,
+    TypeOfAny,
+    TypeVarLikeType,
+)
 
 from .error_codes import (
     OPTIONAL_ARGUMENT,
@@ -39,6 +47,29 @@ def from_fn_def(
     ) -> Sequence[TestArgument] | None:
         return TestArgumentParser(checker).parse_fn_def(fn_def, source=source)
 
+    @classmethod
+    def from_type(cls, type: CallableType) -> Sequence[TestArgument]:
+        return [
+            argument
+            for formal_argument in type.formal_arguments()
+            if (
+                argument := TestArgument.from_formal_argument(
+                    formal_argument, type_variables=type.variables
+                )
+            )
+            is not None
+        ]
+
+    @classmethod
+    def from_formal_argument(
+        cls, argument: FormalArgument, type_variables: Sequence[TypeVarLikeType]
+    ) -> Self | None:
+        if argument.name is None or argument.name == "request":
+            return None
+        return cls(
+            name=argument.name, type_=argument.typ, type_variables=type_variables, context=Context()
+        )
+
 
 @dataclass(frozen=True, slots=True)
 class TestArgumentParser:

mypy_pytest_plugin_types/fixture_type.pyi

@@ -2,4 +2,4 @@ from collections.abc import Callable
 
 from _pytest.fixtures import FixtureFunctionDefinition
 
-class FixtureType[S, F: Callable](FixtureFunctionDefinition): ...
+class FixtureType[S: str, F: Callable, G: bool, N: str](FixtureFunctionDefinition): ...

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mypy-pytest-plugin"
 requires-python = ">=3.12,<3.15"
-version = "0.7.0"
+version = "0.7.1"
 dynamic = ["dependencies"]
 
 [tool.setuptools]