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 test_update_inits(testdata, etas_file, force, file_exists): with Patcher(additional_skip_names=['pkgutil']) as patcher: set_uid(0) # Set to root user for write permission fs = patcher.fs fs.add_real_file(testdata / 'nonmem/pheno.mod', target_path='run1.mod') fs.add_real_file(testdata / 'nonmem/pheno.phi', target_path='run1.phi') fs.add_real_file(testdata / 'nonmem/pheno.ext', target_path='run1.ext') fs.add_real_file(testdata / 'nonmem/pheno.dta', target_path='pheno.dta') with open('run1.mod', 'a') as f: f.write(etas_file) model = Model('run1.mod') update_inits(model, force) model.update_source() assert ('$ETAS FILE=run1_input.phi' in str(model)) is file_exists assert (os.path.isfile('run1_input.phi')) is file_exists
def __init__(self, additional_skip_names=None, modules_to_reload=None, modules_to_patch=None, allow_root_user=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.modules_to_reload = [tempfile] if modules_to_reload is not None: self.modules_to_reload.extend(modules_to_reload) # Attributes set by _findModules() # IMPORTANT TESTING NOTE: Whenever you add a new module below, test # it by adding an attribute in fixtures/module_with_attributes.py # and a test in fake_filesystem_unittest_test.py, class # TestAttributesWithFakeModuleNames. self._fake_module_classes = { 'os': fake_filesystem.FakeOsModule, 'shutil': fake_filesystem_shutil.FakeShutilModule, 'io': fake_filesystem.FakeIoModule, } if IS_PY2 or IS_PYPY: # in Python 2 io.open, the module is referenced as _io self._fake_module_classes['_io'] = fake_filesystem.FakeIoModule # class modules maps class names against a list of modules they can # be contained in - this allows for alternative modules like # `pathlib` and `pathlib2` self._class_modules = {} if pathlib: self._class_modules['Path'] = [] if pathlib: self._fake_module_classes[ 'pathlib'] = fake_pathlib.FakePathlibModule self._class_modules['Path'].append('pathlib') if pathlib2: self._fake_module_classes[ 'pathlib2'] = fake_pathlib.FakePathlibModule self._class_modules['Path'].append('pathlib2') self._fake_module_classes[ 'Path'] = fake_pathlib.FakePathlibPathModule if use_scandir: self._fake_module_classes[ 'scandir'] = fake_scandir.FakeScanDirModule if modules_to_patch is not None: for name, fake_module in modules_to_patch.items(): self._fake_module_classes[name] = fake_module # handle patching function imported separately like # `from os import stat` # each patched function name has to be looked up separately self._fake_module_functions = {} for mod_name, fake_module in self._fake_module_classes.items(): if (hasattr(fake_module, 'dir') and inspect.isfunction(fake_module.dir)): for fct_name in fake_module.dir(): module_attr = (getattr(fake_module, fct_name), mod_name) self._fake_module_functions.setdefault( fct_name, {})[mod_name] = module_attr if mod_name == 'os': self._fake_module_functions.setdefault( fct_name, {})[OS_MODULE] = module_attr # special handling for functions in os.path fake_module = fake_filesystem.FakePathModule for fct_name in fake_module.dir(): module_attr = (getattr(fake_module, fct_name), PATH_MODULE) self._fake_module_functions.setdefault( fct_name, {})['genericpath'] = module_attr self._fake_module_functions.setdefault( fct_name, {})[PATH_MODULE] = module_attr # Attributes set by _refresh() self._modules = {} self._fct_modules = {} 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 mock_io_iter(fs): fake_filesystem.set_uid(1000) fake_filesystem.set_gid(1000) yield IOIter('/foo', block_size=2)
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