{"author":"Andrzej Klajnert","author_email":"python@aklajnert.pl","bugtrack_url":null,"classifiers":["Development Status :: 5 - Production/Stable","Framework :: Pytest","Intended Audience :: Developers","License :: OSI Approved :: MIT License","Operating System :: OS Independent","Programming Language :: Python","Programming Language :: Python :: 3","Programming Language :: Python :: 3.10","Programming Language :: Python :: 3.11","Programming Language :: Python :: 3.12","Programming Language :: Python :: 3.13","Programming Language :: Python :: 3.6","Programming Language :: Python :: 3.7","Programming Language :: Python :: 3.8","Programming Language :: Python :: 3.9","Programming Language :: Python :: Implementation :: CPython","Programming Language :: Python :: Implementation :: PyPy","Topic :: Software Development :: Testing"],"description":"\r\npytest-subprocess\r\n=================\r\n\r\n.. image:: https://img.shields.io/pypi/v/pytest-subprocess.svg\r\n :target: https://pypi.org/project/pytest-subprocess\r\n :alt: PyPI version\r\n\r\n.. image:: https://img.shields.io/pypi/pyversions/pytest-subprocess.svg\r\n :target: https://pypi.org/project/pytest-subprocess\r\n :alt: Python versions\r\n\r\n.. image:: https://readthedocs.org/projects/pytest-subprocess/badge/?version=latest\r\n :target: https://pytest-subprocess.readthedocs.io/en/latest/?badge=latest\r\n :alt: Documentation Status\r\n\r\nPytest plugin to fake subprocess.\r\n\r\n.. contents:: :local:\r\n\r\n.. include-start\r\n\r\nUsage\r\n=====\r\n\r\nThe plugin adds the ``fake_process`` fixture (and ``fp`` as an alias).\r\nIt can be used it to register subprocess results so you won't need to rely on\r\nthe real processes. The plugin hooks on the ``subprocess.Popen()``, which is\r\nthe base for other subprocess functions. That makes the ``subprocess.run()``,\r\n``subprocess.call()``, ``subprocess.check_call()`` and\r\n``subprocess.check_output()`` methods also functional.\r\n\r\nInstallation\r\n------------\r\n\r\nYou can install ``pytest-subprocess`` via `pip`_ from `PyPI`_::\r\n\r\n $ pip install pytest-subprocess\r\n\r\n\r\nBasic usage\r\n-----------\r\n\r\nThe most important method is ``fp.register()``\r\n(or ``register_subprocess`` if you prefer to be more verbose), which\r\nallows defining the fake processes behavior.\r\n\r\n.. code-block:: python\r\n\r\n def test_echo_null_byte(fp):\r\n fp.register([\"echo\", \"-ne\", \"\\x00\"], stdout=bytes.fromhex(\"00\"))\r\n\r\n process = subprocess.Popen(\r\n [\"echo\", \"-ne\", \"\\x00\"],\r\n stdout=subprocess.PIPE,\r\n )\r\n out, _ = process.communicate()\r\n\r\n assert process.returncode == 0\r\n assert out == b\"\\x00\"\r\n\r\nOptionally, the ``stdout`` and ``stderr`` parameters can be a list (or tuple)\r\nof lines to be joined together with a trailing ``os.linesep`` on each line.\r\n\r\n.. code-block:: python\r\n\r\n def test_git(fp):\r\n fp.register([\"git\", \"branch\"], stdout=[\"* fake_branch\", \" master\"])\r\n\r\n process = subprocess.Popen(\r\n [\"git\", \"branch\"],\r\n stdout=subprocess.PIPE,\r\n universal_newlines=True,\r\n )\r\n out, _ = process.communicate()\r\n\r\n assert process.returncode == 0\r\n assert out == \"* fake_branch\\n master\\n\"\r\n\r\nPassing input\r\n-------------\r\n\r\nBy default, if you use ``input`` argument to the ``Popen.communicate()``\r\nmethod, it won't crash, but also won't do anything useful. By passing\r\na function as ``stdin_callable`` argument for the\r\n``fp.register()`` method you can specify the behavior\r\nbased on the input. The function shall accept one argument, which will be\r\nthe input data. If the function will return a dictionary with ``stdout`` or\r\n``stderr`` keys, its value will be appended to according stream.\r\n\r\n.. code-block:: python\r\n\r\n def test_pass_input(fp):\r\n def stdin_function(input):\r\n return {\r\n \"stdout\": \"This input was added: {data}\".format(\r\n data=input.decode()\r\n )\r\n }\r\n\r\n fp.register(\r\n [\"command\"],\r\n stdout=[b\"Just stdout\"],\r\n stdin_callable=stdin_function,\r\n )\r\n\r\n process = subprocess.Popen(\r\n [\"command\"],\r\n stdin=subprocess.PIPE,\r\n stdout=subprocess.PIPE,\r\n )\r\n out, _ = process.communicate(input=b\"sample input\\n\")\r\n\r\n assert out.splitlines() == [\r\n b\"Just stdout\",\r\n b\"This input was added: sample input\",\r\n ]\r\n\r\nUnregistered commands\r\n---------------------\r\n\r\nBy default, when the ``fp`` fixture is being used, any attempt to\r\nrun subprocess that has not been registered will raise\r\nthe ``ProcessNotRegisteredError`` exception. To allow it, use\r\n``fp.allow_unregistered(True)``, which will execute all unregistered\r\nprocesses with real ``subprocess``, or use\r\n``fp.pass_command(\"command\")`` to allow just a single command.\r\n\r\n.. code-block:: python\r\n\r\n def test_real_process(fp):\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n # this will fail, as \"ls\" command is not registered\r\n subprocess.call(\"ls\")\r\n\r\n fp.pass_command(\"ls\")\r\n # now it should be fine\r\n assert subprocess.call(\"ls\") == 0\r\n\r\n # allow all commands to be called by real subprocess\r\n fp.allow_unregistered(True)\r\n assert subprocess.call([\"ls\", \"-l\"]) == 0\r\n\r\n\r\nDiffering results\r\n-----------------\r\n\r\nEach ``register()`` or ``pass_command()`` method call will register\r\nonly one command execution. You can call those methods multiple times, to\r\nchange the faked output on each subprocess run. When you call subprocess more\r\nwill be raised. To prevent that, call ``fp.keep_last_process(True)``,\r\nwhich will keep the last registered process forever.\r\n\r\n.. code-block:: python\r\n\r\n def test_different_output(fp):\r\n # register process with output changing each execution\r\n fp.register(\"test\", stdout=\"first execution\")\r\n # the second execution will return non-zero exit code\r\n fp.register(\"test\", stdout=\"second execution\", returncode=1)\r\n\r\n assert subprocess.check_output(\"test\") == b\"first execution\"\r\n second_process = subprocess.run(\"test\", stdout=subprocess.PIPE)\r\n assert second_process.stdout == b\"second execution\"\r\n assert second_process.returncode == 1\r\n\r\n # 3rd time shall raise an exception\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n subprocess.check_call(\"test\")\r\n\r\n # now, register two processes once again,\r\n # but the last one will be kept forever\r\n fp.register(\"test\", stdout=\"first execution\")\r\n fp.register(\"test\", stdout=\"second execution\")\r\n fp.keep_last_process(True)\r\n\r\n # now the processes can be called forever\r\n assert subprocess.check_output(\"test\") == b\"first execution\"\r\n assert subprocess.check_output(\"test\") == b\"second execution\"\r\n assert subprocess.check_output(\"test\") == b\"second execution\"\r\n assert subprocess.check_output(\"test\") == b\"second execution\"\r\n\r\n\r\nUsing callbacks\r\n---------------\r\n\r\nYou can pass a function as ``callback`` argument to the ``register()``\r\nmethod which will be executed instead of the real subprocess. The callback function\r\ncan raise exceptions which will be interpreted in tests as an exception raised\r\nby the subprocess. The fixture will pass ``FakePopen`` class instance into the\r\ncallback function, that can be used to change the return code or modify output\r\nstreams.\r\n\r\n.. code-block:: python\r\n\r\n def callback_function(process):\r\n process.returncode = 1\r\n raise PermissionError(\"exception raised by subprocess\")\r\n\r\n\r\n def test_raise_exception(fp):\r\n fp.register([\"test\"], callback=callback_function)\r\n\r\n with pytest.raises(\r\n PermissionError, match=\"exception raised by subprocess\"\r\n ):\r\n process = subprocess.Popen([\"test\"])\r\n process.wait()\r\n\r\n assert process.returncode == 1\r\n\r\nIt is possible to pass additional keyword arguments into ``callback`` by using\r\nthe ``callback_kwargs`` argument:\r\n\r\n.. code-block:: python\r\n\r\n def callback_function_with_kwargs(process, return_code):\r\n process.returncode = return_code\r\n\r\n\r\n def test_callback_with_arguments(fp):\r\n return_code = 127\r\n\r\n fp.register(\r\n [\"test\"],\r\n callback=callback_function_with_kwargs,\r\n callback_kwargs={\"return_code\": return_code},\r\n )\r\n\r\n process = subprocess.Popen([\"test\"])\r\n process.wait()\r\n\r\n assert process.returncode == return_code\r\n\r\nAs a context manager\r\n--------------------\r\n\r\nThe ``fp`` fixture provides ``context()`` method that allows us to\r\nuse it as a context manager. It can be used to limit the scope when a certain\r\ncommand is allowed, e.g. to make sure that the code doesn't want to execute\r\nit somewhere else.\r\n\r\n.. code-block:: python\r\n\r\n def test_context_manager(fp):\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n # command not registered, so will raise an exception\r\n subprocess.check_call(\"test\")\r\n\r\n with fp.context() as nested_process:\r\n nested_process.register(\"test\", occurrences=3)\r\n # now, we can call the command 3 times without error\r\n assert subprocess.check_call(\"test\") == 0\r\n assert subprocess.check_call(\"test\") == 0\r\n\r\n # the command was called 2 times, so one occurrence left, but since the\r\n # context manager has been left, it is not registered anymore\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n subprocess.check_call(\"test\")\r\n\r\nNon-exact command matching\r\n--------------------------\r\n\r\nIf you need to catch a command with some non-predictable elements, like a path\r\nto a randomly-generated file name, you can use ``fake_subprocess.any()`` for\r\nthat purpose. The number of arguments that should be matched can be controlled\r\nby ``min`` and ``max`` arguments. To use ``fake_subprocess.any()`` you need\r\nto define the command as a ``tuple`` or ``list``. The matching will work even\r\nif the subprocess command will be called with a string argument.\r\n\r\n.. code-block:: python\r\n\r\n def test_non_exact_matching(fp):\r\n # define a command that will take any number of arguments\r\n fp.register([\"ls\", fp.any()])\r\n assert subprocess.check_call(\"ls -lah\") == 0\r\n\r\n # `fake_subprocess.any()` is OK even with no arguments\r\n fp.register([\"ls\", fp.any()])\r\n assert subprocess.check_call(\"ls\") == 0\r\n\r\n # but it can force a minimum amount of arguments\r\n fp.register([\"cp\", fp.any(min=2)])\r\n\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n # only one argument is used, so registered command won't match\r\n subprocess.check_call(\"cp /source/dir\")\r\n # but two arguments will be fine\r\n assert subprocess.check_call(\"cp /source/dir /tmp/random-dir\") == 0\r\n\r\n # the `max` argument can be used to limit maximum amount of arguments\r\n fp.register([\"cd\", fp.any(max=1)])\r\n\r\n with pytest.raises(fp.exceptions.ProcessNotRegisteredError):\r\n # cd with two arguments won't match with max=1\r\n subprocess.check_call(\"cd ~/ /tmp\")\r\n # but any single argument is fine\r\n assert subprocess.check_call(\"cd ~/\") == 0\r\n\r\n # `min` and `max` can be used together\r\n fp.register([\"my_app\", fp.any(min=1, max=2)])\r\n assert subprocess.check_call([\"my_app\", \"--help\"]) == 0\r\n\r\n\r\nYou can also specify just the command name, and have it match any command with\r\nthe same name, regardless of the location. This is accomplished with\r\n``fake_subprocess.program(\"name\")``.\r\n\r\n.. code-block:: python\r\n\r\n def test_any_matching_program(fp):\r\n # define a command that can come from anywhere\r\n fp.register([fp.program(\"ls\")])\r\n assert subprocess.check_call(\"/bin/ls\") == 0\r\n\r\n\r\nCheck if process was called\r\n---------------------------\r\n\r\nYou may want to simply check if a certain command was called, you can do this\r\nby accessing ``fp.calls``, where all commands are stored as-called.\r\nYou can also use a utility function ``fp.call_count()`` to see\r\nhow many a command has been called. The latter supports ``fp.any()``.\r\n\r\n.. code-block:: python\r\n\r\n def test_check_if_called(fp):\r\n fp.keep_last_process(True)\r\n # any command can be called\r\n fp.register([fp.any()])\r\n\r\n subprocess.check_call([\"cp\", \"/tmp/source\", \"/source\"])\r\n subprocess.check_call([\"cp\", \"/source\", \"/destination\"])\r\n subprocess.check_call([\"cp\", \"/source\", \"/other/destination\"])\r\n\r\n # you can check if command is in ``fp.calls``\r\n assert [\"cp\", \"/tmp/source\", \"/source\"] in fp.calls\r\n assert [\"cp\", \"/source\", \"/destination\"] in fp.calls\r\n assert [\"cp\", \"/source\", \"/other/destination\"] in fp.calls\r\n\r\n # or check how many it was called, possibly with wildcard arguments\r\n assert fp.call_count([\"cp\", \"/source\", \"/destination\"]) == 1\r\n\r\n # with ``call_count()`` you don't need to use the same type as\r\n # the subprocess was called\r\n assert fp.call_count(\"cp /tmp/source /source\") == 1\r\n\r\n # can be used with ``fp.any()`` to match more calls\r\n assert fp.call_count([\"cp\", fp.any()]) == 3\r\n\r\n\r\nCheck Popen arguments\r\n---------------------\r\n\r\nYou can use the recorded calls functionality to introspect the keyword\r\narguments that were passed to `Popen`.\r\n\r\n.. code-block:: python\r\n\r\n def test_process_recorder_kwargs(fp):\r\n fp.keep_last_process(True)\r\n recorder = fp.register([\"test_script\", fp.any()])\r\n\r\n subprocess.run(\r\n (\"test_script\", \"arg1\"), env={\"foo\": \"bar\"}, cwd=\"/home/user\"\r\n )\r\n subprocess.Popen(\r\n [\"test_script\", \"arg2\"],\r\n env={\"foo\": \"bar1\"},\r\n executable=\"test_script\",\r\n shell=True,\r\n )\r\n\r\n assert recorder.calls[0].args == (\"test_script\", \"arg1\")\r\n assert recorder.calls[0].kwargs == {\r\n \"cwd\": \"/home/user\",\r\n \"env\": {\"foo\": \"bar\"},\r\n }\r\n assert recorder.calls[1].args == [\"test_script\", \"arg2\"]\r\n assert recorder.calls[1].kwargs == {\r\n \"env\": {\"foo\": \"bar1\"},\r\n \"executable\": \"test_script\",\r\n \"shell\": True,\r\n }\r\n\r\nHandling signals\r\n----------------\r\n\r\nYou can use standard ``kill()``, ``terminate()`` or ``send_signal()`` methods\r\nin ``Popen`` instances. There is an additional ``received_signals()`` method\r\nto get a tuple of all signals received by the process. It is also possible to\r\nset up an optional callback function for signals.\r\n\r\n.. code-block:: python\r\n\r\n import signal\r\n\r\n\r\n def test_signal_callback(fp):\r\n \"\"\"Test that signal callbacks work.\"\"\"\r\n\r\n def callback(process, sig):\r\n if sig == signal.SIGTERM:\r\n process.returncode = -1\r\n\r\n # the `register()` method returns a ProgressRecorder object, where\r\n # all future matching `Popen()` instances will be appended\r\n process_recorder = fp.register(\"test\", signal_callback=callback)\r\n\r\n process = subprocess.Popen(\"test\")\r\n process.send_signal(signal.SIGTERM)\r\n process.wait()\r\n\r\n assert process.returncode == -1\r\n assert process.received_signals() == (signal.SIGTERM,)\r\n\r\n # the instance appended to `register()` output is the `Popen` instance\r\n # created later\r\n assert process_recorder.first_call is process\r\n\r\n\r\nAsyncio support\r\n---------------\r\n\r\nThe plugin now supports asyncio and works for ``asyncio.create_subprocess_shell``\r\nand ``asyncio.create_subprocess_exec``:\r\n\r\n.. code-block:: python\r\n\r\n @pytest.mark.asyncio\r\n async def test_basic_usage(\r\n fp,\r\n ):\r\n fp.register(\r\n [\"some-command-that-is-definitely-unavailable\"], returncode=500\r\n )\r\n\r\n process = await asyncio.create_subprocess_shell(\r\n \"some-command-that-is-definitely-unavailable\"\r\n )\r\n returncode = await process.wait()\r\n\r\n assert process.returncode == returncode\r\n assert process.returncode == 500\r\n\r\n.. _`pip`: https://pypi.org/project/pip/\r\n.. _`PyPI`: https://pypi.org/project\r\n\r\n\r\n.. include-end\r\n\r\nDocumentation\r\n-------------\r\n\r\nFor full documentation, including API reference, please see https://pytest-subprocess.readthedocs.io/en/latest/.\r\n\r\nContributing\r\n------------\r\nContributions are very welcome. Tests can be run with `tox`_, please ensure\r\nthe coverage at least stays the same before you submit a pull request.\r\n\r\nLicense\r\n-------\r\n\r\nDistributed under the terms of the `MIT`_ license, \"pytest-subprocess\" is free and open source software\r\n\r\n\r\nIssues\r\n------\r\n\r\nIf you encounter any problems, please `file an issue`_ along with a detailed description.\r\n\r\n----\r\n\r\nThis `pytest`_ plugin was generated with `Cookiecutter`_ along with `@hackebrot`_'s `cookiecutter-pytest-plugin`_ template.\r\n\r\n.. _`Cookiecutter`: https://github.com/audreyr/cookiecutter\r\n.. _`@hackebrot`: https://github.com/hackebrot\r\n.. _`MIT`: http://opensource.org/licenses/MIT\r\n.. _`BSD-3`: http://opensource.org/licenses/BSD-3-Clause\r\n.. _`GNU GPL v3.0`: http://www.gnu.org/licenses/gpl-3.0.txt\r\n.. _`Apache Software License 2.0`: http://www.apache.org/licenses/LICENSE-2.0\r\n.. _`cookiecutter-pytest-plugin`: https://github.com/pytest-dev/cookiecutter-pytest-plugin\r\n.. _`file an issue`: https://github.com/aklajnert/pytest-subprocess/issues\r\n.. _`pytest`: https://github.com/pytest-dev/pytest\r\n.. _`tox`: https://tox.readthedocs.io/en/latest/\r\n\r\nHistory\r\n=======\r\n\r\n1.5.3 (2025-01-04) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#171 `_, `#178 `_: Allow to access keyword arguments passed to Popen.\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#180 `_: Fixed an incorrect wait timeout calculation.\r\n* `#170 `_: Wrapped ProcessDispatcher.dispatch into FakePopenWrapper as it was causing TypeError when Popen is used as a type.\r\n* `#169 `_: Get rid of using thread in AsyncFakePopen as it causes thread.join() to hang indefinitely.\r\n\r\n1.5.2 (2024-07-24) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#162 `_: Include tests (and docs) and sdist correctly, and stop installing them to site-packages.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#163 `_: Add support for Python 3.12.\r\n\r\n1.5.1 (2024-07-23) \r\n------------------\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#160 `_: Changed pytest entrypoint to avoid error while loading plugin with `-p` argument.\r\n* `#128 `_: Add `tests` directory to sdist.\r\n\r\n1.5.0 (2023-01-28) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#109 `_: Match also `os.PathLike`.\r\n* `#105 `_: Add program matcher.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#110 `_: Produce TypeError on Win Py<3.8 for Path args.\r\n\r\n1.4.2 (2022-10-02) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#87 `_: Add support for Python 3.11.\r\n* `#80 `_, `#86 `_: The `register()` method returns an auxiliary object that will contain all matching `FakePopen` instances.\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#93 `_: Raise callback exceptions on `communicate()` calls.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#97 `_: Fixed warnings in tests, treat warnings as errors.\r\n* `#91 `_: Use `sys.executable` instead just `\"python\"` in tests while invoking python subprocess.\r\n* `#90 `_: Fix documentation build, add CI check for it.\r\n\r\n1.4.1 (2022-02-09) \r\n------------------\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#74 `_: Add ``fp`` alias for the fixture, and ``register`` for the ``regisiter_subprocess``.\r\n\r\n1.4.0 (2022-01-23) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#71 `_: Add support for stdin with asyncio.\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#68 `_: Make `stdout` and `stderr` an `asyncio.StreamReader` instance when using asyncio functions.\r\n* `#63 `_, `#67 `_: Add missing items to `asyncio.subprocess`.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#69 `_: Extracted code into separate files to improve navigation.\r\n\r\n1.3.2 (2021-11-07) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#61 `_: Fixed behavior of ``asyncio.create_subproess_exec()``.\r\n\r\n1.3.1 (2021-11-01) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#58 `_: Correctly handle file stream output.\r\n\r\n1.3.0 (2021-10-24) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#55 `_: Add support for ``terminate()``, ``kill()``, ``send_signal()``.\r\n\r\n1.2.0 (2021-10-09) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#49 `_, `#52 `_: Add support for ``asyncio``.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#50 `_: Change docs theme.\r\n\r\n1.1.2 (2021-07-17) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#47 `_: Prevent `allow_unregistered()` and `keep_last_process()` from affecting other tests.\r\n\r\n1.1.1 (2021-06-18) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#43 `_: Wait for callback thread to finish when calling ``communicate()``.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#42 `_: Fix type annotations for `register_subprocess()`.\r\n\r\n1.1.0 (2021-04-18) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#37 `_: Preserve original command in `proc.args` to prevent leaking the internal `Command` type.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#38 `_: Switched CI from Azure Pipelines to GitHub Actions.\r\n* `#35 `_: Drop support for python 3.4 and 3.5. Move type annotations from `.pyi` files into sources.\r\n\r\n1.0.1 (2021-03-20) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#34 `_: Prevent appending newlines to outputs unless defined as list/tuple.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#32 `_: Make the ``Command`` class iterable.\r\n\r\n1.0.0 (2020-08-22) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#29 `_: Remember subprocess calls to check if expected commands were executed.\r\n* `#28 `_: Allow to match a command with variable arguments (non-exact matching).\r\n\r\n0.1.5 (2020-06-19) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#26 `_: `encoding` and `errors` arguments will properly trigger `text` mode.\r\n\r\n0.1.4 (2020-04-28) \r\n------------------\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#22 `_: The `returncode` will not be ignored when `callback` is used.\r\n* `#21 `_: The exception raised from callback will take precedence over those from subprocess.\r\n* `#20 `_: Registering process will be now consistent regardless of the command type.\r\n* `#19 `_: Fixed crash for stderr redirect with an empty stream definition.\r\n\r\n0.1.3 (2020-03-04) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#13 `_: Allow passing keyword arguments into callbacks.\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#12 `_: Properly raise exceptions from callback functions.\r\n\r\nDocumentation changes \r\n~~~~~~~~~~~~~~~~~~~~~\r\n* `#15 `_: Add documentation chapter about the callback functions.\r\n\r\n0.1.2 (2020-01-17) \r\n------------------\r\n\r\nFeatures \r\n~~~~~~~~\r\n* `#3 `_: Add basic support for process input.\r\n\r\nBug fixes \r\n~~~~~~~~~\r\n* `#5 `_: Make ``wait()`` method to raise ``TimeoutError`` after the desired time will elapse.\r\n\r\nDocumentation changes \r\n~~~~~~~~~~~~~~~~~~~~~\r\n* `#7 `_, `#8 `_, `#9 `_: Create Sphinx documentation.\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#10 `_: Switch from ``tox`` to ``nox`` for running tests and tasks.\r\n* `#4 `_: Add classifier for Python 3.9. Update CI config to test also on that interpreter version.\r\n\r\n0.1.1 (2019-11-24) \r\n------------------\r\n\r\nOther changes \r\n~~~~~~~~~~~~~\r\n* `#1 `_, `#2 `_: Enable support for Python 3.4, add CI tests for that version.\r\n\r\n0.1.0 (2019-11-23) \r\n------------------\r\n\r\nInitial release \r\n","description_content_type":null,"docs_url":null,"download_url":null,"downloads":{"last_day":-1,"last_month":-1,"last_week":-1},"dynamic":null,"home_page":null,"keywords":null,"license":"MIT","license_expression":null,"license_files":null,"maintainer":"Andrzej Klajnert","maintainer_email":"python@aklajnert.pl","name":"pytest-subprocess","package_url":"https://pypi.org/project/pytest-subprocess/","platform":null,"project_url":"https://pypi.org/project/pytest-subprocess/","project_urls":{"Documentation":"https://pytest-subprocess.readthedocs.io","Source":"https://github.com/aklajnert/pytest-subprocess","Tracker":"https://github.com/aklajnert/pytest-subprocess/issues"},"provides_extra":["test","dev","docs"],"release_url":"https://pypi.org/project/pytest-subprocess/1.5.3/","requires_dist":["pytest>=4.0.0","pytest>=4.0; extra == \"test\"","docutils>=0.12; extra == \"test\"","Pygments>=2.0; extra == \"test\"","pytest-rerunfailures; extra == \"test\"","pytest-asyncio>=0.15.1; extra == \"test\"","pytest-timeout; extra == \"test\"","anyio; extra == \"test\"","nox; extra == \"dev\"","changelogd; extra == \"dev\"","sphinx; extra == \"docs\"","furo; extra == \"docs\"","sphinxcontrib-napoleon; extra == \"docs\"","sphinx-autodoc-typehints; extra == \"docs\"","changelogd; extra == \"docs\""],"requires_python":">=3.6","summary":"A plugin to fake subprocess for pytest","version":"1.5.3","yanked":false,"yanked_reason":null}

Dependency	Optional
pytest	false
anyio	true
changelogd	true
docutils	true
furo	true
nox	true
Pygments	true
pytest-asyncio	true
pytest-rerunfailures	true
pytest-timeout	true
sphinx	true
sphinx-autodoc-typehints	true
sphinxcontrib-napoleon	true

Package search

pytest-subprocess

project_urls

Dependencies

All package metadata

Releases