pytest-subprocess 1.5.2__tar.gz → 1.5.3__tar.gz

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/HISTORY.rst

@@ -1,6 +1,19 @@
 History
 =======
 
+1.5.3 (2025-01-04)  
+------------------
+
+Features  
+~~~~~~~~
+* `#171 <https://github.com/aklajnert/pytest-subprocess/pull/171>`_, `#178 <https://github.com/aklajnert/pytest-subprocess/pull/178>`_: Allow to access keyword arguments passed to Popen.
+
+Bug fixes  
+~~~~~~~~~
+* `#180 <https://github.com/aklajnert/pytest-subprocess/pull/180>`_: Fixed an incorrect wait timeout calculation.
+* `#170 <https://github.com/aklajnert/pytest-subprocess/pull/170>`_: Wrapped ProcessDispatcher.dispatch into FakePopenWrapper as it was causing TypeError when Popen is used as a type.
+* `#169 <https://github.com/aklajnert/pytest-subprocess/pull/169>`_: Get rid of using thread in AsyncFakePopen as it causes thread.join() to hang indefinitely.
+
 1.5.2 (2024-07-24)  
 ------------------
 

{pytest_subprocess-1.5.2/pytest_subprocess.egg-info → pytest_subprocess-1.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytest-subprocess
-Version: 1.5.2
+Version: 1.5.3
 Summary: A plugin to fake subprocess for pytest
 Author: Andrzej Klajnert
 Author-email: python@aklajnert.pl
@@ -22,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: OS Independent
@@ -31,7 +33,6 @@ License-File: LICENSE
 Requires-Dist: pytest>=4.0.0
 Provides-Extra: test
 Requires-Dist: pytest>=4.0; extra == "test"
-Requires-Dist: coverage; extra == "test"
 Requires-Dist: docutils>=0.12; extra == "test"
 Requires-Dist: Pygments>=2.0; extra == "test"
 Requires-Dist: pytest-rerunfailures; extra == "test"
@@ -60,9 +61,6 @@ pytest-subprocess
     :target: https://pypi.org/project/pytest-subprocess
     :alt: Python versions
 
-.. image:: https://codecov.io/gh/aklajnert/pytest-subprocess/branch/master/graph/badge.svg?token=JAU1cGoYL8
-  :target: https://codecov.io/gh/aklajnert/pytest-subprocess
-
 .. image:: https://readthedocs.org/projects/pytest-subprocess/badge/?version=latest
    :target: https://pytest-subprocess.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status
@@ -402,6 +400,40 @@ how many a command has been called. The latter supports ``fp.any()``.
         assert fp.call_count(["cp", fp.any()]) == 3
 
 
+Check Popen arguments
+---------------------
+
+You can use the recorded calls functionality to introspect the keyword
+arguments that were passed to `Popen`.
+
+.. code-block:: python
+
+    def test_process_recorder_kwargs(fp):
+        fp.keep_last_process(True)
+        recorder = fp.register(["test_script", fp.any()])
+
+        subprocess.run(
+            ("test_script", "arg1"), env={"foo": "bar"}, cwd="/home/user"
+        )
+        subprocess.Popen(
+            ["test_script", "arg2"],
+            env={"foo": "bar1"},
+            executable="test_script",
+            shell=True,
+        )
+
+        assert recorder.calls[0].args == ("test_script", "arg1")
+        assert recorder.calls[0].kwargs == {
+            "cwd": "/home/user",
+            "env": {"foo": "bar"},
+        }
+        assert recorder.calls[1].args == ["test_script", "arg2"]
+        assert recorder.calls[1].kwargs == {
+            "env": {"foo": "bar1"},
+            "executable": "test_script",
+            "shell": True,
+        }
+
 Handling signals
 ----------------
 
@@ -507,6 +539,19 @@ This `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`
 History
 =======
 
+1.5.3 (2025-01-04)  
+------------------
+
+Features  
+~~~~~~~~
+* `#171 <https://github.com/aklajnert/pytest-subprocess/pull/171>`_, `#178 <https://github.com/aklajnert/pytest-subprocess/pull/178>`_: Allow to access keyword arguments passed to Popen.
+
+Bug fixes  
+~~~~~~~~~
+* `#180 <https://github.com/aklajnert/pytest-subprocess/pull/180>`_: Fixed an incorrect wait timeout calculation.
+* `#170 <https://github.com/aklajnert/pytest-subprocess/pull/170>`_: Wrapped ProcessDispatcher.dispatch into FakePopenWrapper as it was causing TypeError when Popen is used as a type.
+* `#169 <https://github.com/aklajnert/pytest-subprocess/pull/169>`_: Get rid of using thread in AsyncFakePopen as it causes thread.join() to hang indefinitely.
+
 1.5.2 (2024-07-24)  
 ------------------
 

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/README.rst

@@ -10,9 +10,6 @@ pytest-subprocess
     :target: https://pypi.org/project/pytest-subprocess
     :alt: Python versions
 
-.. image:: https://codecov.io/gh/aklajnert/pytest-subprocess/branch/master/graph/badge.svg?token=JAU1cGoYL8
-  :target: https://codecov.io/gh/aklajnert/pytest-subprocess
-
 .. image:: https://readthedocs.org/projects/pytest-subprocess/badge/?version=latest
    :target: https://pytest-subprocess.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status
@@ -352,6 +349,40 @@ how many a command has been called. The latter supports ``fp.any()``.
         assert fp.call_count(["cp", fp.any()]) == 3
 
 
+Check Popen arguments
+---------------------
+
+You can use the recorded calls functionality to introspect the keyword
+arguments that were passed to `Popen`.
+
+.. code-block:: python
+
+    def test_process_recorder_kwargs(fp):
+        fp.keep_last_process(True)
+        recorder = fp.register(["test_script", fp.any()])
+
+        subprocess.run(
+            ("test_script", "arg1"), env={"foo": "bar"}, cwd="/home/user"
+        )
+        subprocess.Popen(
+            ["test_script", "arg2"],
+            env={"foo": "bar1"},
+            executable="test_script",
+            shell=True,
+        )
+
+        assert recorder.calls[0].args == ("test_script", "arg1")
+        assert recorder.calls[0].kwargs == {
+            "cwd": "/home/user",
+            "env": {"foo": "bar"},
+        }
+        assert recorder.calls[1].args == ["test_script", "arg2"]
+        assert recorder.calls[1].kwargs == {
+            "env": {"foo": "bar1"},
+            "executable": "test_script",
+            "shell": True,
+        }
+
 Handling signals
 ----------------
 

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/pytest_subprocess/__init__.py

@@ -1,4 +1,5 @@
 """Main module"""
+
 from . import exceptions
 from .fake_process import FakeProcess
 

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/pytest_subprocess/fake_popen.py

@@ -1,6 +1,9 @@
 """FakePopen class declaration"""
+
 import asyncio
 import collections.abc
+import concurrent.futures
+import copy
 import io
 import os
 import signal
@@ -66,16 +69,22 @@ class FakePopen:
                     msg = f"argument of type {arg.__class__.__name__!r} is not iterable"
                     raise TypeError(msg)
         self.args = command
+        self.__kwargs: Optional[Dict[str, AnyType]] = None
         self.__stdout: OPTIONAL_TEXT_OR_ITERABLE = stdout
         self.__stderr: OPTIONAL_TEXT_OR_ITERABLE = stderr
-        self.__returncode: Optional[int] = returncode
-        self.__wait: Optional[float] = wait
         self.__thread: Optional[Thread] = None
-        self.__callback: Optional[Optional[Callable]] = callback
-        self.__callback_kwargs: Optional[Dict[str, AnyType]] = callback_kwargs
         self.__signal_callback: Optional[Callable] = signal_callback
         self.__stdin_callable: Optional[Optional[Callable]] = stdin_callable
+        self.__universal_newlines: Optional[Dict[AnyType, AnyType]] = None
         self._signals: List[int] = []
+        self._returncode: Optional[int] = returncode
+        self._wait_timeout: Optional[float] = wait
+        self._callback: Optional[Optional[Callable]] = callback
+        self._callback_kwargs: Optional[Dict[str, AnyType]] = callback_kwargs
+
+    @property
+    def kwargs(self) -> Optional[Dict[str, AnyType]]:
+        return self.__kwargs
 
     def __enter__(self) -> "FakePopen":
         return self
@@ -115,8 +124,8 @@ class FakePopen:
         if self.__thread is None:
             return
         self.__thread.join(timeout)
-        if self.returncode is None and self.__returncode is not None:
-            self.returncode = self.__returncode
+        if self.returncode is None and self._returncode is not None:
+            self.returncode = self._returncode
         if self.__thread.exception:
             raise self.__thread.exception
 
@@ -132,9 +141,10 @@ class FakePopen:
         return self.returncode
 
     def wait(self, timeout: Optional[float] = None) -> int:
-        if timeout and self.__wait and timeout < self.__wait:
-            self.__wait -= timeout
-            raise subprocess.TimeoutExpired(self.args, timeout)
+        if timeout and self._wait_timeout:
+            self._wait_timeout -= timeout
+            if timeout < self._wait_timeout:
+                raise subprocess.TimeoutExpired(self.args, timeout)
         self._finalize_thread(timeout)
         if self.returncode is None:
             raise exceptions.PluginInternalError
@@ -156,6 +166,7 @@ class FakePopen:
 
     def configure(self, **kwargs: Optional[Dict]) -> None:
         """Setup the FakePopen instance based on a real Popen arguments."""
+        self.__kwargs = self.safe_copy(kwargs)
         self.__universal_newlines = kwargs.get("universal_newlines", None)
         text = kwargs.get("text", None)
         encoding = kwargs.get("encoding", None)
@@ -192,6 +203,16 @@ class FakePopen:
         elif isinstance(stderr, (io.BufferedWriter, io.TextIOWrapper)):
             self._write_to_buffer(self.__stderr, stderr)
 
+    @staticmethod
+    def safe_copy(kwargs: Dict[str, AnyType]) -> Dict[str, AnyType]:
+        """
+        Deepcopy can fail if the value is not serializable, fallback to shallow copy.
+        """
+        try:
+            return copy.deepcopy(kwargs)
+        except TypeError:
+            return dict(**kwargs)
+
     def _prepare_buffer(
         self,
         input: OPTIONAL_TEXT_OR_ITERABLE,
@@ -284,21 +305,21 @@ class FakePopen:
 
     def run_thread(self) -> None:
         """Run the user-defined callback or wait in a thread."""
-        if self.__wait is None and self.__callback is None:
+        if self._wait_timeout is None and self._callback is None:
             self._finish_process()
         else:
-            if self.__callback:
+            if self._callback:
                 self.__thread = Thread(
-                    target=self.__callback,
+                    target=self._callback,
                     args=(self,),
-                    kwargs=self.__callback_kwargs or {},
+                    kwargs=self._callback_kwargs or {},
                 )
             else:
-                self.__thread = Thread(target=self._wait, args=(self.__wait,))
+                self.__thread = Thread(target=self._wait, args=(self._wait_timeout,))
             self.__thread.start()
 
     def _finish_process(self) -> None:
-        self.returncode = self.__returncode
+        self.returncode = self._returncode
 
         self._finalize_streams()
 
@@ -334,16 +355,20 @@ class AsyncFakePopen(FakePopen):
 
             # feed eof one more time as streams were opened
             self._finalize_streams()
-
-        self._finalize_thread(timeout)
-
+        await self._finalize(timeout)
         return (
             await self.stdout.read() if self.stdout else None,
             await self.stderr.read() if self.stderr else None,
         )
 
     async def wait(self, timeout: Optional[float] = None) -> int:  # type: ignore
-        return super().wait(timeout)
+        if timeout and self._wait_timeout and timeout < self._wait_timeout:
+            self._wait_timeout -= timeout
+            raise subprocess.TimeoutExpired(self.args, timeout)
+        await self._finalize(timeout)
+        if self.returncode is None:
+            raise exceptions.PluginInternalError
+        return self.returncode
 
     def _get_empty_buffer(self, _: bool) -> asyncio.StreamReader:
         return asyncio.StreamReader()
@@ -361,3 +386,34 @@ class AsyncFakePopen(FakePopen):
             fresh_stream.feed_data(data)
             return fresh_stream
         return None
+
+    def run_thread(self) -> None:
+        """Async impl should not contain any thread based implementation"""
+
+    def evaluate(self) -> None:
+        """Check if process needs to be finished."""
+        if self._wait_timeout is None and self._callback is None:
+            self._finish_process()
+
+    async def _run_callback_in_executor(self) -> None:
+        """Run in executor the user-defined callback or wait."""
+        loop = asyncio.get_running_loop()
+        with concurrent.futures.ThreadPoolExecutor() as pool:
+            if self._callback:
+                kwargs = self._callback_kwargs or {}
+                cbk = partial(self._callback, **kwargs)
+                await loop.run_in_executor(pool, cbk, self)
+            elif self._wait_timeout is not None:
+                await loop.run_in_executor(pool, self._wait, self._wait_timeout)
+
+    async def _finalize(self, timeout: Optional[float] = None) -> None:
+        """Run the user-defined callback or wait. Finish process"""
+        if self.returncode is not None:
+            return
+        if timeout is not None:
+            await asyncio.wait_for(self._run_callback_in_executor(), timeout=timeout)
+        else:
+            await self._run_callback_in_executor()
+        if self.returncode is None:
+            self.returncode = self._returncode
+        self._finalize_streams()

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/pytest_subprocess/fake_process.py

@@ -1,4 +1,5 @@
 """FakeProcess class declaration"""
+
 from collections import defaultdict
 from collections import deque
 from typing import Any as AnyType

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/pytest_subprocess/process_dispatcher.py

@@ -1,4 +1,5 @@
 """ProcessDispatcher class declaration"""
+
 import asyncio
 import subprocess
 import sys
@@ -7,10 +8,12 @@ from collections import deque
 from copy import deepcopy
 from functools import partial
 from typing import Any as AnyType
+from typing import AnyStr
 from typing import Awaitable
 from typing import Callable
 from typing import Deque
 from typing import Dict
+from typing import Generic
 from typing import List
 from typing import Optional
 from typing import Tuple
@@ -28,6 +31,9 @@ if typing.TYPE_CHECKING:
     from .fake_process import FakeProcess
 
 
+__all__ = ["ProcessDispatcher"]
+
+
 class ProcessDispatcher:
     """Main class for handling processes."""
 
@@ -43,7 +49,7 @@ class ProcessDispatcher:
     def register(cls, process: "FakeProcess") -> None:
         if not cls.process_list:
             cls.built_in_popen = subprocess.Popen
-            subprocess.Popen = cls.dispatch  # type: ignore
+            subprocess.Popen = FakePopenWrapper  # type: ignore
 
             cls.built_in_async_subprocess = asyncio.subprocess
             asyncio.create_subprocess_shell = cls.async_shell  # type: ignore
@@ -161,7 +167,7 @@ class ProcessDispatcher:
         result = cls._prepare_instance(AsyncFakePopen, command, kwargs, process)
         if not isinstance(result, AsyncFakePopen):
             raise exceptions.PluginInternalError
-        result.run_thread()
+        result.evaluate()
         return result
 
     @classmethod
@@ -237,3 +243,10 @@ class ProcessDispatcher:
             if processes and isinstance(processes, deque):
                 return command_instance, processes, process_instance
         return None, None, None
+
+
+class FakePopenWrapper(Generic[AnyStr]):
+    def __new__(  # type: ignore
+        cls, command: COMMAND, **kwargs: Optional[Dict]
+    ) -> FakePopen:
+        return ProcessDispatcher.dispatch(command, **kwargs)  # type: ignore

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3/pytest_subprocess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytest-subprocess
-Version: 1.5.2
+Version: 1.5.3
 Summary: A plugin to fake subprocess for pytest
 Author: Andrzej Klajnert
 Author-email: python@aklajnert.pl
@@ -22,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: OS Independent
@@ -31,7 +33,6 @@ License-File: LICENSE
 Requires-Dist: pytest>=4.0.0
 Provides-Extra: test
 Requires-Dist: pytest>=4.0; extra == "test"
-Requires-Dist: coverage; extra == "test"
 Requires-Dist: docutils>=0.12; extra == "test"
 Requires-Dist: Pygments>=2.0; extra == "test"
 Requires-Dist: pytest-rerunfailures; extra == "test"
@@ -60,9 +61,6 @@ pytest-subprocess
     :target: https://pypi.org/project/pytest-subprocess
     :alt: Python versions
 
-.. image:: https://codecov.io/gh/aklajnert/pytest-subprocess/branch/master/graph/badge.svg?token=JAU1cGoYL8
-  :target: https://codecov.io/gh/aklajnert/pytest-subprocess
-
 .. image:: https://readthedocs.org/projects/pytest-subprocess/badge/?version=latest
    :target: https://pytest-subprocess.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status
@@ -402,6 +400,40 @@ how many a command has been called. The latter supports ``fp.any()``.
         assert fp.call_count(["cp", fp.any()]) == 3
 
 
+Check Popen arguments
+---------------------
+
+You can use the recorded calls functionality to introspect the keyword
+arguments that were passed to `Popen`.
+
+.. code-block:: python
+
+    def test_process_recorder_kwargs(fp):
+        fp.keep_last_process(True)
+        recorder = fp.register(["test_script", fp.any()])
+
+        subprocess.run(
+            ("test_script", "arg1"), env={"foo": "bar"}, cwd="/home/user"
+        )
+        subprocess.Popen(
+            ["test_script", "arg2"],
+            env={"foo": "bar1"},
+            executable="test_script",
+            shell=True,
+        )
+
+        assert recorder.calls[0].args == ("test_script", "arg1")
+        assert recorder.calls[0].kwargs == {
+            "cwd": "/home/user",
+            "env": {"foo": "bar"},
+        }
+        assert recorder.calls[1].args == ["test_script", "arg2"]
+        assert recorder.calls[1].kwargs == {
+            "env": {"foo": "bar1"},
+            "executable": "test_script",
+            "shell": True,
+        }
+
 Handling signals
 ----------------
 
@@ -507,6 +539,19 @@ This `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`
 History
 =======
 
+1.5.3 (2025-01-04)  
+------------------
+
+Features  
+~~~~~~~~
+* `#171 <https://github.com/aklajnert/pytest-subprocess/pull/171>`_, `#178 <https://github.com/aklajnert/pytest-subprocess/pull/178>`_: Allow to access keyword arguments passed to Popen.
+
+Bug fixes  
+~~~~~~~~~
+* `#180 <https://github.com/aklajnert/pytest-subprocess/pull/180>`_: Fixed an incorrect wait timeout calculation.
+* `#170 <https://github.com/aklajnert/pytest-subprocess/pull/170>`_: Wrapped ProcessDispatcher.dispatch into FakePopenWrapper as it was causing TypeError when Popen is used as a type.
+* `#169 <https://github.com/aklajnert/pytest-subprocess/pull/169>`_: Get rid of using thread in AsyncFakePopen as it causes thread.join() to hang indefinitely.
+
 1.5.2 (2024-07-24)  
 ------------------
 

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/pytest_subprocess.egg-info/requires.txt

@@ -13,7 +13,6 @@ changelogd
 
 [test]
 pytest>=4.0
-coverage
 docutils>=0.12
 Pygments>=2.0
 pytest-rerunfailures

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/setup.py

@@ -16,7 +16,7 @@ requirements = ["pytest>=4.0.0"]
 
 setup(
     name="pytest-subprocess",
-    version="1.5.2",
+    version="1.5.3",
     author="Andrzej Klajnert",
     author_email="python@aklajnert.pl",
     maintainer="Andrzej Klajnert",
@@ -34,7 +34,6 @@ setup(
     extras_require={
         "test": [
             "pytest>=4.0",
-            "coverage",
             "docutils>=0.12",
             "Pygments>=2.0",
             "pytest-rerunfailures",
@@ -66,6 +65,8 @@ setup(
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",
         "Operating System :: OS Independent",

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/tests/example_script.py

@@ -1,4 +1,5 @@
 """An example script to test subprocess."""
+
 import sys
 import time
 

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/tests/test_asyncio.py

@@ -338,10 +338,7 @@ async def test_popen_recorder(fp):
         pytest.param(None, id="no-callback"),
         pytest.param(
             lambda process: process,
-            id="noop-callback-causes-infinite-loop",
-            marks=pytest.mark.xfail(
-                strict=True, raises=asyncio.TimeoutError, reason="Github #120"
-            ),
+            id="with-callback",
         ),
     ],
 )
@@ -353,15 +350,53 @@ async def test_asyncio_subprocess_using_callback(callback, fp):
             stderr=asyncio.subprocess.PIPE,
         )
         await process.wait()
-
-        # This reads forever when passing a callback to fp.register
-        # Add a timeout to abort test when condition occurs.
-        return await asyncio.wait_for(process.stdout.read(), timeout=1)
+        return await process.stdout.read()
 
     fp.register(["test"], stdout=b"fizz", callback=callback)
     assert await my_async_func() == b"fizz"
 
 
+@pytest.mark.asyncio
+async def test_asyncio_subprocess_using_communicate_with_callback_kwargs(fp):
+    expected_some_value = 2
+
+    def cbk(fake_obj, some_value=None):
+        assert expected_some_value == some_value
+        return fake_obj
+
+    async def my_async_func():
+        process = await asyncio.create_subprocess_exec(
+            "test",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        out, _ = await process.communicate()
+        return out
+
+    fp.register(
+        ["test"],
+        stdout=b"fizz",
+        callback=cbk,
+        callback_kwargs={"some_value": expected_some_value},
+    )
+    assert await my_async_func() == b"fizz"
+
+
+@pytest.mark.asyncio
+async def test_process_recorder_args(fp):
+    fp.keep_last_process(True)
+    recorder = fp.register(["test_script", fp.any()])
+    await asyncio.create_subprocess_exec(
+        "test_script",
+        "arg1",
+        env={"foo": "bar"},
+    )
+
+    assert recorder.call_count() == 1
+    assert recorder.calls[0].args == ["test_script", "arg1"]
+    assert recorder.calls[0].kwargs == {"env": {"foo": "bar"}}
+
+
 @pytest.fixture(autouse=True)
 def skip_on_pypy():
     """Async test for some reason crash on pypy 3.6 on Windows"""

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/tests/test_subprocess.py

@@ -482,15 +482,15 @@ def test_ambiguous_input(fp, fake):
 @pytest.mark.parametrize("fake", [False, True])
 def test_multiple_wait(fp, fake):
     """
-    Wait multiple times for 0.2 seconds with process lasting for 0.5.
-    Third wait shall is a bit longer and will not raise an exception,
+    Wait multiple times for 0.2 seconds with process lasting for 1s.
+    Third wait shall be a bit longer and will not raise an exception,
     due to exceeding the subprocess runtime.
     """
     fp.allow_unregistered(not fake)
     if fake:
         fp.register(
             [PYTHON, "example_script.py", "wait"],
-            wait=0.5,
+            wait=1,
         )
 
     process = subprocess.Popen(
@@ -500,9 +500,9 @@ def test_multiple_wait(fp, fake):
         process.wait(timeout=0.2)
 
     with pytest.raises(subprocess.TimeoutExpired):
-        process.wait(timeout=0.1)
+        process.wait(timeout=0.2)
 
-    process.wait(0.4)
+    process.wait(0.9)
 
     assert process.returncode == 0
 
@@ -1232,3 +1232,51 @@ def test_process_recorder(fp):
     recorder.clear()
 
     assert not recorder.was_called()
+
+
+def test_process_recorder_args(fp):
+    fp.keep_last_process(True)
+    recorder = fp.register(["test_script", fp.any()])
+
+    subprocess.call(("test_script", "arg1"))
+    subprocess.run(("test_script", "arg2"), env={"foo": "bar"}, cwd="/home/user")
+    subprocess.Popen(
+        ["test_script", "arg3"],
+        env={"foo": "bar1"},
+        executable="test_script",
+        shell=True,
+    )
+
+    assert recorder.call_count() == 3
+    assert recorder.calls[0].args == ("test_script", "arg1")
+    assert recorder.calls[0].kwargs == {}
+    assert recorder.calls[1].args == ("test_script", "arg2")
+    assert recorder.calls[1].kwargs == {"cwd": "/home/user", "env": {"foo": "bar"}}
+    assert recorder.calls[2].args == ["test_script", "arg3"]
+    assert recorder.calls[2].kwargs == {
+        "env": {"foo": "bar1"},
+        "executable": "test_script",
+        "shell": True,
+    }
+
+
+def test_fake_popen_is_typed(fp):
+    fp.allow_unregistered(True)
+    fp.register(
+        [PYTHON, "example_script.py"],
+        stdout=b"Stdout line 1\r\nStdout line 2\r\n",
+    )
+
+    def spawn_process() -> subprocess.Popen[str]:
+        import subprocess
+
+        return subprocess.Popen(
+            (PYTHON, "example_script.py"),
+            universal_newlines=True,
+            stdout=subprocess.PIPE,
+        )
+
+    proc = spawn_process()
+    proc.wait()
+
+    assert proc.stdout.read() == "Stdout line 1\nStdout line 2\n"

{pytest_subprocess-1.5.2 → pytest_subprocess-1.5.3}/tests/test_typing.py

@@ -1,4 +1,5 @@
 """Additional target for mypy type checking"""
+
 from pytest_subprocess import FakeProcess