|`
* :meth:`monkeypatch.delattr(obj, name, raising=True) `
* :meth:`monkeypatch.setitem(mapping, name, value) `
* :meth:`monkeypatch.delitem(obj, name, raising=True) `
* :meth:`monkeypatch.setenv(name, value, prepend=None) `
* :meth:`monkeypatch.delenv(name, raising=True) `
* :meth:`monkeypatch.syspath_prepend(path) `
* :meth:`monkeypatch.chdir(path) `
* :meth:`monkeypatch.context() `
All modifications will be undone after the requesting test function or
fixture has finished. The ``raising`` parameter determines if a :class:`KeyError`
or :class:`AttributeError` will be raised if the set/deletion operation does not have the
specified target.
To undo modifications done by the fixture in a contained scope,
use :meth:`context() `.
N)r undo)mpatchs e/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib/python3.11/site-packages/_pytest/monkeypatch.py monkeypatchr s+ 2 ]]F
LLL
KKMMMMM namec | d }| d }t | }|D ]}|d|z z
} t || } # t $ r Y nw xY w t | nV# t
$ rI}t
| d }||k r t d| d| |d }~ww xY wt ||| }|S )N.r zimport error in z: )splitpop
__import__getattrAttributeError ImportErrorstrannotated_getattr)r partsusedfoundpartexexpecteds r resolver. ; s JJsOOE 99Q< selfs r __repr__zNotset.__repr__n s zr N)r4
__module__ __qualname__r& rG rD r r rB rB m s/ # r rB c e Zd ZdZd dZeeded fd Ze d de
d e d
e d e
ddf
d Ze d de d e
d
e d e
ddf
d
Zedfdee
e f d ee e
f d
e d e
ddf
dZedfdee e
f d ee
e f d e
ddfdZdeeef d ed
eddfdZd deeef d ed e
ddfdZd d e
d
e
dee
ddfdZd d e
d e
ddfdZd dZdee
df ddfdZd dZ dS )!r a Helper to conveniently monkeypatch attributes/items/environment
variables/syspath.
Returned by the :fixture:`monkeypatch` fixture.
.. versionchanged:: 6.2
Can now also be used directly as `pytest.MonkeyPatch()`, for when
the fixture is not available. In this case, use
:meth:`with MonkeyPatch.context() as mp: ` or remember to call
:meth:`undo` explicitly.
r Nc > g | _ g | _ d | _ d | _ d S N)_setattr_setitem_cwd _savesyspathrE s r __init__zMonkeyPatch.__init__ s% :<
HJ
#' 15r r c # K | } |V | dS # | w xY w)a] Context manager that returns a new :class:`MonkeyPatch` object
which undoes any patching done inside the ``with`` block upon exit.
Example:
.. code-block:: python
import functools
def test_partial(monkeypatch):
with monkeypatch.context() as m:
m.setattr(functools, "partial", 3)
Useful in situations where it is desired to undo some patches before the test ends,
such as mocking ``stdlib`` functions that might break pytest itself if mocked (for examples
of this see :issue:`3290`).
N)r )clsms r contextzMonkeyPatch.context sD *
CEE GGG
FFHHHHHAFFHHHHs ( >.r? r valuer7 c d S rL rD rF r? r rV r7 s r setattrzMonkeyPatch.setattr r c d S rL rD rX s r rY zMonkeyPatch.setattr rZ r Tc ( d}ddl }t |t r:t |t st d |}t || \ }}n$t |t st d t
||t }|r |t u rt |d| | | r |j
|t }| j
|||f t ||| dS )a
Set attribute value on target, memorizing the old value.
For example:
.. code-block:: python
import os
monkeypatch.setattr(os, "getcwd", lambda: "/")
The code above replaces the :func:`os.getcwd` function by a ``lambda`` which
always returns ``"/"``.
For convenience, you can specify a string as ``target`` which
will be interpreted as a dotted import path, with the last part
being the attribute name:
.. code-block:: python
monkeypatch.setattr("os.getcwd", lambda: "/")
Raises :class:`AttributeError` if the attribute does not exist, unless
``raising`` is set to False.
**Where to patch**
``monkeypatch.setattr`` works by (temporarily) changing the object that a name points to with another one.
There can be many names pointing to any individual object, so for patching to work you must ensure
that you patch the name used by the system under test.
See the section :ref:`Where to patch ` in the :mod:`unittest.mock`
docs for a complete explanation, which is meant for :func:`unittest.mock.patch` but
applies to ``monkeypatch.setattr`` as well.
Tr Nzcuse setattr(target, name, value) or setattr(target, value) with target being a dotted import stringz|use setattr(target, name, value) with name being a string or setattr(target, value) with target being a dotted import stringz has no attribute )inspectr: rB r& r; r@ r# notsetr$ isclass__dict__getrM appendrY )rF r? r rV r7 __tracebackhide__r] oldvals r rY zMonkeyPatch.setattr s8 T ! eV $ $ fc**
$
E,VW==LD&& dC((
$ v.. Jv'' F!H!H!H!HII I ??6 " " 7_((v66F
fdF 3444e$$$$$r c d}ddl }t |t r7t |t st d t || \ }}t
|| s|rt | dS t ||t }|
| r |j |t }| j
|||f t || dS )aK Delete attribute ``name`` from ``target``.
If no ``name`` is specified and ``target`` is a string
it will be interpreted as a dotted import path with the
last part being the attribute name.
Raises AttributeError it the attribute does not exist, unless
``raising`` is set to False.
Tr NzUuse delattr(target, name) or delattr(target) with target being a dotted import string)r] r: rB r& r; r@ hasattrr$ r# r^ r_ r` ra rM rb delattr)rF r? r r7 rc r] rd s r rg zMonkeyPatch.delattr s ! dF # # > fc**
$
-VW==LD&vt$$ "
+$T***
+
+ VT622Fv&&
; ,,T6:: M &$!7 8 8 8 FD ! ! ! ! !r dicc | | j ||| |t f |||< dS )z'Set dictionary entry ``name`` to value.N)rN rb ra r^ )rF rh r rV s r setitemzMonkeyPatch.setitem& s:
c4v)>)> ?@@@D r c ||vr|rt | dS | j ||| |t f ||= dS )zDelete ``name`` from dict.
Raises ``KeyError`` if it doesn't exist, unless ``raising`` is set to
False.
N)KeyErrorrN rb ra r^ )rF rh r r7 s r delitemzMonkeyPatch.delitem, sc s??
% tnn$
%
%
M #tSWWT6-B-B!C D D DD r prependc v t |t sZt j t d ||t
| j d t | }|r&|t j v r||z t j | z }|
t j || dS )zSet environment variable ``name`` to ``value``.
If ``prepend`` is a character, read the current environment variable
value and prepend the ``value`` adjoined with the ``prepend``
character.
zvValue of environment variable {name} type should be str, but got {value!r} (type: {type}); converted to str implicitly)r rV r3 )
stacklevelN) r: r& warningswarnr r2 r3 r4 osenvironrj )rF r rV rn s r setenvzMonkeyPatch.setenv: s %%%
M LLRF !T%[[5I MS M M
JJE 7trz))GObj&66E RZu-----r c N t j }| ||| dS )zDelete ``name`` from the environment.
Raises ``KeyError`` if it does not exist, unless ``raising`` is set to
False.
)r7 N)rt ru rm )rF r r7 ru s r delenvzMonkeyPatch.delenvP s) -/J WdG 44444r c | j t j dd | _ t j dt | dt j v r ddlm} |t | ddlm } | dS )z:Prepend ``path`` to ``sys.path`` list of import locations.Nr
pkg_resources)fixup_namespace_packages)invalidate_caches)
rP syspathinsertr& modulesrz r{ importlibr| )rF r~ r{ r| s r syspath_prependzMonkeyPatch.syspath_prependY s $ # D 3t99%%% ck ) ) > > > > > > $ $SYY / / / 0/////r r~ zos.PathLike[str]c l | j t j | _ t j | dS )zChange the current working directory to the specified path.
:param path:
The path to change into.
N)rO rt getcwdchdir)rF r~ s r r zMonkeyPatch.chdirr s* 9 DI
r c t | j D ]1\ }}}|t urt ||| !t || 2g | j dd< t | j D ])\ }}}|t u r ||= # t $ r Y w xY w|||< *g | j dd< | j | j t j dd< d| _ | j
"t j | j
d| _
dS dS )a Undo previous changes.
This call consumes the undo stack. Calling it a second time has no
effect unless you do more monkeypatching after the undo call.
There is generally no need to call `undo()`, since it is
called automatically during tear-down.
.. note::
The same `monkeypatch` fixture is used across a
single test function invocation. If `monkeypatch` is used both by
the test function itself and one of the test fixtures,
calling `undo()` will undo all of the changes made in
both functions.
Prefer to use :meth:`context() ` instead.
N)
reversedrM r^ rY rg rN rl rP r} r~ rO rt r )rF r/ r rV
dictionarykeys r r zMonkeyPatch.undo| s+ $ !) 7 7 # # CuF""T5))))T""""
aaa&.t}&=&= ( ( "JU"3 D #(
3
aaa ( +CHQQQK $D 9 HTY DIII ! s 7A;;
BB)r N)..).)TrL ) r4 rH rI __doc__rQ classmethodr r rU r
r& objectrB boolrY r^ r
rg r r r rj rm r rv rx r r r rD r r r r u s
6 6 6 6 ";< ^ [2
X
X F% F%c6k"F% FCK F% F%
F%
F% F% F% F%V $* $" $"fck"$" CK $" $"
$" $" $" $"L71a4= ! 71a4= D D . .3 .s .Xc] .d . . . .,5 53 5 5 5 5 5 5 2%%7 78 T ) ) ) ) ) ) r r )&r rt rer} rr
contextlibr typingr r r r r r r
r r r
_pytest.compatr _pytest.fixturesr _pytest.warning_typesr compileRE_IMPORT_ERROR_NAMEr r r r& r r. r' r r@ rB r^ r rD r r r s / /
% % % % % % ! ! ! ! ! ! $ $ $ $ $ $ / / / / / /!rz";<< GCLL GCLL Y 89 :# & 8 6 3 6 3 %V :L
o o o o o o o o o o r