Remove the "module_cleanup_mode" argument from Patcher

- had been introduced in the previous patch release
  as a stop-gap measure for problems with django
- superseded by module cleanup handlers

Author: mrbean-bremen

CHANGES.md

@@ -6,6 +6,8 @@ The released versions correspond to PyPI releases.
 ### Changes
 * the handling of file permissions under Posix is should now mostly match the behavior
   of the real filesystem, which may change the behavior of some tests
+* removed the argument `module_cleanup_mode`, that was introduced as a temporary workaround
+  in the previous version - related problems shall be handled using a cleanup handler
 
 ### Fixes
 * fixed a specific problem on reloading a pandas-related module (see [#947](../../issues/947)),

docs/usage.rst

@@ -678,24 +678,10 @@ for modules loaded locally inside of functions).
 Can be switched off if it causes unwanted side effects, though that would mean that
 dynamically loaded modules are no longer patched, if they use file system functions.
 
-module_cleanup_mode
-~~~~~~~~~~~~~~~~~~~
-This is a setting that works around a potential problem with the cleanup of
-dynamically loaded modules (e.g. modules loaded after the test has started).
-As the original problem related to `django` has now been resolved in another way (see below),
-the setting may not be needed anymore, and is subject to removal in a future version.
-
-The setting defines how the dynamically loaded modules are cleaned up after the test.
-Any dynamically loaded module is cleaned up after the test to ensure that no patched modules
-can be used after that.
-The default (`ModuleCleanupMode.AUTO`) is currently the same as `ModuleCleanupMode.DELETE`.
-`DELETE` will delete all dynamically loaded modules (so that they are reloaded the next time
-they are needed), while `RELOAD` will reload them immediately.
-Under some rare conditions, changing this setting may help to avoid problems related
-to incorrect test cleanup.
-
-Problems with unloading dynamically loaded modules may also be solved more
-specifically by registering a handler for specific modules (using `Patcher.register_cleanup_handler`),
+A possible problem with dynamically loaded modules is their unloading, for example if
+reloading the module fails after unloading due to a problem in the module.
+This kind of problem may be solved more specifically by registering a handler
+for specific modules (using `Patcher.register_cleanup_handler`),
 that will be called during the cleanup process. This is used internally
 to handle known problems with the `django` and `pandas` packages.
 

pyfakefs/fake_filesystem_unittest.py

@@ -47,7 +47,6 @@
 import sys
 import tempfile
 import tokenize
-from enum import Enum
 from importlib.abc import Loader, MetaPathFinder
 from types import ModuleType, TracebackType, FunctionType
 from typing import (
@@ -95,14 +94,6 @@
 PATH_MODULE = "ntpath" if sys.platform == "win32" else "posixpath"
 
 
-class ModuleCleanupMode(Enum):
-    """Defines the behavior of module cleanup on dynamic patcher shutdown."""
-
-    AUTO = 1
-    DELETE = 2
-    RELOAD = 3
-
-
 def patchfs(
     _func: Optional[Callable] = None,
     *,
@@ -115,7 +106,6 @@ def patchfs(
     patch_default_args: bool = False,
     use_cache: bool = True,
     use_dynamic_patch: bool = True,
-    module_cleanup_mode: ModuleCleanupMode = ModuleCleanupMode.AUTO,
 ) -> Callable:
     """Convenience decorator to use patcher with additional parameters in a
     test function.
@@ -144,7 +134,6 @@ def wrapped(*args, **kwargs):
                 patch_default_args=patch_default_args,
                 use_cache=use_cache,
                 use_dynamic_patch=use_dynamic_patch,
-                module_cleanup_mode=module_cleanup_mode,
             ) as p:
                 args = list(args)
                 args.append(p.fs)
@@ -181,7 +170,6 @@ def load_doctests(
     patch_open_code: PatchMode = PatchMode.OFF,
     patch_default_args: bool = False,
     use_dynamic_patch: bool = True,
-    module_cleanup_mode: ModuleCleanupMode = ModuleCleanupMode.AUTO,
 ) -> TestSuite:  # pylint:disable=unused-argument
     """Load the doctest tests for the specified module into unittest.
         Args:
@@ -202,7 +190,6 @@ def load_doctests(
             patch_open_code=patch_open_code,
             patch_default_args=patch_default_args,
             use_dynamic_patch=use_dynamic_patch,
-            module_cleanup_mode=module_cleanup_mode,
             is_doc_test=True,
         )
     assert Patcher.DOC_PATCHER is not None
@@ -283,7 +270,6 @@ def setUpPyfakefs(
         patch_default_args: bool = False,
         use_cache: bool = True,
         use_dynamic_patch: bool = True,
-        module_cleanup_mode: ModuleCleanupMode = ModuleCleanupMode.AUTO,
     ) -> None:
         """Bind the file-related modules to the :py:class:`pyfakefs` fake file
         system instead of the real file system.  Also bind the fake `open()`
@@ -316,7 +302,6 @@ def setUpPyfakefs(
             patch_default_args=patch_default_args,
             use_cache=use_cache,
             use_dynamic_patch=use_dynamic_patch,
-            module_cleanup_mode=module_cleanup_mode,
         )
 
         self._patcher.setUp()
@@ -334,7 +319,6 @@ def setUpClassPyfakefs(
         patch_default_args: bool = False,
         use_cache: bool = True,
         use_dynamic_patch: bool = True,
-        module_cleanup_mode: ModuleCleanupMode = ModuleCleanupMode.AUTO,
     ) -> None:
         """Similar to :py:func:`setUpPyfakefs`, but as a class method that
         can be used in `setUpClass` instead of in `setUp`.
@@ -373,7 +357,6 @@ def setUpClassPyfakefs(
             patch_default_args=patch_default_args,
             use_cache=use_cache,
             use_dynamic_patch=use_dynamic_patch,
-            module_cleanup_mode=module_cleanup_mode,
         )
 
         Patcher.PATCHER.setUp()
@@ -539,7 +522,6 @@ def __init__(
         patch_default_args: bool = False,
         use_cache: bool = True,
         use_dynamic_patch: bool = True,
-        module_cleanup_mode: ModuleCleanupMode = ModuleCleanupMode.AUTO,
         is_doc_test: bool = False,
     ) -> None:
         """
@@ -575,11 +557,6 @@ def __init__(
             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.
-            module_cleanup_mode: Defines how the modules in the dynamic patcher are
-                cleaned up after the test. The default (AUTO) currently depends
-                on the availability of the `django` module, DELETE will delete
-                all dynamically loaded modules, RELOAD will reload them.
-                This option is subject to change in later versions.
         """
         self.is_doc_test = is_doc_test
         if is_doc_test:
@@ -618,7 +595,6 @@ def __init__(
         self.patch_default_args = patch_default_args
         self.use_cache = use_cache
         self.use_dynamic_patch = use_dynamic_patch
-        self.module_cleanup_mode = module_cleanup_mode
         self.cleanup_handlers: Dict[str, Callable[[str], bool]] = {}
 
         if use_known_patches:
@@ -971,7 +947,7 @@ def start_patching(self) -> None:
                 if sys.modules.get(module.__name__) is module:
                     reload(module)
             if not self.use_dynamic_patch:
-                self._dyn_patcher.cleanup(ModuleCleanupMode.DELETE)
+                self._dyn_patcher.cleanup()
                 sys.meta_path.pop(0)
 
     def patch_functions(self) -> None:
@@ -1049,7 +1025,7 @@ def stop_patching(self, temporary=False) -> None:
                 self._stubs.smart_unset_all()
             self.unset_defaults()
             if self.use_dynamic_patch and self._dyn_patcher:
-                self._dyn_patcher.cleanup(self.module_cleanup_mode)
+                self._dyn_patcher.cleanup()
                 sys.meta_path.pop(0)
 
     @property
@@ -1142,7 +1118,7 @@ def __init__(self, patcher: Patcher) -> None:
         for name, module in self.modules.items():
             sys.modules[name] = module
 
-    def cleanup(self, cleanup_mode: ModuleCleanupMode) -> None:
+    def cleanup(self) -> None:
         for module_name in self.sysmodules:
             sys.modules[module_name] = self.sysmodules[module_name]
         for module in self._patcher.modules_to_reload:
@@ -1153,21 +1129,11 @@ def cleanup(self, cleanup_mode: ModuleCleanupMode) -> None:
         ]
         # Delete all modules loaded during the test, ensuring that
         # they are reloaded after the test.
-        # If cleanup_mode is set to RELOAD, reload the modules instead.
-        # This is probably not needed anymore with the cleanup handlers in place.
-        if cleanup_mode == ModuleCleanupMode.AUTO:
-            cleanup_mode = ModuleCleanupMode.DELETE
         for name in self._loaded_module_names:
             if name in sys.modules and name not in reloaded_module_names:
                 if name in self.cleanup_handlers and self.cleanup_handlers[name](name):
                     continue
-                if cleanup_mode == ModuleCleanupMode.RELOAD:
-                    try:
-                        reload(sys.modules[name])
-                    except Exception:
-                        del sys.modules[name]
-                else:
-                    del sys.modules[name]
+                del sys.modules[name]
 
     def needs_patch(self, name: str) -> bool:
         """Check if the module with the given name shall be replaced."""