Avoid monkeypatching sys for frames tests

It's software bankruptcy and breaks sysmon coverage.

Author: hynek

.pre-commit-config.yaml

@@ -4,12 +4,12 @@ ci:
 
 repos:
   - repo: https://github.com/psf/black
-    rev: 23.11.0
+    rev: 23.12.1
     hooks:
       - id: black
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.7
+    rev: v0.1.9
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

src/structlog/_frames.py

@@ -10,6 +10,7 @@
 
 from io import StringIO
 from types import FrameType
+from typing import Callable
 
 from .contextvars import _ASYNC_CALLING_STACK
 from .typing import ExcInfo
@@ -37,21 +38,25 @@ def _format_exception(exc_info: ExcInfo) -> str:
 
 def _find_first_app_frame_and_name(
     additional_ignores: list[str] | None = None,
+    *,
+    _getframe: Callable[[], FrameType] = sys._getframe,
 ) -> tuple[FrameType, str]:
     """
     Remove all intra-structlog calls and return the relevant app frame.
 
-    Parameters:
-
+    Args:
         additional_ignores:
             Additional names with which the first frame must not start.
 
-    Returns:
+        _getframe:
+            Callable to find current frame. Only for testing to avoid
+            monkeypatching of sys._getframe.
 
+    Returns:
         tuple of (frame, name)
     """
     ignores = ["structlog"] + (additional_ignores or [])
-    f = _ASYNC_CALLING_STACK.get(sys._getframe())
+    f = _ASYNC_CALLING_STACK.get(_getframe())
     name = f.f_globals.get("__name__") or "?"
     while any(tuple(name.startswith(i) for i in ignores)):
         if f.f_back is None:

tests/test_frames.py

@@ -9,8 +9,6 @@
 
 from pretend import stub
 
-import structlog._frames
-
 from structlog._frames import (
     _find_first_app_frame_and_name,
     _format_exception,
@@ -19,68 +17,69 @@
 
 
 class TestFindFirstAppFrameAndName:
-    def test_ignores_structlog_by_default(self, monkeypatch):
+    def test_ignores_structlog_by_default(self):
         """
         No matter what you pass in, structlog frames get always ignored.
         """
         f1 = stub(f_globals={"__name__": "test"}, f_back=None)
         f2 = stub(f_globals={"__name__": "structlog.blubb"}, f_back=f1)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f2)
-        f, n = _find_first_app_frame_and_name()
+
+        f, n = _find_first_app_frame_and_name(_getframe=lambda: f2)
 
         assert (f1, "test") == (f, n)
 
-    def test_ignoring_of_additional_frame_names_works(self, monkeypatch):
+    def test_ignoring_of_additional_frame_names_works(self):
         """
         Additional names are properly ignored too.
         """
         f1 = stub(f_globals={"__name__": "test"}, f_back=None)
         f2 = stub(f_globals={"__name__": "ignored.bar"}, f_back=f1)
         f3 = stub(f_globals={"__name__": "structlog.blubb"}, f_back=f2)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f3)
-        f, n = _find_first_app_frame_and_name(additional_ignores=["ignored"])
+
+        f, n = _find_first_app_frame_and_name(
+            additional_ignores=["ignored"], _getframe=lambda: f3
+        )
 
         assert (f1, "test") == (f, n)
 
-    def test_tolerates_missing_name(self, monkeypatch):
+    def test_tolerates_missing_name(self):
         """
         Use ``?`` if `f_globals` lacks a `__name__` key
         """
         f1 = stub(f_globals={}, f_back=None)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f1)
-        f, n = _find_first_app_frame_and_name()
+
+        f, n = _find_first_app_frame_and_name(_getframe=lambda: f1)
 
         assert (f1, "?") == (f, n)
 
-    def test_tolerates_name_explicitly_None_oneframe(self, monkeypatch):
+    def test_tolerates_name_explicitly_None_oneframe(self):
         """
         Use ``?`` if `f_globals` has a `None` valued `__name__` key
         """
         f1 = stub(f_globals={"__name__": None}, f_back=None)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f1)
-        f, n = _find_first_app_frame_and_name()
+
+        f, n = _find_first_app_frame_and_name(_getframe=lambda: f1)
 
         assert (f1, "?") == (f, n)
 
-    def test_tolerates_name_explicitly_None_manyframe(self, monkeypatch):
+    def test_tolerates_name_explicitly_None_manyframe(self):
         """
         Use ``?`` if `f_globals` has a `None` valued `__name__` key,
         multiple frames up.
         """
         f1 = stub(f_globals={"__name__": None}, f_back=None)
         f2 = stub(f_globals={"__name__": "structlog.blubb"}, f_back=f1)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f2)
-        f, n = _find_first_app_frame_and_name()
+        f, n = _find_first_app_frame_and_name(_getframe=lambda: f2)
 
         assert (f1, "?") == (f, n)
 
-    def test_tolerates_f_back_is_None(self, monkeypatch):
+    def test_tolerates_f_back_is_None(self):
         """
         Use ``?`` if all frames are in ignored frames.
         """
         f1 = stub(f_globals={"__name__": "structlog"}, f_back=None)
