TST,STY: Make a subprocess.run helper to xfail fork failures.

This way I have fewer places to get things wrong and fewer places to remember to fix things.
Ideally, at least.

Author: DWesl

lib/matplotlib/testing/__init__.py

@@ -50,6 +50,63 @@ def setup():
     set_reproducibility_for_testing()
 
 
+def subprocess_run_for_testing(
+        command: "list[str]",
+        env: "dict[str, str]",
+        timeout=float,
+        stdout=None,
+        stderr=None,
+        check=False,
+        universal_newlines=True,
+        capture_output=False
+) -> "subprocess.Popen":
+    """
+    Create and run a subprocess.
+
+    Thin wrapper around subprocess.run, intended for testing.
+
+    Arguments
+    ---------
+    args : list of str
+    env : dict[str, str]
+    timeout : float
+    stdout, stderr
+    check : bool
+    universal_newlines : bool
+    capture_output : bool
+        Set stdout and stderr to subprocess.PIPE
+
+    Returns
+    -------
+    proc : subprocess.Popen
+
+    See Also
+    --------
+    subprocess.run
+
+    Raises
+    ------
+    pytest.xfail
+        If platform is Cygwin and subprocess reports a fork() failure.
+    """
+    if capture_output:
+        stdout = stderr = subprocess.PIPE
+    try:
+        proc = subprocess.run(
+            command, env=env,
+            timeout=timeout, check=check,
+            stdout=stdout, stderr=stderr,
+            universal_newlines=universal_newlines
+        )
+    except BlockingIOError:
+        if sys.platform == "cygwin":
+            # Might want to make this more specific
+            import pytest
+            pytest.xfail("Fork failure")
+        raise
+    return proc
+
+
 def subprocess_run_helper(func, *args, timeout, extra_env=None):
     """
     Run a function in a sub-process.
@@ -66,23 +123,16 @@ def subprocess_run_helper(func, *args, timeout, extra_env=None):
     """
     target = func.__name__
     module = func.__module__
-    try:
-        proc = subprocess.run(
-            [sys.executable,
-             "-c",
-             f"from {module} import {target}; {target}()",
-             *args],
-            env={**os.environ, "SOURCE_DATE_EPOCH": "0", **(extra_env or {})},
-            timeout=timeout, check=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            universal_newlines=True)
-    except BlockingIOError:
-        if sys.platform == "cygwin":
-            import pytest
-            pytest.xfail("Fork failure")
-        else:
-            raise
+    proc = subprocess_run_for_testing(
+        [sys.executable,
+         "-c",
+         f"from {module} import {target}; {target}()",
+         *args],
+        env={**os.environ, "SOURCE_DATE_EPOCH": "0", **(extra_env or {})},
+        timeout=timeout, check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True)
     return proc
 
 

lib/matplotlib/tests/test_preprocess_data.py

@@ -1,12 +1,12 @@
 import re
-import subprocess
 import sys
 
 import numpy as np
 import pytest
 
 from matplotlib import _preprocess_data
 from matplotlib.axes import Axes
+from matplotlib.testing import subprocess_run_for_testing
 from matplotlib.testing.decorators import check_figures_equal
 
 # Notes on testing the plotting functions itself
@@ -259,12 +259,9 @@ def test_data_parameter_replacement():
         "import matplotlib.pyplot as plt"
     )
     cmd = [sys.executable, "-c", program]
-    try:
-        completed_proc = subprocess.run(cmd, text=True, capture_output=True)
-    except BlockingIOError:
-        if sys.platform == "cygwin":
-            pytest.xfail("Fork failure")
-        raise
+    completed_proc = subprocess_run_for_testing(
+        cmd, text=True, capture_output=True
+    )
     assert 'data parameter docstring error' not in completed_proc.stderr
 
 

lib/matplotlib/tests/test_pyplot.py

@@ -1,13 +1,13 @@
 import difflib
 
 import numpy as np
-import subprocess
 import sys
 from pathlib import Path
 
 import pytest
 
 import matplotlib as mpl
+from matplotlib.testing import subprocess_run_for_testing
 from matplotlib import pyplot as plt
 from matplotlib._api import MatplotlibDeprecationWarning
 
@@ -20,13 +20,9 @@ def test_pyplot_up_to_date(tmpdir):
     plt_file = tmpdir.join('pyplot.py')
     plt_file.write_text(orig_contents, 'utf-8')
 
-    try:
-        subprocess.run([sys.executable, str(gen_script), str(plt_file)],
-                       check=True)
-    except BlockingIOError:
-        if sys.platform == "cygwin":
-            pytest.xfail("Fork failure")
-        raise
+    subprocess_run_for_testing(
+        [sys.executable, str(gen_script), str(plt_file)],
+        check=True)
     new_contents = plt_file.read_text('utf-8')
 
     if orig_contents != new_contents:

lib/matplotlib/tests/test_sphinxext.py

@@ -4,9 +4,9 @@
 import os
 from pathlib import Path
 import shutil
-from subprocess import Popen, PIPE
 import sys
 
+from matplotlib.testing import subprocess_run_for_testing
 import pytest
 
 
@@ -19,15 +19,11 @@ def build_sphinx_html(source_dir, doctree_dir, html_dir, extra_args=None):
     extra_args = [] if extra_args is None else extra_args
     cmd = [sys.executable, '-msphinx', '-W', '-b', 'html',
            '-d', str(doctree_dir), str(source_dir), str(html_dir), *extra_args]
-    try:
-        proc = Popen(cmd, stdout=PIPE, stderr=PIPE, universal_newlines=True,
-                     env={**os.environ, "MPLBACKEND": ""})
-    except BlockingIOError:
-        if sys.platform == "cygwin":
-            pytest.xfail("Fork failure")
-        else:
-            raise
-    out, err = proc.communicate()
+    proc = subprocess_run_for_testing(
+        cmd, capture_output=True, universal_newlines=True,
+        env={**os.environ, "MPLBACKEND": ""})
+    out = proc.stdout
+    err = proc.stderr
 
     assert proc.returncode == 0, \
         f"sphinx build failed with stdout:\n{out}\nstderr:\n{err}\n"
@@ -50,17 +46,12 @@ def test_tinypages(tmp_path):
     # On CI, gcov emits warnings (due to agg headers being included with the
     # same name in multiple extension modules -- but we don't care about their
     # coverage anyways); hide them using GCOV_ERROR_FILE.
-    try:
-        proc = Popen(
-            cmd, stdout=PIPE, stderr=PIPE, universal_newlines=True,
-            env={**os.environ, "MPLBACKEND": "", "GCOV_ERROR_FILE": os.devnull}
-        )
-    except BlockingIOError:
-        if sys.platform == "cygwin":
-            pytest.xfail("Fork failure")
-        else:
-            raise
-    out, err = proc.communicate()
+    proc = subprocess_run_for_testing(
+        cmd, capture_output=True, universal_newlines=True,
+        env={**os.environ, "MPLBACKEND": "", "GCOV_ERROR_FILE": os.devnull}
+    )
+    out = proc.stdout
+    err = proc.stderr
 
     # Build the pages with warnings turned into errors
     build_sphinx_html(tmp_path, doctree_dir, html_dir)