def __init__(self,
additional_skip_names=None,
modules_to_reload=None,
modules_to_patch=None,
allow_root_user=True,
use_known_patches=True):
"""For a description of the arguments, see TestCase.__init__"""
if not allow_root_user:
# set non-root IDs even if the real user is root
set_uid(1)
set_gid(1)
self._skipNames = self.SKIPNAMES.copy()
# save the original open function for use in pytest plugin
self.original_open = open
self.fake_open = None
if additional_skip_names is not None:
skip_names = [
m.__name__ if inspect.ismodule(m) else m
for m in additional_skip_names
]
self._skipNames.update(skip_names)
self._fake_module_classes = {}
self._class_modules = {}
self._init_fake_module_classes()
self.modules_to_reload = modules_to_reload or []
if use_known_patches:
modules_to_patch = modules_to_patch or {}
modules_to_patch.update(get_modules_to_patch())
self._class_modules.update(get_classes_to_patch())
self._fake_module_classes.update(get_fake_module_classes())
if modules_to_patch is not None:
for name, fake_module in modules_to_patch.items():
self._fake_module_classes[name] = fake_module
self._fake_module_functions = {}
self._init_fake_module_functions()
# Attributes set by _refresh()
self._modules = {}
self._fct_modules = {}
self._def_functions = []
self._open_functions = {}
self._stubs = None
self.fs = None
self.fake_modules = {}
self._dyn_patcher = None
# _isStale is set by tearDown(), reset by _refresh()
self._isStale = True
self._patching = False
def __init__(self,
additional_skip_names=None,
modules_to_reload=None,
modules_to_patch=None,
allow_root_user=True,
use_known_patches=True,
patch_open_code=PatchMode.OFF,
patch_default_args=False,
use_cache=True):
"""
Args:
additional_skip_names: names of modules inside of which 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.
"""
if not allow_root_user:
# set non-root IDs even if the real user is root
set_uid(1)
set_gid(1)
self._skip_names = self.SKIPNAMES.copy()
# save the original open function for use in pytest plugin
self.original_open = open
self.patch_open_code = patch_open_code
if additional_skip_names is not None:
skip_names = [
m.__name__ if inspect.ismodule(m) else m
for m in additional_skip_names
]
self._skip_names.update(skip_names)
self._fake_module_classes = {}
self._unfaked_module_classes = {}
self._class_modules = {}
self._init_fake_module_classes()
# reload tempfile under posix to patch default argument
self.modules_to_reload = [] if sys.platform == 'win32' else [tempfile]
if modules_to_reload is not None:
self.modules_to_reload.extend(modules_to_reload)
self.patch_default_args = patch_default_args
self.use_cache = use_cache
if use_known_patches:
modules_to_patch = modules_to_patch or {}
modules_to_patch.update(get_modules_to_patch())
self._class_modules.update(get_classes_to_patch())
self._fake_module_classes.update(get_fake_module_classes())
if modules_to_patch is not None:
for name, fake_module in modules_to_patch.items():
self._fake_module_classes[name] = fake_module
patched_module_names = set(modules_to_patch)
clear_cache = not use_cache
if use_cache:
if patched_module_names != self.PATCHED_MODULE_NAMES:
self.__class__.PATCHED_MODULE_NAMES = patched_module_names
clear_cache = True
if self._skip_names != self.ADDITIONAL_SKIP_NAMES:
self.__class__.ADDITIONAL_SKIP_NAMES = self._skip_names
clear_cache = True
if patch_default_args != self.PATCH_DEFAULT_ARGS:
self.__class__.PATCH_DEFAULT_ARGS = patch_default_args
clear_cache = True
if clear_cache:
self.clear_cache()
self._fake_module_functions = {}
self._init_fake_module_functions()
# Attributes set by _refresh()
self._stubs = None
self.fs = None
self.fake_modules = {}
self.unfaked_modules = {}
# _isStale is set by tearDown(), reset by _refresh()
self._isStale = True
self._dyn_patcher = None
self._patching = False
def __init__(self,
additional_skip_names=None,
modules_to_reload=None,
modules_to_patch=None,
allow_root_user=True,
use_known_patches=True,
patch_open_code=PatchMode.OFF):
"""
Args:
additional_skip_names: names of modules inside of which 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.
"""
if not allow_root_user:
# set non-root IDs even if the real user is root
set_uid(1)
set_gid(1)
self._skip_names = self.SKIPNAMES.copy()
# save the original open function for use in pytest plugin
self.original_open = open
self.fake_open = None
self.patch_open_code = patch_open_code
if additional_skip_names is not None:
skip_names = [
m.__name__ if inspect.ismodule(m) else m
for m in additional_skip_names
]
self._skip_names.update(skip_names)
self._fake_module_classes = {}
self._unfaked_module_classes = {}
self._class_modules = {}
self._init_fake_module_classes()
self.modules_to_reload = modules_to_reload or []
if use_known_patches:
modules_to_patch = modules_to_patch or {}
modules_to_patch.update(get_modules_to_patch())
self._class_modules.update(get_classes_to_patch())
self._fake_module_classes.update(get_fake_module_classes())
if modules_to_patch is not None:
for name, fake_module in modules_to_patch.items():
self._fake_module_classes[name] = fake_module
self._fake_module_functions = {}
self._init_fake_module_functions()
# Attributes set by _refresh()
self._modules = {}
self._skipped_modules = {}
self._fct_modules = {}
self._def_functions = []
self._open_functions = {}
self._stubs = None
self.fs = None
self.fake_modules = {}
self.unfaked_modules = {}
self._dyn_patcher = None
# _isStale is set by tearDown(), reset by _refresh()
self._isStale = True
self._patching = False