-        monkeypatch.setattr(structlog._frames.sys, "_getframe", lambda: f1)
-        f, n = _find_first_app_frame_and_name()
+
+        f, n = _find_first_app_frame_and_name(_getframe=lambda: f1)
 
         assert (f1, "?") == (f, n)
 

tests/test_processors.py

@@ -865,23 +865,12 @@ def test_additional_ignores(self, monkeypatch: pytest.MonkeyPatch) -> None:
         processor = self.make_processor(None, additional_ignores)
         event_dict: EventDict = {"event": test_message}
 
-        # `functools.partial` is used instead of a lambda because a lambda will
-        # add an additional frame in a module that should not be ignored.
-        _sys_getframe = functools.partial(additional_frame, sys._getframe)
-
-        # WARNING: The below three lines are sensitive to relative line numbers
-        # (i.e. the invocation of processor must be two lines after the
-        # invocation of get_callsite_parameters) and is order sensitive (i.e.
-        # monkeypatch.setattr must occur after get_callsite_parameters but
-        # before invocation of processor).
-        callsite_params = self.get_callsite_parameters(2)
-        monkeypatch.setattr(sys, "_getframe", value=_sys_getframe)
+        # Warning: the next two lines must appear exactly like this to make
+        # line numbers match.
+        callsite_params = self.get_callsite_parameters(1)
         actual = processor(None, None, event_dict)
 
-        expected = {
-            "event": test_message,
-            **callsite_params,
-        }
+        expected = {"event": test_message, **callsite_params}
 
         assert expected == actual
 
@@ -941,10 +930,7 @@ def test_processor(
         callsite_params = self.filter_parameter_dict(
             callsite_params, parameter_strings
         )
-        expected = {
-            "event": test_message,
-            **callsite_params,
-        }
+        expected = {"event": test_message, **callsite_params}
 
         assert expected == actual
 
@@ -1029,10 +1015,7 @@ def test_e2e(
             for key, value in json.loads(string_io.getvalue()).items()
             if not key.startswith("_")
         }
-        expected = {
-            "event": test_message,
-            **callsite_params,
-        }
+        expected = {"event": test_message, **callsite_params}
 
         assert expected == actual
 
@@ -1044,18 +1027,16 @@ def make_processor(
     ) -> CallsiteParameterAdder:
         """
         Creates a ``CallsiteParameterAdder`` with parameters matching the
-        supplied ``parameter_strings`` values and with the supplied
-        ``additional_ignores`` values.
-
-        Parameters:
+        supplied *parameter_strings* values and with the supplied
+        *additional_ignores* values.
 
+        Args:
             parameter_strings:
                 Strings for which corresponding ``CallsiteParameters`` should
                 be included in the resulting ``CallsiteParameterAdded``.
 
             additional_ignores:
-
-                Used as ``additional_ignores`` for the resulting
+                Used as *additional_ignores* for the resulting
                 ``CallsiteParameterAdded``.
         """
         if parameter_strings is None:
@@ -1097,11 +1078,10 @@ def filter_parameter_dict(
         cls, input: dict[str, object], parameter_strings: set[str] | None
     ) -> dict[str, object]:
         """
-        Returns a dictionary that is equivalent to ``input`` but with all keys
-        not in ``parameter_strings`` removed.
-
-        Parameters:
+        Returns a dictionary that is equivalent to *input* but with all keys
+        not in *parameter_strings* removed.
 
+        Args:
             parameter_strings:
                 The keys to keep in the dictionary, if this value is ``None``
                 then all keys matching ``cls.parameter_strings`` are kept.
@@ -1120,8 +1100,7 @@ def get_callsite_parameters(cls, offset: int = 1) -> dict[str, object]:
         This function creates dictionary of callsite parameters for the line
         that is ``offset`` lines after the invocation of this function.
 
-        Parameters:
-
+        Args:
             offset:
                 The amount of lines after the invocation of this function that
                 callsite parameters should be generated for.

tests/test_tracebacks.py

@@ -469,6 +469,12 @@ def bar(n):
         )
         == frames[0]
     )
+
+    # If we run the tests under Python 3.12 with sysmon enabled, it inserts
+    # frames at the end.
+    if sys.version_info >= (3, 12):
+        frames = [f for f in frames if "coverage" not in f.filename]
+
     # Depending on whether we invoke pytest directly or run tox, either "foo()"
     # or "bar()" is at the end of the stack.
     assert frames[-1] in [

tox.ini

@@ -24,19 +24,21 @@ commands =
 
 
 # Run oldest and latest under Coverage.
-[testenv:py3{8,11}-tests{,-colorama,-be,-rich}]
+[testenv:py3{8,12}-tests{,-colorama,-be,-rich}]
+set_env =
+    py312: COVERAGE_CORE=sysmon
 deps =
     coverage[toml]
-    py311: twisted
+    py312: twisted
     colorama: colorama
     rich: rich
     be: better-exceptions
 commands = coverage run -m pytest {posargs}
 
 
 [testenv:coverage-report]
-# Keep in sync with .python-version
-base_python = py311
+# Keep in sync with .python-version-default
+base_python = py312
 deps = coverage[toml]
 skip_install = true
 parallel_show_output = true