Merge pull request #35 from George-Ogden/unknown-mock

Add Error When Mocked Location is Unknown

Author: George-Ogden

README.md

@@ -14,6 +14,7 @@ A Mypy plugin for type checking Pytest code.
   - [x] All the fixture arguments are included
   - [x] You don't have conflicting fixtures
 - Checks your mocks
+  - [x] You're mocking something that exists
   - [x] Your mock has the correct type (or close enough)
 - Checks your marks
   - [x] You're using a pre-defined mark
@@ -44,7 +45,7 @@ plugins = ["mypy_pytest_plugin.plugin"]
 
 `mypy.ini`:
 
-```toml
+```ini
 plugins = mypy_pytest_plugin.plugin
 ```
 

mypy_pytest_plugin/object_patch_call_checker.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from mypy.checker import TypeChecker
-from mypy.nodes import CallExpr, Expression, MemberExpr
+from mypy.nodes import CallExpr, Context, Expression, MemberExpr
 from mypy.types import AnyType, Type
 
 from .argmapper import ArgMapper
@@ -17,18 +17,24 @@ def add_patch_generics(self, call: CallExpr) -> Type | None:
             (target_arg := self._target_arg(call)) is not None
             and (attribute_arg := self._attribute_arg(call)) is not None
             and (attribute_value := self._string_value(attribute_arg)) is not None
-            and (original_type := self._attribute_type(target_arg, attribute_value)) is not None
+            and (
+                original_type := self._attribute_type(
+                    target_arg, attribute_value, context=attribute_arg
+                )
+            )
+            is not None
         ):
             return self._specialized_patcher_type(original_type, attribute="object")
         return None
 
     def _attribute_arg(self, call: CallExpr) -> Expression | None:
         return ArgMapper.named_arg_mapping(call, self.checker).get("attribute")
 
-    def _attribute_type(self, base: Expression, attribute: str) -> Type | None:
-        type_ = self.checker.expr_checker.analyze_ordinary_member_access(
-            MemberExpr(base, name=attribute), is_lvalue=False
-        )
+    def _attribute_type(self, base: Expression, attribute: str, *, context: Context) -> Type | None:
+        member = MemberExpr(base, name=attribute)
+        member.line = context.line
+        member.column = context.column
+        type_ = self.checker.expr_checker.analyze_ordinary_member_access(member, is_lvalue=False)
         if isinstance(type_, AnyType) and type_.is_from_error:
             return None
         return type_

mypy_pytest_plugin/object_patch_call_checker_test.py

@@ -2,7 +2,7 @@
 from mypy.subtypes import is_same_type
 
 from .object_patch_call_checker import ObjectPatchCallChecker
-from .test_utils import dump_expr, parse
+from .test_utils import check_error_messages, dump_expr, get_error_messages, parse
 
 
 def _attribute_arg_test_body(defs: str) -> None:
@@ -65,14 +65,17 @@ def foo[T](target: Any, attribute: str, test: T, *, extra_arg: int = 0) -> int:
     )
 
 
-def _attribute_type_test_body(defs: str, attribute: str) -> None:
+def _attribute_type_test_body(
+    defs: str, attribute: str, *, errors: None | list[str] = None
+) -> None:
     parse_result = parse(defs)
-    patch_call_checker = ObjectPatchCallChecker(parse_result.checker)
+    checker = parse_result.checker
+    patch_call_checker = ObjectPatchCallChecker(checker)
 
     base = parse_result.defs["base"]
     assert isinstance(base, Expression)
 
-    attribute_type = patch_call_checker._attribute_type(base, attribute)
+    attribute_type = patch_call_checker._attribute_type(base, attribute, context=base)
 
     expected = parse_result.types.get("expected")
     if expected is None:
@@ -81,6 +84,9 @@ def _attribute_type_test_body(defs: str, attribute: str) -> None:
         assert attribute_type is not None
         assert is_same_type(attribute_type, expected)
 
+    error_messages = get_error_messages(checker)
+    check_error_messages(error_messages, errors=errors)
+
 
 def test_attribute_type_simple_class() -> None:
     _attribute_type_test_body(
@@ -116,6 +122,7 @@ def test_attribute_type_invalid_base() -> None:
         base = None
         """,
         "attribute",
+        errors=["attr-defined"],
     )
 
 
@@ -128,6 +135,7 @@ class Base:
         base = Base()
         """,
         "not_an_attribute",
+        errors=["attr-defined"],
     )
 
 

mypy_pytest_plugin/patch_call_checker.py

@@ -2,13 +2,9 @@
 from typing import Any
 
 from mypy.checker import TypeChecker
+from mypy.errorcodes import NAME_DEFINED
 from mypy.expandtype import expand_type_by_instance
-from mypy.nodes import (
-    CallExpr,
-    Expression,
-    MypyFile,
-    StrExpr,
-)
+from mypy.nodes import CallExpr, Context, Expression, MypyFile, StrExpr
 from mypy.types import (
     CallableType,
     Instance,
@@ -32,7 +28,7 @@ def add_patch_generics(self, call: CallExpr) -> Type | None:
         if (
             (target_arg := self._target_arg(call)) is not None
             and (arg_value := self._string_value(target_arg)) is not None
-            and (original_type := self._lookup_fullname_type(arg_value))
+            and (original_type := self._lookup_fullname_type(arg_value, context=target_arg))
         ):
             return self._specialized_patcher_type(original_type)
         return None
@@ -49,7 +45,7 @@ def _string_value(self, expression: Expression) -> str | None:
             return literal_type.value
         return None
 
-    def _lookup_fullname_type(self, fullname: str) -> Type | None:
+    def _lookup_fullname_type(self, fullname: str, *, context: Context) -> Type | None:
         module_name, target = Fullname.from_string(fullname), Fullname(())
         while module_name:
             if (module := self.checker.modules.get(str(module_name))) and (
@@ -58,6 +54,7 @@ def _lookup_fullname_type(self, fullname: str) -> Type | None:
                 return type_
             target = target.push_front(module_name.name)
             module_name = module_name.module_name
+        self.checker.fail(f"{fullname!r} does not exist.", context=context, code=NAME_DEFINED)
         return None
 
     def _lookup_fullname_type_in_module(self, module: MypyFile, target: Fullname) -> Type | None:

pyproject.toml

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

test_samples/patch_object_test.py

@@ -41,3 +41,6 @@ def prop(self) -> bool:
 mock.patch.object(PropertyClass(), "prop", False)
 mock.patch.object(PropertyClass(), "prop", mock.PropertyMock(2.0))
 mock.patch.object(PropertyClass(), "prop", mock.PropertyMock(False))
+
+
+mock.patch.object(X(), "doesnotexist", mock.MagicMock())

tests/snapshots/mypy_test/test_check_files/patch_object_test/patch_object_test.out

@@ -33,4 +33,5 @@ test_samples/patch_object_test.py:43: note: Possible overload variants:
 test_samples/patch_object_test.py:43: note:     def object(target: Any, attribute: str, new: MagicMock[Any, Any] | bool, spec: Literal[False] | None = ..., create: bool = ..., spec_set: Literal[False] | None = ..., autospec: Literal[False] | None = ..., new_callable: None = ..., *, unsafe: bool = ...) -> _patch[MagicMock[Any, Any] | bool]
 test_samples/patch_object_test.py:43: note:     def object(target: Any, attribute: str, *, spec: Any | Literal[False] | None = ..., create: bool = ..., spec_set: Any | Literal[False] | None = ..., autospec: Literal[False] | None = ..., new_callable: Callable[..., MagicMock[Any, Any] | bool], unsafe: bool = ..., **kwargs: Any) -> _patch_pass_arg[MagicMock[Any, Any] | bool]
 test_samples/patch_object_test.py:43: note:     def object(target: Any, attribute: str, *, spec: Any | bool | None = ..., create: bool = ..., spec_set: Any | bool | None = ..., autospec: Any | bool | None = ..., new_callable: None = ..., unsafe: bool = ..., **kwargs: Any) -> _patch_pass_arg[MagicMock[[VarArg(Any), KwArg(Any)], Any] | AsyncMock[[VarArg(Any), KwArg(Any)], Any]]
-Found 11 errors in 1 file (checked 1 source file)
+test_samples/patch_object_test.py:46: error: "X" has no attribute "doesnotexist"  [attr-defined]
+Found 12 errors in 1 file (checked 1 source file)

tests/snapshots/mypy_test/test_check_files/patch_test/patch_test.out

@@ -12,6 +12,7 @@ test_samples/patch_test.py:29: note: Possible overload variants:
 test_samples/patch_test.py:29: note:     def __call__(self, target: str, new: Mock[[SupportsFloat | SupportsIndex], float] | Callable[[SupportsFloat | SupportsIndex], float], spec: Literal[False] | None = ..., create: bool = ..., spec_set: Literal[False] | None = ..., autospec: Literal[False] | None = ..., new_callable: None = ..., *, unsafe: bool = ...) -> _patch[Mock[[SupportsFloat | SupportsIndex], float] | Callable[[SupportsFloat | SupportsIndex], float]]
 test_samples/patch_test.py:29: note:     def __call__(self, target: str, *, spec: Any | Literal[False] | None = ..., create: bool = ..., spec_set: Any | Literal[False] | None = ..., autospec: Literal[False] | None = ..., new_callable: Callable[..., Mock[[SupportsFloat | SupportsIndex], float] | Callable[[SupportsFloat | SupportsIndex], float]], unsafe: bool = ..., **kwargs: Any) -> _patch_pass_arg[Mock[[SupportsFloat | SupportsIndex], float] | Callable[[SupportsFloat | SupportsIndex], float]]
 test_samples/patch_test.py:29: note:     def __call__(self, target: str, *, spec: Any | bool | None = ..., create: bool = ..., spec_set: Any | bool | None = ..., autospec: Any | bool | None = ..., new_callable: None = ..., unsafe: bool = ..., **kwargs: Any) -> _patch_pass_arg[MagicMock[[VarArg(Any), KwArg(Any)], Any] | AsyncMock[[VarArg(Any), KwArg(Any)], Any]]
+test_samples/patch_test.py:31: error: 'unknown.unknown' does not exist.  [name-defined]
 test_samples/patch_test.py:57: error: Cannot infer type of lambda  [misc]
 test_samples/patch_test.py:57: error: Argument 2 to "__call__" of "_patcher" has incompatible type "Callable[[], None]"; expected "Mock[[str], None] | Callable[[str], None]"  [arg-type]
 test_samples/patch_test.py:59: error: Cannot infer type of lambda  [misc]
@@ -36,4 +37,4 @@ test_samples/patch_test.py:90: note:     def __call__(self, target: str, *, spec
 test_samples/patch_test.py:92: error: Argument 2 to "__call__" of "_patcher" has incompatible type "PropertyMock[None]"; expected "Mock[[PropertyClass], int] | Callable[[PropertyClass], int]"  [arg-type]
 test_samples/patch_test.py:101: error: Cannot infer type of lambda  [misc]
 test_samples/patch_test.py:101: error: Argument 3 to "object" of "_patcher" has incompatible type "Callable[[], None]"; expected "Mock[[int], int] | Callable[[int], int]"  [arg-type]
-Found 18 errors in 1 file (checked 1 source file)
+Found 19 errors in 1 file (checked 1 source file)