refactor: separate inner and outer coverage during metacov

Author: nedbat

Makefile

@@ -38,6 +38,7 @@ clean: debug_clean _clean_platform	## Remove artifacts of test execution, instal
 	@rm -f .coverage .coverage.* .metacov*
 	@rm -f coverage.xml coverage.json
 	@rm -f .tox/*/lib/*/site-packages/zzz_metacov.pth
+	@rm -f .tox/*/lib/*/site-packages/subcover.pth
 	@rm -f */.coverage */*/.coverage */*/*/.coverage */*/*/*/.coverage */*/*/*/*/.coverage */*/*/*/*/*/.coverage
 	@rm -f tests/covmain.zip tests/zipmods.zip tests/zip1.zip
 	@rm -rf doc/_build doc/_spell doc/sample_html_beta

coverage/cmdline.py

@@ -991,7 +991,7 @@ def main(argv: list[str] | None = None) -> int | None:
 #   pip install git+https://github.com/emin63/ox_profile.git
 #
 # $set_env.py: COVERAGE_PROFILE - Set to use ox_profile.
-_profile = os.getenv("COVERAGE_PROFILE")
+_profile = env.getenv("COVERAGE_PROFILE")
 if _profile:                                                # pragma: debugging
     from ox_profile.core.launchers import SimpleLauncher    # pylint: disable=import-error
     original_main = main

coverage/config.py

@@ -12,11 +12,10 @@
 import os.path
 import re
 
-from typing import (
-    Any, Callable, Final, Mapping, Union,
-)
 from collections.abc import Iterable
+from typing import Any, Callable, Final, Mapping, Union
 
+from coverage import env
 from coverage.exceptions import ConfigError
 from coverage.misc import isolate_module, human_sorted_items, substitute_variables
 from coverage.tomlconfig import TomlConfigParser, TomlDecodeError
@@ -559,7 +558,7 @@ def config_files_to_try(config_file: bool | str) -> list[tuple[str, bool, bool]]
     specified_file = (config_file is not True)
     if not specified_file:
         # No file was specified. Check COVERAGE_RCFILE.
-        rcfile = os.getenv("COVERAGE_RCFILE")
+        rcfile = env.getenv("COVERAGE_RCFILE")
         if rcfile:
             config_file = rcfile
             specified_file = True
@@ -612,19 +611,19 @@ def read_coverage_config(
                 raise ConfigError(f"Couldn't read {fname!r} as a config file")
 
     # 3) from environment variables:
-    env_data_file = os.getenv("COVERAGE_FILE")
+    env_data_file = env.getenv("COVERAGE_FILE")
     if env_data_file:
         config.data_file = env_data_file
     # $set_env.py: COVERAGE_DEBUG - Debug options: https://coverage.rtfd.io/cmd.html#debug
-    debugs = os.getenv("COVERAGE_DEBUG")
+    debugs = env.getenv("COVERAGE_DEBUG")
     if debugs:
         config.debug.extend(d.strip() for d in debugs.split(","))
 
     # 4) from constructor arguments:
     config.from_args(**kwargs)
 
     # 5) for our benchmark, force settings using a secret environment variable:
-    force_file = os.getenv("COVERAGE_FORCE_CONFIG")
+    force_file = env.getenv("COVERAGE_FORCE_CONFIG")
     if force_file:
         config.from_file(force_file, warn, our_file=True)
 

coverage/control.py

@@ -316,7 +316,7 @@ def __init__(                       # pylint: disable=too-many-arguments
         # is already coverage-aware, so don't auto-measure it.  By now, the
         # auto-creation of a Coverage object has already happened.  But we can
         # find it and tell it not to save its data.
-        if not env.METACOV:
+        if not env.INNER_METACOV:
             _prevent_sub_process_measurement()
 
     def _init(self) -> None:
@@ -549,7 +549,6 @@ def _init_for_start(self) -> None:
         self._core = Core(
             warn=self._warn,
             timid=self.config.timid,
-            metacov=self._metacov,
         )
         self._collector = Collector(
             core=self._core,
@@ -1347,7 +1346,7 @@ def plugin_info(plugins: list[Any]) -> list[str]:
 
 # Mega debugging...
 # $set_env.py: COVERAGE_DEBUG_CALLS - Lots and lots of output about calls to Coverage.
-if int(os.getenv("COVERAGE_DEBUG_CALLS", 0)):               # pragma: debugging
+if int(env.getenv("COVERAGE_DEBUG_CALLS", "0")):            # pragma: debugging
     from coverage.debug import decorate_methods, show_calls
 
     Coverage = decorate_methods(        # type: ignore[misc]
@@ -1379,7 +1378,7 @@ def process_startup() -> Coverage | None:
     not started by this call.
 
     """
-    cps = os.getenv("COVERAGE_PROCESS_START")
+    cps = env.getenv("COVERAGE_PROCESS_START")
     if not cps:
         # No request for coverage, nothing to do.
         return None

coverage/core.py

@@ -30,7 +30,7 @@
     HAS_CTRACER = True
 except ImportError:
     # Couldn't import the C extension, maybe it isn't built.
-    if os.getenv("COVERAGE_CORE") == "ctrace":      # pragma: part covered
+    if env.getenv("COVERAGE_CORE") == "ctrace":     # pragma: part covered
         # During testing, we use the COVERAGE_CORE environment variable
         # to indicate that we've fiddled with the environment to test this
         # fallback code.  If we thought we had a C tracer, but couldn't import
@@ -55,7 +55,6 @@ class Core:
     def __init__(self,
         warn: TWarnFn,
         timid: bool,
-        metacov: bool,
     ) -> None:
         # Defaults
         self.tracer_kwargs = {}
@@ -64,7 +63,7 @@ def __init__(self,
         if timid:
             core_name = "pytrace"
         else:
-            core_name = os.getenv("COVERAGE_CORE")
+            core_name = env.getenv("COVERAGE_CORE")
 
             if core_name == "sysmon" and not env.PYBEHAVIOR.pep669:
                 warn("sys.monitoring isn't available, using default core", slug="no-sysmon")
@@ -81,7 +80,7 @@ def __init__(self,
 
         if core_name == "sysmon":
             self.tracer_class = SysMonitor
-            self.tracer_kwargs = {"tool_id": 3 if metacov else 1}
+            self.tracer_kwargs = {"tool_id": 3 if env.OUTER_METACOV else 1}
             self.file_disposition_class = FileDisposition
             self.supports_plugins = False
             self.packed_arcs = False

coverage/debug.py

@@ -19,12 +19,10 @@
 import types
 import _thread
 
-from typing import (
-    overload,
-    Any, Callable, Final, IO,
-)
+from typing import overload, Any, Callable, Final, IO
 from collections.abc import Iterable, Iterator, Mapping
 
+from coverage import env
 from coverage.misc import human_sorted_items, isolate_module
 from coverage.types import AnyCallable, TWritable
 
@@ -35,7 +33,7 @@
 # debugging the configuration mechanisms you usually use to control debugging!
 # This is a list of forced debugging options.
 FORCED_DEBUG: list[str] = []
-FORCED_DEBUG_FILE = None
+FORCED_DEBUG_FILE = ""
 
 
 class DebugControl:
@@ -402,7 +400,7 @@ def __init__(self) -> None:
 
     def filter(self, text: str) -> str:
         """Add a message when the pytest test changes."""
-        test_name = os.getenv("PYTEST_CURRENT_TEST")
+        test_name = env.getenv("PYTEST_CURRENT_TEST")
         if test_name != self.test_name:
             text = f"Pytest context: {test_name}\n" + text
             self.test_name = test_name
@@ -452,7 +450,7 @@ def get_one(
                 fileobj = open(file_name, "a", encoding="utf-8")
             else:
                 # $set_env.py: COVERAGE_DEBUG_FILE - Where to write debug output
-                file_name = os.getenv("COVERAGE_DEBUG_FILE", FORCED_DEBUG_FILE)
+                file_name = env.getenv("COVERAGE_DEBUG_FILE", FORCED_DEBUG_FILE)
                 if file_name in ("stdout", "stderr"):
                     fileobj = getattr(sys, file_name)
                 elif file_name:
@@ -587,14 +585,14 @@ def _wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
     return _decorator
 
 
-def relevant_environment_display(env: Mapping[str, str]) -> list[tuple[str, str]]:
+def relevant_environment_display(env_map: Mapping[str, str]) -> Iterable[tuple[str, str]]:
     """Filter environment variables for a debug display.
 
     Select variables to display (with COV or PY in the name, or HOME, TEMP, or
     TMP), and also cloak sensitive values with asterisks.
 
     Arguments:
-        env: a dict of environment variable names and values.
+        env_map: a dict of environment variable names and values.
 
     Returns:
         A list of pairs (name, value) to show.
@@ -605,7 +603,7 @@ def relevant_environment_display(env: Mapping[str, str]) -> list[tuple[str, str]
     cloak = {"API", "TOKEN", "KEY", "SECRET", "PASS", "SIGNATURE"}
 
     to_show = []
-    for name, val in env.items():
+    for name, val in env_map.items():
         keep = False
         if name in include:
             keep = True

coverage/env.py

@@ -9,15 +9,15 @@
 import platform
 import sys
 
-from typing import Any, Final
+from typing import Any, Final, overload
 from collections.abc import Iterable
 
 # debug_info() at the bottom wants to show all the globals, but not imports.
 # Grab the global names here to know which names to not show. Nothing defined
 # above this line will be in the output.
 _UNINTERESTING_GLOBALS = list(globals())
 # These names also shouldn't be shown.
-_UNINTERESTING_GLOBALS += ["PYBEHAVIOR", "debug_info"]
+_UNINTERESTING_GLOBALS += ["PYBEHAVIOR", "debug_info", "PREFIX", "getenv"]
 
 # Operating systems.
 WINDOWS = sys.platform == "win32"
@@ -156,16 +156,36 @@ class PYBEHAVIOR:
     # PEP649 and PEP749: Deferred annotations
     deferred_annotations = (PYVERSION >= (3, 14))
 
+# Environment variable access.
+PREFIX = "COVERAGE_"
+
+@overload
+def getenv(name: str) -> str | None:
+    ...
+
+@overload
+def getenv(name: str, default: str) -> str:
+    ...
+
+def getenv(name: str, default: str = "") -> str | None:
+    """Like os.getenv, but understands about switching prefixes."""
+    real_name = name.replace("COVERAGE_", PREFIX, 1)
+    return os.getenv(real_name, default)
+
 
 # Coverage.py specifics, about testing scenarios. See tests/testenv.py also.
 
 # Are we coverage-measuring ourselves?
-METACOV = os.getenv("COVERAGE_COVERAGE") is not None
+OUTER_METACOV = bool(getenv("COVERAGE_METAFILE"))
+if OUTER_METACOV:
+    PREFIX = "METACOV_"
+
+INNER_METACOV = bool(getenv("COVERAGE_INNER_META"))
 
 # Are we running our test suite?
 # Even when running tests, you can use COVERAGE_TESTING=0 to disable the
 # test-specific behavior like AST checking.
-TESTING = os.getenv("COVERAGE_TESTING") == "True"
+TESTING = getenv("COVERAGE_TESTING") == "True"
 
 
 def debug_info() -> Iterable[tuple[str, Any]]:

coverage/parser.py

@@ -713,7 +713,7 @@ def __init__(
 
         # Turn on AST dumps with an environment variable.
         # $set_env.py: COVERAGE_AST_DUMP - Dump the AST nodes when parsing code.
-        dump_ast = bool(int(os.getenv("COVERAGE_AST_DUMP", "0")))
+        dump_ast = bool(int(env.getenv("COVERAGE_AST_DUMP", "0")))
 
         if dump_ast:                                # pragma: debugging
             # Dump the AST so that failing tests have helpful output.
@@ -735,7 +735,7 @@ def __init__(
         self.with_exits: set[TArc] = set()
 
         # $set_env.py: COVERAGE_TRACK_ARCS - Trace possible arcs added while parsing code.
-        self.debug = bool(int(os.getenv("COVERAGE_TRACK_ARCS", "0")))
+        self.debug = bool(int(env.getenv("COVERAGE_TRACK_ARCS", "0")))
 
     def analyze(self) -> None:
         """Examine the AST tree from `self.root_node` to determine possible arcs."""

coverage/pytracer.py

@@ -348,7 +348,7 @@ def stop(self) -> None:
         # warn if we are measuring ourselves.
         suppress_warning = (
             (env.PYPY and self.in_atexit and tf is None)
-            or env.METACOV
+            or env.INNER_METACOV
         )
         if self.warn and not suppress_warning:
             if tf != self._cached_bound_method_trace:   # pylint: disable=comparison-with-callable

coverage/sysmon.py

@@ -90,7 +90,7 @@ def log(msg: str) -> None:
         if tid not in seen_threads:
             seen_threads.add(tid)
             log(f"New thread {tid} {tslug}:\n{short_stack()}")
-        # log_seq = int(os.getenv("PANSEQ", "0"))
+        # log_seq = int(env.getenv("PANSEQ", "0"))
         # root = f"/tmp/pan.{log_seq:03d}"
         for filename in [
             "/tmp/foo.out",

igor.py

@@ -14,6 +14,7 @@
 import inspect
 import itertools
 import os
+import os.path
 import platform
 import pprint
 import re
@@ -170,14 +171,17 @@ def run_tests(core, *runner_args):
 
 def run_tests_with_coverage(core, *runner_args):
     """Run tests, but with coverage."""
+    if "coverage" in sys.modules:
+        raise RuntimeError("Something imported coverage too early! `make clean` to fix.")
+
     # Need to define this early enough that the first import of env.py sees it.
     os.environ["COVERAGE_TESTING"] = "True"
     os.environ["COVERAGE_PROCESS_START"] = os.path.abspath("metacov.ini")
     os.environ["COVERAGE_HOME"] = os.getcwd()
     context = os.getenv("COVERAGE_CONTEXT")
     if context:
         if context[0] == "$":
-            context = os.environ[context[1:]]
+            context = os.getenv(context[1:])
         os.environ["COVERAGE_CONTEXT"] = context + "." + core
 
     # Create the .pth file that will let us measure coverage in subprocesses.
@@ -197,27 +201,24 @@ def run_tests_with_coverage(core, *runner_args):
     cov = coverage.Coverage(config_file="metacov.ini")
     cov._warn_unimported_source = False
     cov._warn_preimported_source = False
-    cov._metacov = True
     cov.start()
 
+    del os.environ["COVERAGE_METAFILE"]
+
     try:
-        # Re-import coverage to get it coverage tested!  I don't understand all
-        # the mechanics here, but if I don't carry over the imported modules
-        # (in covmods), then things go haywire (os is None, eventually).
-        covmods = {}
+        # Re-import coverage to get it coverage tested!
         covdir = os.path.split(coverage.__file__)[0]
         # We have to make a list since we'll be deleting in the loop.
         modules = list(sys.modules.items())
         for name, mod in modules:
             if name.startswith("coverage"):
                 if getattr(mod, "__file__", "??").startswith(covdir):
-                    covmods[name] = mod
                     del sys.modules[name]
-        import coverage  # pylint: disable=reimported
 
-        sys.modules.update(covmods)
+        os.environ["COVERAGE_INNER_META"] = "1"
+        import coverage  # pylint: disable=reimported
 
-        # Run tests, with the arguments from our command line.
+        # Run tests with the arguments from our command line.
         status = run_tests(core, *runner_args)
 
     finally:

metacov.ini

@@ -54,8 +54,8 @@ exclude_lines =
 
     # Lines that we can't run during metacov.
     pragma: no metacov
-    pytest.mark.skipif\(env.METACOV
-    if not env.METACOV:
+    pytest.mark.skipif\(env.INNER_METACOV
+    if not env.INNER_METACOV:
 
     # These lines only happen if tests fail.
     raise AssertionError
@@ -84,7 +84,7 @@ partial_branches =
     # If we're asserting that any() is true, it didn't finish.
     assert any\(
     if env.TESTING:
-    if env.METACOV:
+    if env.INNER_METACOV:
 
 precision = 3
 

tests/coveragetest.py

@@ -24,7 +24,7 @@
 from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
 
 import coverage
-from coverage import Coverage
+from coverage import Coverage, env
 from coverage.cmdline import CoverageScript
 from coverage.data import CoverageData
 from coverage.misc import import_local_file
@@ -44,7 +44,7 @@
 # Install arguments to pass to pip when reinstalling ourselves.
 # Defaults to the top of the source tree, but can be overridden if we need
 # some help on certain platforms.
-COVERAGE_INSTALL_ARGS = os.getenv("COVERAGE_INSTALL_ARGS", nice_file(TESTS_DIR, ".."))
+COVERAGE_INSTALL_ARGS = env.getenv("COVERAGE_INSTALL_ARGS", nice_file(TESTS_DIR, ".."))
 
 
 def arcs_to_branches(arcs: Iterable[TArc]) -> dict[TLineNo, list[TLineNo]]: