pytest-subprocess 1.5.4__tar.gz → 1.6.0__tar.gz

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/HISTORY.rst

@@ -1,6 +1,18 @@
 History
 =======
 
+1.6.0 (2026-05-10)  
+------------------
+
+Features  
+~~~~~~~~
+* `#206 <https://github.com/aklajnert/pytest-subprocess/pull/206>`_: Add fp.regex() for regex-based command argument matching.
+
+Bug fixes  
+~~~~~~~~~
+* `#207 <https://github.com/aklajnert/pytest-subprocess/pull/207>`_: Fix poll() not reflecting returncode when a callback is registered.
+* `#205 <https://github.com/aklajnert/pytest-subprocess/pull/205>`_: Fix stdin not respecting text mode when text=True or encoding is set.
+
 1.5.4 (2026-03-21)  
 ------------------
 

{pytest_subprocess-1.5.4/pytest_subprocess.egg-info → pytest_subprocess-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-subprocess
-Version: 1.5.4
+Version: 1.6.0
 Summary: A plugin to fake subprocess for pytest
 Author: Andrzej Klajnert
 Author-email: python@aklajnert.pl
@@ -377,10 +377,53 @@ the same name, regardless of the location. This is accomplished with
 
     def test_any_matching_program(fp):
         # define a command that can come from anywhere
-        fp.register([fp.program("python")])
+        executable_name = os.path.basename(sys.executable)
+        fp.register([fp.program(executable_name)])
         assert subprocess.check_call(sys.executable) == 0
 
 
+Regex argument matching
+-----------------------
+
+When a command argument has a predictable *structure* but an unpredictable
+*value* (e.g. a path determined at runtime), you can match it with a regular
+expression using ``fp.regex()``:
+
+.. code-block:: python
+
+    def test_cmake_varying_paths(fp):
+        # Register once; the pattern matches any -S<path> and -B<path> argument.
+        fp.register(
+            ["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")],
+            occurrences=2,
+        )
+
+        # Both calls are matched, even though the paths differ.
+        subprocess.run(
+            ["cmake", "-S/tmp/generated_data", "-B/tmp/build_1234"]
+        )
+        subprocess.run(["cmake", "-S/other/source", "-B/other/build_5678"])
+
+        # This would raise ProcessNotRegisteredError — different subcommand:
+        # subprocess.run(["cmake", "--build", "/tmp/build_1234"])
+
+``fp.regex()`` accepts an optional second argument for ``re`` module flags:
+
+.. code-block:: python
+
+    import re
+
+
+    def test_case_insensitive(fp):
+        fp.register(["git", fp.regex(r"commit", re.IGNORECASE)])
+        subprocess.run(["git", "COMMIT"])  # matches
+
+.. note::
+   ``fp.regex()`` uses ``re.fullmatch()``, so the pattern must cover the
+   **entire** argument string.  Use ``.*`` at the start or end if you need
+   partial matching.
+
+
 Check if process was called
 ---------------------------
 
@@ -555,6 +598,18 @@ This `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`
 History
 =======
 
+1.6.0 (2026-05-10)  
+------------------
+
+Features  
+~~~~~~~~
+* `#206 <https://github.com/aklajnert/pytest-subprocess/pull/206>`_: Add fp.regex() for regex-based command argument matching.
+
+Bug fixes  
+~~~~~~~~~
+* `#207 <https://github.com/aklajnert/pytest-subprocess/pull/207>`_: Fix poll() not reflecting returncode when a callback is registered.
+* `#205 <https://github.com/aklajnert/pytest-subprocess/pull/205>`_: Fix stdin not respecting text mode when text=True or encoding is set.
+
 1.5.4 (2026-03-21)  
 ------------------
 

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/README.rst

@@ -311,10 +311,53 @@ the same name, regardless of the location. This is accomplished with
 
     def test_any_matching_program(fp):
         # define a command that can come from anywhere
-        fp.register([fp.program("python")])
+        executable_name = os.path.basename(sys.executable)
+        fp.register([fp.program(executable_name)])
         assert subprocess.check_call(sys.executable) == 0
 
 
+Regex argument matching
+-----------------------
+
+When a command argument has a predictable *structure* but an unpredictable
+*value* (e.g. a path determined at runtime), you can match it with a regular
+expression using ``fp.regex()``:
+
+.. code-block:: python
+
+    def test_cmake_varying_paths(fp):
+        # Register once; the pattern matches any -S<path> and -B<path> argument.
+        fp.register(
+            ["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")],
+            occurrences=2,
+        )
+
+        # Both calls are matched, even though the paths differ.
+        subprocess.run(
+            ["cmake", "-S/tmp/generated_data", "-B/tmp/build_1234"]
+        )
+        subprocess.run(["cmake", "-S/other/source", "-B/other/build_5678"])
+
+        # This would raise ProcessNotRegisteredError — different subcommand:
+        # subprocess.run(["cmake", "--build", "/tmp/build_1234"])
+
+``fp.regex()`` accepts an optional second argument for ``re`` module flags:
+
+.. code-block:: python
+
+    import re
+
+
+    def test_case_insensitive(fp):
+        fp.register(["git", fp.regex(r"commit", re.IGNORECASE)])
+        subprocess.run(["git", "COMMIT"])  # matches
+
+.. note::
+   ``fp.regex()`` uses ``re.fullmatch()``, so the pattern must cover the
+   **entire** argument string.  Use ``.*`` at the start or end if you need
+   partial matching.
+
+
 Check if process was called
 ---------------------------
 

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/pytest_subprocess/fake_popen.py

@@ -139,6 +139,16 @@ class FakePopen:
         return None
 
     def poll(self) -> Optional[int]:
+        if (
+            self.returncode is None
+            and self.__thread is not None
+            and not self.__thread.is_alive()
+        ):
+            # The callback/wait thread has finished but _finalize_thread() has
+            # not been called yet (e.g. the caller uses poll() instead of
+            # wait()/communicate()).  Finalise now so returncode is updated,
+            # mirroring real subprocess.Popen.poll() behaviour.
+            self._finalize_thread(None)
         return self.returncode
 
     def wait(self, timeout: Optional[float] = None) -> int:
@@ -170,10 +180,6 @@ class FakePopen:
         self.__kwargs = self.safe_copy(kwargs)
         self.__universal_newlines = kwargs.get("universal_newlines", None)
 
-        stdin = kwargs.get("stdin")
-        if stdin == subprocess.PIPE:
-            self.stdin = self._get_empty_buffer(False)
-
         text = kwargs.get("text", None)
         encoding = kwargs.get("encoding", None)
         errors = kwargs.get("errors", None)
@@ -183,6 +189,10 @@ class FakePopen:
 
         self.text_mode = bool(text or self.__universal_newlines or encoding or errors)
 
+        stdin = kwargs.get("stdin")
+        if stdin == subprocess.PIPE:
+            self.stdin = self._get_empty_buffer(self.text_mode)
+
         # validation taken from the real subprocess
         if (
             text is not None

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/pytest_subprocess/fake_process.py

@@ -21,6 +21,7 @@ from .types import OPTIONAL_TEXT_OR_ITERABLE
 from .utils import Any
 from .utils import Command
 from .utils import Program
+from .utils import Regex
 
 
 class FakeProcess:
@@ -28,6 +29,7 @@ class FakeProcess:
 
     any: ClassVar[Type[Any]] = Any
     program: ClassVar[Type[Program]] = Program
+    regex: ClassVar[Type[Regex]] = Regex
 
     def __init__(self) -> None:
         self.definitions: DefaultDict[Command, Deque[Union[Dict, bool]]] = defaultdict(

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/pytest_subprocess/utils.py

@@ -1,4 +1,5 @@
 import os
+import re
 import shlex
 import sys
 import threading
@@ -15,7 +16,7 @@ from typing import Union
 if TYPE_CHECKING:
     from .types import COMMAND
 
-ARGUMENT = Union[str, "Any", os.PathLike, "Program"]
+ARGUMENT = Union[str, "Any", "Regex", os.PathLike, "Program"]
 
 
 class Thread(threading.Thread):
@@ -189,3 +190,54 @@ class Program:
 
     def __hash__(self) -> int:
         return hash(self.program)
+
+
+class Regex:
+    """Match a single command argument against a regular expression.
+
+    Uses :func:`re.fullmatch`, so the pattern must cover the *entire* argument
+    string.  Use ``.*`` at the start or end if partial matching is desired.
+
+    Example::
+
+        def test_cmake_varying_paths(fp):
+            fp.register(["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")])
+
+            # All of these would match:
+            subprocess.run(["cmake", "-S/tmp/src", "-B/tmp/build"])
+            subprocess.run(["cmake", "-S/other/src", "-B/other/build"])
+
+            # This would NOT match (wrong argument order or missing args):
+            # subprocess.run(["cmake", "-B/tmp/build", "-S/tmp/src"])
+
+    Args:
+        pattern: Regular expression pattern to match against.
+        flags: Optional :mod:`re` flags (e.g. ``re.IGNORECASE``).
+    """
+
+    def __init__(self, pattern: str, flags: int = 0) -> None:
+        self._compiled = re.compile(pattern, flags)
+
+    @property
+    def pattern(self) -> str:
+        """The original pattern string."""
+        return self._compiled.pattern
+
+    @property
+    def flags(self) -> int:
+        """The compiled regex flags."""
+        return self._compiled.flags
+
+    def __eq__(self, other: AnyType) -> bool:
+        if isinstance(other, str):
+            return bool(self._compiled.fullmatch(other))
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash((self._compiled.pattern, self._compiled.flags))
+
+    def __repr__(self) -> str:
+        return f"Regex({self._compiled.pattern!r})"
+
+    def __str__(self) -> str:
+        return repr(self)

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0/pytest_subprocess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-subprocess
-Version: 1.5.4
+Version: 1.6.0
 Summary: A plugin to fake subprocess for pytest
 Author: Andrzej Klajnert
 Author-email: python@aklajnert.pl
@@ -377,10 +377,53 @@ the same name, regardless of the location. This is accomplished with
 
     def test_any_matching_program(fp):
         # define a command that can come from anywhere
-        fp.register([fp.program("python")])
+        executable_name = os.path.basename(sys.executable)
+        fp.register([fp.program(executable_name)])
         assert subprocess.check_call(sys.executable) == 0
 
 
+Regex argument matching
+-----------------------
+
+When a command argument has a predictable *structure* but an unpredictable
+*value* (e.g. a path determined at runtime), you can match it with a regular
+expression using ``fp.regex()``:
+
+.. code-block:: python
+
+    def test_cmake_varying_paths(fp):
+        # Register once; the pattern matches any -S<path> and -B<path> argument.
+        fp.register(
+            ["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")],
+            occurrences=2,
+        )
+
+        # Both calls are matched, even though the paths differ.
+        subprocess.run(
+            ["cmake", "-S/tmp/generated_data", "-B/tmp/build_1234"]
+        )
+        subprocess.run(["cmake", "-S/other/source", "-B/other/build_5678"])
+
+        # This would raise ProcessNotRegisteredError — different subcommand:
+        # subprocess.run(["cmake", "--build", "/tmp/build_1234"])
+
+``fp.regex()`` accepts an optional second argument for ``re`` module flags:
+
+.. code-block:: python
+
+    import re
+
+
+    def test_case_insensitive(fp):
+        fp.register(["git", fp.regex(r"commit", re.IGNORECASE)])
+        subprocess.run(["git", "COMMIT"])  # matches
+
+.. note::
+   ``fp.regex()`` uses ``re.fullmatch()``, so the pattern must cover the
+   **entire** argument string.  Use ``.*`` at the start or end if you need
+   partial matching.
+
+
 Check if process was called
 ---------------------------
 
@@ -555,6 +598,18 @@ This `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`
 History
 =======
 
+1.6.0 (2026-05-10)  
+------------------
+
+Features  
+~~~~~~~~
+* `#206 <https://github.com/aklajnert/pytest-subprocess/pull/206>`_: Add fp.regex() for regex-based command argument matching.
+
+Bug fixes  
+~~~~~~~~~
+* `#207 <https://github.com/aklajnert/pytest-subprocess/pull/207>`_: Fix poll() not reflecting returncode when a callback is registered.
+* `#205 <https://github.com/aklajnert/pytest-subprocess/pull/205>`_: Fix stdin not respecting text mode when text=True or encoding is set.
+
 1.5.4 (2026-03-21)  
 ------------------
 

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/setup.py

@@ -16,7 +16,7 @@ requirements = ["pytest>=4.0.0"]
 
 setup(
     name="pytest-subprocess",
-    version="1.5.4",
+    version="1.6.0",
     author="Andrzej Klajnert",
     author_email="python@aklajnert.pl",
     maintainer="Andrzej Klajnert",

{pytest_subprocess-1.5.4 → pytest_subprocess-1.6.0}/tests/test_subprocess.py

@@ -1,5 +1,6 @@
 import contextlib
 import getpass
+import io
 import os
 import platform
 import signal
@@ -913,6 +914,49 @@ def test_callback_and_return_code(fp):
     assert process.returncode == 5
 
 
+def test_poll_reflects_returncode_after_callback(fp):
+    """
+    poll() must return the registered returncode once the callback thread has
+    finished, without requiring the caller to invoke wait() or communicate().
+
+    Before the fix, poll() always returned None when a callback was registered.
+    """
+
+    def slow_callback(process):
+        time.sleep(0.1)
+
+    fp.register(["my-tool"], returncode=1, callback=slow_callback)
+    proc = subprocess.Popen(["my-tool"])
+
+    # While the callback is still running, poll() must return None.
+    assert proc.poll() is None
+
+    # Wait for the callback thread to finish, then poll() must return the
+    # registered returncode.
+    proc.wait()
+    assert proc.poll() == 1
+
+
+def test_poll_reflects_returncode_after_callback_polling_loop(fp):
+    """
+    Callers that spin on proc.poll() is None (a common real-subprocess idiom)
+    must eventually observe a non-None returncode once the callback finishes.
+    """
+
+    def callback_with_delay(process):
+        time.sleep(0.05)
+
+    fp.register(["my-tool"], returncode=42, callback=callback_with_delay)
+    proc = subprocess.Popen(["my-tool"])
+
+    deadline = time.monotonic() + 5.0  # generous upper bound
+    while proc.poll() is None:
+        assert time.monotonic() < deadline, "poll() never reflected returncode"
+        time.sleep(0.01)
+
+    assert proc.returncode == 42
+
+
 @pytest.mark.skipif(
     sys.version_info <= (3, 6),
     reason="encoding and errors has been introduced in 3.6",
@@ -1351,6 +1395,62 @@ def test_stdin_pipe(fp):
         process.stdin.write(b"more data")
 
 
+def test_stdin_pipe_text_mode(fp):
+    """
+    Test that stdin is a StringIO (text) buffer when using
+    subprocess.PIPE with text=True.
+
+    From GitHub #204
+    """
+    fp.register(["my-command"], stdout="hello\n")
+
+    process = subprocess.Popen(
+        ["my-command"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    assert process.stdin is not None
+    assert isinstance(process.stdin, io.StringIO)
+    assert process.stdin.writable()
+
+    # Should accept str, not bytes, in text mode.
+    process.stdin.write("some input")
+    process.stdin.flush()
+
+    process.stdin.seek(0)
+    assert process.stdin.read() == "some input"
+
+    process.stdin.close()
+    with pytest.raises(ValueError):
+        process.stdin.write("more data")
+
+
+def test_stdin_pipe_encoding_mode(fp):
+    """
+    Test that stdin is a StringIO (text) buffer when
+    using subprocess.PIPE with encoding set.
+
+    From GitHub #204
+    """
+    fp.register(["my-command"])
+
+    process = subprocess.Popen(
+        ["my-command"],
+        stdin=subprocess.PIPE,
+        encoding="utf-8",
+    )
+
+    assert process.stdin is not None
+    assert isinstance(process.stdin, io.StringIO)
+    assert process.stdin.writable()
+
+    process.stdin.write("some input")
+    process.stdin.close()
+
+
 def test_stdout_stderr_as_file_bug(fp):
     """
     Test that no TypeError is raised when stdout/stderr is a file
@@ -1401,3 +1501,91 @@ def test_imported_popen_is_patched(fp):
 
     assert process.returncode == 0
     assert out == b"\x00"
+
+
+# ---------------------------------------------------------------------------
+# Regex command matching – issue #154
+# ---------------------------------------------------------------------------
+
+
+def test_regex_matches_varying_argument(fp):
+    """
+    fp.regex() must match a single command argument against a regex pattern,
+    allowing commands with variable argument values to be registered once.
+    """
+    fp.register(["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")], occurrences=2)
+
+    # Both calls use the same registration; argument values differ.
+    proc1 = subprocess.run(["cmake", "-S/tmp/source1", "-B/tmp/build1"])
+    proc2 = subprocess.run(["cmake", "-S/other/source", "-B/other/build"])
+
+    assert proc1.returncode == 0
+    assert proc2.returncode == 0
+
+
+def test_regex_does_not_match_wrong_argument(fp):
+    """
+    Commands whose arguments do NOT match the registered regex pattern must
+    raise ProcessNotRegisteredError, not silently succeed.
+    """
+    fp.register(["cmake", fp.regex(r"-S.+"), fp.regex(r"-B.+")])
+
+    # Wrong subcommand — does not match the -S/-B pattern.
+    with pytest.raises(fp.exceptions.ProcessNotRegisteredError):
+        subprocess.run(["cmake", "--build", "/tmp/build"])
+
+
+def test_regex_case_insensitive_flag(fp):
+    """
+    fp.regex() must accept re module flags such as re.IGNORECASE.
+    """
+    import re
+
+    fp.register(["git", fp.regex(r"commit", re.IGNORECASE)], stdout="sha: abc123\n")
+
+    # Exact case
+    proc1 = subprocess.run(["git", "commit"], capture_output=True)
+    assert proc1.stdout == b"sha: abc123\n"
+
+    # Different case
+    fp.register(["git", fp.regex(r"commit", re.IGNORECASE)], stdout="sha: abc123\n")
+    proc2 = subprocess.run(["git", "COMMIT"], capture_output=True)
+    assert proc2.stdout == b"sha: abc123\n"
+
+
+def test_regex_fullmatch_semantics(fp):
+    """
+    fp.regex() uses fullmatch: the pattern must cover the *entire* argument
+    string.  A pattern that only matches a substring must NOT match.
+    """
+    # "-S" alone does not fullmatch "-S/some/path" (pattern too short)
+    fp.register(["cmake", fp.regex(r"-S"), fp.regex(r"-B")])
+    with pytest.raises(fp.exceptions.ProcessNotRegisteredError):
+        # "-S/tmp/source" does not fullmatch the pattern "-S" (no extra chars)
+        subprocess.run(["cmake", "-S/tmp/source", "-B/tmp/build"])
+
+
+def test_regex_repr(fp):
+    """
+    fp.regex() instances have a helpful repr for debugging.
+    """
+    r = fp.regex(r"-S.+")
+    assert "-S.+" in repr(r)
+
+
+def test_regex_combined_with_any(fp):
+    """
+    fp.regex() can be combined freely with fp.any() and exact strings in
+    the same command registration.
+    """
+    # Exact "cmake", then any number of arguments matching the -D prefix
+    fp.register(
+        ["cmake", fp.regex(r"-D.+=.+"), fp.any()],
+        stdout="configured\n",
+    )
+
+    proc = subprocess.run(
+        ["cmake", "-DCMAKE_BUILD_TYPE=Release", "-S/tmp/src", "-B/tmp/build"],
+        capture_output=True,
+    )
+    assert proc.stdout == b"configured\n"