pytest-revealtype-injector 0.4.1__tar.gz → 0.5.0__tar.gz

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-revealtype-injector
-Version: 0.4.1
+Version: 0.5.0
 Summary: Pytest plugin for replacing reveal_type() calls inside test functions with static and runtime type checking result comparison, for confirming type annotation validity.
 Project-URL: homepage, https://github.com/abelcheung/pytest-revealtype-injector
 Author-email: Abel Cheung <abelcheung@gmail.com>

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.0}/src/pytest_revealtype_injector/__init__.py

@@ -1,3 +1,3 @@
 """Pytest plugin for replacing reveal_type() calls inside test functions with static and runtime type checking result comparison, for confirming type annotation validity."""  # noqa: E501
 
-__version__ = "0.4.1"
+__version__ = "0.5.0"

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.0}/src/pytest_revealtype_injector/hooks.py

@@ -17,7 +17,6 @@ adapter_stash_key: pytest.StashKey[set[TypeCheckerAdapter]]
 def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
     assert pyfuncitem.module is not None
     adapters = pyfuncitem.config.stash[adapter_stash_key].copy()
-    injected = functools.partial(revealtype_injector, adapters=adapters)
 
     for name in dir(pyfuncitem.module):
         if name.startswith("__") or name.startswith("@py"):
@@ -25,21 +24,32 @@ def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> None:
 
         item = getattr(pyfuncitem.module, name)
         if inspect.isfunction(item):
