feat: patch=execv

wip: we need this to make it work?

wip: this has to make it work, right?

Author: nedbat

CHANGES.rst

@@ -37,6 +37,11 @@ Unreleased
     <python:os.execl>` or :func:`spawnv <python:os.spawnl>` family of
     functions. Closes old `issue 367`_ and duplicate `issue 378`_.
 
+  - ``patch = execv`` adjusts the :func:`execv <python:os.execl>` family of
+    functions to save coverage data before ending the current program and
+    starting the next. Not available on Windows. Closes `issue 43`_ after 15
+    years!
+
 - The HTML report now dimly colors subsequent lines in multi-line statements.
   They used to have no color.  This gives a better indication of the amount of
   code missing in the report.  Closes `issue 1308`_.
@@ -65,6 +70,7 @@ Unreleased
 - In the very unusual situation of not having a current frame, coverage no
   longer crashes when using the sysmon core, fixing `issue 2005`_.
 
+.. _issue 43: https://github.com/nedbat/coveragepy/issues/43
 .. _issue 310: https://github.com/nedbat/coveragepy/issues/310
 .. _issue 312: https://github.com/nedbat/coveragepy/issues/312
 .. _issue 367: https://github.com/nedbat/coveragepy/issues/367

coverage/patch.py

@@ -8,9 +8,10 @@
 import atexit
 import os
 
-from typing import Callable, NoReturn, TYPE_CHECKING
+from typing import Any, Callable, NoReturn, TYPE_CHECKING
 
-from coverage.exceptions import ConfigError
+from coverage import env
+from coverage.exceptions import ConfigError, CoverageException
 from coverage.files import create_pth_file
 
 if TYPE_CHECKING:
@@ -21,17 +22,60 @@
 def apply_patches(cov: Coverage, config: CoverageConfig) -> None:
     """Apply invasive patches requested by `[run] patch=`."""
 
-    for patch in set(config.patch):
+    for patch in sorted(set(config.patch)):
         if patch == "_exit":
-            def make_patch(old_os_exit: Callable[[int], NoReturn]) -> Callable[[int], NoReturn]:
-                def _coverage_os_exit_patch(status: int) -> NoReturn:
+
+            def make_exit_patch(
+                old_exit: Callable[[int], NoReturn],
+            ) -> Callable[[int], NoReturn]:
+                def coverage_os_exit_patch(status: int) -> NoReturn:
                     try:
                         cov.save()
-                    except: # pylint: disable=bare-except
+                    except:  # pylint: disable=bare-except
                         pass
-                    old_os_exit(status)
-                return _coverage_os_exit_patch
-            os._exit = make_patch(os._exit)  # type: ignore[assignment]
+                    old_exit(status)
+
+                return coverage_os_exit_patch
+
+            os._exit = make_exit_patch(os._exit)  # type: ignore[assignment]
+
+        elif patch == "execv":
+            if env.WINDOWS:
+                raise CoverageException("patch=execv isn't supported yet on Windows.")
+
+            def make_execv_patch(fname: str, old_execv: Any) -> Any:
+                def coverage_execv_patch(*args: Any, **kwargs: Any) -> Any:
+                    try:
+                        cov.save()
+                    except:  # pylint: disable=bare-except
+                        pass
+
+                    if fname.endswith("e"):
+                        # Assume the `env` argument is passed positionally.
+                        new_env = args[-1]
+                        # Pass our environment variable in the new environment.
+                        new_env["COVERAGE_PROCESS_START"] = config.config_file
+                        if env.TESTING:
+                            # The subprocesses need to use the same core as the main process.
+                            new_env["COVERAGE_CORE"] = os.getenv("COVERAGE_CORE")
+
+                            # When testing locally, we need to honor the pyc file location
+                            # or they get written to the .tox directories and pollute the
+                            # next run with a different core.
+                            if (
+                                cache_prefix := os.getenv("PYTHONPYCACHEPREFIX")
+                            ) is not None:
+                                new_env["PYTHONPYCACHEPREFIX"] = cache_prefix
+
+                            # Without this, it fails on PyPy and Ubuntu.
+                            new_env["PATH"] = os.getenv("PATH")
+                    old_execv(*args, **kwargs)
+
+                return coverage_execv_patch
+
+            # All the exec* and spawn* functions eventually call execv or execve.
+            os.execv = make_execv_patch("execv", os.execv)
+            os.execve = make_execv_patch("execve", os.execve)
 
         elif patch == "subprocess":
             pth_file = create_pth_file()

doc/config.rst

@@ -459,6 +459,11 @@ Available patches:
   and will require combining data files before reporting.  See
   :ref:`cmd_combine` for more details.
 
+- ``execv``: The :func:`execv <python:os.execl>` family of functions end the
+  current program without giving coverage a chance to write collected data.
+  This patch adjusts those functions to save the data before starting the next
+  executable. Not available on Windows.
+
 .. versionadded:: 7.10
 
 

doc/subprocess.rst

@@ -4,9 +4,9 @@
 .. _subprocess:
 .. _processes:
 
-======================
-Coordinating processes
-======================
+==================
+Managing processes
+==================
 
 For coverage measurement to work properly, coverage has to be involved at the
 very beginning and very end of the Python process.  There a number of ways to
@@ -71,7 +71,8 @@ families of functions start new execution, either replacing the current process
 or starting a new subprocess.  The ``exec*e`` and ``spawn*e`` variants take a
 new set of environment variables to use for the new program.  To start coverage
 measurement, the ``COVERAGE_PROCESS_START`` value must be copied from the
-current environment into the new environment.
+current environment into the new environment or set. It should be the absolute
+path to the coverage configuration file to use.
 
 
 Ending processes
@@ -95,6 +96,14 @@ If your program ends by calling :func:`python:os._exit` (or a library does),
 you can patch that function with :ref:`patch = _exit <config_run_patch>` to
 give coverage a chance to write data before the process exits.
 
+execv
+.....
+
+If your program ends by calling one of the :func:`execv <python:os.execl>`
+functions, using :ref:`patch = execv <config_run_patch>` will let coverage
+write its data before the execution begins.
+
+
 Long-running processes
 ......................
 

tests/test_process.py

@@ -7,6 +7,7 @@
 
 import csv
 import glob
+import itertools
 import os
 import os.path
 import platform
@@ -693,9 +694,8 @@ def test_module_name(self) -> None:
 
     @pytest.mark.skipif(env.WINDOWS, reason="This test is not for Windows")
     def test_save_signal_usr1(self) -> None:
-        test_file = "dummy_hello.py"
         self.assert_doesnt_exist(".coverage")
-        self.make_file(test_file, """\
+        self.make_file("dummy_hello.py", """\
             import os
             import signal
 
@@ -706,7 +706,7 @@ def test_save_signal_usr1(self) -> None:
             print("Done and goodbye")
             """)
         out = self.run_command(
-            f"coverage run --save-signal=USR1 {test_file}",
+            "coverage run --save-signal=USR1 dummy_hello.py",
             status=-signal.SIGKILL,
         )
         # `startswith` because on Linux it also prints "Killed"
@@ -1321,6 +1321,7 @@ def test_removing_directory_with_error(self) -> None:
 
 
 @pytest.mark.skipif(env.METACOV, reason="Can't test subprocess pth file during metacoverage")
+@pytest.mark.xdist_group(name="needs_pth")
 class ProcessStartupTest(CoverageTest):
     """Test that we can measure coverage in subprocesses."""
 
@@ -1340,7 +1341,6 @@ def setUp(self) -> None:
             f.close()
             """)
 
-    @pytest.mark.xdist_group(name="needs_pth")
     def test_patch_subprocess(self) -> None:
         self.make_file(".coveragerc", """\
             [run]
@@ -1349,12 +1349,11 @@ def test_patch_subprocess(self) -> None:
         self.run_command("coverage run main.py")
         self.run_command("coverage combine")
         self.assert_exists(".coverage")
-        data = coverage.CoverageData(".coverage")
+        data = coverage.CoverageData()
         data.read()
         assert line_counts(data)["main.py"] == 3
         assert line_counts(data)["sub.py"] == 3
 
-    @pytest.mark.xdist_group(name="needs_pth")
     def test_subprocess_with_pth_files(self, _create_pth_file: None) -> None:
         # An existing data file should not be read when a subprocess gets
         # measured automatically.  Create the data file here with bogus data in
@@ -1379,7 +1378,6 @@ def test_subprocess_with_pth_files(self, _create_pth_file: None) -> None:
         data.read()
         assert line_counts(data)['sub.py'] == 3
 
-    @pytest.mark.xdist_group(name="needs_pth")
     def test_subprocess_with_pth_files_and_parallel(self, _create_pth_file: None) -> None:
         # https://github.com/nedbat/coveragepy/issues/492
         self.make_file("coverage.ini", """\
@@ -1410,6 +1408,76 @@ def test_subprocess_with_pth_files_and_parallel(self, _create_pth_file: None) ->
         assert len(data_files) == 1, msg
 
 
+@pytest.mark.skipif(env.METACOV, reason="Can't test subprocess pth file during metacoverage")
+@pytest.mark.skipif(env.WINDOWS, reason="patch=execv isn't supported on Windows")
+@pytest.mark.xdist_group(name="needs_pth")
+class ExecvTest(CoverageTest):
+    """Test that we can measure coverage in subprocesses."""
+
+    @pytest.mark.parametrize("fname",
+        [base + suffix for base, suffix in itertools.product(
+            ["exec", "spawn"],
+            ["l", "le", "lp", "lpe", "v", "ve", "vp", "vpe"],
+        )]
+    )
+    def test_execv_patch(self, fname: str) -> None:
+        if not hasattr(os, fname):
+            pytest.skip(f"This OS doesn't have os.{fname}")
+
+        self.make_file(".coveragerc", """\
+            [run]
+            patch = subprocess, execv
+            """)
+        self.make_file("main.py", f"""\
+            import os, sys
+            print("In main")
+            args = []
+            if "spawn" in {fname!r}:
+                args.append(os.P_WAIT)
+            args.append(sys.executable)
+            prog_args = ["python", {os.path.abspath("other.py")!r}, "cat", "dog"]
+            if "l" in {fname!r}:
+                args.extend(prog_args)
+            else:
+                args.append(prog_args)
+            if {fname!r}.endswith("e"):
+                args.append({{"SUBVAR": "the-sub-var"}})
+            os.environ["MAINVAR"] = "the-main-var"
+            sys.stdout.flush()
+            os.{fname}(*args)
+            """)
+        self.make_file("other.py", """\
+            import os, sys
+            print(f"MAINVAR = {os.getenv('MAINVAR', 'none')}")
+            print(f"SUBVAR = {os.getenv('SUBVAR', 'none')}")
+            print(f"{sys.argv[1:] = }")
+            """)
+
+        out = self.run_command("coverage run main.py")
+        expected = "In main\n"
+        if fname.endswith("e"):
+            expected += "MAINVAR = none\n"
+            expected += "SUBVAR = the-sub-var\n"
+        else:
+            expected += "MAINVAR = the-main-var\n"
+            expected += "SUBVAR = none\n"
+        expected += "sys.argv[1:] = ['cat', 'dog']\n"
+        assert out == expected
+
+        self.run_command("coverage combine")
+        data = coverage.CoverageData()
+        data.read()
+
+        main_lines = 12
+        if "spawn" in fname:
+            main_lines += 1
+        if fname.endswith("e"):
+            main_lines += 1
+
+        assert line_counts(data)["main.py"] == main_lines
+        assert line_counts(data)["other.py"] == 4
+
+
 class ProcessStartupWithSourceTest(CoverageTest):
     """Show that we can configure {[run]source} during process-level coverage.