1j . d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlmZ ddlmZmZ ddlmZ ddlmZmZ ddlmZmZm Z ddl m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* dd l
m+Z+ dd
l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 dd l,m3Z3 dd l,m4Z4 dd
l,m5Z5 ddl,m6Z6 ddl7m8Z8m9Z9m:Z:m;Z;mZ> ddl?m@Z@mAZA ddlBmCZCmDZD ddlEmFZF e
jG dk rdndZHe
jG dk rdndZI G d d ZJ G d d ZK d;dddd d e;jL d d d d d e$e d!e$e!e%eMef d"e$e!e d#e$e eMef d$eNd%eNd&e;d'eNd(eNd)eNd*e fd+ZOdZPdddd d e;jL d d fd,e d-e+d.e d/ed!e$e!e%eMef d"e$e!e d#e$e eMef d$eNd%eNd&e;d'eNd)eNd*e+fd0ZQ G d1 d2 ZR G d3 d4e
jS eR ZS G d5 d6 ZT G d7 d8 ZU G d9 d:ee ZVdS ).cleanupl s( %%eWf6I JJJJJr> rA
_rmtreec . t j j | i |S r7 )tempfile_shutilrmtree)argskwargss r< rL z/TempfilePatcher.start_patching.._rmtreeu s #+2DCFCCCr> r/ c L | |p t j d S r7 rD )rG rF r; s r< closez-TempfilePatcher.start_patching..close} s& %%eV-@ryAAAAAr> r7 )
r8 sys version_inforE namerN _TemporaryFileCloserrI hasattrrL r9 platformrT )r; rI rL rT s ` r< start_patchingz TempfilePatcher.start_patchingg s , F w & &(*4
K
K
K
K
K
K %-$A$ID !4;H ) 1 7**wx/K/K*D D D (0'7$#* +*** \W
$
$
B
B
B
B
B
B %-$A$GD !27H ) / / /
%
$r> c | j d S t j dk r| j t j _ n| j t j _ d | _ | j | j t _ d | _ d t _ d S )Nr@ )
r8 rU rV rN rX rT rI r9 rL tempdirr: s r<
stop_patchingz TempfilePatcher.stop_patching so ( F g % %262GH ) / /484IH ) 1 $ + # 3H #'D r> N__name__
__module__ __qualname____doc__r= r[ r^ r> r< r5 r5 ` sG 66$ $ $8 8 88 r> r5 c $ e Zd ZdZd Zd Zd ZdS )LineCachePatcherz5Handles linecache patching for newer Python versions.c " d | _ d | _ d S r7 )linecache_updatecachelinecache_checkcacher: s r< r= zLineCachePatcher.__init__ s %)"$(!!!r> c j d S d fd }d fd }t j dk s t j dk rLt j dk r>t j _ |t _ t j _ |t _ d S d S d S )Nc ~ t 5 | cddd S # 1 swxY w Y dS )zZCalls the original linecache.checkcache making sure no fake OS calls
are used.N)r) ri )filenamer; s r<
checkcachez3LineCachePatcher.start_patching..checkcache s !""
;
;00::
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;s 266c t 5 t r'| d s" | | cddd S g cddd S # 1 swxY w Y dS )z[Calls the original linecache.updatecache making sure no fake OS calls
are used.zpytest.exe\__main__.pyN)r) r+ lowerendswithrh )rl module_globalsr; s r< updatecachez4LineCachePatcher.start_patching..updatecache s !""
PX^^%5%5%>%>-& & P 55hOO
s AA/!A//A36A3rJ r/ r@ r7 )rh rU rV rZ linecacherr rm ri )r; rm rr s ` r< r[ z LineCachePatcher.start_patching s % 1 F ; ; ; ; ; ;
' '|w&& G++ *3)>D &$/I !(1( c x | j d S | j t _ | j t _ d | _ d | _ d S r7 )rh rs rr ri rm r: s r< r^ z LineCachePatcher.stop_patching s< % - F $ : # 8 %)"$(!!!r> Nr_ rd r> r< rf rf sH ??) ) ) . . .D) ) ) ) )r> rf TF additional_skip_namesmodules_to_reloadmodules_to_patchallow_root_useruse_known_patchespatch_open_codepatch_default_args use_cacheuse_dynamic_patch_funcrv rw rx ry rz r{ r| r} r~ returnc
dt dt f f d }
| rRt | st d t | d rt | j | _ |
| S |
S )a= Convenience decorator to use patcher with additional parameters in a
test function.
Usage::
@patchfs
def test_my_function(fake_fs):
fake_fs.create_file('foo')
@patchfs(allow_root_user=False)
def test_with_patcher_args(fs):
os.makedirs('foo/bar')
fr c Z t j
f
d }|S )Nc
t
5 }t | } | |j | i |cd d d S # 1 swxY w Y d S )Nru )Patcherlistappendfs)
rQ rR prv ry r rx rw r| r{ r} r~ rz s
r< wrappedz.patchfs..wrap_patchfs..wrapped s &;"3!1 /"3 /#5#"3
* Dzz AD!!!q$)&))
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*s 1AA A ) functoolswraps) r r rv ry rx rw r| r{ r} r~ rz s ` r< wrap_patchfsz patchfs..wrap_patchfs sf * * * * * * * * * * * * *
* r> zYDecorator argument is not a function.
Did you mean `@patchfs(additional_skip_names=...)`? patchings)r
callable TypeErrorrY lenr
nr_patches) r rv rw rx ry rz r{ r| r} r~ r s ````````` r< patchfsr s 6 X (
# F
5+ & & 4 "5? 3 3E |E""" r> loadertestsignoremodulec p t j du} | s"t |||||| |
| d t _ t j J t j t | }
| t j ||
t j j t j j |S )aY Load the doctest tests for the specified module into unittest.
Args:
loader, tests, ignore : arguments passed in from `load_tests()`
module: module under test
remaining args: see :py:class:`TestCase` for an explanation
File `example_test.py` in the pyfakefs release provides a usage example.
NT) rv rw rx ry rz r{ r| r~ is_doc_test)globssetUptearDown) r DOC_PATCHER
replace_globsvarsaddTestsdoctest DocTestSuiter r )r r r r rv rw rx ry rz r{ r| r~ has_patcherr s r<
load_doctestsr s , %T1K
%"7 / - + / + 1 /
* * * - -d6ll ; ;E NN %+ (1
Lr> c V e Zd ZU dZdZeeeee f e
d< dZ eee e
d< dZ ee
ee f e
d< ed Zedefd Zdddd d ej d
d d f deeeee f deee dee
ee f d ed ed
ededededdfdZedddd d ej d
d d f deeeee f deee dee
ee f d ed ed
ededededdfd Zed ZddZddZdS )
TestCaseMixina Test case mixin that automatically replaces file-system related
modules by fake implementations.
Attributes:
additional_skip_names: names of modules where no module
replacement shall be performed, in addition to the names in
:py:attr:`fake_filesystem_unittest.Patcher.SKIPNAMES`.
Instead of the module names, the modules themselves may be used.
modules_to_reload: A list of modules that need to be reloaded
to be patched dynamically; may be needed if the module
imports file system modules under an alias
.. caution:: Reloading modules may have unwanted side effects.
modules_to_patch: A dictionary of fake modules mapped to the
fully qualified patched module names. Can be used to add patching
of modules not provided by `pyfakefs`.
If you specify some of these attributes here, and you have DocTests,
consider also specifying the same arguments to :py:func:`load_doctests`.
Example usage in derived test classes::
from unittest import TestCase
from fake_filesystem_unittest import TestCaseMixin
class MyTestCase(TestCase, TestCaseMixin):
def __init__(self, methodName='runTest'):
super(MyTestCase, self).__init__(
methodName=methodName,
additional_skip_names=['posixpath'])
import sut
class AnotherTestCase(TestCase, TestCaseMixin):
def __init__(self, methodName='runTest'):
super(MyTestCase, self).__init__(
methodName=methodName, modules_to_reload=[sut])
Nrv rw rx c ` t | d r| j p t j S t j S )N_patcher)rY r r PATCHERr: s r< patcherzTestCaseMixin.patcher_ s+ 4 $ $ 4=3GO 3 r> r c @ t t | j j S r7 )r r( r r r: s r< r zTestCaseMixin.fse s NDLO444r> TFry rz r{ r| r} r~ c
( t j dS || j }|| j }|| j }t ||||||||| | _ | j t t | | j j
dS )a6 Bind the file-related modules to the :py:class:`pyfakefs` fake file
system instead of the real file system. Also bind the fake `open()`
function.
Invoke this at the beginning of the `setUp()` method in your unit test
class.
For the arguments, see the `TestCaseMixin` attribute description.
If any of the arguments is not `None`, it overwrites the settings for
the current test case. Settings the arguments here may be a more
convenient way to adapt the setting than overwriting `__init__()`.
Nru ) r r rv rw rx r r r TestCase
addCleanupr )
r; rv rw rx ry rz r{ r| r} r~ s
r<
setUpPyfakefszTestCaseMixin.setUpPyfakefsi s 0 ? & F ($($> ! $ $ 6 # # 4 "7 / - + / + 1 /
Xt ''
(>?????r> c
t j dk rt d t j dS || j }|| j }|| j }t ||||||||| t _ t j t t | t j j dS )aC Similar to :py:func:`setUpPyfakefs`, but as a class method that
can be used in `setUpClass` instead of in `setUp`.
The fake filesystem will live in all test methods in the test class
and can be used in the usual way.
Note that using both :py:func:`setUpClassPyfakefs` and
:py:func:`setUpPyfakefs` in the same class will not work correctly.
.. note:: This method is only available from Python 3.8 onwards.
.. note:: If using `pytest` as testrunner, you need at least pytest 6.2
for this method to work.
)rA zIsetUpClassPyfakefs is only available in Python versions starting from 3.8Nru )
rU rV NotImplementedErrorr r rv rw rx r r r addClassCleanupr )
clsrv rw rx ry rz r{ r| r} r~ s
r< setUpClassPyfakefsz TestCaseMixin.setUpClassPyfakefs s 0 f $ $%4
? & F ($'$= ! $ # 5 # " 3 !"7 / - + / + 1 /
Xs++GO,DEEEEEr> c @ t j rt j j S dS )zConvenience class method for accessing the fake filesystem.
For use inside `setUpClass`, after :py:func:`setUpClassPyfakefs`
has been called.
N)r r r r s r< fake_fszTestCaseMixin.fake_fs s ? &?% %tr> c 8 | j dS )Pause the patching of the file system modules until `resume` is
called. After that call, all file system calls are executed in the
real file system.
Calling pause() twice is silently ignored.
N)r pauser: s r< r zTestCaseMixin.pause s
r> c 8 | j dS zResume the patching of the file system modules if `pause` has
been called before. After that call, all file system calls are
executed in the fake file system.
Does nothing if patching is not paused.
N)r resumer: s r< r zTestCaseMixin.resume s
r> r N)r` ra rb rc rv r r r strr __annotations__rw rx r propertyr r( r r' OFFboolr classmethodr r r r rd r> r< r r 3 s % %N EI8DsJ)?$@AHHH48xZ 018888<htCO 45<<<
X
5N 5 5 5 X5
IM8<<@ $"&%.]#( "&.@ .@ 'U3
?-C(D E.@ $D$45.@ #4Z#89 .@
.@
.@ #.@ !.@ .@ .@
.@ .@ .@ .@` IM8<<@ $"&%.]#( "&4F 4F 'U3
?-C(D E4F $D$454F #4Z#89 4F
4F
4F #4F !4F 4F 4F
4F 4F 4F [4Fl [ r> r c e Zd ZdZ d dedeeeeef deee dee eef f fd
Z
d d
Z xZ S )
r zTest case class that automatically replaces file-system related
modules by fake implementations. Inherits :py:class:`TestCaseMixin`.
The arguments are explained in :py:class:`TestCaseMixin`.
runTestN
methodNamerv rw rx c t t | || _ || _ || _ dS )zCreates the test class instance and the patcher used to stub out
file system related modules.
Args:
methodName: The name of the test method (same as in
unittest.TestCase)
N)superr= rv rw rx )r; r rv rw rx __class__s r< r= zTestCase.__init__ s; $$$%:"!2 0 r> r c dS )zgThis method is deprecated and exists only for backward
compatibility. It does nothing.
Nrd r: s r< tearDownPyfakefszTestCase.tearDownPyfakefs s r> )r NNNr )
r` ra rb rc r r r r r r r= r
__classcell__r s @r< r r s $HL8<<@ 1 11 (U3
?-C(D E1 $D$45 1
#4Z#89 1 1 1 1 1 1( r> r c
e Zd ZU dZ deeeeee e
e e e
eeeeej hZe j dk r3ddlZddlZe e e e nKddlZddlZddlZe e e e e e g ddgdZ e Z e e e d< i Z!e"e#e e$e e#f f e d < i Z%e"e$e#e#e#f e e f e d
< g Z&e'e$e(e)e*d e+f f e d < i Z,e"e#e e$e e#f f e d
< dev s
J d e j dv Z- e Z.e e# e d< e Z/e e# e d< e Z0e e# e d< dZ1dZ2e3d e d< dZ4e3d e d< dZ5dZ6 fdZ7ddddde8j9 ddddf
de3e'e:e#e f de3e'e de3e"e#e f de;d e;d e8d e;d e;d e;d!e;d"dfd#ZdJd%Z?d&e#d'e*e#ge;f fd(Z@dJd)ZAdJd*ZBdKd+ZCd,e3eDeE d-e3eE d.e3eF d"dfd/ZGd0e d&e#d1e'e# d"e;fd2ZHd3e(d"e;fd4ZId5e(d"eJe$e(e)e+f fd6ZKd7eLe#e(f d"dfd8ZMdJd9ZNdJd:ZOdLd;e+d"dfd<ZPdJd=ZQd> ZRdJd?ZSdJd@ZTdJdAZUdBe"e#e+f d"e"e#e+f fdCZVdLd;e+fdDZWdMdJdEZXeYdF ZZdJdGZ[dJdHZ\dJdIZ] xZ^S )Nr at
Instantiate a stub creator to bind and un-bind the file-related modules to
the :py:mod:`pyfakefs` fake modules.
The arguments are explained in :py:class:`TestCaseMixin`.
:py:class:`Patcher` is used in :py:class:`TestCaseMixin`.
:py:class:`Patcher` also works as a context manager for other tests::
with Patcher():
doStuff()
Nr/ r )_pydevd_pydevd_pydev__jb_)r _jb_runner_toolsCACHED_MODULES
FS_MODULES FS_FUNCTIONS.
FS_DEFARGSSKIPPED_FS_MODULESz3sys.modules contains 'None' values; must skip them.)r/ cygwin SKIPNAMESPATCHED_MODULE_NAMESADDITIONAL_SKIP_NAMESFr r c | dd r4| j &t | | _ | j S | j &t | | _ | j S )Nr F)getr r __new__r )r rQ rR r s r< r zPatcher.__new__c sg ::mU + + #&"'''//#"6"6? " ; ''//#..CK{r> Trv rw rx ry rz r{ r| r} r~ r r c |
| _ |
r| j dk rdS nA| j dk r6|s |s |s|r|r|t j k s|s|r| st j d dS |s t d t d | j
| _ t | _
|| _ t | _ t# | _ |&d |D } | j | i | _ i | _ i | _ | g | _ || j | || _ || _ | | _ i | _ d| _ d| _ i | _ i | _! d| _" d| _# d| _$ d| _% d| _& d| _' |rddl(m)} m*}
m+}m,} |pi }| | | j |
| j | | j | |4|- D ]\ }}|| j |< t] | }nt] }| }|rU|| j/ k r|| j0 _/ d}| j | j1 k r| j | j0 _1 d}|| j2 k r|| j0 _2 d}|r| 3 i | _4 | 5 dS ) aV
Args:
additional_skip_names: names of modules where no module
replacement shall be performed, in addition to the names in
:py:attr:`fake_filesystem_unittest.Patcher.SKIPNAMES`.
Instead of the module names, the modules themselves
may be used.
modules_to_reload: A list of modules that need to be reloaded
to be patched dynamically; may be needed if the module
imports file system modules under an alias
.. caution:: Reloading modules may have unwanted side effects.
modules_to_patch: A dictionary of fake modules mapped to the
fully qualified patched module names. Can be used to add
patching of modules not provided by `pyfakefs`.
allow_root_user: If `True` (default), if the test is run as root
user, the user in the fake file system is also considered a
root user, otherwise it is always considered a regular user.
use_known_patches: If `True` (the default), some patches for commonly
used packages are applied which make them usable with pyfakefs.
patch_open_code: If `True`, `io.open_code` is patched. The default
is not to patch it, as it mostly is used to load compiled
modules that are not in the fake file system.
patch_default_args: If `True`, default arguments are checked for
file system functions, which are patched. This check is
expansive, so it is off by default.
use_cache: If `True` (default), patched and non-patched modules are
cached between tests for performance reasons. As this is a new
feature, this argument allows to turn it off in case it
causes any problems.
use_dynamic_patch: If `True`, dynamic patching after setup is used
(for example for modules loaded locally inside of functions).
Can be switched off if it causes unwanted side effects.
r Nz{Nested fake filesystem invocation using custom arguments - using the existing fake filesystem, discarding custom arguments! c g | ]E}t j | rt t | j nt t
| FS rd )inspectismoduler r r` r ).0ms r<
z$Patcher.__init__.. sS 180@0C0CUZ##,,cST r> TF)get_modules_to_patchget_classes_to_patchget_fake_module_classesget_cleanup_handlers)6r
DOC_REF_COUNT REF_COUNTr' r warningswarnr$ r% r copy
skip_namesopen
original_openr{ r5 tempfile_patcherrf linecache_patcherupdate_fake_module_classes_unfaked_module_classes_class_modules_init_fake_module_classesrw extendr| r} r~ cleanup_handlers_stubsr fake_modulesunfaked_modules_isStale _dyn_patcher _patching_pausedhas_copy_file_range
has_copy_filepyfakefs.patched_packagesr r r r itemssetr r r PATCH_DEFAULT_ARGS clear_cache_fake_module_functions_init_fake_module_functions)r; rv rw rx ry rz r{ r| r} r~ r r r r r r rW fake_modulepatched_module_namesr s r< r= zPatcher.__init__l s ^ ' !A%% &
^a
%
$
$
'
)
#im33% 4 4 ) 4
W
F AJJJ AJJJ .--// ! . / 1 1 !1!3!3 , . J
O " ": . . .46!79$46 &&((( 46 ( " ) )*; < < <"4 "!2 BD 48 ,0,./1
6: #( " A
0 52 # #$8$8$:$: ; ; ; & &';';'='= > > > % , ,-D-D-F-F G G G ! ( ()=)=)?)? @ @ @ '%5%;%;%=%=
>
>!k2=)$//#&'7#8#8 #&55 #m ##t'@@@6J3 " $"<<<7;4 " !T%<<<4F1 " 79# ((*****r> c d t | _ i | _ i | _ g | _ i | _ dS )zClear the module cache.N)r
r r r r r r s r< clear_fs_cachezPatcher.clear_fs_cache s4 !UU !# r> c 8 | j dS )z5Clear the module cache (convenience instance method).N)r r r: s r< r zPatcher.clear_cache
s %%'''''r> rW handlerc || j |< dS )aQ Register a handler for cleaning up a module after it had been loaded by
the dynamic patcher. This allows to handle modules that cannot be reloaded
without unwanted side effects.
Args:
name: The fully qualified module name.
handler: A callable that may do any module cleanup, or do nothing
and return `True` in case reloading shall be prevented.
Returns:
`True` if no further cleanup/reload shall occur after the handler is
executed, `False` if the cleanup/reload shall still happen.
N)r )r; rW r s r< register_cleanup_handlerz Patcher.register_cleanup_handler s '. d###r> c dt fd}dt fd}t j t j t
j |d| _ t j d d dk r
|| j d< t st j dk rt
j | j d < t j d
k rt j | j d < nt j | j d < d
g| j d< t j d d dk r | j d d t& j | j d
< t j d d dk rt& j | j d< t, rHt. j | j d< | j d d t& j | j d< t2 rt. j | j d< || j d< t& j | j d< d S )Nr c . t j | d S NT) from_patcher)r" FakePathlibModuler s r< fake_pathlib_modulez>Patcher._init_fake_module_classes..fake_pathlib_module) s 1"4HHH Hr> c . t j | d S r )r" FakePathlibPathModuler s r< fake_path_modulez;Patcher._init_fake_module_classes..fake_path_module, s 5btLLL Lr> )rE shutiliopathlib rJ zpathlib._localr@ _ior/ r0 fcntlr# Pathr, r- ) r( r FakeOsModuler FakeShutilModuler FakeIoModuler rU rV r*
FakeIoModule2rZ r FakeNtModuler FakeFcntlModuler r r" RealPathlibModuler r, r! FakePathlib2Moduler- FakeScanDirModuleRealPathlibPathModule)r; r r s r< r z!Patcher._init_fake_module_classes! s IN I I I I M M M M M &,=&* %
%
! BQB 7 * * ;ND %&6 7 Ec&'11/6/DD %e , <7 " ".7.DD %d + +1@1PD %g .
(1kF# BQB 7 * * ' . ./? @ @ @2>2P$Y/ BQB 7 * * .
()9 : V#6
%j 1
' . .z : : :7C7UD ( 4 Y3F3XD %i 0,<!&)/;/Q$V,,,r> c p | j D ]\ }}t |d r|j }t j | rp| D ][}t
|| |f}|| j |i |< |dk r#|| j |i t < \t j }| D ]Z}t
|| t f}|| j |i d< || j |i t < [d S )NdirrE genericpath)
r r rY r3 r
isfunctiongetattrr
setdefault OS_MODULEr FakePathModule PATH_MODULE)r; mod_namer
module_dirfct_name module_attrs r< r z#Patcher._init_fake_module_functionsX s_ &*%>%D%D%F%F , , !Hk{E**
, (_
%j11 ,$/OO$5$5 , ,'.{H'E'Ex&P ( 3>>xLL $ $t++ !, ! 7 B B8R P P )
&4 #)) H";99;GK
' 2 28R @ @ O
' 2 28R @ @ M M r> c . | | S )zContext manager for usage outside of
fake_filesystem_unittest.TestCase.
Ensure that all patched modules are removed in case of an
unhandled exception.
)r r: s r< __enter__zPatcher.__enter__u s
r> exc_typeexc_valexc_tbc . | d S r7 )r )r; rA rB rC s r< __exit__zPatcher.__exit__~ s
r> mod module_namesc t j | r |j |v p5t j | o!|j | j |g v S # t $ r Y dS w xY wNF)r r r` isclassra r r Exception)r; rF rW rG s r<
_is_fs_modulezPatcher._is_fs_module s %% 1LL0H?3'' HNd&9&=&=dB&G&GG
55 s AA
A#"A#fctc t j | st j | o&|j | j v o|j | j |j v S # t $ r Y dS w xY wrI )r r5 isbuiltinr` r
ra rK )r; rM s r< _is_fs_functionzPatcher._is_fs_function s} #C((BG,=c,B,B PLD$??PNd&A#,&OO
55 s AA
A A itemc # K |j rJt j | r6t |j D ]!\ }}| | r|||fV "n# t
$ r Y nw xY w t j | r{t j |t j D ]\}t t |d }|j r6t |j D ]!\ }}| | r|||fV "[dS dS # t
$ r Y dS w xY w)zFind default arguments that are file-system functions to be
patched in top-level functions and members of top-level classes.) predicater N)
__defaults__r r5 enumeraterP rK rJ
getmembersr r )r; rQ idr r s r< _def_valueszPatcher._def_values sf
)W%7%=%=
) %d&7 8 8 ) )DAq++A.. ) "Aqj((( D t$$
. !+DG c t
t j t gz
t j }|D ]Q\ } j r j v st j s,nH# t $ r; j r1 j
j n# t $ r Y nw xY wY qw xY w j v p t# fd j D } j }
fd|D }|ra| D ]K\ }} j
j |t- |j f Ln| D ]K\ }} j
j |t- |j f L fd|D }| D ]Q\ }} j
j ||j |j ft- R j r | j r j
j SdS )zFind and cache all modules that import file system modules.
Later, `setUp()` will stub these with the fake file system
modules.
c D g | ] }| j S rd )
startswithr` )r snr s r< r z)Patcher._find_modules.. s' JJJB v//JJJr> c J i | ] \ }} || || S rd )rL )r rW rF rG r; s r<
z)Patcher._find_modules.. sG D#%%c4 >>c r> c F i | ] \ }} | || S rd )rP )r rW rM r; s r< rc z)Patcher._find_modules.. sC "+$t?S?STW?X?X # r> N) r r keysr: rU modulesr r r} r r r rK r addr SKIPMODULESanyr __dict__r r7 r
r` r r ra r| r] ) r; r rW skippedrZ rf rF functionsrM r rG s ` @@r<
_find_moduleszPatcher._find_modules s'
D 5 : : < <==
M ""((** ! 7 : 7 :LD&
N $"555"+F33 6 6
> 599&AAAA$
00 CJJJJ$/JJJ5 5G "?//117799L !- G
8!( ID#N5@@suuMMQQ .
") ID#N-88suuEEII . /; "+ !2!2 " "ID#N/:: s|S^ doctesterc . | j r(| j xj dz
c_ | j j dk rdS n'| j xj dz
c_ | j j dk rdS t j 5 t j d | ddd n # 1 swxY w Y | | | |j
|_
| | j t _ | j t _ dS )zBind the file-related modules to the :py:mod:`pyfakefs` fake
modules real ones. Also bind the fake `file()` and `open()` functions.
r Nr )r r r r r catch_warningsfilterwarningsrm rs r r r[ r rs r tokenize
_builtin_openr; rt s r< r z
Patcher.setUp sL N ( (A - ( (~+a// 0
N $ $ ) $ $~'!++
$
&
& ! ! #H - - - ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
" 0 0 A AIO + !%!3 s *)B B#&B#c | j sId| _ d| _ | j | | | | | j t | | _
t j
d| j
| j D ]7}t j |j |u rt% | 8| j s<| j
t j d d S d S d S NTFr )r r r r[
patch_modulespatch_functionspatch_defaults_set_glob_os_functionsr DynamicPatcherr rU meta_pathinsertrw rf r r` r r~ rI pop)r; r s r< r[ zPatcher.start_patching2 s@ ~ % !DN DL " 1 1 3 3 3 " " " ! ! ! ' ' ) ) ) ! 0 0 2 2 2 .t 4 4D M D$5 6 6 6 0
#
#;??6?33v==6NNN)
%!))+++
!!!$$$$$) % %$
%
%r> c @ t j dk rXt j }t t
j |_ t j dk r t t
j |_ t j dk r%t t
j j |_ d S d S )NrJ )rA )
rU rV glob_StringGlobber staticmethodrE lstatr- rq lexists)r; globbers r< r z Patcher._set_glob_os_functionsI su w & &)G ( 2 2GM '))".rz":": w & & *27? ; ;GOOO ' &r> c | j J | j D ]h\ \ }}}}| j | | \ }}| j | }| ||j }|D ] } | j | || id S r7 )r r r r
r __get__r smart_set)
r; rW ft_nameft_modrf methodr; r attrr s
r< r~ zPatcher.patch_functionsS s {&&&040A0G0G0I0I : : , #T7FW # :7 CF K FH +H5K>>[ 2 D "
:
: %%fdD9999
:
: :r> c g }| j D ](\ }}|t j v r| | )t | }| j J | j D ]\ }}|D ]\ }} |r|j | s(| j
||| j | n0|| j v r'| j
||| j | {# t $ r Y w xY w| j D ]=\ }}|D ]5\ }}|| j v r'| j
||| j | 6>d S r7 )RUNTIME_SKIPMODULESr rU rf r tupler r r` r` r r r rK r ) r; skip_prefix_listrt_skip_moduleprefixes
skip_prefixesrW rf r r s r< r} zPatcher.patch_modules^ s (,(@(F(F(H(H 2 2 $NH ,, ''111 .//
{&&& !_ 2 2 4 4 MD' '
( X0J0J%1 1 X --fdD>[ 2 D L#///!#"233
+
+188 ''---- ''**** $\ 2 2C
3
3r> globs_c | }| j r| | j D ]$}||v r | j | | j ||< %|S r7 )r r rs r r )r; r r rW s r< r zPatcher.replace_globs sf
= MMOOO- G GDu}} =d 7 =dg F Fd r> c 8 | j r(| j xj dz c_ | j j dk rdS n'| j xj dz c_ | j j dk rdS | t | j rd| j _ dS d| j _ dS )z8Clear the fake filesystem bindings created by `setUp()`.r r N)r r r r r^ r& r r rz s r< r zPatcher.tearDown s N ( (A - ( (~+a// 0
N $ $ ) $ $~'!++ *)-DN & & &%)DN " " "r> c | j rd| _ d| _ || _ | j r| j | | j r?| j r8| j t j
d | j
| j
| d S d S r| )r r r r rp unset_defaultsr~ r rI rU r r r r^ r r )r; temporarys r< r^ zPatcher.stop_patching s > * DM "DN$DL{
. ++--- ! ! !%
%$*;
%!))+++
!!!$$$ ! / / 1 1 1 " 0 0 2 2 2 ' ' ) ) ) ) ) * *r> c | j S r7 )r r: s r< is_patchingzPatcher.is_patching s
~ r> c
| j D ]z\ }}}g }t t t |j D ]6\ }}||k r| | !| | 7t
| |_ {d S r7 )r rU r r rT r r )r; rM r r r rW rX s r< r zPatcher.unset_defaults s O 3 3LCb L!$uc.>"?"?@@
+
+188 ''++++ ''**** $\ 2 2C 3 3r> c 2 | d dS )r T)r N)r^ r: s r< r z
Patcher.pause s!
T*****r> c @ | j r| dS dS r )r r[ r: s r< r zPatcher.resume s0 < " ! ! ! ! ! " "r> r )r r r7 )F)_r` ra rb rc r r r r r r r rU rs rx rE r" r% r4 rq rh rZ r0 r2 rg r1 r3 r& r r
r r r r r r r r r r r r intr
r r
IS_WINDOWSr r r r r r r r r r r' r r r r= r r r r r r r@ r
BaseExceptionr
rE rL rP r rY r r] rm rs r r[ r r~ r} r r r r^ r r r r r r r s @r< r r
s
!K$ |w
"""
433 #H '*ceeNC
O+++9;JS#eJO 4556;;;@BL$uS#s]+S_<=BBBEGJU<hsCx.@@ABGGGACS#eJO&<"= =>CCC ; U !44J #%%Is3x &)SUU#c(***&)cee3s8+++ #'GXi
''''+K)$+++IM IM8<<@ $"&%.]#( "& !V+ V+ 'U3
?-C(D EV+ $D$45V+ #4Z#89 V+
V+
V+ #V+ !V+ V+ V+ V+
V+ V+ V+ V+p $ $ $ [$( ( ( (.S .8SE4K;P . . . . 5R 5R 5R 5Rn : 4
./ -( '
%(8: >: >: >:@ $4 4s 4d 4 4 4 46% % % %.< < < : : : :T T T T43 3 3 3 DcN tCH~ * *# * * * *$
*
*
*
*
* X 3 3 3 3+ + + +" " " " " " " "r> r c L e Zd ZdZdeeeef fdZdefdZ de
ddfdZ dS ) PausezSimple context manager that allows to pause/resume patching the
filesystem. Patching is paused in the context manager, and resumed after
going out of its scope.
callerc t |t t f r|j J |j | _ dS t |t
r || _ dS t
d )zInitializes the context manager with the fake filesystem.
Args:
caller: either the FakeFilesystem instance, the Patcher instance
or the pyfakefs test case.
NzInvalid argument - should be of type "fake_filesystem_unittest.Patcher", "fake_filesystem_unittest.TestCase" or "fake_filesystem.FakeFilesystem")
isinstancer r r _fsr(
ValueError)r; r s r< r= zPause.__init__ sj fw
6 7 7 9((('-yDHHH
/
/ DHHH 6
r> r c B | j | j S r7 )r r r: s r< r@ zPause.__enter__ s xr> rQ Nc 8 | j d S r7 )r r )r; rQ s r< rE zPause.__exit__ s r> ) r` ra rb rc r r r r( r= r@ r rE rd r> r< r r s
uWm^%K L (> c d r> r c
e Zd ZdZdeddfdZddZdedefdZ dedefd Z
dd
ed e e e
eef d e e de e fd
Zd
edefdZdS )r zA file loader that replaces file system related modules by their
fake implementation if they are loaded after calling `setUpPyfakefs()`.
Implements the protocol needed for import hooks.
r r Nc || _ i | _ | j j | _ t | _ |j | _ | j D ]L}| | r5|t j v r't j | | j |< t j |= M| j D ]\ }}|t j |< d S r7 )
r
sysmodulesr rf r
_loaded_module_namesr needs_patchrU r )r; r rW r s r< r= zDynamicPatcher.__init__ s
}1 .1ee! ' 8 L & &D %%
&$#+*=*=(+ D(9%K% L . . 0 0 ' 'LD& &CK ' 'r> c n | j D ] }| j | t j |< | j j D ]$}|j t j v rt
| %d | j j D }| j D ]A}|t j v r1||vr-|| j v r | j | | r4t j |= Bd S )Nc g | ] }|j
S rd )r` )r r s r< r z*DynamicPatcher.cleanup.. s' !
!
!
&FO!
!
!
r> ) r rU rf r rw r` r r r )r; module_namer reloaded_module_namesrW s r< rI zDynamicPatcher.cleanup s ? D DK'+{'CCK $ $m5 F#+--v!
!
*.-*I!
!
!
- & &Ds{""t3H'H'H40005PT5J45PQU5V5V0 K% & &r> rW c || j vr | j | dS |t j v r.t t j | | j | u rdS dS )z;Checks if the module with the given name shall be replaced.FT)rf r rg rU typerr s r< r zDynamicPatcher.needs_patch sb t| # # % ) )$ / / /5 3; 4 D(9#:#:dl4>P#P#P5tr> c | j j }|| d|j }t j D ]}| || }|dz }| | r| | c S | |d }| | r| | c S dS )zChecks if the module with the given name is a module existing in the fake
filesystem and returns its path in this case.
N.z.pyz __init__.py ) r r replacepath_separatorrU rq joinpathsexists absnormpath)r; rW r base_pathrq module_pathpy_module_path init_paths r< fake_module_pathz DynamicPatcher.fake_module_path& s ]
> S"*;<>.99999 LLm D D 99Y'' 5 >>)444445rr> fullnamerq targetc 2 | | rt || S | j j t j k rW| | }|r@t || }|r.t | }|t j
|< t || S dS )zModule finder.N) r r r r{ r' r r r r rU rf )r; r rq r r specr s r< find_speczDynamicPatcher.find_spec8 s H % % . h-- - = (IM 9 9 //99K
6.xEE 6 -d 3 3F,2CK)%h555tr> c P | j | t j |< | j | S )z/Replaces the module by its fake implementation.)rf rU )r; r s r< load_modulezDynamicPatcher.load_moduleL s" $ X 6 H |H%%r> r r7 )r` ra rb rc r r= rI r r r r r r r bytesr r r r rd r> r< r r s
' 'D ' ' ' '"& & & &" S S , (, xeSj 123 $
* (&C &J & & & & & &r> r r7 )Wrc r% r r r4 r r r" rs rE rU rN rx unittestr importlibr
importlib.abcr r importlib.machineryr importlib.utilr r typesr r
r typingr r
r r r r r r r r r r r r pyfakefsr r r r r r r r! r" r# pyfakefs.fake_filesystemr$ r% r& r' r( pyfakefs.fake_osr) pyfakefs.helpersr* r+ pyfakefs.legacy_packagesr, r- pyfakefs.mox3_stuboutr. rZ r8 r: r5 rf r r r r DOCTEST_PATCHERr r r r r r rd r> r< r s
.
0 0 0 0 0 0 0 0 * * * * * * D D D D D D D D 9 9 9 9 9 9 9 9 9 9 W W W W W W W W W W W W W W W W + + + + + + ( ( ( ( ( ( ! ! ! ! ! ! ! ! ! ! ! ! - , , , , , , , , , , , , , 6 6 6 6 6 6 6 6 3 3 3 3 3 3LG++DD ,'11hh{ / / / / / / / / d/) /) /) /) /) /) /) /)f !%9 EI488< "!* $ "9 9 9 H 9 $DsJ)?$@A9 Z 01 9
tCO 45 9
9 9 9 9 9 9 9 9 9 9x EI488< "!* $ "- - - -
-
-
$DsJ)?$@A - Z 01
- tCO 45- - - - - - - - - -`v v v v v v v v r x - BC " C " C " C " C " C " C " C "L DZ& Z& Z& Z& Z&^V Z& Z& Z& Z& Z&r>