-            if item.__name__ == "reveal_type" and item.__module__ in {
+            if item.__name__ != "reveal_type" or item.__module__ not in {
                 "typing",
                 "typing_extensions",
             }:
-                setattr(pyfuncitem.module, name, injected)
-                _logger.info(f"Replaced {name}() from global import with {injected}")
                 continue
+            injected = functools.partial(
+                revealtype_injector,
+                adapters=adapters,
+                rt_funcname=name,
+            )
+            setattr(pyfuncitem.module, name, injected)
+            _logger.info(f"Replaced {name}() from global import with {injected}")
+            break
 
-        if inspect.ismodule(item):
+        elif inspect.ismodule(item):
             if item.__name__ not in {"typing", "typing_extensions"}:
                 continue
             assert hasattr(item, "reveal_type")
+            injected = functools.partial(
+                revealtype_injector,
+                adapters=adapters,
+                rt_funcname=f"{name}.reveal_type",
+            )
             setattr(item, "reveal_type", injected)
             _logger.info(f"Replaced {name}.reveal_type() with {injected}")
-            continue
+            break
 
 
 def pytest_collection_finish(session: pytest.Session) -> None:
@@ -49,7 +59,9 @@ def pytest_collection_finish(session: pytest.Session) -> None:
             adp.run_typechecker_on(files)
         except Exception as e:
             _logger.error(f"({adp.id}) {e}")
-            pytest.exit(f"({type(e).__name__}) " + str(e), pytest.ExitCode.INTERNAL_ERROR)
+            pytest.exit(
+                f"({type(e).__name__}) " + str(e), pytest.ExitCode.INTERNAL_ERROR
+            )
         else:
             _logger.info(f"({adp.id}) Type checker ran successfully")
 

{pytest_revealtype_injector-0.4.1 → pytest_revealtype_injector-0.5.0}/src/pytest_revealtype_injector/main.py

@@ -27,41 +27,50 @@ _logger = log.get_logger()
 
 
 class RevealTypeExtractor(ast.NodeVisitor):
-    target = None
+    def __init__(self, funcname: str | None = None) -> None:
+        self._rt_funcname = funcname  # normally "reveal_type"
+        self.target: ast.expr | None = None
 
     def visit_Call(self, node: ast.Call) -> Any:
-        # HACK node.func is not necessarily "reveal_type" as we allow
-        # "import as" syntax. We just assume the outmost call is
-        # reveal_type(), and never descend into recursive ast.Call nodes.
-        # IDEA Is it possible to retrieve the function name from
-        # pytest_pyfunc_call() hook and store it in stash somewhere?
-        self.target = node.args[0]
-        return node
+        # If we don't know how reveal_type is called, just assume
+        # it is the outmost call.
+        if not self._rt_funcname:
+            self.target = node.args[0]
+            return node
+        if ast.unparse(node.func).strip() == self._rt_funcname:
+            self.target = node.args[0]
+        else:
+            self.generic_visit(node)
 
 
-def _get_var_name(frame: inspect.Traceback) -> str | None:
+def _get_var_name(frame: inspect.Traceback, rt_funcname: str) -> str | None:
     filename = pathlib.Path(frame.filename)
     if not filename.exists():
         _logger.warning(
             f"Stack frame points to file '{filename}' "
             "which doesn't exist on local system."
         )
+    # TODO is it possible to have multiline reveal_type()?
     ctxt, idx = frame.code_context, frame.index
     assert ctxt is not None
     assert idx is not None
     code = ctxt[idx].strip()
 
-    walker = RevealTypeExtractor()
-    # TODO Use 'exec' mode which results in more complex AST but doesn't impose
+    walker = RevealTypeExtractor(rt_funcname)
+    # 'exec' mode results in more complex AST but doesn't impose
     # as much restriction on test code as 'eval' mode does.
-    walker.visit(ast.parse(code, mode="eval"))
+    walker.visit(ast.parse(code, mode="exec"))
     assert walker.target is not None
     result = ast.get_source_segment(code, walker.target)
     _logger.debug(f"Extraction OK: {code=}, {result=}")
     return result
 
 
-def revealtype_injector(var: _T, adapters: set[TypeCheckerAdapter]) -> _T:
+def revealtype_injector(
+    var: _T,
+    adapters: set[TypeCheckerAdapter],
+    rt_funcname: str,
+) -> _T:
     """Replacement of `reveal_type()` that matches static and runtime type
     checking result
 
@@ -99,7 +108,7 @@ def revealtype_injector(var: _T, adapters: set[TypeCheckerAdapter]) -> _T:
     # get data from my caller, not mine
     caller_frame = sys._getframe(1)  # pyright: ignore[reportPrivateUsage]
     caller = inspect.getframeinfo(caller_frame)
-    var_name = _get_var_name(caller)
+    var_name = _get_var_name(caller, rt_funcname)
     pos = FilePos(pathlib.Path(caller.filename).name, caller.lineno)
 
     globalns = caller_frame.f_globals

pytest_revealtype_injector-0.5.0/tests/test_ast_mode.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import pytest
+
+
+class TestAstExecMode:
+    def test_return_result(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.basedpyright]
+            reportUnreachable = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            """
+            import sys
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type
+            else:
+                from typing_extensions import reveal_type
+
+            def test_result_int() -> None:
+                x = 1
+                assert reveal_type(x) == 0 + 1
+
+            def test_result_str() -> None:
+                x = "foo"
+                if hasattr(x, "lower"):
+                    assert reveal_type(x.lower()) is not None
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)
+
+    def test_nested_call(self, pytester: pytest.Pytester) -> None:
+        pytester.makeconftest("pytest_plugins = ['pytest_revealtype_injector.plugin']")
+        pytester.makepyprojecttoml(
+            """
+            [tool.basedpyright]
+            reportUnreachable = false
+            """
+        )
+        pytester.makepyfile(  # pyright: ignore[reportUnknownMemberType]
+            """
+            import sys
+
+            if sys.version_info >= (3, 11):
+                from typing import reveal_type as rt
+            else:
+                from typing_extensions import reveal_type as rt
+
+            def test_inner_call() -> None:
+                x = 42
+                assert int(rt(str(x).upper())) == x
+
+            def test_outer_call() -> None:
+                x = "42"
+                assert rt(str(int(x)).upper()) == x
+            """
+        )
+        result = pytester.runpytest("--tb=short", "-v")
+        result.assert_outcomes(passed=2)