Automatically reset filesystem on changing os

- now done on changing is_windows_fs or is_macos

Author: mrbean-bremen

.github/workflows/pythonpackage.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        python-version:  [3.9]
+        python-version:  ["3.10"]
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python ${{ matrix.python-version }}

CHANGES.md

@@ -3,8 +3,17 @@ The released versions correspond to PyPi releases.
 
 ## Unreleased
 
+### Changes
+* automatically reset filesystem on changing `is_windows_fs` or `is_macos`
+  (see [#692](../../issues/692)) - ensures better upwards compatibility in
+  most cases
+
+  :warning: Make sure you write to the filesystem _after_ you change  
+  `is_windows_fs` or `is_macos`, otherwise the changes will be lost.
+  
+
 ### Fixes
-* fixed regression: `os.exists` returned `True` for any root drive path under Windows
+* fixed regression: `os.path.exists` returned `True` for any root drive path under Windows
 
 ## [Version 4.6.2](https://pypi.python.org/pypi/pyfakefs/4.6.2) (2022-07-14)
 Patch release that fixes an error in the previous patch.

pyfakefs/fake_filesystem.py

@@ -933,14 +933,16 @@ def __init__(self, path_separator: str = os.path.sep,
         # Windows fs on non-Windows systems and vice verse;
         # is it used to support drive letters, UNC paths and some other
         # Windows-specific features
-        self.is_windows_fs = sys.platform == 'win32'
+        self._is_windows_fs = sys.platform == 'win32'
 
         # can be used to test some MacOS-specific behavior under other systems
-        self.is_macos = sys.platform == 'darwin'
+        self._is_macos = sys.platform == 'darwin'
 
         # is_case_sensitive can be used to test pyfakefs for case-sensitive
         # file systems on non-case-sensitive systems and vice verse
-        self.is_case_sensitive = not (self.is_windows_fs or self.is_macos)
+        self.is_case_sensitive: bool = (
+            not (self.is_windows_fs or self._is_macos)
+        )
 
         self.root = FakeDirectory(self.path_separator, filesystem=self)
         self._cwd = ''
@@ -955,8 +957,8 @@ def __init__(self, path_separator: str = os.path.sep,
         # A heap containing all free positions in self.open_files list
         self._free_fd_heap: List[int] = []
         # last used numbers for inodes (st_ino) and devices (st_dev)
-        self.last_ino = 0
-        self.last_dev = 0
+        self.last_ino: int = 0
+        self.last_dev: int = 0
         self.mount_points: Dict[AnyString, Dict] = OrderedDict()
         self._add_root_mount_point(total_size)
         self._add_standard_streams()
@@ -969,6 +971,28 @@ def __init__(self, path_separator: str = os.path.sep,
     def is_linux(self) -> bool:
         return not self.is_windows_fs and not self.is_macos
 
+    @property
+    def is_windows_fs(self) -> bool:
+        return self._is_windows_fs
+
+    @is_windows_fs.setter
+    def is_windows_fs(self, value: bool) -> None:
+        if self._is_windows_fs != value:
+            self._is_windows_fs = value
+            self.reset()
+            FakePathModule.reset(self)
+
+    @property
+    def is_macos(self) -> bool:
+        return self._is_macos
+
+    @is_macos.setter
+    def is_macos(self, value: bool) -> None:
+        if self._is_macos != value:
+            self._is_macos = value
+            self.reset()
+            FakePathModule.reset(self)
+
     @property
     def cwd(self) -> str:
         """Return the current working directory of the fake filesystem."""
@@ -1009,8 +1033,8 @@ def os(self) -> OSType:
     def os(self, value: OSType) -> None:
         """Set the simulated type of operating system underlying the fake
         file system."""
-        self.is_windows_fs = value == OSType.WINDOWS
-        self.is_macos = value == OSType.MACOS
+        self._is_windows_fs = value == OSType.WINDOWS
+        self._is_macos = value == OSType.MACOS
         self.is_case_sensitive = value == OSType.LINUX
         self.path_separator = '\\' if value == OSType.WINDOWS else '/'
         self.alternative_path_separator = ('/' if value == OSType.WINDOWS
@@ -2311,7 +2335,8 @@ def lresolve(self, path: AnyPath) -> FakeFile:
             return (parent_obj.get_entry(to_string(child_name)) if child_name
                     else parent_obj)
         except KeyError:
-            self.raise_os_error(errno.ENOENT, path_str)
+            pass
+        raise OSError(errno.ENOENT, path_str)
 
     def add_object(self, file_path: AnyStr, file_object: AnyFile) -> None:
         """Add a fake file or directory into the filesystem at file_path.

pyfakefs/tests/fake_filesystem_test.py

@@ -67,7 +67,6 @@ def test_path(self):
 
     def test_path_with_drive(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         dir_path = 'C:/foo/bar/baz'
         self.filesystem.create_dir(dir_path)
         dir_object = self.filesystem.get_object(dir_path)
@@ -83,7 +82,6 @@ def test_path_after_chdir(self):
 
     def test_path_after_chdir_with_drive(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         dir_path = 'C:/foo/bar/baz'
         self.filesystem.create_dir(dir_path)
         self.os.chdir(dir_path)
@@ -124,11 +122,9 @@ def test_leave_file_unchanged_if_size_is_equal_to_current_size(self):
     def test_set_contents_to_dir_raises(self):
         # Regression test for #276
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         with self.raises_os_error(errno.EISDIR):
             self.fake_dir.set_contents('a')
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         with self.raises_os_error(errno.EISDIR):
             self.fake_dir.set_contents('a')
 
@@ -320,7 +316,6 @@ def test_add_object_to_root(self):
 
     def test_windows_root_dir_name(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.assertEqual('C:/', self.filesystem.root_dir_name)
         self.filesystem.cwd = 'E:/foo'
         self.assertEqual('E:/', self.filesystem.root_dir_name)
@@ -333,7 +328,6 @@ def test_exists_added_file(self):
 
     def test_exists_relative_path_posix(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.filesystem.create_file('/a/b/file_one')
         self.filesystem.create_file('/a/c/file_two')
         self.assertTrue(self.filesystem.exists('a/b/../c/file_two'))
@@ -351,7 +345,6 @@ def test_exists_relative_path_posix(self):
     def test_exists_relative_path_windows(self):
         self.filesystem.is_windows_fs = True
         self.filesystem.is_macos = False
-        self.filesystem.reset()
         self.filesystem.create_file('/a/b/file_one')
         self.filesystem.create_file('/a/c/file_two')
         self.assertTrue(self.filesystem.exists('a/b/../c/file_two'))
@@ -400,15 +393,13 @@ def test_add_object_to_child(self):
 
     def test_add_object_to_regular_file_error_posix(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.filesystem.add_object(
             self.filesystem.root_dir_name, self.fake_file)
         with self.raises_os_error(errno.ENOTDIR):
             self.filesystem.add_object(self.fake_file.name, self.fake_file)
 
     def test_add_object_to_regular_file_error_windows(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.filesystem.add_object(self.root_name, self.fake_file)
         with self.raises_os_error(errno.ENOENT):
             self.filesystem.add_object(self.fake_file.name, self.fake_file)
@@ -520,7 +511,6 @@ def test_create_directory_already_exists_error(self):
 
     def test_create_file_in_read_only_directory_raises_in_posix(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         dir_path = '/foo/bar'
         self.filesystem.create_dir(dir_path, perm_bits=0o555)
         file_path = dir_path + '/baz'
@@ -534,7 +524,6 @@ def test_create_file_in_read_only_directory_raises_in_posix(self):
 
     def test_create_file_in_read_only_directory_possible_in_windows(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         dir_path = 'C:/foo/bar'
         self.filesystem.create_dir(dir_path, perm_bits=0o555)
         file_path = dir_path + '/baz'
@@ -657,12 +646,10 @@ def check_lresolve_object(self):
 
     def test_lresolve_object_windows(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.check_lresolve_object()
 
     def test_lresolve_object_posix(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.check_lresolve_object()
 
     def check_directory_access_on_file(self, error_subtype):
@@ -674,12 +661,10 @@ def check_directory_access_on_file(self, error_subtype):
 
     def test_directory_access_on_file_windows(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.check_directory_access_on_file(errno.ENOENT)
 
     def test_directory_access_on_file_posix(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.check_directory_access_on_file(errno.ENOTDIR)
 
     def test_pickle_fs(self):
@@ -753,7 +738,6 @@ def test_getsize(self):
 
     def test_getsize_with_looping_symlink(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         dir_path = '/foo/bar'
         self.filesystem.create_dir(dir_path)
         link_path = dir_path + "/link"
@@ -891,7 +875,6 @@ def setUp(self):
     def check_abspath(self, is_windows):
         # the implementation differs in Windows and Posix, so test both
         self.filesystem.is_windows_fs = is_windows
-        self.filesystem.reset()
         filename = 'foo'
         abspath = self.filesystem.root_dir_name + filename
         self.filesystem.create_file(abspath)
@@ -909,7 +892,6 @@ def test_abspath_posix(self):
     def check_abspath_bytes(self, is_windows):
         """abspath should return a consistent representation of a file."""
         self.filesystem.is_windows_fs = is_windows
-        self.filesystem.reset()
         filename = b'foo'
         abspath = self.filesystem.root_dir_name.encode() + filename
         self.filesystem.create_file(abspath)
@@ -943,21 +925,18 @@ def test_abspath_deals_with_relative_non_root_path(self):
 
     def test_abs_path_with_drive_component(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.filesystem.cwd = 'C:!foo'
         self.assertEqual('C:!foo!bar', self.path.abspath('bar'))
         self.assertEqual('C:!foo!bar', self.path.abspath('C:bar'))
         self.assertEqual('C:!foo!bar', self.path.abspath('!foo!bar'))
 
     def test_isabs_with_drive_component(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.assertFalse(self.path.isabs('C:!foo'))
         self.assertFalse(self.path.isabs(b'C:!foo'))
         self.assertTrue(self.path.isabs('!'))
         self.assertTrue(self.path.isabs(b'!'))
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.assertTrue(self.path.isabs('C:!foo'))
         self.assertTrue(self.path.isabs(b'C:!foo'))
         self.assertTrue(self.path.isabs('!'))
@@ -981,7 +960,6 @@ def test_relpath(self):
 
     def test_realpath_vs_abspath(self):
         self.filesystem.is_windows_fs = False
-        self.filesystem.reset()
         self.filesystem.create_file('!george!washington!bridge')
         self.filesystem.create_symlink('!first!president',
                                        '!george!washington')
@@ -1049,7 +1027,6 @@ def test_lexists(self):
 
     def test_dirname_with_drive(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.assertEqual('c:!foo',
                          self.path.dirname('c:!foo!bar'))
         self.assertEqual(b'c:!',
@@ -1201,7 +1178,6 @@ def test_ismount(self):
 
     def test_ismount_with_drive_letters(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.assertTrue(self.path.ismount('!'))
         self.assertTrue(self.path.ismount('c:!'))
         self.assertFalse(self.path.ismount('c:'))
@@ -1212,7 +1188,6 @@ def test_ismount_with_drive_letters(self):
 
     def test_ismount_with_unc_paths(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.assertTrue(self.path.ismount('!!a!'))
         self.assertTrue(self.path.ismount('!!a!b'))
         self.assertTrue(self.path.ismount('!!a!b!'))
@@ -1287,7 +1262,6 @@ def test_ignores_up_level_references_starting_from_root(self):
         self.assertEqual(
             '|', self.filesystem.normpath('|..|..|foo|bar|..|..|'))
         self.filesystem.is_windows_fs = False  # not an UNC path
-        self.filesystem.reset()
         self.assertEqual('|', self.filesystem.normpath('||..|.|..||'))
 
     def test_conserves_up_level_references_starting_from_current_dir(self):
@@ -1398,7 +1372,6 @@ def test_normalize_case(self):
 
     def test_normalize_case_for_drive(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.filesystem.create_file('C:/Foo/Bar')
         self.assertEqual('C:/Foo/Bar',
                          self.filesystem._original_path('c:/foo/bar'))
@@ -1465,7 +1438,6 @@ def setUp(self):
         self.filesystem = fake_filesystem.FakeFilesystem(path_separator='!')
         self.filesystem.alternative_path_separator = '^'
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
 
     def test_initial_value(self):
         filesystem = fake_filesystem.FakeFilesystem()
@@ -1870,15 +1842,13 @@ def test_disk_size_on_unlimited_disk(self):
 
     def test_disk_size_on_auto_mounted_drive_on_file_creation(self):
         self.fs.is_windows_fs = True
-        self.fs.reset()
         # drive d: shall be auto-mounted and the used size adapted
         self.fs.create_file('d:!foo!bar', st_size=100)
         self.fs.set_disk_usage(total_size=1000, path='d:')
         self.assertEqual(self.fs.get_disk_usage('d:!foo').free, 900)
 
     def test_disk_size_on_auto_mounted_drive_on_directory_creation(self):
         self.fs.is_windows_fs = True
-        self.fs.reset()
         self.fs.create_dir('d:!foo!bar')
         self.fs.create_file('d:!foo!bar!baz', st_size=100)
         self.fs.create_file('d:!foo!baz', st_size=100)
@@ -1943,40 +1913,42 @@ class MountPointTest(TestCase):
     def setUp(self):
         self.filesystem = fake_filesystem.FakeFilesystem(path_separator='!',
                                                          total_size=100)
-        self.add_mount_points()
 
     def add_mount_points(self):
         self.filesystem.add_mount_point('!foo')
         self.filesystem.add_mount_point('!bar')
         self.filesystem.add_mount_point('!foo!baz')
 
     def test_that_new_mount_points_get_new_device_number(self):
+        self.add_mount_points()
         self.assertEqual(1, self.filesystem.get_object('!').st_dev)
         self.assertEqual(2, self.filesystem.get_object('!foo').st_dev)
         self.assertEqual(3, self.filesystem.get_object('!bar').st_dev)
         self.assertEqual(4, self.filesystem.get_object('!foo!baz').st_dev)
 
     def test_that_new_directories_get_correct_device_number(self):
+        self.add_mount_points()
         self.assertEqual(1, self.filesystem.create_dir('!foo1!bar').st_dev)
         self.assertEqual(2, self.filesystem.create_dir('!foo!bar').st_dev)
         self.assertEqual(4,
                          self.filesystem.create_dir('!foo!baz!foo!bar').st_dev)
 
     def test_that_new_files_get_correct_device_number(self):
+        self.add_mount_points()
         self.assertEqual(1, self.filesystem.create_file('!foo1!bar').st_dev)
         self.assertEqual(2, self.filesystem.create_file('!foo!bar').st_dev)
         self.assertEqual(4, self.filesystem.create_file(
             '!foo!baz!foo!bar').st_dev)
 
     def test_that_mount_point_cannot_be_added_twice(self):
+        self.add_mount_points()
         with self.raises_os_error(errno.EEXIST):
             self.filesystem.add_mount_point('!foo')
         with self.raises_os_error(errno.EEXIST):
             self.filesystem.add_mount_point('!foo!')
 
     def test_that_drives_are_auto_mounted(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.add_mount_points()
         self.filesystem.create_dir('d:!foo!bar')
         self.filesystem.create_file('d:!foo!baz')
@@ -1988,7 +1960,6 @@ def test_that_drives_are_auto_mounted(self):
 
     def test_that_drives_are_auto_mounted_case_insensitive(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.add_mount_points()
         self.filesystem.is_case_sensitive = False
         self.filesystem.create_dir('D:!foo!bar')
@@ -2000,7 +1971,6 @@ def test_that_drives_are_auto_mounted_case_insensitive(self):
 
     def test_that_unc_paths_are_auto_mounted(self):
         self.filesystem.is_windows_fs = True
-        self.filesystem.reset()
         self.add_mount_points()
         self.filesystem.create_dir('!!foo!bar!baz')
         self.filesystem.create_file('!!foo!bar!bip!bop')