wip: separate environments for outer and inner coverages during metacov

Author: nedbat

coverage/__init__.py

@@ -11,16 +11,18 @@
 
 from __future__ import annotations
 
+import sys
+
 # mypy's convention is that "import as" names are public from the module.
 # We import names as themselves to indicate that. Pylint sees it as pointless,
 # so disable its warning.
 # pylint: disable=useless-import-alias
 
+from coverage import env
 from coverage.version import (
     __version__ as __version__,
     version_info as version_info,
 )
-
 from coverage.control import (
     Coverage as Coverage,
     process_startup as process_startup,
@@ -36,3 +38,11 @@
 
 # Backward compatibility.
 coverage = Coverage
+
+# When using coverage to measure itself, we want the outer coverage to be
+# configured separately from the inner coverage running in the tests.
+# To do that, we look at different environment variables.  We check sys.argv
+# here to get set the environment variable prefix as early as possible, before
+# any code looks at environment variables.
+if "--meta" in sys.argv:
+    env.PREFIX = "METACOV_"

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

@@ -1347,7 +1347,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 +1379,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
@@ -64,7 +64,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")

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,32 @@ 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."""
+    return os.getenv(name.replace("COVERAGE_", PREFIX, 1), 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
+METACOV = getenv("COVERAGE_COVERAGE") is not None
 
 # 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/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

@@ -177,7 +177,7 @@ def run_tests_with_coverage(core, *runner_args):
     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.

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]]:

tests/helpers.py

@@ -69,7 +69,7 @@ def run_command(cmd: str) -> tuple[int, str]:
 
 
 # $set_env.py: COVERAGE_DIS - Disassemble test code to /tmp/dis
-SHOW_DIS = bool(int(os.getenv("COVERAGE_DIS", "0")))
+SHOW_DIS = bool(int(env.getenv("COVERAGE_DIS", "0")))
 
 def make_file(
     filename: str,

tests/testenv.py

@@ -5,16 +5,16 @@
 
 from __future__ import annotations
 
-import os
+from coverage import env
 
 # Are we testing the C-implemented trace function?
-C_TRACER = os.getenv("COVERAGE_CORE", "ctrace") == "ctrace"
+C_TRACER = env.getenv("COVERAGE_CORE", "ctrace") == "ctrace"
 
 # Are we testing the Python-implemented trace function?
-PY_TRACER = os.getenv("COVERAGE_CORE", "ctrace") == "pytrace"
+PY_TRACER = env.getenv("COVERAGE_CORE", "ctrace") == "pytrace"
 
 # Are we testing the sys.monitoring implementation?
-SYS_MON = os.getenv("COVERAGE_CORE", "ctrace") == "sysmon"
+SYS_MON = env.getenv("COVERAGE_CORE", "ctrace") == "sysmon"
 
 # Are we using a settrace function as a core?
 SETTRACE_CORE = C_TRACER or PY_TRACER