Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:56
📄 __init__.py	0 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 all_tests.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """A test suite that runs all tests for pyfakefs at once. Includes tests with external pathlib2 and scandir packages if installed.""" import sys import unittest from pyfakefs.tests import ( dynamic_patch_test, fake_stat_time_test, example_test, fake_filesystem_glob_test, fake_filesystem_shutil_test, fake_filesystem_test, fake_filesystem_unittest_test, fake_filesystem_vs_real_test, fake_open_test, fake_os_test, fake_pathlib_test, fake_tempfile_test, patched_packages_test, fake_legacy_modules_test, mox3_stubout_test, ) class AllTests(unittest.TestSuite): """A test suite that runs all tests for pyfakefs at once.""" def suite(self): # pylint: disable-msg=C6409 loader = unittest.defaultTestLoader self.addTests( [ loader.loadTestsFromModule(fake_filesystem_test), loader.loadTestsFromModule(fake_filesystem_glob_test), loader.loadTestsFromModule(fake_filesystem_shutil_test), loader.loadTestsFromModule(fake_os_test), loader.loadTestsFromModule(fake_stat_time_test), loader.loadTestsFromModule(fake_open_test), loader.loadTestsFromModule(fake_tempfile_test), loader.loadTestsFromModule(fake_filesystem_vs_real_test), loader.loadTestsFromModule(fake_filesystem_unittest_test), loader.loadTestsFromModule(example_test), loader.loadTestsFromModule(mox3_stubout_test), loader.loadTestsFromModule(dynamic_patch_test), loader.loadTestsFromModule(fake_pathlib_test), loader.loadTestsFromModule(patched_packages_test), loader.loadTestsFromModule(fake_legacy_modules_test), ] ) return self if __name__ == "__main__": result = unittest.TextTestRunner(verbosity=2).run(AllTests().suite()) sys.exit(int(not result.wasSuccessful()))	2.54 KB	2026-01-20 12:58
📄 all_tests_without_extra_packages.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """A test suite that runs all tests for pyfakefs at once. Excludes tests using external scandir package.""" import sys import unittest from pyfakefs import legacy_packages legacy_packages.scandir = None legacy_packages.pathlib2 = None from pyfakefs.tests.all_tests import AllTests # noqa: E402 if __name__ == "__main__": result = unittest.TextTestRunner(verbosity=2).run(AllTests().suite()) sys.exit(int(not result.wasSuccessful()))	993 B	2026-01-20 12:58
📄 dynamic_patch_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Tests for patching modules loaded after `setUpPyfakefs()`. """ import pathlib import unittest from pyfakefs import fake_filesystem_unittest class TestPyfakefsUnittestBase(fake_filesystem_unittest.TestCase): def setUp(self): """Set up the fake file system""" self.setUpPyfakefs() class DynamicImportPatchTest(TestPyfakefsUnittestBase): def __init__(self, methodName="runTest"): super().__init__(methodName) def test_os_patch(self): import os os.mkdir("test") self.assertTrue(self.fs.exists("test")) self.assertTrue(os.path.exists("test")) def test_os_import_as_patch(self): import os as _os _os.mkdir("test") self.assertTrue(self.fs.exists("test")) self.assertTrue(_os.path.exists("test")) def test_os_path_patch(self): import os.path os.mkdir("test") self.assertTrue(self.fs.exists("test")) self.assertTrue(os.path.exists("test")) def test_shutil_patch(self): import shutil self.fs.set_disk_usage(100) self.assertEqual(100, shutil.disk_usage("/").total) def test_pathlib_path_patch(self): file_path = "test.txt" path = pathlib.Path(file_path) with path.open("w", encoding="utf8") as f: f.write("test") self.assertTrue(self.fs.exists(file_path)) file_object = self.fs.get_object(file_path) self.assertEqual("test", file_object.contents) if __name__ == "__main__": unittest.main()	2.03 KB	2026-01-20 12:58
📄 example.py # Copyright 2014 Altera Corporation. All Rights Reserved. # Author: John McGehee # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Example module that is tested in :py:class`pyfakefs.example_test.TestExample`. This demonstrates the usage of the :py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class. The modules related to file handling are bound to the respective fake modules: >>> os #doctest: +ELLIPSIS <pyfakefs.fake_os.FakeOsModule object...> >>> os.path #doctest: +ELLIPSIS <pyfakefs.fake_path.FakePathModule object...> >>> shutil #doctest: +ELLIPSIS <pyfakefs.fake_filesystem_shutil.FakeShutilModule object...> `open()` is an alias for `io.open()` and is bound to `FakeIoModule.open`. """ import glob import os import shutil try: import scandir has_scandir = True except ImportError: scandir = None has_scandir = False def create_file(path): """Create the specified file and add some content to it. Use the `open()` built in function. For example, the following file operations occur in the fake file system. In the real file system, we would not even have permission to write `/test`: >>> os.path.isdir('/test') False >>> os.mkdir('/test') >>> os.path.isdir('/test') True >>> os.path.exists('/test/file.txt') False >>> create_file('/test/file.txt') >>> os.path.exists('/test/file.txt') True >>> with open('/test/file.txt', encoding='utf8') as f: ... f.readlines() ["This is test file '/test/file.txt'.\\n", \ 'It was created using open().\\n'] """ with open(path, "w", encoding="utf8") as f: f.write(f"This is test file '{path}'.\n") f.write("It was created using open().\n") def delete_file(path): """Delete the specified file. For example: >>> os.mkdir('/test') >>> os.path.exists('/test/file.txt') False >>> create_file('/test/file.txt') >>> os.path.exists('/test/file.txt') True >>> delete_file('/test/file.txt') >>> os.path.exists('/test/file.txt') False """ os.remove(path) def path_exists(path): """Return True if the specified file exists. For example: >>> path_exists('/test') False >>> os.mkdir('/test') >>> path_exists('/test') True >>> >>> path_exists('/test/file.txt') False >>> create_file('/test/file.txt') >>> path_exists('/test/file.txt') True """ return os.path.exists(path) def get_glob(glob_path): r"""Return the list of paths matching the specified glob expression. For example: >>> os.mkdir('/test') >>> create_file('/test/file1.txt') >>> create_file('/test/file2.txt') >>> file_names = sorted(get_glob('/test/file*.txt')) >>> >>> import sys >>> if sys.platform.startswith('win'): ... # Windows style path ... file_names == [r'/test\file1.txt', r'/test\file2.txt'] ... else: ... # UNIX style path ... file_names == ['/test/file1.txt', '/test/file2.txt'] True """ return glob.glob(glob_path) def rm_tree(path): """Delete the specified file hierarchy.""" shutil.rmtree(path) def scan_dir(path): """Return a list of directory entries for the given path.""" if has_scandir: return list(scandir.scandir(path)) return list(os.scandir(path)) def file_contents(path): """Return the contents of the given path as byte array.""" with open(path, "rb") as f: return f.read()	3.91 KB	2026-01-20 12:58
📄 example_test.py # Copyright 2014 Altera Corporation. All Rights Reserved. # Author: John McGehee # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Test the :py:class`pyfakefs.example` module to demonstrate the usage of the :py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class. Fake filesystem functions like `create_file()`, `create_dir()` or `create_symlink()` are often used to set up file structures at the beginning of a test. While you could also use the familiar `open()`, `os.mkdirs()` and similar functions, these functions can make the test code shorter and more readable. `create_file()` is particularly convenient because it creates all parent directories and allows you to specify the contents or the size of the file. """ import io import os import sys import unittest from pyfakefs import fake_filesystem_unittest from pyfakefs.legacy_packages import scandir from pyfakefs.tests import example # The module under test # Work around pyupgrade auto-rewriting `io.open()` to `open()`. io_open = io.open def load_tests(loader, tests, ignore): """Load the pyfakefs/example.py doctest tests into unittest.""" return fake_filesystem_unittest.load_doctests(loader, tests, ignore, example) class TestExample(fake_filesystem_unittest.TestCase): # pylint: disable=R0904 """Test the example module. The os and shutil modules have been replaced with the fake modules, so that all of the calls to os and shutil in the tested example code occur in the fake filesystem. """ def setUp(self): """Invoke the :py:class:`pyfakefs.fake_filesystem_unittest.TestCase` `self.setUp()` method. This defines: * Attribute `self.fs`, an instance of :py:class:`pyfakefs.fake_filesystem.FakeFilesystem`. This is useful for creating test files. * Attribute `self.stubs`, an instance of :py:class:`pyfakefs.mox3_stubout.StubOutForTesting`. Use this if you need to define additional stubs. """ # This is before setUpPyfakefs(), so still using the real file system self.filepath = os.path.realpath(__file__) with io_open(self.filepath, "rb") as f: self.real_contents = f.read() self.setUpPyfakefs() def tearDown(self): # No longer need self.tearDownPyfakefs() pass def test_create_file(self): """Test example.create_file() which uses `open()` and `file.write()`. """ self.assertFalse(os.path.isdir("/test")) os.mkdir("/test") self.assertTrue(os.path.isdir("/test")) self.assertFalse(os.path.exists("/test/file.txt")) example.create_file("/test/file.txt") self.assertTrue(os.path.exists("/test/file.txt")) def test_delete_file(self): """Test example.delete_file() which uses `os.remove()`.""" self.fs.create_file("/test/full.txt", contents="First line\nSecond Line\n") self.assertTrue(os.path.exists("/test/full.txt")) example.delete_file("/test/full.txt") self.assertFalse(os.path.exists("/test/full.txt")) def test_file_exists(self): """Test example.path_exists() which uses `os.path.exists()`.""" self.assertFalse(example.path_exists("/test/empty.txt")) self.fs.create_file("/test/empty.txt") self.assertTrue(example.path_exists("/test/empty.txt")) def test_get_globs(self): """Test example.get_glob().""" self.assertFalse(os.path.isdir("/test")) self.fs.create_dir("/test/dir1/dir2a") self.assertTrue(os.path.isdir("/test/dir1/dir2a")) # os.mkdirs() works, too. os.makedirs("/test/dir1/dir2b") self.assertTrue(os.path.isdir("/test/dir1/dir2b")) self.assertEqual(example.get_glob("/test/dir1/nonexistent"), []) is_windows = sys.platform.startswith("win") matching_paths = sorted(example.get_glob("/test/dir1/dir")) if is_windows: self.assertEqual(matching_paths, [r"/test/dir1\dir2a", r"/test/dir1\dir2b"]) else: self.assertEqual(matching_paths, ["/test/dir1/dir2a", "/test/dir1/dir2b"]) def test_rm_tree(self): """Test example.rm_tree() using `shutil.rmtree()`.""" self.fs.create_dir("/test/dir1/dir2a") # os.mkdirs() works, too. os.makedirs("/test/dir1/dir2b") self.assertTrue(os.path.isdir("/test/dir1/dir2b")) self.assertTrue(os.path.isdir("/test/dir1/dir2a")) example.rm_tree("/test/dir1") self.assertFalse(os.path.exists("/test/dir1")) def test_os_scandir(self): """Test example.scandir() which uses `os.scandir()`. The os module has been replaced with the fake os module so the fake filesystem path entries are returned instead of `os.DirEntry` objects. """ self.fs.create_file("/test/text.txt") self.fs.create_dir("/test/dir") self.fs.create_file("/linktest/linked") self.fs.create_symlink("/test/linked_file", "/linktest/linked") entries = sorted(example.scan_dir("/test"), key=lambda e: e.name) self.assertEqual(3, len(entries)) self.assertEqual("linked_file", entries[1].name) self.assertTrue(entries[0].is_dir()) self.assertTrue(entries[1].is_symlink()) self.assertTrue(entries[2].is_file()) @unittest.skipIf(scandir is None, "Testing only if scandir module is installed") def test_scandir_scandir(self): """Test example.scandir() which uses `scandir.scandir()`. The scandir module has been replaced with the fake_scandir module so the fake filesystem path entries are returned instead of `scandir.DirEntry` objects. """ self.fs.create_file("/test/text.txt") self.fs.create_dir("/test/dir") entries = sorted(example.scan_dir("/test"), key=lambda e: e.name) self.assertEqual(2, len(entries)) self.assertEqual("text.txt", entries[1].name) self.assertTrue(entries[0].is_dir()) self.assertTrue(entries[1].is_file()) def test_real_file_access(self): """Test `example.file_contents()` for a real file after adding it using `add_real_file()`.""" with self.assertRaises(OSError): example.file_contents(self.filepath) self.fs.add_real_file(self.filepath) self.assertEqual(example.file_contents(self.filepath), self.real_contents) if __name__ == "__main__": unittest.main()	6.84 KB	2026-01-20 12:58
📄 fake_filesystem_glob_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Test for glob using fake_filesystem.""" import contextlib import glob import os import sys import unittest from pyfakefs import fake_filesystem_unittest class FakeGlobUnitTest(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs() directory = "./xyzzy" self.fs.create_dir(directory) self.fs.create_dir("%s/subdir" % directory) self.fs.create_dir("%s/subdir2" % directory) self.fs.create_file("%s/subfile" % directory) self.fs.create_file("[Temp]") def test_glob_empty(self): self.assertEqual(glob.glob(""), []) def test_glob_star(self): basedir = "/xyzzy" self.assertEqual( [ os.path.join(basedir, "subdir"), os.path.join(basedir, "subdir2"), os.path.join(basedir, "subfile"), ], sorted(glob.glob("/xyzzy/")), ) def test_glob_exact(self): self.assertEqual(["/xyzzy"], glob.glob("/xyzzy")) self.assertEqual(["/xyzzy/subfile"], glob.glob("/xyzzy/subfile")) def test_glob_question(self): basedir = "/xyzzy" self.assertEqual( [ os.path.join(basedir, "subdir"), os.path.join(basedir, "subdir2"), os.path.join(basedir, "subfile"), ], sorted(glob.glob("/x?zz?/")), ) def test_glob_no_magic(self): self.assertEqual(["/xyzzy"], glob.glob("/xyzzy")) self.assertEqual(["/xyzzy/subdir"], glob.glob("/xyzzy/subdir")) def test_non_existent_path(self): self.assertEqual([], glob.glob("nonexistent")) def test_magic_dir(self): self.assertEqual(["/[Temp]"], glob.glob("/emp")) def test_glob1(self): warning_context = ( contextlib.nullcontext() if sys.version_info < (3, 13) else self.assertWarns(DeprecationWarning) ) with warning_context: self.assertEqual(["[Temp]"], glob.glob1("/", "Tem")) def test_has_magic(self): self.assertTrue(glob.has_magic("[")) self.assertFalse(glob.has_magic("a")) if __name__ == "__main__": unittest.main()	2.75 KB	2026-01-20 12:58
📄 fake_filesystem_shutil_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for `fake_filesystem_shutil` if used in `fake_filesystem_unittest.TestCase`. Note that almost all of the functionality is delegated to the real `shutil` and works correctly with the fake filesystem because of the faked `os` module. """ import os import shutil import sys import tempfile import unittest from pathlib import Path from pyfakefs import fake_filesystem_unittest from pyfakefs.helpers import get_uid, set_uid, is_root, IS_PYPY from pyfakefs.tests.test_utils import RealFsTestMixin, skip_if_symlink_not_supported is_windows = sys.platform == "win32" class RealFsTestCase(fake_filesystem_unittest.TestCase, RealFsTestMixin): def __init__(self, methodName="runTest"): fake_filesystem_unittest.TestCase.__init__(self, methodName) RealFsTestMixin.__init__(self) def setUp(self): RealFsTestMixin.setUp(self) self.cwd = os.getcwd() self.uid = get_uid() set_uid(1000) if not self.use_real_fs(): self.setUpPyfakefs() self.filesystem = self.fs self.os = os self.open = open self.create_basepath() self.fs.set_disk_usage(1000, self.base_path) def tearDown(self): set_uid(self.uid) RealFsTestMixin.tearDown(self) @property def is_windows_fs(self): if self.use_real_fs(): return sys.platform == "win32" return self.filesystem.is_windows_fs class FakeShutilModuleTest(RealFsTestCase): @unittest.skipIf(is_windows, "Posix specific behavior") def test_catch_permission_error(self): root_path = self.make_path("rootpath") self.create_dir(root_path) dir1_path = self.os.path.join(root_path, "dir1") dir2_path = self.os.path.join(root_path, "dir2") self.create_dir(dir1_path) self.os.chmod(dir1_path, 0o555) # remove write permissions self.create_dir(dir2_path) old_file_path = self.os.path.join(dir2_path, "f1.txt") new_file_path = self.os.path.join(dir1_path, "f1.txt") self.create_file(old_file_path) with self.assertRaises(PermissionError): shutil.move(old_file_path, new_file_path) def test_rmtree(self): directory = self.make_path("xyzzy") dir_path = os.path.join(directory, "subdir") self.create_dir(dir_path) file_path = os.path.join(directory, "subfile") self.create_file(file_path) self.assertTrue(os.path.exists(directory)) shutil.rmtree(directory) self.assertFalse(os.path.exists(directory)) self.assertFalse(os.path.exists(dir_path)) self.assertFalse(os.path.exists(file_path)) def test_rmtree_with_trailing_slash(self): directory = self.make_path("xyzzy") dir_path = os.path.join(directory, "subdir") self.create_dir(dir_path) file_path = os.path.join(directory, "subfile") self.create_file(file_path) shutil.rmtree(directory + "/") self.assertFalse(os.path.exists(directory)) self.assertFalse(os.path.exists(dir_path)) self.assertFalse(os.path.exists(file_path)) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_rmtree_without_permission_for_a_file_in_windows(self): self.check_windows_only() dir_path = self.make_path("foo") self.create_file(os.path.join(dir_path, "bar")) file_path = os.path.join(dir_path, "baz") self.create_file(file_path) self.os.chmod(file_path, 0o444) with self.assertRaises(OSError): shutil.rmtree(dir_path) self.assertTrue(os.path.exists(file_path)) self.os.chmod(file_path, 0o666) @unittest.skipIf(is_windows, "Posix specific behavior") def test_rmtree_without_permission_for_a_dir_in_posix(self): self.check_posix_only() dir_path = self.make_path("foo") self.create_file(os.path.join(dir_path, "bar")) file_path = os.path.join(dir_path, "baz") self.create_file(file_path) self.os.chmod(dir_path, 0o555) if not is_root(): with self.assertRaises(OSError): shutil.rmtree(dir_path) self.assertTrue(os.path.exists(file_path)) self.os.chmod(dir_path, 0o777) else: shutil.rmtree(dir_path) self.assertFalse(os.path.exists(file_path)) @unittest.skipIf(is_windows, "Posix specific behavior") def test_rmtree_with_open_file_posix(self): self.check_posix_only() dir_path = self.make_path("foo") self.create_file(os.path.join(dir_path, "bar")) file_path = os.path.join(dir_path, "baz") self.create_file(file_path) with open(file_path, encoding="utf8"): shutil.rmtree(dir_path) self.assertFalse(os.path.exists(file_path)) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_rmtree_with_open_file_fails_under_windows(self): self.check_windows_only() dir_path = self.make_path("foo") self.create_file(os.path.join(dir_path, "bar")) file_path = os.path.join(dir_path, "baz") self.create_file(file_path) with open(file_path, encoding="utf8"): with self.assertRaises(OSError): shutil.rmtree(dir_path) self.assertTrue(os.path.exists(dir_path)) def test_rmtree_non_existing_dir(self): directory = "nonexisting" with self.assertRaises(OSError): shutil.rmtree(directory) try: shutil.rmtree(directory, ignore_errors=True) except OSError: self.fail("rmtree raised despite ignore_errors True") def test_rmtree_non_existing_dir_with_handler(self): class NonLocal: pass def error_handler(_, path, _error_info): NonLocal.errorHandled = True NonLocal.errorPath = path directory = self.make_path("nonexisting") NonLocal.errorHandled = False NonLocal.errorPath = "" try: shutil.rmtree(directory, onerror=error_handler) except OSError: self.fail("rmtree raised exception despite onerror defined") self.assertTrue(NonLocal.errorHandled) self.assertEqual(NonLocal.errorPath, directory) NonLocal.errorHandled = False NonLocal.errorPath = "" try: shutil.rmtree(directory, ignore_errors=True, onerror=error_handler) except OSError: self.fail("rmtree raised exception despite ignore_errors True") # ignore_errors is True, so the onerror() error handler was # not executed self.assertFalse(NonLocal.errorHandled) self.assertEqual(NonLocal.errorPath, "") def test_rmtree_in_windows(self): # regression test for #979 self.check_windows_only() base_path = self.make_path("foo", "bar") self.os.makedirs(self.os.path.join(base_path, "res")) self.assertTrue(self.os.path.exists(base_path)) shutil.rmtree(base_path) self.assertFalse(self.os.path.exists(base_path)) def test_copy(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") self.create_file(src_file) os.chmod(src_file, 0o750) self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_file)) shutil.copy(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.assertEqual(os.stat(src_file).st_mode, os.stat(dst_file).st_mode) def test_copytree_with_copy_function(self): # regression test for #1235 (deadlock) source_dir = Path(self.make_path("source_dir")) target_dir = Path(self.make_path("target_dir")) test_contents = "Test contents" source_file = source_dir / "test.txt" target_file = target_dir / "test.txt" self.create_file(source_file, contents=test_contents) shutil.copytree(source_dir, target_dir, copy_function=shutil.copy2) assert target_file.read_text() == test_contents def test_permission_error_message(self): self.check_posix_only() dst_dir = Path(self.make_path("home1")) src_dir2 = os.path.join(dst_dir, "dir1") os.makedirs(src_dir2) dst_dir.chmod(0o555) src_dir = Path(self.make_path("drive1")) os.makedirs(src_dir) src_file = src_dir / "new.txt" src_file.touch() msg = f"[Errno 13] Permission denied: '{dst_dir}'" with self.assertRaises(PermissionError, msg=msg): shutil.copy2(src_file, dst_dir) dst_dir2 = dst_dir / "dir2" msg = f"[Errno 13] Permission denied: '{dst_dir2}'" with self.assertRaises(PermissionError, msg=msg): shutil.move(src_dir2, dst_dir2) def test_copy_directory(self): src_file = self.make_path("xyzzy") parent_directory = self.make_path("parent") dst_file = os.path.join(parent_directory, "xyzzy") self.create_file(src_file) self.create_dir(parent_directory) os.chmod(src_file, 0o750) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(parent_directory)) self.assertFalse(os.path.exists(dst_file)) shutil.copy(src_file, parent_directory) self.assertTrue(os.path.exists(dst_file)) self.assertEqual(os.stat(src_file).st_mode, os.stat(dst_file).st_mode) def test_copystat(self): src_file = self.make_path("xyzzy") self.create_file(src_file) os.chmod(src_file, 0o750) dst_file = self.make_path("xyzzy_copy") self.create_file(dst_file) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(dst_file)) shutil.copystat(src_file, dst_file) src_stat = os.stat(src_file) dst_stat = os.stat(dst_file) self.assertEqual(src_stat.st_mode, dst_stat.st_mode) self.assertAlmostEqual(src_stat.st_atime, dst_stat.st_atime, places=0) self.assertAlmostEqual(src_stat.st_mtime, dst_stat.st_mtime, places=2) @unittest.skipIf(IS_PYPY, "Functionality not supported in PyPy") def test_copystat_symlinks(self): """Regression test for #799""" skip_if_symlink_not_supported() f = self.make_path("xyzzy") self.create_file(f) sym1 = self.make_path("sym1") sym2 = self.make_path("sym2") self.create_symlink(sym1, f) self.create_symlink(sym2, f) shutil.copystat(sym1, sym2, follow_symlinks=False) def test_copy2(self): src_file = self.make_path("xyzzy") self.create_file(src_file) os.chmod(src_file, 0o750) dst_file = self.make_path("xyzzy_copy") self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_file)) shutil.copy2(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) src_stat = os.stat(src_file) dst_stat = os.stat(dst_file) self.assertEqual(src_stat.st_mode, dst_stat.st_mode) self.assertAlmostEqual(src_stat.st_atime, dst_stat.st_atime, places=0) self.assertAlmostEqual(src_stat.st_mtime, dst_stat.st_mtime, places=2) def test_copy2_directory(self): src_file = self.make_path("xyzzy") parent_directory = self.make_path("parent") dst_file = os.path.join(parent_directory, "xyzzy") self.create_file(src_file) self.create_dir(parent_directory) os.chmod(src_file, 0o750) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(parent_directory)) self.assertFalse(os.path.exists(dst_file)) shutil.copy2(src_file, parent_directory) self.assertTrue(os.path.exists(dst_file)) src_stat = os.stat(src_file) dst_stat = os.stat(dst_file) self.assertEqual(src_stat.st_mode, dst_stat.st_mode) self.assertAlmostEqual(src_stat.st_atime, dst_stat.st_atime, places=0) self.assertAlmostEqual(src_stat.st_mtime, dst_stat.st_mtime, places=2) def test_copytree(self): src_directory = self.make_path("xyzzy") dst_directory = self.make_path("xyzzy_copy") self.create_dir(src_directory) self.create_dir("%s/subdir" % src_directory) self.create_file(os.path.join(src_directory, "subfile")) self.assertTrue(os.path.exists(src_directory)) self.assertFalse(os.path.exists(dst_directory)) shutil.copytree(src_directory, dst_directory) self.assertTrue(os.path.exists(dst_directory)) self.assertTrue(os.path.exists(os.path.join(dst_directory, "subdir"))) self.assertTrue(os.path.exists(os.path.join(dst_directory, "subfile"))) def test_copytree_src_is_file(self): src_file = self.make_path("xyzzy") dst_directory = self.make_path("xyzzy_copy") self.create_file(src_file) self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_directory)) with self.assertRaises(OSError): shutil.copytree(src_file, dst_directory) def test_move_file_in_same_filesystem(self): self.skip_real_fs() src_file = "/original_xyzzy" dst_file = "/moved_xyzzy" src_object = self.fs.create_file(src_file) src_ino = src_object.st_ino src_dev = src_object.st_dev self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_file)) shutil.move(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.assertFalse(os.path.exists(src_file)) dst_object = self.fs.get_object(dst_file) self.assertEqual(src_ino, dst_object.st_ino) self.assertEqual(src_dev, dst_object.st_dev) def test_move_file_into_other_filesystem(self): self.skip_real_fs() mount_point = self.create_mount_point() src_file = self.make_path("original_xyzzy") dst_file = self.os.path.join(mount_point, "moved_xyzzy") src_object = self.fs.create_file(src_file) src_ino = src_object.st_ino src_dev = src_object.st_dev shutil.move(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.assertFalse(os.path.exists(src_file)) dst_object = self.fs.get_object(dst_file) self.assertNotEqual(src_ino, dst_object.st_ino) self.assertNotEqual(src_dev, dst_object.st_dev) def test_move_file_into_directory(self): src_file = self.make_path("xyzzy") dst_directory = self.make_path("directory") dst_file = os.path.join(dst_directory, "xyzzy") self.create_file(src_file) self.create_dir(dst_directory) self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_file)) shutil.move(src_file, dst_directory) self.assertTrue(os.path.exists(dst_file)) self.assertFalse(os.path.exists(src_file)) def test_move_directory(self): src_directory = self.make_path("original_xyzzy") dst_directory = self.make_path("moved_xyzzy") self.create_dir(src_directory) self.create_file(os.path.join(src_directory, "subfile")) self.create_dir(os.path.join(src_directory, "subdir")) self.assertTrue(os.path.exists(src_directory)) self.assertFalse(os.path.exists(dst_directory)) shutil.move(src_directory, dst_directory) self.assertTrue(os.path.exists(dst_directory)) self.assertTrue(os.path.exists(os.path.join(dst_directory, "subfile"))) self.assertTrue(os.path.exists(os.path.join(dst_directory, "subdir"))) self.assertFalse(os.path.exists(src_directory)) def test_disk_usage(self): self.skip_real_fs() file_path = self.make_path("foo", "bar") self.fs.create_file(file_path, st_size=400) disk_usage = shutil.disk_usage(file_path) self.assertEqual(1000, disk_usage.total) self.assertEqual(400, disk_usage.used) self.assertEqual(600, disk_usage.free) self.assertEqual((1000, 400, 600), disk_usage) mount_point = self.create_mount_point() dir_path = self.os.path.join(mount_point, "foo") file_path = self.os.path.join(dir_path, "bar") self.fs.create_file(file_path, st_size=400) disk_usage = shutil.disk_usage(dir_path) self.assertEqual((500, 400, 100), disk_usage) def test_disk_usage_with_path(self): self.skip_real_fs() file_path = self.make_path("foo", "bar") self.fs.create_file(file_path, st_size=400) path = Path(file_path) disk_usage = shutil.disk_usage(path) self.assertEqual(1000, disk_usage.total) self.assertEqual(400, disk_usage.used) self.assertEqual(600, disk_usage.free) self.assertEqual((1000, 400, 600), disk_usage) def create_mount_point(self): mount_point = "M:" if self.is_windows_fs else "/mount" self.fs.add_mount_point(mount_point, total_size=500) return mount_point class RealShutilModuleTest(FakeShutilModuleTest): def use_real_fs(self): return True class FakeCopyFileTest(RealFsTestCase): def tearDown(self): super().tearDown() def test_common_case(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") contents = "contents of file" self.create_file(src_file, contents=contents) self.assertTrue(os.path.exists(src_file)) self.assertFalse(os.path.exists(dst_file)) shutil.copyfile(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.check_contents(dst_file, contents) def test_raises_if_source_and_dest_are_the_same_file(self): src_file = self.make_path("xyzzy") dst_file = src_file contents = "contents of file" self.create_file(src_file, contents=contents) self.assertTrue(os.path.exists(src_file)) with self.assertRaises(shutil.Error): shutil.copyfile(src_file, dst_file) def test_raises_if_dest_is_a_symlink_to_src(self): skip_if_symlink_not_supported() src_file = self.make_path("foo") dst_file = self.make_path("bar") contents = "contents of file" self.create_file(src_file, contents=contents) self.create_symlink(dst_file, src_file) self.assertTrue(os.path.exists(src_file)) with self.assertRaises(shutil.Error): shutil.copyfile(src_file, dst_file) def test_succeeds_if_dest_exists_and_is_writable(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") src_contents = "contents of source file" dst_contents = "contents of dest file" self.create_file(src_file, contents=src_contents) self.create_file(dst_file, contents=dst_contents) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(dst_file)) shutil.copyfile(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.check_contents(dst_file, src_contents) def test_raises_if_dest_exists_and_is_not_writable(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") src_contents = "contents of source file" dst_contents = "contents of dest file" self.create_file(src_file, contents=src_contents) self.create_file(dst_file, contents=dst_contents) os.chmod(dst_file, 0o400) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(dst_file)) if is_root(): shutil.copyfile(src_file, dst_file) self.assertTrue(self.os.path.exists(dst_file)) with self.open(dst_file) as f: self.assertEqual("contents of source file", f.read()) else: with self.assertRaises(OSError): shutil.copyfile(src_file, dst_file) os.chmod(dst_file, 0o666) @unittest.skipIf(is_windows, "Posix specific behavior") def test_raises_if_dest_dir_is_not_writable_under_posix(self): self.check_posix_only() src_file = self.make_path("xyzzy") dst_dir = self.make_path("tmp", "foo") dst_file = os.path.join(dst_dir, "xyzzy") src_contents = "contents of source file" self.create_file(src_file, contents=src_contents) self.create_dir(dst_dir) os.chmod(dst_dir, 0o555) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(dst_dir)) if not is_root(): with self.assertRaises(OSError): shutil.copyfile(src_file, dst_file) else: shutil.copyfile(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.check_contents(dst_file, src_contents) def test_raises_if_src_doesnt_exist(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") self.assertFalse(os.path.exists(src_file)) with self.assertRaises(OSError): shutil.copyfile(src_file, dst_file) @unittest.skipIf(is_windows, "Posix specific behavior") def test_raises_if_src_not_readable(self): self.check_posix_only() src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") src_contents = "contents of source file" self.create_file(src_file, contents=src_contents) os.chmod(src_file, 0o000) self.assertTrue(os.path.exists(src_file)) if not is_root(): with self.assertRaises(OSError): shutil.copyfile(src_file, dst_file) else: shutil.copyfile(src_file, dst_file) self.assertTrue(os.path.exists(dst_file)) self.check_contents(dst_file, src_contents) def test_raises_if_src_is_a_directory(self): src_file = self.make_path("xyzzy") dst_file = self.make_path("xyzzy_copy") self.create_dir(src_file) self.assertTrue(os.path.exists(src_file)) with self.assertRaises(OSError): shutil.copyfile(src_file, dst_file) def test_raises_if_dest_is_a_directory(self): src_file = self.make_path("xyzzy") dst_dir = self.make_path("tmp", "foo") src_contents = "contents of source file" self.create_file(src_file, contents=src_contents) self.create_dir(dst_dir) self.assertTrue(os.path.exists(src_file)) self.assertTrue(os.path.exists(dst_dir)) with self.assertRaises(OSError): shutil.copyfile(src_file, dst_dir) def test_moving_dir_into_dir(self): # regression test for #515 source_dir = tempfile.mkdtemp() target_dir = tempfile.mkdtemp() filename = "foo.pdf" with open(os.path.join(source_dir, filename), "wb") as fp: fp.write(b"stub") shutil.move(source_dir, target_dir) shutil.rmtree(target_dir) class RealCopyFileTest(FakeCopyFileTest): def use_real_fs(self): return True if __name__ == "__main__": unittest.main()	23.34 KB	2026-01-20 12:58
📄 fake_filesystem_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unittest for fake_filesystem module.""" import contextlib import errno import os import pathlib import shutil import stat import sys import tempfile import unittest from unittest.mock import patch try: import pytest except ImportError: pytest = None from pyfakefs import fake_filesystem, fake_os, fake_open from pyfakefs.fake_filesystem import ( set_uid, set_gid, is_root, reset_ids, OSType, ) from pyfakefs.helpers import IS_WIN from pyfakefs.tests.test_utils import ( TestCase, RealFsTestCase, time_mock, skip_if_symlink_not_supported, ) class FakeDirectoryUnitTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.os = fake_os.FakeOsModule(self.filesystem) self.time = time_mock(10, 1) self.time.start() self.fake_file = fake_filesystem.FakeFile( "foobar", contents="dummy_file", filesystem=self.filesystem ) self.fake_dir = fake_filesystem.FakeDirectory( "somedir", filesystem=self.filesystem ) def tearDown(self): self.time.stop() def test_new_file_and_directory(self): self.assertTrue(stat.S_IFREG & self.fake_file.st_mode) self.assertTrue(stat.S_IFDIR & self.fake_dir.st_mode) self.assertEqual({}, self.fake_dir.entries) def test_add_entry(self): self.fake_dir.add_entry(self.fake_file) self.assertEqual({"foobar": self.fake_file}, self.fake_dir.entries) def test_get_entry(self): self.fake_dir.add_entry(self.fake_file) self.assertEqual(self.fake_file, self.fake_dir.get_entry("foobar")) def test_path(self): root_dir = self.filesystem.root_dir_name self.filesystem.root.add_entry(self.fake_dir) self.fake_dir.add_entry(self.fake_file) self.assertEqual(f"{root_dir}somedir/foobar", self.fake_file.path) self.assertEqual(f"{root_dir}somedir", self.fake_dir.path) def test_path_with_drive(self): self.filesystem.is_windows_fs = True dir_path = "C:/foo/bar/baz" self.filesystem.create_dir(dir_path) dir_object = self.filesystem.get_object(dir_path) self.assertEqual(dir_path, dir_object.path) def test_path_after_chdir(self): root_dir = self.filesystem.root_dir_name dir_path = "/foo/bar/baz" self.filesystem.create_dir(dir_path) self.os.chdir(dir_path) dir_object = self.filesystem.get_object(dir_path) self.assertEqual(f"{root_dir}foo/bar/baz", dir_object.path) def test_path_after_chdir_with_drive(self): self.filesystem.is_windows_fs = True dir_path = "C:/foo/bar/baz" self.filesystem.create_dir(dir_path) self.os.chdir(dir_path) dir_object = self.filesystem.get_object(dir_path) self.assertEqual(dir_path, dir_object.path) def test_remove_entry(self): self.fake_dir.add_entry(self.fake_file) self.assertEqual(self.fake_file, self.fake_dir.get_entry("foobar")) self.fake_dir.remove_entry("foobar") with self.assertRaises(KeyError): self.fake_dir.get_entry("foobar") def test_should_throw_if_set_size_is_not_integer(self): with self.raises_os_error(errno.ENOSPC): self.fake_file.size = 0.1 def test_should_throw_if_set_size_is_negative(self): with self.raises_os_error(errno.ENOSPC): self.fake_file.size = -1 def test_produce_empty_file_if_set_size_is_zero(self): self.fake_file.size = 0 self.assertEqual("", self.fake_file.contents) def test_sets_content_empty_if_set_size_is_zero(self): self.fake_file.size = 0 self.assertEqual("", self.fake_file.contents) def test_truncate_file_if_size_is_smaller_than_current_size(self): self.fake_file.size = 6 self.assertEqual("dummy_", self.fake_file.contents) def test_leave_file_unchanged_if_size_is_equal_to_current_size(self): self.fake_file.size = 10 self.assertEqual("dummy_file", self.fake_file.contents) def test_set_contents_to_dir_raises(self): # Regression test for #276 self.filesystem.is_windows_fs = True with self.raises_os_error(errno.EISDIR): self.fake_dir.set_contents("a") self.filesystem.is_windows_fs = False with self.raises_os_error(errno.EISDIR): self.fake_dir.set_contents("a") def test_pads_with_nullbytes_if_size_is_greater_than_current_size(self): self.fake_file.size = 13 self.assertEqual("dummy_file\0\0\0", self.fake_file.contents) def test_set_m_time(self): self.assertEqual(10, self.fake_file.st_mtime) self.fake_file.st_mtime = 14 self.assertEqual(14, self.fake_file.st_mtime) self.fake_file.st_mtime = 131 self.assertEqual(131, self.fake_file.st_mtime) def test_file_inode(self): filesystem = fake_filesystem.FakeFilesystem(path_separator="/") fake_os_module = fake_os.FakeOsModule(filesystem) file_path = "some_file1" filesystem.create_file(file_path, contents="contents here1") self.assertLess(0, fake_os_module.stat(file_path)[stat.ST_INO]) file_obj = filesystem.get_object(file_path) file_obj.st_ino = 43 self.assertEqual(43, fake_os_module.stat(file_path)[stat.ST_INO]) def test_directory_inode(self): filesystem = fake_filesystem.FakeFilesystem(path_separator="/") fake_os_module = fake_os.FakeOsModule(filesystem) dirpath = "testdir" filesystem.create_dir(dirpath) self.assertLess(0, fake_os_module.stat(dirpath)[stat.ST_INO]) dir_obj = filesystem.get_object(dirpath) dir_obj.st_ino = 43 self.assertEqual(43, fake_os_module.stat(dirpath)[stat.ST_INO]) def test_directory_size(self): fs = fake_filesystem.FakeFilesystem(path_separator="/") foo_dir = fs.create_dir("/foo") fs.create_file("/foo/bar.txt", st_size=20) bar_dir = fs.create_dir("/foo/bar/") fs.create_file("/foo/bar/baz1.txt", st_size=30) fs.create_file("/foo/bar/baz2.txt", st_size=40) foo1_dir = fs.create_dir("/foo1") fs.create_file("/foo1/bar.txt", st_size=50) fs.create_file("/foo1/bar/baz/file", st_size=60) self.assertEqual(90, foo_dir.size) self.assertEqual(70, bar_dir.size) self.assertEqual(110, foo1_dir.size) self.assertEqual(200, fs.root_dir.size) with self.raises_os_error(errno.EISDIR): foo1_dir.size = 100 def test_ordered_dirs(self): filesystem = fake_filesystem.FakeFilesystem(path_separator="/") filesystem.create_dir("/foo") filesystem.create_file("/foo/2") filesystem.create_file("/foo/4") filesystem.create_file("/foo/1") filesystem.create_file("/foo/3") fake_dir = filesystem.get_object("/foo") self.assertEqual(["2", "4", "1", "3"], fake_dir.ordered_dirs) class SetLargeFileSizeTest(TestCase): def setUp(self): filesystem = fake_filesystem.FakeFilesystem() self.fake_file = fake_filesystem.FakeFile("foobar", filesystem=filesystem) def test_should_throw_if_size_is_not_integer(self): with self.raises_os_error(errno.ENOSPC): self.fake_file.set_large_file_size(0.1) def test_should_throw_if_size_is_negative(self): with self.raises_os_error(errno.ENOSPC): self.fake_file.set_large_file_size(-1) def test_sets_content_none_if_size_is_non_negative_integer(self): self.fake_file.set_large_file_size(1000000000) self.assertEqual(None, self.fake_file.contents) self.assertEqual(1000000000, self.fake_file.st_size) class NormalizePathTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.root_name = self.filesystem.root_dir_name def test_empty_path_should_get_normalized_to_root_path(self): self.assertEqual(self.root_name, self.filesystem.absnormpath("")) def test_root_path_remains_unchanged(self): self.assertEqual(self.root_name, self.filesystem.absnormpath(self.root_name)) def test_relative_path_forced_to_cwd(self): path = "bar" self.filesystem.cwd = "/foo" self.assertEqual("/foo/bar", self.filesystem.absnormpath(path)) def test_cwd_from_pathlib_path(self): self.filesystem.cwd = pathlib.Path("/foo/bar") self.assertEqual("/foo/bar", self.filesystem.cwd) def test_absolute_path_remains_unchanged(self): path = "foo/bar" self.assertEqual(self.root_name + path, self.filesystem.absnormpath(path)) def test_dotted_path_is_normalized(self): path = "/foo/.." self.assertEqual( self.filesystem.root_dir_name, self.filesystem.absnormpath(path) ) path = "foo/../bar" self.assertEqual( f"{self.filesystem.root_dir_name}bar", self.filesystem.absnormpath(path), ) def test_dot_path_is_normalized(self): path = "." self.assertEqual(self.root_name, self.filesystem.absnormpath(path)) class GetPathComponentsTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.root_name = "/" def test_root_path_should_return_empty_list(self): self.assertEqual([], self.filesystem._path_components(self.root_name)) def test_empty_path_should_return_empty_list(self): self.assertEqual([], self.filesystem._path_components("")) def test_relative_path_with_one_component_should_return_component(self): self.assertEqual(["foo"], self.filesystem._path_components("foo")) def test_absolute_path_with_one_component_should_return_component(self): self.assertEqual(["foo"], self.filesystem._path_components("/foo")) def test_two_level_relative_path_should_return_components(self): self.assertEqual(["foo", "bar"], self.filesystem._path_components("foo/bar")) def test_two_level_absolute_path_should_return_components(self): self.assertEqual(["foo", "bar"], self.filesystem._path_components("/foo/bar")) class FakeFilesystemUnitTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.root_name = self.filesystem.root_dir_name self.fake_file = fake_filesystem.FakeFile("foobar", filesystem=self.filesystem) self.fake_child = fake_filesystem.FakeDirectory( "foobaz", filesystem=self.filesystem ) self.fake_grandchild = fake_filesystem.FakeDirectory( "quux", filesystem=self.filesystem ) def test_new_filesystem(self): self.assertEqual("/", self.filesystem.path_separator) self.assertTrue(stat.S_IFDIR & self.filesystem.root.st_mode) self.assertEqual({}, self.filesystem.root_dir.entries) def test_none_raises_type_error(self): with self.assertRaises(TypeError): self.filesystem.exists(None) def test_empty_string_does_not_exist(self): self.assertFalse(self.filesystem.exists("")) def test_exists_root(self): self.assertTrue(self.filesystem.exists(self.root_name)) def test_exists_unadded_file(self): self.assertFalse(self.filesystem.exists(self.fake_file.name)) def test_not_exists_subpath_named_like_file_contents(self): # Regression test for #219 file_path = "/foo/bar" self.filesystem.create_file(file_path, contents="baz") self.assertFalse(self.filesystem.exists(file_path + "/baz")) def test_get_root_object(self): self.assertEqual( self.filesystem.root_dir, self.filesystem.get_object(self.root_name), ) def test_add_object_to_root(self): self.filesystem.add_object(self.root_name, self.fake_file) self.assertEqual({"foobar": self.fake_file}, self.filesystem.root_dir.entries) def test_windows_root_dir_name(self): self.filesystem.is_windows_fs = True self.assertEqual("C:/", self.filesystem.root_dir_name) self.filesystem.cwd = "E:/foo" self.assertEqual("E:/", self.filesystem.root_dir_name) self.filesystem.cwd = "//foo/bar" self.assertEqual("//foo/bar/", self.filesystem.root_dir_name) def test_exists_added_file(self): self.filesystem.add_object(self.root_name, self.fake_file) self.assertTrue(self.filesystem.exists(self.fake_file.name)) def test_exists_relative_path_posix(self): self.filesystem.is_windows_fs = False 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")) self.assertTrue(self.filesystem.exists("/a/c/../b/file_one")) self.assertTrue(self.filesystem.exists("/a/c/../../a/b/file_one")) self.assertFalse(self.filesystem.exists("a/b/../z/d")) self.assertFalse(self.filesystem.exists("a/b/../z/../c/file_two")) self.filesystem.cwd = "/a/c" self.assertTrue(self.filesystem.exists("../b/file_one")) self.assertTrue(self.filesystem.exists("../../a/b/file_one")) self.assertTrue(self.filesystem.exists("../../a/b/../../a/c/file_two")) self.assertFalse(self.filesystem.exists("../z/file_one")) self.assertFalse(self.filesystem.exists("../z/../c/file_two")) def test_exists_relative_path_windows(self): self.filesystem.is_windows_fs = True self.filesystem.is_macos = False 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")) self.assertTrue(self.filesystem.exists("/a/c/../b/file_one")) self.assertTrue(self.filesystem.exists("/a/c/../../a/b/file_one")) self.assertFalse(self.filesystem.exists("a/b/../z/d")) self.assertTrue(self.filesystem.exists("a/b/../z/../c/file_two")) self.filesystem.cwd = "C:/a/c" self.assertTrue(self.filesystem.exists("../b/file_one")) self.assertTrue(self.filesystem.exists("../../a/b/file_one")) self.assertTrue(self.filesystem.exists("../../a/b/../../a/c/file_two")) self.assertFalse(self.filesystem.exists("../z/file_one")) self.assertTrue(self.filesystem.exists("../z/../c/file_two")) def test_get_object_from_root(self): self.filesystem.add_object(self.root_name, self.fake_file) self.assertEqual(self.fake_file, self.filesystem.get_object("foobar")) def test_get_nonexistent_object_from_root_error(self): self.filesystem.add_object(self.root_name, self.fake_file) self.assertEqual(self.fake_file, self.filesystem.get_object("foobar")) with self.raises_os_error(errno.ENOENT): self.filesystem.get_object("some_bogus_filename") def test_remove_object_from_root(self): self.filesystem.add_object(self.root_name, self.fake_file) self.filesystem.remove_object(self.fake_file.name) with self.raises_os_error(errno.ENOENT): self.filesystem.get_object(self.fake_file.name) def test_remove_nonexisten_object_from_root_error(self): with self.raises_os_error(errno.ENOENT): self.filesystem.remove_object("some_bogus_filename") def test_exists_removed_file(self): self.filesystem.add_object(self.root_name, self.fake_file) self.filesystem.remove_object(self.fake_file.name) self.assertFalse(self.filesystem.exists(self.fake_file.name)) def test_add_object_to_child(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) self.assertEqual( {self.fake_file.name: self.fake_file}, self.filesystem.root_dir.get_entry(self.fake_child.name).entries, ) def test_add_object_to_regular_file_error_posix(self): self.filesystem.is_windows_fs = False 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.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) def test_exists_file_added_to_child(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) path = self.filesystem.joinpaths(self.fake_child.name, self.fake_file.name) self.assertTrue(self.filesystem.exists(path)) def test_get_object_from_child(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) self.assertEqual( self.fake_file, self.filesystem.get_object( self.filesystem.joinpaths(self.fake_child.name, self.fake_file.name) ), ) def test_get_nonexistent_object_from_child_error(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) with self.raises_os_error(errno.ENOENT): self.filesystem.get_object( self.filesystem.joinpaths(self.fake_child.name, "some_bogus_filename") ) def test_remove_object_from_child(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) target_path = self.filesystem.joinpaths( self.fake_child.name, self.fake_file.name ) self.filesystem.remove_object(target_path) with self.raises_os_error(errno.ENOENT): self.filesystem.get_object(target_path) def test_remove_object_from_child_error(self): self.filesystem.add_object(self.root_name, self.fake_child) with self.raises_os_error(errno.ENOENT): self.filesystem.remove_object( self.filesystem.joinpaths(self.fake_child.name, "some_bogus_filename") ) def test_remove_object_from_non_directory_error(self): self.filesystem.add_object(self.root_name, self.fake_file) with self.raises_os_error(errno.ENOTDIR): self.filesystem.remove_object( self.filesystem.joinpaths( "%s" % self.fake_file.name, "file_does_not_matter_since_parent_not_a_directory", ) ) def test_exists_file_removed_from_child(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_file) path = self.filesystem.joinpaths(self.fake_child.name, self.fake_file.name) self.filesystem.remove_object(path) self.assertFalse(self.filesystem.exists(path)) def test_operate_on_grandchild_directory(self): self.filesystem.add_object(self.root_name, self.fake_child) self.filesystem.add_object(self.fake_child.name, self.fake_grandchild) grandchild_directory = self.filesystem.joinpaths( self.fake_child.name, self.fake_grandchild.name ) grandchild_file = self.filesystem.joinpaths( grandchild_directory, self.fake_file.name ) with self.assertRaises(OSError): self.filesystem.get_object(grandchild_file) self.filesystem.add_object(grandchild_directory, self.fake_file) self.assertEqual(self.fake_file, self.filesystem.get_object(grandchild_file)) self.assertTrue(self.filesystem.exists(grandchild_file)) self.filesystem.remove_object(grandchild_file) with self.assertRaises(OSError): self.filesystem.get_object(grandchild_file) self.assertFalse(self.filesystem.exists(grandchild_file)) def test_create_directory_in_root_directory(self): path = "foo" self.filesystem.create_dir(path) new_dir = self.filesystem.get_object(path) self.assertEqual(os.path.basename(path), new_dir.name) self.assertTrue(stat.S_IFDIR & new_dir.st_mode) def test_create_directory_in_root_directory_already_exists_error(self): path = "foo" self.filesystem.create_dir(path) with self.raises_os_error(errno.EEXIST): self.filesystem.create_dir(path) def test_create_directory(self): path = "foo/bar/baz" self.filesystem.create_dir(path) new_dir = self.filesystem.get_object(path) self.assertEqual(os.path.basename(path), new_dir.name) self.assertTrue(stat.S_IFDIR & new_dir.st_mode) # Create second directory to make sure first is OK. path = "%s/quux" % path self.filesystem.create_dir(path) new_dir = self.filesystem.get_object(path) self.assertEqual(os.path.basename(path), new_dir.name) self.assertTrue(stat.S_IFDIR & new_dir.st_mode) def test_create_dir_umask(self): old_umask = self.filesystem.umask self.filesystem.umask = 0o22 path = "foo/bar/baz" self.filesystem.create_dir(path, perm_bits=0o777) new_dir = self.filesystem.get_object(path) self.assertEqual(stat.S_IFDIR \| 0o755, new_dir.st_mode) path = "foo/bar/boo" self.filesystem.create_dir(path, perm_bits=0o777, apply_umask=False) new_dir = self.filesystem.get_object(path) self.assertEqual(stat.S_IFDIR \| 0o777, new_dir.st_mode) self.filesystem.umask = old_umask def test_create_directory_already_exists_error(self): path = "foo/bar/baz" self.filesystem.create_dir(path) with self.raises_os_error(errno.EEXIST): self.filesystem.create_dir(path) def test_create_file_in_read_only_directory_raises_in_posix(self): self.filesystem.is_windows_fs = False dir_path = "/foo/bar" self.filesystem.create_dir(dir_path, perm_bits=0o555) file_path = dir_path + "/baz" if not is_root(): with self.raises_os_error(errno.EACCES): self.filesystem.create_file(file_path) else: self.filesystem.create_file(file_path) self.assertTrue(self.filesystem.exists(file_path)) def test_create_file_in_read_only_directory_possible_in_windows(self): self.filesystem.is_windows_fs = True dir_path = "C:/foo/bar" self.filesystem.create_dir(dir_path, perm_bits=0o555) file_path = dir_path + "/baz" self.filesystem.create_file(file_path) self.assertTrue(self.filesystem.exists(file_path)) def test_create_file_in_current_directory(self): path = "foo" contents = "dummy data" self.filesystem.create_file(path, contents=contents) self.assertTrue(self.filesystem.exists(path)) self.assertFalse(self.filesystem.exists(os.path.dirname(path))) path = "./%s" % path self.assertTrue(self.filesystem.exists(os.path.dirname(path))) def test_create_file_in_root_directory(self): path = "/foo" contents = "dummy data" self.filesystem.create_file(path, contents=contents) new_file = self.filesystem.get_object(path) self.assertTrue(self.filesystem.exists(path)) self.assertTrue(self.filesystem.exists(os.path.dirname(path))) self.assertEqual(os.path.basename(path), new_file.name) self.assertTrue(stat.S_IFREG & new_file.st_mode) self.assertEqual(contents, new_file.contents) def test_create_file_with_size_but_no_content_creates_large_file(self): path = "large_foo_bar" self.filesystem.create_file(path, st_size=100000000) new_file = self.filesystem.get_object(path) self.assertEqual(None, new_file.contents) self.assertEqual(100000000, new_file.st_size) def test_create_file_in_root_directory_already_exists_error(self): path = "foo" self.filesystem.create_file(path) with self.raises_os_error(errno.EEXIST): self.filesystem.create_file(path) def test_create_file(self): path = "foo/bar/baz" retval = self.filesystem.create_file(path, contents="dummy_data") self.assertTrue(self.filesystem.exists(path)) self.assertTrue(self.filesystem.exists(os.path.dirname(path))) new_file = self.filesystem.get_object(path) self.assertEqual(os.path.basename(path), new_file.name) if IS_WIN: fake_id = 0 if is_root() else 1 self.assertEqual(fake_id, new_file.st_uid) self.assertEqual(fake_id, new_file.st_gid) else: self.assertEqual(os.getuid(), new_file.st_uid) self.assertEqual(os.getgid(), new_file.st_gid) self.assertEqual(new_file, retval) def test_create_file_with_changed_ids(self): path = "foo/bar/baz" set_uid(42) set_gid(2) self.filesystem.create_file(path) self.assertTrue(self.filesystem.exists(path)) new_file = self.filesystem.get_object(path) self.assertEqual(42, new_file.st_uid) self.assertEqual(2, new_file.st_gid) reset_ids() def test_empty_file_created_for_none_contents(self): fake_open = fake_filesystem.FakeFileOpen(self.filesystem) path = "foo/bar/baz" self.filesystem.create_file(path, contents=None) with fake_open(path, encoding="utf8") as f: self.assertEqual("", f.read()) def test_create_file_with_incorrect_mode_type(self): with self.assertRaises(TypeError): self.filesystem.create_file("foo", "bar") def test_create_file_already_exists_error(self): path = "foo/bar/baz" self.filesystem.create_file(path, contents="dummy_data") with self.raises_os_error(errno.EEXIST): self.filesystem.create_file(path) def test_create_link(self): path = "foo/bar/baz" target_path = "foo/bar/quux" new_file = self.filesystem.create_symlink(path, "quux") # Neither the path nor the final target exists before we actually # write to one of them, even though the link appears in the file # system. self.assertFalse(self.filesystem.exists(path)) self.assertFalse(self.filesystem.exists(target_path)) self.assertTrue(stat.S_IFLNK & new_file.st_mode) # but once we write the linked to file, they both will exist. self.filesystem.create_file(target_path) self.assertTrue(self.filesystem.exists(path)) self.assertTrue(self.filesystem.exists(target_path)) def test_resolve_object(self): target_path = "dir/target" target_contents = "0123456789ABCDEF" link_name = "x" self.filesystem.create_dir("dir") self.filesystem.create_file("dir/target", contents=target_contents) self.filesystem.create_symlink(link_name, target_path) obj = self.filesystem.resolve(link_name) self.assertEqual("target", obj.name) self.assertEqual(target_contents, obj.contents) def check_lresolve_object(self): target_path = "dir/target" target_contents = "0123456789ABCDEF" link_name = "x" self.filesystem.create_dir("dir") self.filesystem.create_file("dir/target", contents=target_contents) self.filesystem.create_symlink(link_name, target_path) obj = self.filesystem.lresolve(link_name) self.assertEqual(link_name, obj.name) self.assertEqual(target_path, obj.contents) def test_lresolve_object_windows(self): self.filesystem.is_windows_fs = True self.check_lresolve_object() def test_lresolve_object_posix(self): self.filesystem.is_windows_fs = False self.check_lresolve_object() def check_directory_access_on_file(self, error_subtype): self.filesystem.create_file("not_a_dir") with self.raises_os_error(error_subtype): self.filesystem.resolve("not_a_dir/foo") with self.raises_os_error(error_subtype): self.filesystem.lresolve("not_a_dir/foo/bar") def test_directory_access_on_file_windows(self): self.filesystem.is_windows_fs = True self.check_directory_access_on_file(errno.ENOENT) def test_directory_access_on_file_posix(self): self.filesystem.is_windows_fs = False self.check_directory_access_on_file(errno.ENOTDIR) def test_pickle_fs(self): """Regression test for #445""" import pickle self.filesystem.open_files = [] p = pickle.dumps(self.filesystem) fs = pickle.loads(p) self.assertEqual(str(fs.root), str(self.filesystem.root)) self.assertEqual(fs.mount_points, self.filesystem.mount_points) class CaseInsensitiveFakeFilesystemTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.filesystem.is_case_sensitive = False self.os = fake_os.FakeOsModule(self.filesystem) self.path = self.os.path def test_get_object(self): self.filesystem.create_dir("/foo/bar") self.filesystem.create_file("/foo/bar/baz") self.assertTrue(self.filesystem.get_object("/Foo/Bar/Baz")) def test_remove_object(self): self.filesystem.create_dir("/foo/bar") self.filesystem.create_file("/foo/bar/baz") self.filesystem.remove_object("/Foo/Bar/Baz") self.assertFalse(self.filesystem.exists("/foo/bar/baz")) def test_exists(self): self.filesystem.create_dir("/Foo/Bar") self.assertTrue(self.filesystem.exists("/Foo/Bar")) self.assertTrue(self.filesystem.exists("/foo/bar")) self.filesystem.create_file("/foo/Bar/baz") self.assertTrue(self.filesystem.exists("/Foo/bar/BAZ")) self.assertTrue(self.filesystem.exists("/foo/bar/baz")) def test_create_directory_with_different_case_root(self): self.filesystem.create_dir("/Foo/Bar") self.filesystem.create_dir("/foo/bar/baz") dir1 = self.filesystem.get_object("/Foo/Bar") dir2 = self.filesystem.get_object("/foo/bar") self.assertEqual(dir1, dir2) def test_create_file_with_different_case_dir(self): self.filesystem.create_dir("/Foo/Bar") self.filesystem.create_file("/foo/bar/baz") dir1 = self.filesystem.get_object("/Foo/Bar") dir2 = self.filesystem.get_object("/foo/bar") self.assertEqual(dir1, dir2) def test_resolve_path(self): self.filesystem.create_dir("/foo/baz") self.filesystem.create_symlink("/Foo/Bar", "./baz/bip") self.assertEqual( f"{self.filesystem.root_dir_name}foo/baz/bip", self.filesystem.resolve_path("/foo/bar"), ) def test_isdir_isfile(self): self.filesystem.create_file("foo/bar") self.assertTrue(self.path.isdir("Foo")) self.assertFalse(self.path.isfile("Foo")) self.assertTrue(self.path.isfile("Foo/Bar")) self.assertFalse(self.path.isdir("Foo/Bar")) def test_getsize(self): file_path = "foo/bar/baz" self.filesystem.create_file(file_path, contents="1234567") self.assertEqual(7, self.path.getsize("FOO/BAR/BAZ")) def test_getsize_with_looping_symlink(self): self.filesystem.is_windows_fs = False dir_path = "/foo/bar" self.filesystem.create_dir(dir_path) link_path = dir_path + "/link" link_target = link_path + "/link" self.os.symlink(link_target, link_path) with self.raises_os_error(errno.ELOOP): self.os.path.getsize(link_path) def test_get_mtime(self): test_file = self.filesystem.create_file("foo/bar1.txt") test_file.st_mtime = 24 self.assertEqual(24, self.path.getmtime("Foo/Bar1.TXT")) def test_get_object_with_file_size(self): self.filesystem.create_file("/Foo/Bar", st_size=10) self.assertTrue(self.filesystem.get_object("/foo/bar")) class CaseSensitiveFakeFilesystemTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.filesystem.is_case_sensitive = True self.os = fake_os.FakeOsModule(self.filesystem) self.path = self.os.path def test_get_object(self): self.filesystem.create_dir("/foo/bar") self.filesystem.create_file("/foo/bar/baz") with self.assertRaises(OSError): self.filesystem.get_object("/Foo/Bar/Baz") def test_remove_object(self): self.filesystem.create_dir("/foo/bar") self.filesystem.create_file("/foo/bar/baz") with self.assertRaises(OSError): self.filesystem.remove_object("/Foo/Bar/Baz") self.assertTrue(self.filesystem.exists("/foo/bar/baz")) def test_exists(self): self.filesystem.create_dir("/Foo/Bar") self.assertTrue(self.filesystem.exists("/Foo/Bar")) self.assertFalse(self.filesystem.exists("/foo/bar")) self.filesystem.create_file("/foo/Bar/baz") self.assertFalse(self.filesystem.exists("/Foo/bar/BAZ")) self.assertFalse(self.filesystem.exists("/foo/bar/baz")) def test_create_directory_with_different_case_root(self): self.filesystem.create_dir("/Foo/Bar") self.filesystem.create_dir("/foo/bar/baz") dir1 = self.filesystem.get_object("/Foo/Bar") dir2 = self.filesystem.get_object("/foo/bar") self.assertNotEqual(dir1, dir2) def test_create_file_with_different_case_dir(self): self.filesystem.create_dir("/Foo/Bar") self.filesystem.create_file("/foo/bar/baz") dir1 = self.filesystem.get_object("/Foo/Bar") dir2 = self.filesystem.get_object("/foo/bar") self.assertNotEqual(dir1, dir2) def test_isdir_isfile(self): self.filesystem.create_file("foo/bar") self.assertFalse(self.path.isdir("Foo")) self.assertFalse(self.path.isfile("Foo")) self.assertFalse(self.path.isfile("Foo/Bar")) self.assertFalse(self.path.isdir("Foo/Bar")) def test_getsize(self): file_path = "foo/bar/baz" self.filesystem.create_file(file_path, contents="1234567") with self.assertRaises(os.error): self.path.getsize("FOO/BAR/BAZ") def test_get_mtime(self): test_file = self.filesystem.create_file("foo/bar1.txt") test_file.st_mtime = 24 with self.raises_os_error(errno.ENOENT): self.path.getmtime("Foo/Bar1.TXT") class OsPathInjectionRegressionTest(TestCase): """Test faking os.path before calling os.walk. Found when investigating a problem with gws/tools/labrat/rat_utils_unittest, which was faking out os.path before calling os.walk. """ def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.os_path = os.path # The bug was that when os.path gets faked, the FakePathModule doesn't # get called in self.os.walk(). FakePathModule now insists that it is # created as part of FakeOsModule. self.os = fake_os.FakeOsModule(self.filesystem) def tearDown(self): os.path = self.os_path def test_create_top_level_directory(self): top_level_dir = "/x" self.assertFalse(self.filesystem.exists(top_level_dir)) self.filesystem.create_dir(top_level_dir) self.assertTrue(self.filesystem.exists("/")) self.assertTrue(self.filesystem.exists(top_level_dir)) self.filesystem.create_dir("%s/po" % top_level_dir) self.filesystem.create_file("%s/po/control" % top_level_dir) self.filesystem.create_file("%s/po/experiment" % top_level_dir) self.filesystem.create_dir("%s/gv" % top_level_dir) self.filesystem.create_file("%s/gv/control" % top_level_dir) expected = [ ("/", ["x"], []), ("/x", ["gv", "po"], []), ("/x/gv", [], ["control"]), ("/x/po", [], ["control", "experiment"]), ] # as the result is unsorted, we have to check against sorted results result = sorted([step for step in self.os.walk("/")], key=lambda v: v[0]) self.assertEqual(len(expected), len(result)) for entry, expected_entry in zip(result, expected): self.assertEqual(expected_entry[0], entry[0]) self.assertEqual(expected_entry[1], sorted(entry[1])) self.assertEqual(expected_entry[2], sorted(entry[2])) class FakePathModuleTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="!") self.os = fake_os.FakeOsModule(self.filesystem) self.path = self.os.path def check_abspath(self, is_windows): # the implementation differs in Windows and Posix, so test both self.filesystem.is_windows_fs = is_windows filename = "foo" abspath = self.filesystem.root_dir_name + filename self.filesystem.create_file(abspath) self.assertEqual(abspath, self.path.abspath(abspath)) self.assertEqual(abspath, self.path.abspath(filename)) self.assertEqual(abspath, self.path.abspath("..!%s" % filename)) def test_abspath_windows(self): self.check_abspath(is_windows=True) def test_abspath_posix(self): """abspath should return a consistent representation of a file.""" self.check_abspath(is_windows=False) def check_abspath_bytes(self, is_windows): """abspath should return a consistent representation of a file.""" self.filesystem.is_windows_fs = is_windows filename = b"foo" abspath = self.filesystem.root_dir_name.encode() + filename self.filesystem.create_file(abspath) self.assertEqual(abspath, self.path.abspath(abspath)) self.assertEqual(abspath, self.path.abspath(filename)) self.assertEqual(abspath, self.path.abspath(b"..!" + filename)) def test_abspath_bytes_windows(self): self.check_abspath_bytes(is_windows=True) def test_abspath_bytes_posix(self): self.check_abspath_bytes(is_windows=False) def test_abspath_deals_with_relative_non_root_path(self): """abspath should correctly handle relative paths from a non-! directory. This test is distinct from the basic functionality test because fake_filesystem has historically been based in !. """ filename = "!foo!bar!baz" file_components = filename.split(self.path.sep) root_name = self.filesystem.root_dir_name basedir = f"{root_name}{file_components[0]}" self.filesystem.create_file(filename) self.os.chdir(basedir) self.assertEqual(basedir, self.path.abspath(self.path.curdir)) self.assertEqual(root_name, self.path.abspath("..")) self.assertEqual( self.path.join(basedir, file_components[1]), self.path.abspath(file_components[1]), ) def test_abs_path_with_drive_component(self): self.filesystem.is_windows_fs = True 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.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.assertTrue(self.path.isabs("C:!foo")) self.assertTrue(self.path.isabs(b"C:!foo")) if sys.version_info < (3, 13): self.assertTrue(self.path.isabs("!")) self.assertTrue(self.path.isabs(b"!")) else: self.assertFalse(self.path.isabs("!")) self.assertFalse(self.path.isabs(b"!")) def test_relpath(self): path_foo = "!path!to!foo" path_bar = "!path!to!bar" path_other = "!some!where!else" with self.assertRaises(ValueError): self.path.relpath(None) with self.assertRaises(ValueError): self.path.relpath("") self.assertEqual("path!to!foo", self.path.relpath(path_foo)) self.assertEqual("..!foo", self.path.relpath(path_foo, path_bar)) self.assertEqual( "..!..!..%s" % path_other, self.path.relpath(path_other, path_bar) ) self.assertEqual(".", self.path.relpath(path_bar, path_bar)) def test_realpath_vs_abspath(self): self.filesystem.is_windows_fs = False self.filesystem.create_file("!george!washington!bridge") self.filesystem.create_symlink("!first!president", "!george!washington") self.assertEqual( "!first!president!bridge", self.os.path.abspath("!first!president!bridge"), ) self.assertEqual( "!george!washington!bridge", self.os.path.realpath("!first!president!bridge"), ) self.os.chdir("!first!president") self.assertEqual("!george!washington!bridge", self.os.path.realpath("bridge")) @unittest.skipIf(sys.version_info < (3, 10), "'strict' new in Python 3.10") def test_realpath_strict(self): self.filesystem.create_file("!foo!bar") root_dir = self.filesystem.root_dir_name self.filesystem.cwd = f"{root_dir}foo" self.assertEqual( f"{root_dir}foo!baz", self.os.path.realpath("baz", strict=False) ) with self.raises_os_error(errno.ENOENT): self.os.path.realpath("baz", strict=True) self.assertEqual( f"{root_dir}foo!bar", self.os.path.realpath("bar", strict=True) ) @unittest.skipIf( not hasattr(os.path, "ALLOW_MISSING"), "ALLOW_MISSING has been added in different patch versions", ) def test_realpath_allow_missing(self): f = self.filesystem.create_file("!foo!bar") root_dir = self.filesystem.root_dir_name self.filesystem.cwd = f"{root_dir}foo" self.assertEqual( f"{root_dir}foo!baz", self.os.path.realpath("baz", strict=os.path.ALLOW_MISSING), # type: ignore[attr-defined] ) if not is_root(): self.os.chmod(f.path, 0) with self.raises_os_error(errno.EACCES): self.os.path.realpath(f.path, strict=os.path.ALLOW_MISSING) # type: ignore[attr-defined] def test_samefile(self): file_path1 = "!foo!bar!baz" file_path2 = "!foo!bar!boo" self.filesystem.create_file(file_path1) self.filesystem.create_file(file_path2) self.assertTrue(self.path.samefile(file_path1, file_path1)) self.assertFalse(self.path.samefile(file_path1, file_path2)) self.assertTrue(self.path.samefile(file_path1, "!foo!..!foo!bar!..!bar!baz")) self.assertTrue(self.path.samefile(file_path1, b"!foo!..!foo!bar!..!bar!baz")) def test_exists(self): file_path = "foo!bar!baz" file_path_bytes = b"foo!bar!baz" self.filesystem.create_file(file_path) self.assertTrue(self.path.exists(file_path)) self.assertTrue(self.path.exists(file_path_bytes)) self.assertFalse(self.path.exists("!some!other!bogus!path")) def test_exists_with_drive(self): self.filesystem.os = OSType.WINDOWS self.filesystem.add_mount_point("F:") self.assertTrue(self.path.exists("C:")) self.assertTrue(self.path.exists("c:\\")) self.assertTrue(self.path.exists("f:")) self.assertTrue(self.path.exists("F:\\")) self.assertFalse(self.path.exists("Z:")) self.assertFalse(self.path.exists("z:\\")) def test_lexists(self): file_path = "foo!bar!baz" file_path_bytes = b"foo!bar!baz" self.filesystem.create_dir("foo!bar") self.filesystem.create_symlink(file_path, "bogus") self.assertTrue(self.path.lexists(file_path)) self.assertTrue(self.path.lexists(file_path_bytes)) self.assertFalse(self.path.exists(file_path)) self.assertFalse(self.path.exists(file_path_bytes)) self.filesystem.create_file("foo!bar!bogus") self.assertTrue(self.path.exists(file_path)) def test_dirname_with_drive(self): self.filesystem.is_windows_fs = True self.assertEqual("c:!foo", self.path.dirname("c:!foo!bar")) self.assertEqual(b"c:!", self.path.dirname(b"c:!foo")) self.assertEqual("!foo", self.path.dirname("!foo!bar")) self.assertEqual(b"!", self.path.dirname(b"!foo")) self.assertEqual("c:foo", self.path.dirname("c:foo!bar")) self.assertEqual(b"c:", self.path.dirname(b"c:foo")) self.assertEqual("foo", self.path.dirname("foo!bar")) def test_dirname(self): dirname = "foo!bar" self.assertEqual(dirname, self.path.dirname("%s!baz" % dirname)) def test_join_strings(self): components = ["foo", "bar", "baz"] self.assertEqual("foo!bar!baz", self.path.join(components)) def test_join_bytes(self): components = [b"foo", b"bar", b"baz"] self.assertEqual(b"foo!bar!baz", self.path.join(components)) @unittest.skipIf( sys.platform != "win32" or sys.version_info < (3, 8), "Windows specific test" ) @patch.dict(os.environ, {"USERPROFILE": r"C:\Users\John"}) def test_expand_user_windows(self): self.assertEqual(self.path.expanduser("~"), "C:!Users!John") @unittest.skipIf(sys.platform == "win32", "Posix specific test") @patch.dict(os.environ, {"HOME": "/home/john"}) def test_expand_user(self): self.assertEqual(self.path.expanduser("~"), "!home!john") @patch.dict(os.environ, {}, clear=True) def test_expand_user_no_home_environment(self): """Make sure this also works without HOME / USERPROFILE set""" # we just check that it does not crash and has some result, # as the result is system-dependent self.assertTrue(self.path.expanduser("~")) @unittest.skipIf( TestCase.is_windows or TestCase.is_cygwin, "only tested on unix systems", ) def test_expand_root(self): if sys.platform == "darwin": roothome = "!var!root" else: roothome = "!root" self.assertEqual(self.path.expanduser("~root"), roothome) def test_getsize_path_nonexistent(self): file_path = "foo!bar!baz" with self.assertRaises(os.error): self.path.getsize(file_path) def test_getsize_file_empty(self): file_path = "foo!bar!baz" self.filesystem.create_file(file_path) self.assertEqual(0, self.path.getsize(file_path)) def test_getsize_file_non_zero_size(self): file_path = "foo!bar!baz" file_path_bytes = b"foo!bar!baz" self.filesystem.create_file(file_path, contents="1234567") self.assertEqual(7, self.path.getsize(file_path)) self.assertEqual(7, self.path.getsize(file_path_bytes)) def test_getsize_dir_empty(self): # For directories, only require that the size is non-negative. dir_path = "foo!bar" self.filesystem.create_dir(dir_path) size = self.path.getsize(dir_path) self.assertFalse(int(size) < 0, "expected non-negative size; actual: %s" % size) def test_getsize_dir_non_zero_size(self): # For directories, only require that the size is non-negative. dir_path = "foo!bar" self.filesystem.create_file(self.filesystem.joinpaths(dir_path, "baz")) size = self.path.getsize(dir_path) self.assertFalse(int(size) < 0, "expected non-negative size; actual: %s" % size) def test_isdir(self): self.filesystem.create_file("foo!bar") self.assertTrue(self.path.isdir("foo")) self.assertTrue(self.path.isdir(b"foo")) self.assertFalse(self.path.isdir("foo!bar")) self.assertFalse(self.path.isdir("it_dont_exist")) def test_isdir_with_cwd_change(self): self.filesystem.create_file("!foo!bar!baz") self.assertTrue(self.path.isdir("!foo")) self.assertTrue(self.path.isdir("!foo!bar")) self.assertTrue(self.path.isdir("foo")) self.assertTrue(self.path.isdir("foo!bar")) self.filesystem.cwd = f"{self.filesystem.root_dir_name}foo" self.assertTrue(self.path.isdir("!foo")) self.assertTrue(self.path.isdir("!foo!bar")) self.assertTrue(self.path.isdir("bar")) def test_isfile(self): self.filesystem.create_file("foo!bar") self.assertFalse(self.path.isfile("foo")) self.assertTrue(self.path.isfile("foo!bar")) self.assertTrue(self.path.isfile(b"foo!bar")) self.assertFalse(self.path.isfile("it_dont_exist")) def test_get_mtime(self): test_file = self.filesystem.create_file("foo!bar1.txt") self.assertNotEqual(24, self.path.getmtime("foo!bar1.txt")) test_file.st_mtime = 24 self.assertEqual(24, self.path.getmtime("foo!bar1.txt")) self.assertEqual(24, self.path.getmtime(b"foo!bar1.txt")) def test_get_mtime_raises_os_error(self): self.assertFalse(self.path.exists("does_not_exist")) with self.raises_os_error(errno.ENOENT): self.path.getmtime("does_not_exist") def test_islink(self): self.filesystem.create_dir("foo") self.filesystem.create_file("foo!regular_file") self.filesystem.create_symlink("foo!link_to_file", "regular_file") self.assertFalse(self.path.islink("foo")) # An object can be both a link and a file or file, according to the # comments in Python/Lib/posixpath.py. self.assertTrue(self.path.islink("foo!link_to_file")) self.assertTrue(self.path.isfile("foo!link_to_file")) self.assertTrue(self.path.islink(b"foo!link_to_file")) self.assertTrue(self.path.isfile(b"foo!link_to_file")) self.assertTrue(self.path.isfile("foo!regular_file")) self.assertFalse(self.path.islink("foo!regular_file")) self.assertFalse(self.path.islink("it_dont_exist")) def test_is_link_case_sensitive(self): # Regression test for #306 self.filesystem.is_case_sensitive = False self.filesystem.create_dir("foo") self.filesystem.create_symlink("foo!bar", "foo") self.assertTrue(self.path.islink("foo!Bar")) def test_ismount(self): self.assertFalse(self.path.ismount("")) self.assertTrue(self.path.ismount("!")) self.assertTrue(self.path.ismount(b"!")) self.assertFalse(self.path.ismount("!mount!")) self.filesystem.add_mount_point("!mount") self.assertTrue(self.path.ismount("!mount")) self.assertTrue(self.path.ismount(b"!mount")) self.assertTrue(self.path.ismount("!mount!")) def test_ismount_with_drive_letters(self): self.filesystem.is_windows_fs = True self.assertTrue(self.path.ismount("!")) self.assertTrue(self.path.ismount("c:!")) self.assertFalse(self.path.ismount("c:")) self.assertTrue(self.path.ismount("z:!")) self.filesystem.add_mount_point("!mount") self.assertTrue(self.path.ismount("!mount")) self.assertTrue(self.path.ismount("!mount!")) def test_ismount_with_unc_paths(self): self.filesystem.is_windows_fs = True self.assertTrue(self.path.ismount("!!a!")) self.assertTrue(self.path.ismount("!!a!b")) self.assertTrue(self.path.ismount("!!a!b!")) self.assertFalse(self.path.ismount("!a!b!")) self.assertFalse(self.path.ismount("!!a!b!c")) def test_ismount_with_alternate_path_separator(self): self.filesystem.alternative_path_separator = "!" self.filesystem.add_mount_point("!mount") self.assertTrue(self.path.ismount("!mount")) self.assertTrue(self.path.ismount("!mount!")) self.assertTrue(self.path.ismount("!mount!!")) self.filesystem.is_windows_fs = True self.assertTrue(self.path.ismount("Z:!")) def test_getattr_forward_to_real_os_path(self): """Forwards any non-faked calls to os.path.""" self.assertTrue(hasattr(self.path, "sep"), "Get a faked os.path function") private_path_function = None if sys.version_info < (3, 6): if self.is_windows: private_path_function = "_get_bothseps" else: private_path_function = "_join_real_path" if private_path_function: self.assertTrue( hasattr(self.path, private_path_function), "Get a real os.path function not implemented in fake os.path", ) self.assertFalse(hasattr(self.path, "nonexistent")) def test_splitroot_posix(self): self.filesystem.is_windows_fs = False self.assertEqual(("", "", "foo!bar"), self.filesystem.splitroot("foo!bar")) self.assertEqual(("", "!", "foo!bar"), self.filesystem.splitroot("!foo!bar")) self.assertEqual( ("", "!!", "foo!!bar"), self.filesystem.splitroot("!!foo!!bar") ) @unittest.skipIf(sys.version_info < (3, 13), "Introduced in Python 3.13") @unittest.skipIf(TestCase.is_windows, "Posix specific behavior") def test_is_reserved_posix(self): self.assertFalse(self.filesystem.isreserved("!dev")) self.assertFalse(self.filesystem.isreserved("!")) self.assertFalse(self.filesystem.isreserved("COM1")) self.assertFalse(self.filesystem.isreserved("nul.txt")) @unittest.skipIf(sys.version_info < (3, 13), "Introduced in Python 3.13") @unittest.skipIf(not TestCase.is_windows, "Windows specific behavior") def test_is_reserved_windows(self): self.assertFalse(self.filesystem.isreserved("!dev")) self.assertFalse(self.filesystem.isreserved("!")) self.assertTrue(self.filesystem.isreserved("COM1")) self.assertTrue(self.filesystem.isreserved("nul.txt")) class PathManipulationTestBase(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="\|") class CollapsePathPipeSeparatorTest(PathManipulationTestBase): """Tests CollapsePath (mimics os.path.normpath) using \| as path separator.""" def test_empty_path_becomes_dot_path(self): self.assertEqual(".", self.filesystem.normpath("")) def test_dot_path_unchanged(self): self.assertEqual(".", self.filesystem.normpath(".")) def test_slashes_are_not_collapsed(self): """Tests that '/' is not treated specially if the path separator is '\|'. In particular, multiple slashes should not be collapsed. """ self.assertEqual("/", self.filesystem.normpath("/")) self.assertEqual("/////", self.filesystem.normpath("/////")) def test_root_path(self): self.assertEqual("\|", self.filesystem.normpath("\|")) def test_multiple_separators_collapsed_into_root_path(self): self.assertEqual("\|", self.filesystem.normpath("\|\|\|\|\|")) def test_all_dot_paths_removed_but_one(self): self.assertEqual(".", self.filesystem.normpath(".\|.\|.\|.")) def test_all_dot_paths_removed_if_another_path_component_exists(self): self.assertEqual("\|", self.filesystem.normpath("\|.\|.\|.\|")) self.assertEqual("foo\|bar", self.filesystem.normpath("foo\|.\|.\|.\|bar")) def test_ignores_up_level_references_starting_from_root(self): self.assertEqual("\|", self.filesystem.normpath("\|..\|..\|..\|")) self.assertEqual("\|", self.filesystem.normpath("\|..\|..\|foo\|bar\|..\|..\|")) self.filesystem.is_windows_fs = False # not an UNC path self.assertEqual("\|", self.filesystem.normpath("\|\|..\|.\|..\|\|")) def test_conserves_up_level_references_starting_from_current_dir(self): self.assertEqual("..\|..", self.filesystem.normpath("..\|foo\|bar\|..\|..\|..")) def test_combine_dot_and_up_level_references_in_absolute_path(self): self.assertEqual("\|yes", self.filesystem.normpath("\|\|\|\|\|.\|..\|\|\|yes\|no\|..\|.\|\|\|")) def test_dots_in_path_collapses_to_last_path(self): self.assertEqual("bar", self.filesystem.normpath("foo\|..\|bar")) self.assertEqual("bar", self.filesystem.normpath("foo\|..\|yes\|..\|no\|..\|bar")) class SplitPathTest(PathManipulationTestBase): """Tests SplitPath (which mimics os.path.split) using \| as path separator.""" def test_empty_path(self): self.assertEqual(("", ""), self.filesystem.splitpath("")) def test_no_separators(self): self.assertEqual(("", "ab"), self.filesystem.splitpath("ab")) def test_slashes_do_not_split(self): """Tests that '/' is not treated specially if the path separator is '\|'.""" self.assertEqual(("", "a/b"), self.filesystem.splitpath("a/b")) def test_eliminate_trailing_separators_from_head(self): self.assertEqual(("a", "b"), self.filesystem.splitpath("a\|b")) self.assertEqual(("a", "b"), self.filesystem.splitpath("a\|\|\|b")) self.assertEqual(("\|a", "b"), self.filesystem.splitpath("\|a\|\|b")) self.assertEqual(("a\|b", "c"), self.filesystem.splitpath("a\|b\|c")) self.assertEqual(("\|a\|b", "c"), self.filesystem.splitpath("\|a\|b\|c")) def test_root_separator_is_not_stripped(self): self.assertEqual(("\|\|\|", ""), self.filesystem.splitpath("\|\|\|")) self.assertEqual(("\|", "a"), self.filesystem.splitpath("\|a")) self.assertEqual(("\|\|\|", "a"), self.filesystem.splitpath("\|\|\|a")) def test_empty_tail_if_path_ends_in_separator(self): self.assertEqual(("a\|b", ""), self.filesystem.splitpath("a\|b\|")) def test_empty_path_components_are_preserved_in_head(self): self.assertEqual(("\|a\|\|b", "c"), self.filesystem.splitpath("\|a\|\|b\|\|c")) class JoinPathTest(PathManipulationTestBase): """Tests JoinPath (which mimics os.path.join) using \| as path separator.""" def test_one_empty_component(self): self.assertEqual("", self.filesystem.joinpaths("")) def test_multiple_empty_components(self): self.assertEqual("", self.filesystem.joinpaths("", "", "")) def test_separators_not_stripped_from_single_component(self): self.assertEqual("\|\|a\|\|", self.filesystem.joinpaths("\|\|a\|\|")) def test_one_separator_added_between_components(self): self.assertEqual("a\|b\|c\|d", self.filesystem.joinpaths("a", "b", "c", "d")) def test_no_separator_added_for_components_ending_in_separator(self): self.assertEqual("a\|b\|c", self.filesystem.joinpaths("a\|", "b\|", "c")) self.assertEqual("a\|\|\|b\|\|\|c", self.filesystem.joinpaths("a\|\|\|", "b\|\|\|", "c")) def test_components_preceding_absolute_component_are_ignored(self): self.assertEqual("\|c\|d", self.filesystem.joinpaths("a", "\|b", "\|c", "d")) def test_one_separator_added_for_trailing_empty_components(self): self.assertEqual("a\|", self.filesystem.joinpaths("a", "")) self.assertEqual("a\|", self.filesystem.joinpaths("a", "", "")) def test_no_separator_added_for_leading_empty_components(self): self.assertEqual("a", self.filesystem.joinpaths("", "a")) def test_internal_empty_components_ignored(self): self.assertEqual("a\|b", self.filesystem.joinpaths("a", "", "b")) self.assertEqual("a\|b\|", self.filesystem.joinpaths("a\|", "", "b\|")) class PathSeparatorTest(TestCase): def test_os_path_sep_matches_fake_filesystem_separator(self): filesystem = fake_filesystem.FakeFilesystem(path_separator="!") fake_os_module = fake_os.FakeOsModule(filesystem) self.assertEqual("!", fake_os_module.sep) self.assertEqual("!", fake_os_module.path.sep) class NormalizeCaseTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.filesystem.is_case_sensitive = False def test_normalize_case(self): self.filesystem.create_file("/Foo/Bar") self.assertEqual( f"{self.filesystem.root_dir_name}Foo/Bar", self.filesystem._original_path("/foo/bar"), ) self.assertEqual( f"{self.filesystem.root_dir_name}Foo/Bar", self.filesystem._original_path("/FOO/BAR"), ) def test_normalize_case_for_drive(self): self.filesystem.is_windows_fs = True self.filesystem.create_file("C:/Foo/Bar") self.assertEqual("C:/Foo/Bar", self.filesystem._original_path("c:/foo/bar")) self.assertEqual("C:/Foo/Bar", self.filesystem._original_path("C:/FOO/BAR")) def test_normalize_case_for_non_existing_file(self): self.filesystem.create_dir("/Foo/Bar") self.assertEqual( f"{self.filesystem.root_dir_name}Foo/Bar/baz", self.filesystem._original_path("/foo/bar/baz"), ) self.assertEqual( f"{self.filesystem.root_dir_name}Foo/Bar/BAZ", self.filesystem._original_path("/FOO/BAR/BAZ"), ) @unittest.skipIf( not TestCase.is_windows, "Regression test for Windows problem only" ) def test_normalize_case_for_lazily_added_empty_file(self): # regression test for specific issue with added empty real files filesystem = fake_filesystem.FakeFilesystem() real_dir_path = os.path.split(os.path.dirname(os.path.abspath(__file__)))[0] filesystem.add_real_directory(real_dir_path) initPyPath = os.path.join(real_dir_path, "__init__.py") self.assertEqual(initPyPath, filesystem._original_path(initPyPath.upper())) class AlternativePathSeparatorTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="!") self.filesystem.alternative_path_separator = "?" def test_initial_value(self): filesystem = fake_filesystem.FakeFilesystem() if self.is_windows: self.assertEqual("/", filesystem.alternative_path_separator) else: self.assertIsNone(filesystem.alternative_path_separator) filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.assertIsNone(filesystem.alternative_path_separator) def test_alt_sep(self): fake_os_module = fake_os.FakeOsModule(self.filesystem) self.assertEqual("?", fake_os_module.altsep) self.assertEqual("?", fake_os_module.path.altsep) def test_collapse_path_with_mixed_separators(self): self.assertEqual("!foo!bar", self.filesystem.normpath("!foo??bar")) def test_normalize_path_with_mixed_separators(self): path = "foo?..?bar" self.assertEqual( f"{self.filesystem.root_dir_name}bar", self.filesystem.absnormpath(path), ) def test_exists_with_mixed_separators(self): self.filesystem.create_file("?foo?bar?baz") self.filesystem.create_file("!foo!bar!xyzzy!plugh") self.assertTrue(self.filesystem.exists("!foo!bar!baz")) self.assertTrue(self.filesystem.exists("?foo?bar?xyzzy?plugh")) class DriveLetterSupportTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="!") self.filesystem.alternative_path_separator = "^" self.filesystem.is_windows_fs = True def test_initial_value(self): filesystem = fake_filesystem.FakeFilesystem() if self.is_windows: self.assertTrue(filesystem.is_windows_fs) else: self.assertFalse(filesystem.is_windows_fs) def test_collapse_path(self): self.assertEqual("c:!foo!bar", self.filesystem.normpath("c:!!foo!!bar")) def test_collapse_unc_path(self): self.assertEqual("!!foo!bar!baz", self.filesystem.normpath("!!foo!bar!!baz!!")) def test_normalize_path_str(self): self.filesystem.cwd = "" self.assertEqual("c:!foo!bar", self.filesystem.absnormpath("c:!foo!!bar")) self.filesystem.cwd = "c:!foo" self.assertEqual("c:!foo!bar", self.filesystem.absnormpath("bar")) def test_normalize_path_bytes(self): self.filesystem.cwd = b"" self.assertEqual(b"c:!foo!bar", self.filesystem.absnormpath(b"c:!foo!!bar")) self.filesystem.cwd = b"c:!foo" self.assertEqual(b"c:!foo!bar", self.filesystem.absnormpath(b"bar")) def test_split_path_str(self): self.assertEqual(("c:!foo", "bar"), self.filesystem.splitpath("c:!foo!bar")) self.assertEqual(("c:!", "foo"), self.filesystem.splitpath("c:!foo")) self.assertEqual(("!foo", "bar"), self.filesystem.splitpath("!foo!bar")) self.assertEqual(("!", "foo"), self.filesystem.splitpath("!foo")) self.assertEqual(("c:foo", "bar"), self.filesystem.splitpath("c:foo!bar")) self.assertEqual(("c:", "foo"), self.filesystem.splitpath("c:foo")) self.assertEqual(("foo", "bar"), self.filesystem.splitpath("foo!bar")) def test_split_with_alt_separator(self): self.assertEqual(("a^b", "c"), self.filesystem.splitpath("a^b^c")) self.assertEqual(("a^b!c", "d"), self.filesystem.splitpath("a^b!c^d")) self.assertEqual(("a^b!c", "d"), self.filesystem.splitpath("a^b!c!d")) self.assertEqual((b"a^b", b"c"), self.filesystem.splitpath(b"a^b^c")) self.assertEqual((b"a^b!c", b"d"), self.filesystem.splitpath(b"a^b!c^d")) self.assertEqual((b"a^b!c", b"d"), self.filesystem.splitpath(b"a^b!c!d")) def test_split_path_bytes(self): self.assertEqual((b"c:!foo", b"bar"), self.filesystem.splitpath(b"c:!foo!bar")) self.assertEqual((b"c:!", b"foo"), self.filesystem.splitpath(b"c:!foo")) self.assertEqual((b"!foo", b"bar"), self.filesystem.splitpath(b"!foo!bar")) self.assertEqual((b"!", b"foo"), self.filesystem.splitpath(b"!foo")) self.assertEqual((b"c:foo", b"bar"), self.filesystem.splitpath(b"c:foo!bar")) self.assertEqual((b"c:", b"foo"), self.filesystem.splitpath(b"c:foo")) self.assertEqual((b"foo", b"bar"), self.filesystem.splitpath(b"foo!bar")) def test_characters_before_root_ignored_in_join_paths(self): self.assertEqual("c:d", self.filesystem.joinpaths("b", "c:", "d")) def test_resolve_path(self): self.assertEqual("C:!foo!bar", self.filesystem.resolve_path("C:!foo!bar")) def test_get_path_components(self): self.assertEqual( ["c:", "foo", "bar"], self.filesystem._path_components("c:!foo!bar"), ) self.assertEqual(["c:"], self.filesystem._path_components("c:")) def test_split_drive_str(self): self.assertEqual(("c:", "!foo!bar"), self.filesystem.splitdrive("c:!foo!bar")) self.assertEqual(("", "!foo!bar"), self.filesystem.splitdrive("!foo!bar")) self.assertEqual(("c:", "foo!bar"), self.filesystem.splitdrive("c:foo!bar")) self.assertEqual(("", "foo!bar"), self.filesystem.splitdrive("foo!bar")) def test_split_drive_bytes(self): self.assertEqual( (b"c:", b"!foo!bar"), self.filesystem.splitdrive(b"c:!foo!bar") ) self.assertEqual((b"", b"!foo!bar"), self.filesystem.splitdrive(b"!foo!bar")) def test_split_drive_alt_sep(self): self.assertEqual(("c:", "^foo^bar"), self.filesystem.splitdrive("c:^foo^bar")) self.assertEqual(("", "foo^bar"), self.filesystem.splitdrive("foo^bar")) self.assertEqual(("", "foo^bar!baz"), self.filesystem.splitdrive("foo^bar!baz")) self.assertEqual( (b"c:", b"^foo^bar"), self.filesystem.splitdrive(b"c:^foo^bar") ) self.assertEqual((b"", b"^foo^bar"), self.filesystem.splitdrive(b"^foo^bar")) self.assertEqual( (b"", b"^foo^bar!baz"), self.filesystem.splitdrive(b"^foo^bar!baz") ) def test_split_drive_with_unc_path(self): self.assertEqual( ("!!foo!bar", "!baz"), self.filesystem.splitdrive("!!foo!bar!baz") ) self.assertEqual(("", "!!foo"), self.filesystem.splitdrive("!!foo")) self.assertEqual(("", "!!foo!!bar"), self.filesystem.splitdrive("!!foo!!bar")) self.assertEqual(("!!foo!bar", "!!"), self.filesystem.splitdrive("!!foo!bar!!")) def test_split_drive_with_unc_path_alt_sep(self): self.assertEqual( ("^^foo^bar", "!baz"), self.filesystem.splitdrive("^^foo^bar!baz") ) self.assertEqual(("", "^^foo"), self.filesystem.splitdrive("^^foo")) self.assertEqual(("", "^^foo^^bar"), self.filesystem.splitdrive("^^foo^^bar")) self.assertEqual(("^^foo^bar", "^^"), self.filesystem.splitdrive("^^foo^bar^^")) def test_split_path_with_drive(self): self.assertEqual(("d:!foo", "baz"), self.filesystem.splitpath("d:!foo!baz")) self.assertEqual(("d:!foo!baz", ""), self.filesystem.splitpath("d:!foo!baz!")) self.assertEqual(("c:", ""), self.filesystem.splitpath("c:")) self.assertEqual(("c:!", ""), self.filesystem.splitpath("c:!")) self.assertEqual(("c:!!", ""), self.filesystem.splitpath("c:!!")) def test_split_path_with_drive_alt_sep(self): self.assertEqual(("d:^foo", "baz"), self.filesystem.splitpath("d:^foo^baz")) self.assertEqual(("d:^foo^baz", ""), self.filesystem.splitpath("d:^foo^baz^")) self.assertEqual(("c:", ""), self.filesystem.splitpath("c:")) self.assertEqual(("c:^", ""), self.filesystem.splitpath("c:^")) self.assertEqual(("c:^^", ""), self.filesystem.splitpath("c:^^")) def test_split_path_with_unc_path(self): self.assertEqual( ("!!foo!bar!", "baz"), self.filesystem.splitpath("!!foo!bar!baz") ) self.assertEqual(("!!foo!bar", ""), self.filesystem.splitpath("!!foo!bar")) self.assertEqual(("!!foo!bar!!", ""), self.filesystem.splitpath("!!foo!bar!!")) def test_split_path_with_unc_path_alt_sep(self): self.assertEqual( ("^^foo^bar^", "baz"), self.filesystem.splitpath("^^foo^bar^baz") ) self.assertEqual(("^^foo^bar", ""), self.filesystem.splitpath("^^foo^bar")) self.assertEqual(("^^foo^bar^^", ""), self.filesystem.splitpath("^^foo^bar^^")) def test_splitroot_with_drive(self): self.assertEqual( ("E:", "!", "foo!bar"), self.filesystem.splitroot("E:!foo!bar") ) self.assertEqual( ("E:", "!", "!foo!!!bar"), self.filesystem.splitroot("E:!!foo!!!bar") ) self.assertEqual( (b"E:", b"!", b"!foo!!!bar"), self.filesystem.splitroot(b"E:!!foo!!!bar") ) self.assertEqual( ("C:", "^", "foo^bar"), self.filesystem.splitroot("C:^foo^bar") ) def test_splitroot_with_unc_path(self): self.assertEqual( ("!!foo!bar", "!", "baz"), self.filesystem.splitroot("!!foo!bar!baz") ) self.assertEqual( ("!!?!UNC", "!", "foo!bar"), self.filesystem.splitroot("!!?!UNC!foo!bar") ) self.assertEqual( ("^^foo^bar", "^", "baz"), self.filesystem.splitroot("^^foo^bar^baz") ) self.assertEqual( (b"!!foo!bar", b"!", b"baz"), self.filesystem.splitroot(b"!!foo!bar!baz") ) def test_splitroot_with_empty_parts(self): self.assertEqual(("", "", ""), self.filesystem.splitroot("")) self.assertEqual(("", "!", "foo"), self.filesystem.splitroot("!foo")) self.assertEqual(("!!foo!bar", "", ""), self.filesystem.splitroot("!!foo!bar")) self.assertEqual(("!!foo", "", ""), self.filesystem.splitroot("!!foo")) self.assertEqual( ("!!foo!bar", "!", ""), self.filesystem.splitroot("!!foo!bar!") ) self.assertEqual(("C:", "", "foo!bar"), self.filesystem.splitroot("C:foo!bar")) class DiskSpaceTest(TestCase): def setUp(self): self.fs = fake_filesystem.FakeFilesystem(path_separator="!", total_size=100) self.os = fake_os.FakeOsModule(self.fs) self.open = fake_open.FakeFileOpen(self.fs) def test_disk_usage_on_file_creation(self): total_size = 100 self.fs.add_mount_point("!mount", total_size) def create_too_large_file(): with self.open("!mount!file", "w", encoding="utf8") as dest: dest.write("a" * (total_size + 1)) with self.assertRaises(OSError): create_too_large_file() self.assertEqual(0, self.fs.get_disk_usage("!mount").used) with self.open("!mount!file", "w", encoding="utf8") as dest: dest.write("a" * total_size) self.assertEqual(total_size, self.fs.get_disk_usage("!mount").used) def test_disk_usage_on_automounted_drive(self): self.fs.is_windows_fs = True self.fs.reset(total_size=100) self.fs.create_file("!foo!bar", st_size=50) self.assertEqual(0, self.fs.get_disk_usage("D:!").used) self.fs.cwd = "E:!foo" self.assertEqual(0, self.fs.get_disk_usage("!foo").used) def test_disk_usage_on_mounted_paths(self): self.fs.add_mount_point("!foo", total_size=200) self.fs.add_mount_point("!foo!bar", total_size=400) self.fs.create_file("!baz", st_size=50) self.fs.create_file("!foo!baz", st_size=60) self.fs.create_file("!foo!bar!baz", st_size=100) self.assertEqual(50, self.fs.get_disk_usage("!").used) self.assertEqual(60, self.fs.get_disk_usage("!foo").used) self.assertEqual(100, self.fs.get_disk_usage("!foo!bar").used) self.assertEqual(400, self.fs.get_disk_usage("!foo!bar").total) def test_file_system_size_after_large_file_creation(self): filesystem = fake_filesystem.FakeFilesystem( path_separator="!", total_size=1024 * 1024 * 1024 * 100 ) filesystem.create_file("!foo!baz", st_size=1024 * 1024 * 1024 * 10) self.assertEqual( ( 1024 * 1024 * 1024 * 100, 1024 * 1024 * 1024 * 10, 1024 * 1024 * 1024 * 90, ), filesystem.get_disk_usage(), ) def test_file_system_size_after_binary_file_creation(self): self.fs.create_file("!foo!bar", contents=b"xyzzy") self.assertEqual((100, 5, 95), self.fs.get_disk_usage()) def test_file_system_size_after_ascii_string_file_creation(self): self.fs.create_file("!foo!bar", contents="complicated") self.assertEqual((100, 11, 89), self.fs.get_disk_usage()) def test_filesystem_size_after_2byte_unicode_file_creation(self): self.fs.create_file("!foo!bar", contents="сложно", encoding="utf-8") self.assertEqual((100, 12, 88), self.fs.get_disk_usage()) def test_filesystem_size_after_3byte_unicode_file_creation(self): self.fs.create_file("!foo!bar", contents="複雑", encoding="utf-8") self.assertEqual((100, 6, 94), self.fs.get_disk_usage()) def test_file_system_size_after_file_deletion(self): self.fs.create_file("!foo!bar", contents=b"xyzzy") self.fs.create_file("!foo!baz", st_size=20) self.fs.remove_object("!foo!bar") self.assertEqual((100, 20, 80), self.fs.get_disk_usage()) def test_file_system_size_after_directory_removal(self): self.fs.create_file("!foo!bar", st_size=10) self.fs.create_file("!foo!baz", st_size=20) self.fs.create_file("!foo1!bar", st_size=40) self.fs.remove_object("!foo") self.assertEqual((100, 40, 60), self.fs.get_disk_usage()) def test_creating_file_with_fitting_content(self): initial_usage = self.fs.get_disk_usage() try: self.fs.create_file("!foo!bar", contents=b"a" * 100) except OSError: self.fail( "File with contents fitting into disk space could not be written." ) self.assertEqual(initial_usage.used + 100, self.fs.get_disk_usage().used) def test_creating_file_with_content_too_large(self): def create_large_file(): self.fs.create_file("!foo!bar", contents=b"a" * 101) initial_usage = self.fs.get_disk_usage() with self.assertRaises(OSError): create_large_file() self.assertEqual(initial_usage, self.fs.get_disk_usage()) def test_creating_file_with_fitting_size(self): initial_usage = self.fs.get_disk_usage() try: self.fs.create_file("!foo!bar", st_size=100) except OSError: self.fail("File with size fitting into disk space could not be written.") self.assertEqual(initial_usage.used + 100, self.fs.get_disk_usage().used) def test_creating_file_with_size_too_large(self): initial_usage = self.fs.get_disk_usage() def create_large_file(): self.fs.create_file("!foo!bar", st_size=101) with self.assertRaises(OSError): create_large_file() self.assertEqual(initial_usage, self.fs.get_disk_usage()) def test_resize_file_with_fitting_size(self): file_object = self.fs.create_file("!foo!bar", st_size=50) try: file_object.set_large_file_size(100) file_object.set_contents(b"a" * 100) except OSError: self.fail("Resizing file failed although disk space was sufficient.") def test_resize_file_with_size_too_large(self): file_object = self.fs.create_file("!foo!bar", st_size=50) with self.raises_os_error(errno.ENOSPC): file_object.set_large_file_size(200) with self.raises_os_error(errno.ENOSPC): file_object.set_contents("a" * 150) def test_file_system_size_after_directory_rename(self): self.fs.create_file("!foo!bar", st_size=20) self.os.rename("!foo", "!baz") self.assertEqual(20, self.fs.get_disk_usage().used) def test_file_system_size_after_file_rename(self): self.fs.create_file("!foo!bar", st_size=20) self.os.rename("!foo!bar", "!foo!baz") self.assertEqual(20, self.fs.get_disk_usage().used) def test_that_hard_link_does_not_change_used_size(self): file1_path = "test_file1" file2_path = "test_file2" self.fs.create_file(file1_path, st_size=20) self.assertEqual(20, self.fs.get_disk_usage().used) # creating a hard link shall not increase used space self.os.link(file1_path, file2_path) self.assertEqual(20, self.fs.get_disk_usage().used) # removing a file shall not decrease used space # if a hard link still exists self.os.unlink(file1_path) self.assertEqual(20, self.fs.get_disk_usage().used) self.os.unlink(file2_path) self.assertEqual(0, self.fs.get_disk_usage().used) def test_that_the_size_of_correct_mount_point_is_used(self): self.fs.add_mount_point("!mount_limited", total_size=50) self.fs.add_mount_point("!mount_unlimited") with self.raises_os_error(errno.ENOSPC): self.fs.create_file("!mount_limited!foo", st_size=60) with self.raises_os_error(errno.ENOSPC): self.fs.create_file("!bar", st_size=110) try: self.fs.create_file("!foo", st_size=60) self.fs.create_file("!mount_limited!foo", st_size=40) self.fs.create_file("!mount_unlimited!foo", st_size=1000000) except OSError: self.fail( "File with contents fitting into disk space could not be written." ) def test_that_disk_usage_of_correct_mount_point_is_used(self): self.fs.add_mount_point("!mount1", total_size=20) self.fs.add_mount_point("!mount1!bar!mount2", total_size=50) self.fs.create_file("!foo!bar", st_size=10) self.fs.create_file("!mount1!foo!bar", st_size=10) self.fs.create_file("!mount1!bar!mount2!foo!bar", st_size=10) self.assertEqual(90, self.fs.get_disk_usage("!foo").free) self.assertEqual(10, self.fs.get_disk_usage("!mount1!foo").free) self.assertEqual(40, self.fs.get_disk_usage("!mount1!bar!mount2").free) def test_set_larger_disk_size(self): self.fs.add_mount_point("!mount1", total_size=20) with self.raises_os_error(errno.ENOSPC): self.fs.create_file("!mount1!foo", st_size=100) self.fs.set_disk_usage(total_size=200, path="!mount1") self.fs.create_file("!mount1!foo", st_size=100) self.assertEqual(100, self.fs.get_disk_usage("!mount1!foo").free) def test_set_smaller_disk_size(self): self.fs.add_mount_point("!mount1", total_size=200) self.fs.create_file("!mount1!foo", st_size=100) with self.raises_os_error(errno.ENOSPC): self.fs.set_disk_usage(total_size=50, path="!mount1") self.fs.set_disk_usage(total_size=150, path="!mount1") self.assertEqual(50, self.fs.get_disk_usage("!mount1!foo").free) def test_disk_size_on_unlimited_disk(self): self.fs.add_mount_point("!mount1") self.fs.create_file("!mount1!foo", st_size=100) self.fs.set_disk_usage(total_size=1000, path="!mount1") self.assertEqual(900, self.fs.get_disk_usage("!mount1!foo").free) def test_disk_size_on_auto_mounted_drive_on_file_creation(self): self.fs.is_windows_fs = True # 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.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) self.fs.set_disk_usage(total_size=1000, path="d:") self.assertEqual(800, self.fs.get_disk_usage("d:!foo").free) def test_copying_preserves_byte_contents(self): source_file = self.fs.create_file("foo", contents=b"somebytes") dest_file = self.fs.create_file("bar") dest_file.set_contents(source_file.contents) self.assertEqual(dest_file.contents, source_file.contents) def test_diskusage_after_open_write(self): with self.open("bar.txt", "w", encoding="utf8") as f: f.write("a" * 60) f.flush() self.assertEqual(60, self.fs.get_disk_usage()[1]) def test_disk_full_after_reopened(self): with self.open("bar.txt", "w", encoding="utf8") as f: f.write("a" * 60) with self.open("bar.txt", encoding="utf8") as f: self.assertEqual("a" * 60, f.read()) with self.raises_os_error(errno.ENOSPC): with self.open("bar.txt", "w", encoding="utf8") as f: f.write("b" * 110) with self.raises_os_error(errno.ENOSPC): f.flush() with self.open("bar.txt", encoding="utf8") as f: self.assertEqual("", f.read()) def test_disk_full_append(self): file_path = "bar.txt" with self.open(file_path, "w", encoding="utf8") as f: f.write("a" * 60) with self.open(file_path, encoding="utf8") as f: self.assertEqual("a" * 60, f.read()) with self.raises_os_error(errno.ENOSPC): with self.open(file_path, "a", encoding="utf8") as f: f.write("b" * 41) with self.raises_os_error(errno.ENOSPC): f.flush() with self.open("bar.txt", encoding="utf8") as f: self.assertEqual(f.read(), "a" * 60) def test_disk_full_after_reopened_rplus_seek(self): with self.open("bar.txt", "w", encoding="utf8") as f: f.write("a" * 60) with self.open("bar.txt", encoding="utf8") as f: self.assertEqual(f.read(), "a" * 60) with self.raises_os_error(errno.ENOSPC): with self.open("bar.txt", "r+", encoding="utf8") as f: f.seek(50) f.write("b" * 60) with self.raises_os_error(errno.ENOSPC): f.flush() with self.open("bar.txt", encoding="utf8") as f: self.assertEqual(f.read(), "a" * 60) class MountPointTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem( path_separator="!", total_size=100 ) 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.add_mount_points() self.filesystem.create_dir("d:!foo!bar") self.filesystem.create_file("d:!foo!baz") self.filesystem.create_file("z:!foo!baz") self.assertEqual(5, self.filesystem.get_object("d:").st_dev) self.assertEqual(5, self.filesystem.get_object("d:!foo!bar").st_dev) self.assertEqual(5, self.filesystem.get_object("d:!foo!baz").st_dev) self.assertEqual(6, self.filesystem.get_object("z:!foo!baz").st_dev) def test_that_drives_are_auto_mounted_case_insensitive(self): self.filesystem.is_windows_fs = True self.add_mount_points() self.filesystem.is_case_sensitive = False self.filesystem.create_dir("D:!foo!bar") self.filesystem.create_file("e:!foo!baz") self.assertEqual(5, self.filesystem.get_object("D:").st_dev) self.assertEqual(5, self.filesystem.get_object("d:!foo!bar").st_dev) self.assertEqual(6, self.filesystem.get_object("e:!foo").st_dev) self.assertEqual(6, self.filesystem.get_object("E:!Foo!Baz").st_dev) def test_that_unc_paths_are_auto_mounted(self): self.filesystem.is_windows_fs = True self.add_mount_points() self.filesystem.create_dir("!!foo!bar!baz") self.filesystem.create_file("!!foo!bar!bip!bop") self.assertEqual(5, self.filesystem.get_object("!!foo!bar").st_dev) self.assertEqual(5, self.filesystem.get_object("!!foo!bar!bip!bop").st_dev) class ConvenienceMethodTest(RealFsTestCase): def test_create_link_with_non_existent_parent(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") link_path = self.make_path("nonexistent", "test_file2") self.filesystem.create_file(file1_path, contents="link test") self.assertEqual(self.os.stat(file1_path).st_nlink, 1) self.filesystem.create_link(file1_path, link_path) self.assertEqual(self.os.stat(file1_path).st_nlink, 2) self.assertTrue(self.filesystem.exists(link_path)) def test_create_symlink_with_non_existent_parent(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") link_path = self.make_path("nonexistent", "test_file2") self.filesystem.create_file(file1_path, contents="symlink test") self.filesystem.create_symlink(link_path, file1_path) self.assertTrue(self.filesystem.exists(link_path)) self.assertTrue(self.filesystem.islink(link_path)) class RealFileSystemAccessTest(RealFsTestCase): def setUp(self): # use the real path separator to work with the real file system self.filesystem = fake_filesystem.FakeFilesystem() self.fake_open = fake_filesystem.FakeFileOpen(self.filesystem) self.pyfakefs_path = os.path.split(os.path.dirname(os.path.abspath(__file__)))[ 0 ] self.root_path = os.path.split(self.pyfakefs_path)[0] def test_add_non_existing_real_file_raises(self): nonexisting_path = os.path.join("nonexisting", "test.txt") with self.assertRaises(OSError): self.filesystem.add_real_file(nonexisting_path) self.assertFalse(self.filesystem.exists(nonexisting_path)) def test_add_non_existing_real_directory_raises(self): nonexisting_path = "/nonexisting" with self.raises_os_error(errno.ENOENT): self.filesystem.add_real_directory(nonexisting_path) self.assertFalse(self.filesystem.exists(nonexisting_path)) def test_existing_fake_file_raises(self): real_file_path = __file__ self.filesystem.create_file(real_file_path) with self.raises_os_error(errno.EEXIST): self.filesystem.add_real_file(real_file_path) @contextlib.contextmanager def create_real_paths(self): temp_directory = tempfile.mkdtemp() real_dir_root = os.path.join(temp_directory, "root") try: for dir_name in ("foo", "bar"): real_dir = os.path.join(real_dir_root, dir_name) os.makedirs(real_dir, exist_ok=True) with open( os.path.join(real_dir, "test.txt"), "w", encoding="utf8" ) as f: f.write("test") sub_dir = os.path.join(real_dir, "sub") os.makedirs(sub_dir, exist_ok=True) with open(os.path.join(sub_dir, "sub.txt"), "w", encoding="utf8") as f: f.write("sub") yield real_dir_root finally: shutil.rmtree(temp_directory, ignore_errors=True) def test_existing_fake_directory_is_merged_lazily(self): self.filesystem.create_file(os.path.join("/", "root", "foo", "test1.txt")) self.filesystem.create_dir(os.path.join("root", "baz")) with self.create_real_paths() as root_dir: self.filesystem.add_real_directory(root_dir, target_path="/root") self.assertTrue( self.filesystem.exists(os.path.join("root", "foo", "test.txt")) ) self.assertTrue( self.filesystem.exists(os.path.join("root", "foo", "test1.txt")) ) self.assertTrue( self.filesystem.exists(os.path.join("root", "bar", "sub", "sub.txt")) ) self.assertTrue(self.filesystem.exists(os.path.join("root", "baz"))) def test_existing_fake_directory_is_merged(self): self.filesystem.create_file(os.path.join("/", "root", "foo", "test1.txt")) self.filesystem.create_dir(os.path.join("root", "baz")) with self.create_real_paths() as root_dir: self.filesystem.add_real_directory( root_dir, target_path="/root", lazy_read=False ) self.assertTrue( self.filesystem.exists(os.path.join("root", "foo", "test.txt")) ) self.assertTrue( self.filesystem.exists(os.path.join("root", "foo", "test1.txt")) ) self.assertTrue( self.filesystem.exists(os.path.join("root", "bar", "sub", "sub.txt")) ) self.assertTrue(self.filesystem.exists(os.path.join("root", "baz"))) def test_fake_files_cannot_be_overwritten(self): self.filesystem.create_file(os.path.join("/", "root", "foo", "test.txt")) with self.create_real_paths() as root_dir: with self.raises_os_error(errno.EEXIST): self.filesystem.add_real_directory(root_dir, target_path="/root") def test_cannot_overwrite_file_with_dir(self): self.filesystem.create_file(os.path.join("/", "root", "foo")) with self.create_real_paths() as root_dir: with self.raises_os_error(errno.ENOTDIR): self.filesystem.add_real_directory(root_dir, target_path="/root/") def test_cannot_overwrite_symlink_with_dir(self): self.filesystem.create_symlink( os.path.join("/", "root", "foo"), os.path.join("/", "root", "link") ) with self.create_real_paths() as root_dir: with self.raises_os_error(errno.EEXIST): self.filesystem.add_real_directory(root_dir, target_path="/root/") def test_symlink_is_merged(self): skip_if_symlink_not_supported() self.filesystem.create_dir(os.path.join("/", "root", "foo")) with self.create_real_paths() as root_dir: link_path = os.path.join(root_dir, "link.txt") target_path = os.path.join("foo", "sub", "sub.txt") os.symlink(target_path, link_path) self.filesystem.add_real_directory(root_dir, target_path="/root") fake_link_path = os.path.join("/", "root", "link.txt") self.assertTrue(self.filesystem.exists(fake_link_path)) self.assertTrue(self.filesystem.islink(fake_link_path)) def check_fake_file_stat(self, fake_file, real_file_path, target_path=None): if target_path is None or target_path == real_file_path: self.assertTrue(self.filesystem.exists(real_file_path)) else: self.assertFalse(self.filesystem.exists(real_file_path)) self.assertTrue(self.filesystem.exists(target_path)) real_stat = os.stat(real_file_path) self.assertIsNone(fake_file._byte_contents) self.assertEqual(fake_file.st_size, real_stat.st_size) self.assertAlmostEqual(fake_file.st_ctime, real_stat.st_ctime, places=5) self.assertAlmostEqual(fake_file.st_atime, real_stat.st_atime, places=5) self.assertAlmostEqual(fake_file.st_mtime, real_stat.st_mtime, places=5) self.assertEqual(fake_file.st_uid, real_stat.st_uid) self.assertEqual(fake_file.st_gid, real_stat.st_gid) def check_read_only_file(self, fake_file, real_file_path): with open(real_file_path, "rb") as f: real_contents = f.read() self.assertEqual(fake_file.byte_contents, real_contents) if not is_root(): with self.raises_os_error(errno.EACCES): self.fake_open(real_file_path, "w") else: with self.fake_open(real_file_path, "w"): pass def check_writable_file(self, fake_file, real_file_path): with open(real_file_path, "rb") as f: real_contents = f.read() self.assertEqual(fake_file.byte_contents, real_contents) with self.fake_open(real_file_path, "wb") as f: f.write(b"test") with open(real_file_path, "rb") as f: real_contents1 = f.read() self.assertEqual(real_contents1, real_contents) with self.fake_open(real_file_path, "rb") as f: fake_contents = f.read() self.assertEqual(fake_contents, b"test") def test_add_existing_real_file_read_only(self): real_file_path = os.path.abspath(__file__) fake_file = self.filesystem.add_real_file(real_file_path) self.check_fake_file_stat(fake_file, real_file_path) self.assertEqual(fake_file.st_mode & 0o333, 0) self.check_read_only_file(fake_file, real_file_path) def test_add_existing_real_file_read_write(self): real_file_path = os.path.realpath(__file__) fake_file = self.filesystem.add_real_file(real_file_path, read_only=False) self.check_fake_file_stat(fake_file, real_file_path) self.assertEqual(fake_file.st_mode, os.stat(real_file_path).st_mode) self.check_writable_file(fake_file, real_file_path) def test_add_real_file_to_existing_path(self): real_file_path = os.path.abspath(__file__) self.filesystem.create_file("/foo/bar") with self.raises_os_error(errno.EEXIST): self.filesystem.add_real_file(real_file_path, target_path="/foo/bar") def test_add_real_file_to_non_existing_path(self): real_file_path = os.path.abspath(__file__) fake_file = self.filesystem.add_real_file( real_file_path, target_path="/foo/bar" ) self.check_fake_file_stat(fake_file, real_file_path, target_path="/foo/bar") def test_write_to_real_file(self): # regression test for #470 real_file_path = os.path.abspath(__file__) self.filesystem.add_real_file(real_file_path, read_only=False) with self.fake_open(real_file_path, "w", encoding="utf8") as f: f.write("foo") with self.fake_open(real_file_path, "rb") as f: self.assertEqual(b"foo", f.read()) def test_add_existing_real_directory_read_only(self): self.filesystem.add_real_directory(self.pyfakefs_path) self.assertTrue(self.filesystem.exists(self.pyfakefs_path)) self.assertTrue( self.filesystem.exists( os.path.join(self.pyfakefs_path, "fake_filesystem.py") ) ) self.assertTrue( self.filesystem.exists(os.path.join(self.pyfakefs_path, "fake_pathlib.py")) ) file_path = os.path.join(self.pyfakefs_path, "fake_filesystem_shutil.py") fake_file = self.filesystem.resolve(file_path) self.check_fake_file_stat(fake_file, file_path) self.check_read_only_file(fake_file, file_path) def test_add_existing_real_directory_tree(self): self.filesystem.add_real_directory(self.root_path) self.assertTrue( self.filesystem.exists( os.path.join( self.root_path, "pyfakefs", "tests", "fake_filesystem_test.py", ) ) ) self.assertTrue( self.filesystem.exists( os.path.join(self.root_path, "pyfakefs", "fake_filesystem.py") ) ) self.assertTrue( self.filesystem.exists( os.path.join(self.root_path, "pyfakefs", "__init__.py") ) ) @contextlib.contextmanager def create_symlinks(self, symlinks): for link in symlinks: os.symlink(link[0], link[1]) try: yield finally: for link in symlinks: os.unlink(link[1]) @staticmethod def _setup_temp_directory(): real_directory = tempfile.mkdtemp() os.mkdir(os.path.join(real_directory, "fixtures")) with open(os.path.join(real_directory, "all_tests.py"), "w", encoding="utf8"): pass return real_directory def test_add_existing_real_directory_symlink(self): fake_open = fake_filesystem.FakeFileOpen(self.filesystem) real_directory = self._setup_temp_directory() symlinks = [ ( "..", os.path.join(real_directory, "fixtures", "symlink_dir_relative"), ), ( "../all_tests.py", os.path.join(real_directory, "fixtures", "symlink_file_relative"), ), ( real_directory, os.path.join(real_directory, "fixtures", "symlink_dir_absolute"), ), ( os.path.join(real_directory, "all_tests.py"), os.path.join(real_directory, "fixtures", "symlink_file_absolute"), ), ( "/etc/something", os.path.join( real_directory, "fixtures", "symlink_file_absolute_outside" ), ), ] self.filesystem.create_file("/etc/something") with fake_open("/etc/something", "w", encoding="utf8") as f: f.write("good morning") try: with self.create_symlinks(symlinks): self.filesystem.add_real_directory(real_directory, lazy_read=False) except OSError: if self.is_windows: raise unittest.SkipTest("Symlinks under Windows need admin privileges") raise for link in symlinks: self.assertTrue(self.filesystem.islink(link[1])) # relative self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_dir_relative", ) ) ) self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_dir_relative/all_tests.py", ) ) ) self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_file_relative", ) ) ) # absolute self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_dir_absolute", ) ) ) self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_dir_absolute/all_tests.py", ) ) ) self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_file_absolute", ) ) ) # outside self.assertTrue( self.filesystem.exists( os.path.join( real_directory, "fixtures/symlink_file_absolute_outside", ) ) ) self.assertEqual( fake_open( os.path.join( real_directory, "fixtures/symlink_file_absolute_outside", ), encoding="utf8", ).read(), "good morning", ) def test_add_existing_real_directory_symlink_target_path(self): skip_if_symlink_not_supported() real_directory = self._setup_temp_directory() symlinks = [ ( "..", os.path.join(real_directory, "fixtures", "symlink_dir_relative"), ), ( "../all_tests.py", os.path.join(real_directory, "fixtures", "symlink_file_relative"), ), ] with self.create_symlinks(symlinks): self.filesystem.add_real_directory( real_directory, target_path="/path", lazy_read=False ) self.assertTrue(self.filesystem.exists("/path/fixtures/symlink_dir_relative")) self.assertTrue( self.filesystem.exists("/path/fixtures/symlink_dir_relative/all_tests.py") ) self.assertTrue(self.filesystem.exists("/path/fixtures/symlink_file_relative")) def test_add_existing_real_directory_symlink_lazy_read(self): skip_if_symlink_not_supported() real_directory = self._setup_temp_directory() symlinks = [ ( "..", os.path.join(real_directory, "fixtures", "symlink_dir_relative"), ), ( "../all_tests.py", os.path.join(real_directory, "fixtures", "symlink_file_relative"), ), ] with self.create_symlinks(symlinks): self.filesystem.add_real_directory( real_directory, target_path="/path", lazy_read=True ) self.assertTrue( self.filesystem.exists("/path/fixtures/symlink_dir_relative") ) self.assertTrue( self.filesystem.exists( "/path/fixtures/symlink_dir_relative/all_tests.py" ) ) self.assertTrue( self.filesystem.exists("/path/fixtures/symlink_file_relative") ) def test_add_existing_real_directory_tree_to_other_path(self): self.filesystem.add_real_directory(self.root_path, target_path="/foo/bar") self.assertFalse( self.filesystem.exists( os.path.join(self.pyfakefs_path, "tests", "fake_filesystem_test.py") ) ) self.assertTrue( self.filesystem.exists( os.path.join( "foo", "bar", "pyfakefs", "tests", "fake_filesystem_test.py", ) ) ) self.assertFalse( self.filesystem.exists( os.path.join(self.root_path, "pyfakefs", "fake_filesystem.py") ) ) self.assertTrue( self.filesystem.exists( os.path.join("foo", "bar", "pyfakefs", "__init__.py") ) ) def test_get_object_from_lazily_added_real_directory(self): self.filesystem.is_case_sensitive = True self.filesystem.add_real_directory(self.root_path) self.assertTrue( self.filesystem.get_object( os.path.join(self.root_path, "pyfakefs", "fake_filesystem.py") ) ) self.assertTrue( self.filesystem.get_object( os.path.join(self.root_path, "pyfakefs", "__init__.py") ) ) def test_add_existing_real_directory_lazily(self): disk_size = 1024 * 1024 * 1024 real_dir_path = os.path.join(self.root_path, "pyfakefs") self.filesystem.set_disk_usage(disk_size, real_dir_path) self.filesystem.add_real_directory(real_dir_path) # the directory contents have not been read, the disk usage # has not changed self.assertEqual(disk_size, self.filesystem.get_disk_usage(real_dir_path).free) # checking for existence shall read the directory contents self.assertTrue( self.filesystem.get_object( os.path.join(real_dir_path, "fake_filesystem.py") ) ) # so now the free disk space shall have decreased self.assertGreater( disk_size, self.filesystem.get_disk_usage(real_dir_path).free ) def test_add_existing_real_directory_not_lazily(self): disk_size = 1024 * 1024 * 1024 self.filesystem.set_disk_usage(disk_size, self.pyfakefs_path) self.filesystem.add_real_directory(self.pyfakefs_path, lazy_read=False) # the directory has been read, so the file sizes have # been subtracted from the free space self.assertGreater( disk_size, self.filesystem.get_disk_usage(self.pyfakefs_path).free ) def test_add_existing_real_directory_read_write(self): self.filesystem.add_real_directory(self.pyfakefs_path, read_only=False) self.assertTrue(self.filesystem.exists(self.pyfakefs_path)) self.assertTrue( self.filesystem.exists( os.path.join(self.pyfakefs_path, "fake_filesystem.py") ) ) self.assertTrue( self.filesystem.exists(os.path.join(self.pyfakefs_path, "fake_pathlib.py")) ) file_path = os.path.join(self.pyfakefs_path, "pytest_plugin.py") fake_file = self.filesystem.resolve(file_path) self.check_fake_file_stat(fake_file, file_path) self.check_writable_file(fake_file, file_path) def test_add_existing_real_paths_read_only(self): real_file_path = os.path.realpath(__file__) fixture_path = os.path.join(self.pyfakefs_path, "tests", "fixtures") self.filesystem.add_real_paths([real_file_path, fixture_path]) fake_file = self.filesystem.resolve(real_file_path) self.check_fake_file_stat(fake_file, real_file_path) self.check_read_only_file(fake_file, real_file_path) real_file_path = os.path.join(fixture_path, "module_with_attributes.py") fake_file = self.filesystem.resolve(real_file_path) self.check_fake_file_stat(fake_file, real_file_path) self.check_read_only_file(fake_file, real_file_path) def test_add_existing_real_paths_read_write(self): real_file_path = os.path.realpath(__file__) fixture_path = os.path.join(self.pyfakefs_path, "tests", "fixtures") self.filesystem.add_real_paths([real_file_path, fixture_path], read_only=False) fake_file = self.filesystem.resolve(real_file_path) self.check_fake_file_stat(fake_file, real_file_path) self.check_writable_file(fake_file, real_file_path) real_file_path = os.path.join(fixture_path, "module_with_attributes.py") fake_file = self.filesystem.resolve(real_file_path) self.check_fake_file_stat(fake_file, real_file_path) self.check_writable_file(fake_file, real_file_path) @unittest.skipIf(pytest is None, "pytest is not installed") @unittest.skipIf(sys.version_info < (3, 8), "importlib.metadata not available") @unittest.skipIf("pathlib2" in sys.modules, "pathlib2 may break this test") def test_add_package_metadata(self): parent_path = pathlib.Path(pytest.__file__).parent.parent pytest_dist_path = parent_path / f"pytest-{pytest.__version__}.dist-info" assert pytest_dist_path.exists() # real fs assert not self.filesystem.exists(pytest_dist_path) self.filesystem.add_package_metadata("pytest") assert self.filesystem.exists(pytest_dist_path) assert self.filesystem.exists(pytest_dist_path / "METADATA") class FileSideEffectTests(TestCase): def side_effect(self): test_case = self test_case.side_effect_called = False def __side_effect(file_object): test_case.side_effect_called = True test_case.side_effect_file_object_content = file_object.contents return __side_effect def setUp(self): # use the real path separator to work with the real file system self.filesystem = fake_filesystem.FakeFilesystem() self.filesystem.create_file("/a/b/file_one", side_effect=self.side_effect()) def test_side_effect_called(self): fake_open = fake_filesystem.FakeFileOpen(self.filesystem) self.side_effect_called = False with fake_open("/a/b/file_one", "w", encoding="utf8") as handle: handle.write("foo") self.assertTrue(self.side_effect_called) def test_side_effect_file_object(self): fake_open = fake_filesystem.FakeFileOpen(self.filesystem) self.side_effect_called = False with fake_open("/a/b/file_one", "w", encoding="utf8") as handle: handle.write("foo") self.assertEqual(self.side_effect_file_object_content, "foo") if __name__ == "__main__": unittest.main()	110.66 KB	2026-01-20 12:58
📄 fake_filesystem_unittest_test.py # Copyright 2014 Altera Corporation. All Rights Reserved. # Copyright 2015-2017 John McGehee # Author: John McGehee # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Test the :py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class. """ import glob import importlib.util import io import multiprocessing import os import pathlib import runpy import shutil import sys import tempfile import unittest import warnings from contextlib import redirect_stdout from io import StringIO from pathlib import Path from unittest import TestCase, mock import pyfakefs.tests.import_as_example import pyfakefs.tests.logsio from pyfakefs import fake_filesystem_unittest, fake_filesystem from pyfakefs.fake_filesystem import OSType from pyfakefs.fake_filesystem_unittest import ( Patcher, Pause, patchfs, PatchMode, ) from pyfakefs.tests.fixtures import module_with_attributes if sys.version_info < (3, 12): # distutils removed in Python 3.12 from distutils.dir_util import copy_tree, remove_tree # Work around pyupgrade auto-rewriting `io.open()` to `open()`. io_open = io.open class TestPatcher(TestCase): def test_context_manager(self): with Patcher() as patcher: patcher.fs.create_file("/foo/bar", contents="test") with open("/foo/bar", encoding="utf8") as f: contents = f.read() self.assertEqual("test", contents) @patchfs def test_context_decorator(self, fake_fs): fake_fs.create_file("/foo/bar", contents="test") with open("/foo/bar", encoding="utf8") as f: contents = f.read() self.assertEqual("test", contents) def test_nested_invocation(self): with Patcher() as patcher: patcher.fs.create_file("/foo/bar", contents="test") self.assertTrue(patcher.fs.exists("/foo/bar")) with Patcher() as patcher1: self.assertTrue(patcher1.fs.exists("/foo/bar")) patcher1.fs.create_file("/foo/baz", contents="test") self.assertTrue(patcher1.fs.exists("/foo/baz")) self.assertTrue(patcher.fs.exists("/foo/baz")) def test_nested_invocation_with_args(self): with Patcher() as patcher: patcher.fs.create_file("/foo/bar", contents="test") with self.assertWarnsRegex( UserWarning, "Nested fake filesystem invocation using custom arguments" ): with Patcher(allow_root_user=False): pass class TestPatchfsArgumentOrder(TestCase): @patchfs @mock.patch("os.system") def test_argument_order1(self, fake_fs, patched_system): fake_fs.create_file("/foo/bar", contents="test") with open("/foo/bar", encoding="utf8") as f: contents = f.read() self.assertEqual("test", contents) os.system("foo") patched_system.assert_called_with("foo") @mock.patch("os.system") @patchfs def test_argument_order2(self, patched_system, fake_fs): fake_fs.create_file("/foo/bar", contents="test") with open("/foo/bar", encoding="utf8") as f: contents = f.read() self.assertEqual("test", contents) os.system("foo") patched_system.assert_called_with("foo") class TestPyfakefsUnittestBase(fake_filesystem_unittest.TestCase): def setUp(self): """Set up the fake file system""" self.setUpPyfakefs() class TestPyfakefsUnittest(TestPyfakefsUnittestBase): # pylint: disable=R0904 """Test the `pyfakefs.fake_filesystem_unittest.TestCase` base class.""" def test_open(self): """Fake `open()` function is bound""" self.assertFalse(os.path.exists("/fake_file.txt")) with open("/fake_file.txt", "w", encoding="utf8") as f: f.write("This test file was created using the open() function.\n") self.assertTrue(self.fs.exists("/fake_file.txt")) with open("/fake_file.txt", encoding="utf8") as f: content = f.read() self.assertEqual( "This test file was created using the open() function.\n", content, ) def test_io_open(self): """Fake io module is bound""" self.assertFalse(os.path.exists("/fake_file.txt")) with io_open("/fake_file.txt", "w", encoding="utf8") as f: f.write("This test file was created using the io.open() function.\n") self.assertTrue(self.fs.exists("/fake_file.txt")) with open("/fake_file.txt", encoding="utf8") as f: content = f.read() self.assertEqual( "This test file was created using the io.open() function.\n", content, ) def test_os(self): """Fake os module is bound""" self.assertFalse(self.fs.exists("/test/dir1/dir2")) os.makedirs("/test/dir1/dir2") self.assertTrue(self.fs.exists("/test/dir1/dir2")) def test_glob(self): """Fake glob module is bound""" is_windows = sys.platform.startswith("win") self.assertEqual([], glob.glob("/test/dir1/dir")) self.fs.create_dir("/test/dir1/dir2a") matching_paths = glob.glob("/test/dir1/dir") if is_windows: self.assertEqual([r"/test/dir1\dir2a"], matching_paths) else: self.assertEqual(["/test/dir1/dir2a"], matching_paths) self.fs.create_dir("/test/dir1/dir2b") matching_paths = sorted(glob.glob("/test/dir1/dir*")) if is_windows: self.assertEqual([r"/test/dir1\dir2a", r"/test/dir1\dir2b"], matching_paths) else: self.assertEqual(["/test/dir1/dir2a", "/test/dir1/dir2b"], matching_paths) def test_shutil(self): """Fake shutil module is bound""" self.fs.create_dir("/test/dir1/dir2a") self.fs.create_dir("/test/dir1/dir2b") self.assertTrue(self.fs.exists("/test/dir1/dir2b")) self.assertTrue(self.fs.exists("/test/dir1/dir2a")) shutil.rmtree("/test/dir1") self.assertFalse(self.fs.exists("/test/dir1")) def test_fakepathlib(self): p = pathlib.Path("/fake_file.txt") with p.open("w", encoding="utf8") as f: f.write("text") is_windows = sys.platform.startswith("win") if is_windows: self.assertTrue(self.fs.exists(r"\fake_file.txt")) else: self.assertTrue(self.fs.exists("/fake_file.txt")) class TestPatchingImports(TestPyfakefsUnittestBase): def test_import_as_other_name(self): file_path = "/foo/bar/baz" self.fs.create_file(file_path) self.assertTrue(self.fs.exists(file_path)) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1(file_path)) def test_import_path_from_os(self): """Make sure `from os import path` patches `path`.""" file_path = "/foo/bar/baz" self.fs.create_file(file_path) self.assertTrue(self.fs.exists(file_path)) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2(file_path)) def test_import_path_from_pathlib(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3(file_path)) def test_import_exists_from_os_path(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5(file_path)) def test_import_isfile_from_os_path(self): file_path = "/foo/bar" self.fs.create_file(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_isfile(file_path)) def test_import_isdir_from_os_path(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_isdir(file_path)) def test_import_islink_from_os_path(self): file_path = "/foo/bar" link_path = "/foo/link" self.fs.create_file(file_path) self.fs.create_symlink(link_path, file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_islink(link_path)) def test_import_function_from_os_path_as_other_name(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6(file_path)) def test_import_pathlib_path(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7(file_path)) def test_import_function_from_os(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"abc") stat_result = pyfakefs.tests.import_as_example.file_stat1(file_path) self.assertEqual(3, stat_result.st_size) def test_import_function_from_os_as_other_name(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"abc") stat_result = pyfakefs.tests.import_as_example.file_stat2(file_path) self.assertEqual(3, stat_result.st_size) def test_import_open_as_other_name(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"abc") contents = pyfakefs.tests.import_as_example.file_contents1(file_path) self.assertEqual("abc", contents) def test_import_io_open_as_other_name(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"abc") contents = pyfakefs.tests.import_as_example.file_contents2(file_path) self.assertEqual("abc", contents) class TestPatchingDefaultArgs(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs(patch_default_args=True) def test_path_exists_as_default_arg_in_function(self): file_path = "/foo/bar" self.fs.create_dir(file_path) self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4(file_path)) def test_path_exists_as_default_arg_in_method(self): file_path = "/foo/bar" self.fs.create_dir(file_path) sut = pyfakefs.tests.import_as_example.TestDefaultArg() self.assertTrue(sut.check_if_exists(file_path)) def test_fake_path_exists4(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4("foo")) class TestAttributesWithFakeModuleNames(TestPyfakefsUnittestBase): """Test that module attributes with names like `path` or `io` are not stubbed out. """ def test_attributes(self): """Attributes of module under test are not patched""" self.assertEqual(module_with_attributes.os, "os attribute value") self.assertEqual(module_with_attributes.path, "path attribute value") self.assertEqual(module_with_attributes.pathlib, "pathlib attribute value") self.assertEqual(module_with_attributes.shutil, "shutil attribute value") self.assertEqual(module_with_attributes.io, "io attribute value") import math as path # noqa: E402 wanted import not at top class TestPathNotPatchedIfNotOsPath(TestPyfakefsUnittestBase): """Tests that `path` is not patched if it is not `os.path`. An own path module (in this case an alias to math) can be imported and used. """ def test_own_path_module(self): self.assertEqual(2, path.floor(2.5)) class FailedPatchingTest(TestPyfakefsUnittestBase): """Negative tests: make sure the tests for `modules_to_reload` and `modules_to_patch` fail if not providing the arguments. """ @unittest.expectedFailure def test_system_stat(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"test") self.assertEqual( 4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size ) class ReloadModuleTest(fake_filesystem_unittest.TestCase): """Make sure that reloading a module allows patching of classes not patched automatically. """ def setUp(self): """Set up the fake file system""" self.setUpPyfakefs(modules_to_reload=[pyfakefs.tests.import_as_example]) class NoSkipNamesTest(fake_filesystem_unittest.TestCase): """Reference test for additional_skip_names tests: make sure that the module is patched by default.""" def setUp(self): self.setUpPyfakefs() def test_path_exists(self): self.assertFalse(pyfakefs.tests.import_as_example.exists_this_file()) def test_fake_path_exists1(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1("foo")) def test_fake_path_exists2(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2("foo")) def test_fake_path_exists3(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3("foo")) def test_fake_path_exists5(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5("foo")) def test_fake_path_exists6(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6("foo")) def test_fake_path_exists7(self): self.fs.create_file("foo") self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7("foo")) def test_open_fails(self): with self.assertRaises(OSError): pyfakefs.tests.import_as_example.open_this_file() def test_open_patched_in_module_ending_with_io(self): # regression test for #569 file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"abc") contents = pyfakefs.tests.logsio.file_contents(file_path) self.assertEqual(b"abc", contents) class AdditionalSkipNamesTest(fake_filesystem_unittest.TestCase): """Make sure that modules in additional_skip_names are not patched. Passes module name to `additional_skip_names`.""" def setUp(self): self.setUpPyfakefs(additional_skip_names=["pyfakefs.tests.import_as_example"]) def test_path_exists(self): self.assertTrue(pyfakefs.tests.import_as_example.exists_this_file()) def test_fake_path_does_not_exist1(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists1("foo")) def test_fake_path_does_not_exist2(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists2("foo")) def test_fake_path_does_not_exist3(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists3("foo")) def test_fake_path_does_not_exist4(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists4("foo")) def test_fake_path_does_not_exist5(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists5("foo")) def test_fake_path_does_not_exist6(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists6("foo")) def test_fake_path_does_not_exist7(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists7("foo")) def test_open_succeeds(self): pyfakefs.tests.import_as_example.open_this_file() def test_path_succeeds(self): pyfakefs.tests.import_as_example.return_this_file_path() class AdditionalSkipNamesModuleTest(fake_filesystem_unittest.TestCase): """Make sure that modules in additional_skip_names are not patched. Passes module to `additional_skip_names`.""" def setUp(self): self.setUpPyfakefs(additional_skip_names=[pyfakefs.tests.import_as_example]) def test_path_exists(self): self.assertTrue(pyfakefs.tests.import_as_example.exists_this_file()) def test_fake_path_does_not_exist1(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists1("foo")) def test_fake_path_does_not_exist2(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists2("foo")) def test_fake_path_does_not_exist3(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists3("foo")) def test_fake_path_does_not_exist4(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists4("foo")) def test_fake_path_does_not_exist5(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists5("foo")) def test_fake_path_does_not_exist6(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists6("foo")) def test_fake_path_does_not_exist7(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists7("foo")) def test_open_succeeds(self): pyfakefs.tests.import_as_example.open_this_file() def test_path_succeeds(self): pyfakefs.tests.import_as_example.return_this_file_path() class RuntimeSkipModuleTest(fake_filesystem_unittest.TestCase): """Emulates skipping a module using RUNTIME_SKIPMODULES. Not all functionality implemented for skip modules will work here.""" def setUp(self): Patcher.RUNTIME_SKIPMODULES.update( {"pyfakefs.tests.import_as_example": ["pyfakefs.tests.import_"]} ) self.setUpPyfakefs() def tearDown(self): del self.patcher.RUNTIME_SKIPMODULES["pyfakefs.tests.import_as_example"] def test_fake_path_does_not_exist1(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists1("foo")) def test_fake_path_does_not_exist2(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists2("foo")) def test_fake_path_does_not_exist3(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists3("foo")) def test_fake_path_does_not_exist4(self): self.fs.create_file("foo") self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists4("foo")) class FakeExampleModule: """Used to patch a function that uses system-specific functions that cannot be patched automatically.""" _orig_module = pyfakefs.tests.import_as_example def __init__(self, fs): pass def system_stat(self, filepath): return os.stat(filepath) def __getattr__(self, name): """Forwards any non-faked calls to the standard module.""" return getattr(self._orig_module, name) class PatchModuleTest(fake_filesystem_unittest.TestCase): """Make sure that reloading a module allows patching of classes not patched automatically. """ def setUp(self): """Set up the fake file system""" self.setUpPyfakefs( modules_to_patch={"pyfakefs.tests.import_as_example": FakeExampleModule} ) def test_system_stat(self): file_path = "/foo/bar" self.fs.create_file(file_path, contents=b"test") self.assertEqual( 4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size ) class PatchModuleTestUsingDecorator(unittest.TestCase): """Make sure that reloading a module allows patching of classes not patched automatically - use patchfs decorator with parameter. """ @patchfs @unittest.expectedFailure def test_system_stat_failing(self, fake_fs): file_path = "/foo/bar" fake_fs.create_file(file_path, contents=b"test") self.assertEqual( 4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size ) @patchfs(modules_to_patch={"pyfakefs.tests.import_as_example": FakeExampleModule}) def test_system_stat(self, fake_fs): file_path = "/foo/bar" fake_fs.create_file(file_path, contents=b"test") self.assertEqual( 4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size ) class NoRootUserTest(fake_filesystem_unittest.TestCase): """Test allow_root_user argument to setUpPyfakefs.""" def setUp(self): self.setUpPyfakefs(allow_root_user=False) def test_non_root_behavior(self): """Check that fs behaves as non-root user regardless of actual user rights. """ self.fs.is_windows_fs = False dir_path = "/foo/bar" self.fs.create_dir(dir_path, perm_bits=0o555) file_path = dir_path + "baz" with self.assertRaises(OSError): self.fs.create_file(file_path) file_path = "/baz" self.fs.create_file(file_path) os.chmod(file_path, 0o400) with self.assertRaises(OSError): open(file_path, "w", encoding="utf8") class PauseResumeTest(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs() def test_pause_resume(self): fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) self.pause() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(self.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) self.resume() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) self.pause() real_temp_file.close() self.resume() def test_pause_resume_fs(self): fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) # resume does nothing if not paused self.fs.resume() self.assertTrue(os.path.exists(fake_temp_file.name)) self.fs.pause() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(self.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) # pause does nothing if already paused self.fs.pause() self.assertFalse(self.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) self.fs.resume() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) self.fs.pause() real_temp_file.close() self.fs.resume() def test_pause_resume_contextmanager(self): fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) with Pause(self): self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(self.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) real_temp_file.close() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) def test_pause_resume_fs_contextmanager(self): fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) with Pause(self.fs): self.assertTrue(self.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(self.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) real_temp_file.close() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) def test_pause_resume_without_patcher(self): fs = fake_filesystem.FakeFilesystem() with self.assertRaises(RuntimeError): fs.resume() def test_that_tempfile_is_patched_after_resume(fs): """Regression test for #1098""" fs.pause() fs.resume() with tempfile.NamedTemporaryFile(): pass class PauseResumePatcherTest(fake_filesystem_unittest.TestCase): def test_pause_resume(self): with Patcher() as p: fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(p.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) p.pause() self.assertTrue(p.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(p.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) p.resume() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) fake_temp_file.close() p.pause() real_temp_file.close() p.resume() def test_pause_resume_contextmanager(self): with Patcher() as p: fake_temp_file = tempfile.NamedTemporaryFile() self.assertTrue(p.fs.exists(fake_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) with Pause(p): self.assertTrue(p.fs.exists(fake_temp_file.name)) self.assertFalse(os.path.exists(fake_temp_file.name)) real_temp_file = tempfile.NamedTemporaryFile() self.assertFalse(p.fs.exists(real_temp_file.name)) self.assertTrue(os.path.exists(real_temp_file.name)) real_temp_file.close() self.assertFalse(os.path.exists(real_temp_file.name)) self.assertTrue(os.path.exists(fake_temp_file.name)) fake_temp_file.close() class TestPyfakefsTestCase(unittest.TestCase): def setUp(self): class TestTestCase(fake_filesystem_unittest.TestCase): def runTest(self): pass self.test_case = TestTestCase("runTest") def test_test_case_type(self): self.assertIsInstance(self.test_case, unittest.TestCase) self.assertIsInstance(self.test_case, fake_filesystem_unittest.TestCaseMixin) class TestTempDirCreation(fake_filesystem_unittest.TestCase): """Test that the temp directory exists at test start.""" def setUp(self): self.setUpPyfakefs() def test_tempdir_exists(self): self.assertTrue(os.path.exists(tempfile.gettempdir())) @unittest.skipIf(sys.platform == "win32", "POSIX only test") def test_tmp_exists(self): # directory or link under Linux, link under macOS self.assertTrue(os.path.exists("/tmp")) class TestTempFileReload(unittest.TestCase): """Regression test for #356 to make sure that reloading the tempfile does not affect other tests.""" def test_fakefs(self): with Patcher() as patcher: patcher.fs.create_file("/mytempfile", contents="abcd") def test_value(self): v = multiprocessing.Value("I", 0) self.assertEqual(v.value, 0) class TestPyfakefsTestCaseMixin( unittest.TestCase, fake_filesystem_unittest.TestCaseMixin ): def test_set_up_pyfakefs(self): self.setUpPyfakefs() self.assertTrue(hasattr(self, "fs")) self.assertIsInstance(self.fs, fake_filesystem.FakeFilesystem) class TestShutilWithZipfile(fake_filesystem_unittest.TestCase): """Regression test for #427.""" def setUp(self): self.setUpPyfakefs() self.fs.create_file("foo/bar") def test_a(self): shutil.make_archive("archive", "zip", root_dir="foo") def test_b(self): # used to fail because 'bar' could not be found shutil.make_archive("archive", "zip", root_dir="foo") if sys.version_info < (3, 12): class TestDistutilsCopyTree(fake_filesystem_unittest.TestCase): """Regression test for #501.""" def setUp(self): self.setUpPyfakefs() self.fs.create_dir("./test/subdir/") self.fs.create_dir("./test/subdir2/") self.fs.create_file("./test2/subdir/1.txt") def test_file_copied(self): copy_tree("./test2/", "./test/") remove_tree("./test2/") self.assertTrue(os.path.isfile("./test/subdir/1.txt")) self.assertFalse(os.path.isdir("./test2/")) def test_file_copied_again(self): # used to fail because 'test2' could not be found self.assertTrue(os.path.isfile("./test2/subdir/1.txt")) copy_tree("./test2/", "./test/") remove_tree("./test2/") self.assertTrue(os.path.isfile("./test/subdir/1.txt")) self.assertFalse(os.path.isdir("./test2/")) class PathlibTest(TestCase): """Regression test for #527""" @patchfs def test_cwd(self, fs): """Make sure fake file system is used for os in pathlib""" is_windows = sys.platform.startswith("win") root_dir = "C:" + os.path.sep if is_windows else os.path.sep self.assertEqual(root_dir, str(pathlib.Path.cwd())) dot_abs = pathlib.Path(".").absolute() self.assertEqual(root_dir, str(dot_abs)) self.assertTrue(dot_abs.exists()) class TestDeprecationSuppression(fake_filesystem_unittest.TestCase): def test_no_deprecation_warning(self): """Ensures that deprecation warnings are suppressed during module lookup, see #542. """ from pyfakefs.tests.fixtures.deprecated_property import ( # noqa: F401 DeprecationTest, ) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("error", DeprecationWarning) self.setUpPyfakefs() self.assertEqual(0, len(w)) def load_configs(configs): """Helper code for patching open_code in auto mode, see issue #554.""" retval = [] for config in configs: if len(config) > 3 and config[-3:] == ".py": retval += runpy.run_path(config) else: retval += runpy.run_module(config) return retval @unittest.skipIf(sys.version_info < (3, 8), "open_code new in Python 3.8") class AutoPatchOpenCodeTestCase(fake_filesystem_unittest.TestCase): """Test patching open_code in auto mode, see issue #554.""" def setUp(self): self.setUpPyfakefs(patch_open_code=PatchMode.AUTO) self.configpy = "configpy.py" self.fs.create_file(self.configpy, contents="configurable_value='yup'") self.config_module = "pyfakefs.tests.fixtures.config_module" def test_both(self): load_configs([self.configpy, self.config_module]) def test_run_path(self): load_configs([self.configpy]) def test_run_module(self): load_configs([self.config_module]) def import_foo(self): spec = importlib.util.spec_from_file_location("bar", "/foo/bar.py") mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) def test_exec_module_in_fake_fs(self): self.fs.create_file("/foo/bar.py", contents="print('hello')") with redirect_stdout(StringIO()) as stdout: self.import_foo() assert stdout.getvalue() == "hello\n" def test_dynamic_import(self): # regression test for #1121 self.fs.create_file("/foo.py") self.fs.create_file("/bar.py", contents="import foo") sys.path.insert(0, "") import foo # noqa class TestOtherFS(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs() @mock.patch.dict(os.environ, {"HOME": "/home/john"}) def test_real_file_with_home(self): """Regression test for #558""" self.fs.is_windows_fs = os.name != "nt" if self.fs.is_windows_fs: self.fs.is_macos = False self.fs.add_real_file(__file__) with open(__file__, encoding="utf8") as f: self.assertTrue(f.read()) home = Path.home() os.chdir(home) with open(__file__, encoding="utf8") as f: self.assertTrue(f.read()) def test_windows(self): self.fs.os = OSType.WINDOWS path = r"C:\foo\bar" self.assertEqual(path, os.path.join("C:\\", "foo", "bar")) self.assertEqual(("C:", r"\foo\bar"), os.path.splitdrive(path)) self.fs.create_file(path) self.assertTrue(os.path.exists(path)) self.assertTrue(os.path.exists(path.upper())) self.assertTrue(os.path.ismount(r"\\share\foo")) self.assertTrue(os.path.ismount(r"C:")) self.assertEqual("\\", os.sep) self.assertEqual("\\", os.path.sep) self.assertEqual("/", os.altsep) self.assertEqual(";", os.pathsep) self.assertEqual("\r\n", os.linesep) self.assertEqual("NUL", os.devnull) def test_linux(self): self.fs.os = OSType.LINUX path = "/foo/bar" self.assertEqual(path, os.path.join("/", "foo", "bar")) self.assertEqual(("", "C:/foo/bar"), os.path.splitdrive("C:/foo/bar")) self.fs.create_file(path) self.assertTrue(os.path.exists(path)) self.assertFalse(os.path.exists(path.upper())) self.assertTrue(os.path.ismount("/")) self.assertFalse(os.path.ismount("//share/foo")) self.assertEqual("/", os.sep) self.assertEqual("/", os.path.sep) self.assertEqual(None, os.altsep) self.assertEqual(":", os.pathsep) self.assertEqual("\n", os.linesep) self.assertEqual("/dev/null", os.devnull) def test_macos(self): self.fs.os = OSType.MACOS path = "/foo/bar" self.assertEqual(path, os.path.join("/", "foo", "bar")) self.assertEqual(("", "C:/foo/bar"), os.path.splitdrive("C:/foo/bar")) self.fs.create_file(path) self.assertTrue(os.path.exists(path)) self.assertTrue(os.path.exists(path.upper())) self.assertTrue(os.path.ismount("/")) self.assertFalse(os.path.ismount("//share/foo")) self.assertEqual("/", os.sep) self.assertEqual("/", os.path.sep) self.assertEqual(None, os.altsep) self.assertEqual(":", os.pathsep) self.assertEqual("\n", os.linesep) self.assertEqual("/dev/null", os.devnull) def test_drivelike_path(self): self.fs.os = OSType.LINUX folder = Path("/test") file_path = folder / "C:/testfile" file_path.parent.mkdir(parents=True) file_path.touch() os.chdir(folder) self.assertTrue(os.path.exists(str(file_path.relative_to(folder)))) @unittest.skipIf(sys.platform != "win32", "Windows-specific test") def test_tempfile_access(self): # regression test for #912 self.fs.os = OSType.LINUX tmp_file = tempfile.TemporaryFile() assert tmp_file @unittest.skipIf(sys.platform != "win32", "Windows-specific behavior") class TestAbsolutePathOnWindows(fake_filesystem_unittest.TestCase): @patchfs def test_is_absolute(self, fs): # regression test for #673 self.assertTrue(pathlib.Path(".").absolute().is_absolute()) @unittest.skipIf(sys.version_info < (3, 8), "Not available before Python 3.8") class TestClassSetup(fake_filesystem_unittest.TestCase): @classmethod def setUpClass(cls): cls.setUpClassPyfakefs() cls.fake_fs().create_file("foo/bar", contents="test") def test_using_fs_functions(self): self.assertTrue(os.path.exists("foo/bar")) with open("foo/bar", encoding="utf8") as f: contents = f.read() self.assertEqual("test", contents) def test_using_fakefs(self): self.assertTrue(self.fs.exists("foo/bar")) f = self.fs.get_object("foo/bar") self.assertEqual("test", f.contents) class TestTempPathCreation(fake_filesystem_unittest.TestCase): """Regression test for #965. Checks that the temp file system is properly created with a root-owned root path. """ def setUp(self): self.setUpPyfakefs() def check_write_tmp_after_reset(self, os_type): self.fs.os = os_type # Mark '/' to be modifiable by only root os.chown("/", 0, 0) os.chmod("/", 0b111_101_101) with tempfile.TemporaryFile("wb") as f: assert f.write(b"foo") == 3 def test_write_tmp_linux(self): self.check_write_tmp_after_reset(OSType.LINUX) def test_write_tmp_macos(self): self.check_write_tmp_after_reset(OSType.MACOS) def test_write_tmp_windows(self): self.check_write_tmp_after_reset(OSType.WINDOWS) @unittest.skipIf(sys.version_info < (3, 8), "Not available before Python 3.8") class FakeImportTest(fake_filesystem_unittest.TestCase): """Checks that a fake module can be imported in AUTO patch mode.""" def setUp(self): self.setUpPyfakefs(patch_open_code=PatchMode.AUTO) def test_simple_fake_import(self): fake_module_path = Path("/") / "site-packages" / "fake_module.py" self.fs.create_file(fake_module_path, contents="number = 42") sys.path.insert(0, str(fake_module_path.parent)) module = importlib.import_module("fake_module") del sys.path[0] assert module.__name__ == "fake_module" assert module.number == 42 def test_fake_import_dotted_module(self): fake_pkg_path = Path("/") / "site-packages" self.fs.create_file(fake_pkg_path / "fakepkg" / "__init__.py") fake_module_path = fake_pkg_path / "fakepkg" / "fake_module.py" self.fs.create_file(fake_module_path, contents="number = 42") sys.path.insert(0, str(fake_pkg_path)) module = importlib.import_module("fakepkg.fake_module") del sys.path[0] assert module.__name__ == "fakepkg.fake_module" assert module.number == 42 def test_fake_relative_import(self): fake_module_path = Path("site-packages") / "fake_module.py" self.fs.create_file(fake_module_path, contents="number = 42") sys.path.insert(0, str(fake_module_path.parent)) module = importlib.import_module("fake_module") del sys.path[0] assert module.__name__ == "fake_module" assert module.number == 42 if __name__ == "__main__": unittest.main()	38.79 KB	2026-01-20 12:58
📄 fake_filesystem_vs_real_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Test that FakeFilesystem calls work identically to a real filesystem.""" # pylint: disable-all import os import shutil import sys import tempfile import time import unittest from pyfakefs import fake_filesystem, fake_os, fake_open from pyfakefs.tests.test_utils import skip_if_symlink_not_supported def sep(path): """Converts slashes in the path to the architecture's path separator.""" if isinstance(path, str): return path.replace("/", os.sep) return path def _get_errno(raised_error): if raised_error is not None: try: return raised_error.errno except AttributeError: pass class FakeFilesystemVsRealTest(unittest.TestCase): is_windows = sys.platform.startswith("win") fake_base = "C:\\fakefs" if is_windows else "/fakefs" def _paths(self, path): """For a given path, return paths in the real and fake filesystems.""" if not path: return None, None return ( os.path.join(self.real_base, path), os.path.join(self.fake_base, path), ) def _create_test_file(self, file_type, path, contents=None): """Create a dir, file, or link in both the real fs and the fake.""" path = sep(path) self._created_files.append([file_type, path, contents]) real_path, fake_path = self._paths(path) if file_type == "d": os.mkdir(real_path) self.fake_os.mkdir(fake_path) if file_type == "f": fh = open(real_path, "w", encoding="utf8") fh.write(contents or "") fh.close() fh = self.fake_open(fake_path, "w", encoding="utf8") fh.write(contents or "") fh.close() # b for binary file if file_type == "b": fh = open(real_path, "wb") fh.write(contents or "") fh.close() fh = self.fake_open(fake_path, "wb") fh.write(contents or "") fh.close() # l for symlink, h for hard link if file_type in ("l", "h"): contents = sep(contents) real_target, fake_target = (contents, contents) # If it begins with '/', make it relative to the base. You can't go # creating files in / for the real file system. if contents.startswith(os.sep): real_target, fake_target = self._paths(contents[1:]) if file_type == "l": os.symlink(real_target, real_path) self.fake_os.symlink(fake_target, fake_path) elif file_type == "h": os.link(real_target, real_path) self.fake_os.link(fake_target, fake_path) def setUp(self): # Base paths in the real and test file systems. We keep them different # so that missing features in the fake don't fall through to the base # operations and magically succeed. tsname = "fakefs.%s" % time.time() self.cwd = os.getcwd() # Fully expand the base_path - required on OS X. self.real_base = os.path.realpath(os.path.join(tempfile.gettempdir(), tsname)) os.chdir(tempfile.gettempdir()) if os.path.isdir(self.real_base): shutil.rmtree(self.real_base) os.mkdir(self.real_base) # Make sure we can write to the physical testing temp directory. self.assertTrue(os.access(self.real_base, os.W_OK)) self.fake_filesystem = fake_filesystem.FakeFilesystem() self.fake_filesystem.create_dir(self.fake_base) self.fake_os = fake_os.FakeOsModule(self.fake_filesystem) self.fake_open = fake_open.FakeFileOpen(self.fake_filesystem) self._created_files = [] os.chdir(self.real_base) self.fake_os.chdir(self.fake_base) def tearDown(self): # We have to remove all the files from the real FS. Doing the same for # the fake FS is optional, but doing it is an extra sanity check. os.chdir(tempfile.gettempdir()) try: rev_files = self._created_files[:] rev_files.reverse() for info in rev_files: real_path, fake_path = self._paths(info[1]) if info[0] == "d": try: os.rmdir(real_path) except OSError as e: if "Directory not empty" in e: self.fail( "Real path %s not empty: %s : %s" % (real_path, e, os.listdir(real_path)) ) else: raise self.fake_os.rmdir(fake_path) if info[0] == "f" or info[0] == "l": os.remove(real_path) self.fake_os.remove(fake_path) finally: shutil.rmtree(self.real_base) os.chdir(self.cwd) def _compare_behaviors( self, method_name, path, real, fake, method_returns_path=False ): """Invoke an os method in both real and fake contexts and compare results. Invoke a real filesystem method with a path to a real file and invoke a fake filesystem method with a path to a fake file and compare the results. We expect some calls to throw Exceptions, so we catch those and compare them. Args: method_name: Name of method being tested, for use in error messages. path: potential path to a file in the real and fake file systems, passing an empty tuple indicates that no arguments to pass to method. real: built-in system library or method from the built-in system library which takes a path as an arg and returns some value. fake: fake_filesystem object or method from a fake_filesystem class which takes a path as an arg and returns some value. method_returns_path: True if the method returns a path, and thus we must compensate for expected difference between real and fake. Returns: A description of the difference in behavior, or None. """ # pylint: disable=C6403 def _error_class(exc): if exc: if hasattr(exc, "errno"): return f"{exc.__class__.__name__}({exc.errno})" return exc.__class__.__name__ return "None" real_err, real_value = self._get_real_value(method_name, path, real) fake_err, fake_value = self._get_fake_value(method_name, path, fake) method_call = f"{method_name}" method_call += "()" if path == () else "({path})" # We only compare on the error class because the actual error contents # is almost always different because of the file paths. if _error_class(real_err) != _error_class(fake_err): if real_err is None: return "{}: real version returned {}, fake raised {}".format( method_call, real_value, _error_class(fake_err), ) if fake_err is None: return "{}: real version raised {}, fake returned {}".format( method_call, _error_class(real_err), fake_value, ) return "{}: real version raised {}, fake raised {}".format( method_call, _error_class(real_err), _error_class(fake_err), ) real_errno = _get_errno(real_err) fake_errno = _get_errno(fake_err) if real_errno != fake_errno: return "{}({}): both raised {}, real errno {}, fake errno {}".format( method_name, path, _error_class(real_err), real_errno, fake_errno, ) # If the method is supposed to return a full path AND both values # begin with the expected full path, then trim it off. if method_returns_path: if ( real_value and fake_value and real_value.startswith(self.real_base) and fake_value.startswith(self.fake_base) ): real_value = real_value[len(self.real_base) :] fake_value = fake_value[len(self.fake_base) :] if real_value != fake_value: return "{}: real return {}, fake returned {}".format( method_call, real_value, fake_value, ) return None @staticmethod def _get_fake_value(method_name, path, fake): fake_value = None fake_err = None try: fake_method = fake if not callable(fake): fake_method = getattr(fake, method_name) args = [] if path == () else [path] result = fake_method(args) if isinstance(result, bytes): fake_value = result.decode() else: fake_value = str(result) except Exception as e: # pylint: disable-msg=W0703 fake_err = e return fake_err, fake_value @staticmethod def _get_real_value(method_name, path, real): real_value = None real_err = None # Catching Exception below gives a lint warning, but it's what we need. try: args = [] if path == () else [path] real_method = real if not callable(real): real_method = getattr(real, method_name) result = real_method(args) if isinstance(result, bytes): real_value = result.decode() else: real_value = str(result) except Exception as e: # pylint: disable-msg=W0703 real_err = e return real_err, real_value def assertOsMethodBehaviorMatches( self, method_name, path, method_returns_path=False ): """Invoke an os method in both real and fake contexts and compare. For a given method name (from the os module) and a path, compare the behavior of the system provided module against the fake_filesystem module. We expect results and/or Exceptions raised to be identical. Args: method_name: Name of method being tested. path: potential path to a file in the real and fake file systems. method_returns_path: True if the method returns a path, and thus we must compensate for expected difference between real and fake. Returns: A description of the difference in behavior, or None. """ path = sep(path) return self._compare_behaviors( method_name, path, os, self.fake_os, method_returns_path ) def diff_open_method_behavior( self, method_name, path, mode, data, method_returns_data=True ): """Invoke an open method in both real and fake contexts and compare. Args: method_name: Name of method being tested. path: potential path to a file in the real and fake file systems. mode: how to open the file. data: any data to pass to the method. method_returns_data: True if a method returns some sort of data. For a given method name (from builtin open) and a path, compare the behavior of the system provided module against the fake_filesystem module. We expect results and/or Exceptions raised to be identical. Returns: A description of the difference in behavior, or None. """ kwargs = {} if "b" not in mode: kwargs["encoding"] = "utf8" with open(path, mode, kwargs) as real_fh: with self.fake_open(path, mode, kwargs) as fake_fh: return self._compare_behaviors( method_name, data, real_fh, fake_fh, method_returns_data ) def diff_os_path_method_behavior( self, method_name, path, method_returns_path=False ): """Invoke an os.path method in both real and fake contexts and compare. For a given method name (from the os.path module) and a path, compare the behavior of the system provided module against the fake_filesystem module. We expect results and/or Exceptions raised to be identical. Args: method_name: Name of method being tested. path: potential path to a file in the real and fake file systems. method_returns_path: True if the method returns a path, and thus we must compensate for expected difference between real and fake. Returns: A description of the difference in behavior, or None. """ return self._compare_behaviors( method_name, path, os.path, self.fake_os.path, method_returns_path ) def assertOsPathMethodBehaviorMatches( self, method_name, path, method_returns_path=False ): """Assert that an os.path behaves the same in both real and fake contexts. Wraps DiffOsPathMethodBehavior, raising AssertionError if any differences are reported. Args: method_name: Name of method being tested. path: potential path to a file in the real and fake file systems. method_returns_path: True if the method returns a path, and thus we must compensate for expected difference between real and fake. Raises: AssertionError if there is any difference in behavior. """ path = sep(path) diff = self.diff_os_path_method_behavior(method_name, path, method_returns_path) if diff: self.fail(diff) def assertAllOsBehaviorsMatch(self, path, excludes=None): excludes = excludes or [] path = sep(path) os_method_names = ["readlink"] os_method_names_no_args = ["getcwd"] os_path_method_names = { "isabs", "isdir", "islink", "lexists", "isfile", "exists", } - set(excludes) wrapped_methods = [ ["access", self._access_real, self._access_fake], [ "stat.size", lambda p: self._stat_result_real(p, "st_size", False), lambda p: self._stat_result_fake(p, "st_size", False), ], [ "stat.mode", lambda p: self._stat_result_real(p, "st_mode"), lambda p: self._stat_result_fake(p, "st_mode"), ], ["lstat.size", self._lstat_size_real, self._lstat_size_fake], ] wrapped_methods = [m for m in wrapped_methods if m[0] not in excludes] differences = [] for method_name in os_method_names: diff = self.assertOsMethodBehaviorMatches(method_name, path) if diff: differences.append(diff) for method_name in os_method_names_no_args: diff = self.assertOsMethodBehaviorMatches( method_name, (), method_returns_path=True ) if diff: differences.append(diff) for method_name in os_path_method_names: diff = self.diff_os_path_method_behavior(method_name, path) if diff: differences.append(diff) for m in wrapped_methods: diff = self._compare_behaviors(m[0], path, m[1], m[2]) if diff: differences.append(diff) if differences: self.fail( "Behaviors do not match for %s:\n %s" % (path, "\n ".join(differences)) ) def assertFileHandleBehaviorsMatch(self, path, mode, data): path = sep(path) write_method_names = ["write", "writelines"] read_method_names = ["read", "readlines"] other_method_names = ["truncate", "flush", "close"] differences = [] for method_name in write_method_names: diff = self.diff_open_method_behavior(method_name, path, mode, data) if diff: differences.append(diff) for method_name in read_method_names + other_method_names: diff = self.diff_open_method_behavior(method_name, path, mode, ()) if diff: differences.append(diff) if differences: self.fail( "Behaviors do not match for %s:\n %s" % (path, "\n ".join(differences)) ) def assertFileHandleOpenBehaviorsMatch(self, args, kwargs): """Compare open() function invocation between real and fake. Runs open(args, *kwargs) on both real and fake. Args: args: args to pass through to open() *kwargs: kwargs to pass through to open(). Returns: None. Raises: AssertionError if underlying open() behavior differs from fake. """ real_err = None fake_err = None try: with open(args, *kwargs): pass except Exception as e: # pylint: disable-msg=W0703 real_err = e try: with self.fake_open(args, **kwargs): pass except Exception as e: # pylint: disable-msg=W0703 fake_err = e # default equal in case one is None and other is not. is_exception_equal = real_err == fake_err if real_err and fake_err: # exception __eq__ doesn't evaluate equal ever, thus manual check. is_exception_equal = ( type(real_err) is type(fake_err) and real_err.args == fake_err.args ) if not is_exception_equal: msg = "Behaviors don't match on open with args {} & kwargs {}.\n".format( args, kwargs, ) real_err_msg = "Real open results in: %s\n" % repr(real_err) fake_err_msg = "Fake open results in: %s\n" % repr(fake_err) self.fail(msg + real_err_msg + fake_err_msg) # Helpers for checks which are not straight method calls. @staticmethod def _access_real(path): return os.access(path, os.R_OK) def _access_fake(self, path): return self.fake_os.access(path, os.R_OK) def _stat_result_real(self, path, prop, support_dir=True): real_path, unused_fake_path = self._paths(path) # fake_filesystem.py does not implement stat().st_size for directories if not support_dir and os.path.isdir(real_path): return None return getattr(os.stat(real_path), prop) def _stat_result_fake(self, path, prop, support_dir=True): _, fake_path = self._paths(path) if not support_dir and self.fake_os.path.isdir(fake_path): return None return getattr(self.fake_os.stat(fake_path), prop) def _lstat_size_real(self, path): real_path, unused_fake_path = self._paths(path) if os.path.isdir(real_path): return None size = os.lstat(real_path).st_size # Account for the difference in the lengths of the absolute paths. if os.path.islink(real_path): if os.readlink(real_path).startswith(os.sep): size -= len(self.real_base) return size def _lstat_size_fake(self, path): unused_real_path, fake_path = self._paths(path) # size = 0 if self.fake_os.path.isdir(fake_path): return None size = self.fake_os.lstat(fake_path).st_size # Account for the difference in the lengths of the absolute paths. if self.fake_os.path.islink(fake_path): if self.fake_os.readlink(fake_path).startswith(os.sep): size -= len(self.fake_base) return size def test_isabs(self): # We do not have to create any files for isabs. self.assertOsPathMethodBehaviorMatches("isabs", None) self.assertOsPathMethodBehaviorMatches("isabs", "") self.assertOsPathMethodBehaviorMatches("isabs", "/") self.assertOsPathMethodBehaviorMatches("isabs", "/a") self.assertOsPathMethodBehaviorMatches("isabs", "a") def test_none_path(self): self.assertAllOsBehaviorsMatch(None) def test_empty_path(self): self.assertAllOsBehaviorsMatch("") def test_root_path(self): self.assertAllOsBehaviorsMatch("/", excludes=["stat.mode"]) def test_non_existent_file(self): self.assertAllOsBehaviorsMatch("foo") def test_empty_file(self): self._create_test_file("f", "aFile") self.assertAllOsBehaviorsMatch("aFile") def test_file_with_contents(self): self._create_test_file("f", "aFile", "some contents") self.assertAllOsBehaviorsMatch("aFile") def test_file_with_binary_contents(self): self._create_test_file("b", "aFile", b"some contents") self.assertAllOsBehaviorsMatch("aFile") def test_sym_link_to_empty_file(self): skip_if_symlink_not_supported() self._create_test_file("f", "aFile") self._create_test_file("l", "link_to_empty", "aFile") self.assertAllOsBehaviorsMatch("link_to_empty") def test_hard_link_to_empty_file(self): skip_if_symlink_not_supported() self._create_test_file("f", "aFile") self._create_test_file("h", "link_to_empty", "aFile") self.assertAllOsBehaviorsMatch("link_to_empty") def test_sym_link_to_real_file(self): skip_if_symlink_not_supported() self._create_test_file("f", "aFile", "some contents") self._create_test_file("l", "link_to_file", "aFile") self.assertAllOsBehaviorsMatch("link_to_file") def test_hard_link_to_real_file(self): skip_if_symlink_not_supported() self._create_test_file("f", "aFile", "some contents") self._create_test_file("h", "link_to_file", "aFile") self.assertAllOsBehaviorsMatch("link_to_file") def test_broken_sym_link(self): skip_if_symlink_not_supported() self._create_test_file("l", "broken_link", "broken") self.assertAllOsBehaviorsMatch("broken_link") def test_file_in_a_folder(self): self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("f", "a/b/file", "contents") self.assertAllOsBehaviorsMatch("a/b/file") def test_absolute_sym_link_to_folder(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("f", "a/b/file", "contents") self._create_test_file("l", "a/link", "/a/b") self.assertAllOsBehaviorsMatch("a/link/file") def test_link_to_folder_after_chdir(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("f", "a/b/file", "contents") self._create_test_file("l", "a/link", "/a/b") real_dir, fake_dir = self._paths("a/b") os.chdir(real_dir) self.fake_os.chdir(fake_dir) self.assertAllOsBehaviorsMatch("file") def test_relative_sym_link_to_folder(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("f", "a/b/file", "contents") self._create_test_file("l", "a/link", "b") self.assertAllOsBehaviorsMatch("a/link/file") def test_sym_link_to_parent(self): skip_if_symlink_not_supported() # Soft links on HFS+ / OS X behave differently. if sys.platform != "darwin": self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("l", "a/b/c", "..") self.assertAllOsBehaviorsMatch("a/b/c") def test_path_through_sym_link_to_parent(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("f", "a/target", "contents") self._create_test_file("d", "a/b") self._create_test_file("l", "a/b/c", "..") self.assertAllOsBehaviorsMatch("a/b/c/target") def test_sym_link_to_sibling_directory(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self._create_test_file("l", "a/b/c", "../sibling_of_b") self.assertAllOsBehaviorsMatch("a/b/c/target") def test_sym_link_to_sibling_directory_non_existent_file(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self._create_test_file("l", "a/b/c", "../sibling_of_b") self.assertAllOsBehaviorsMatch("a/b/c/file_does_not_exist") def test_broken_sym_link_to_sibling_directory(self): skip_if_symlink_not_supported() self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self._create_test_file("l", "a/b/c", "../broken_sibling_of_b") self.assertAllOsBehaviorsMatch("a/b/c/target") def test_relative_path(self): self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self.assertAllOsBehaviorsMatch("a/b/../sibling_of_b/target") def test_broken_relative_path(self): self._create_test_file("d", "a") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self.assertAllOsBehaviorsMatch("a/b/../broken/target") def test_bad_relative_path(self): self._create_test_file("d", "a") self._create_test_file("f", "a/target", "contents") self._create_test_file("d", "a/b") self._create_test_file("d", "a/sibling_of_b") self._create_test_file("f", "a/sibling_of_b/target", "contents") self.assertAllOsBehaviorsMatch("a/b/../broken/../target") def test_getmtime_nonexistent_path(self): self.assertOsPathMethodBehaviorMatches("getmtime", "no/such/path") def test_builtin_open_modes(self): self._create_test_file("f", "read", "some contents") self._create_test_file("f", "write", "some contents") self._create_test_file("f", "append", "some contents") self.assertFileHandleBehaviorsMatch("read", "r", "other contents") self.assertFileHandleBehaviorsMatch("write", "w", "other contents") self.assertFileHandleBehaviorsMatch("append", "a", "other contents") self._create_test_file("f", "readplus", "some contents") self._create_test_file("f", "writeplus", "some contents") self.assertFileHandleBehaviorsMatch("readplus", "r+", "other contents") self.assertFileHandleBehaviorsMatch("writeplus", "w+", "other contents") self._create_test_file("b", "binaryread", b"some contents") self._create_test_file("b", "binarywrite", b"some contents") self._create_test_file("b", "binaryappend", b"some contents") self.assertFileHandleBehaviorsMatch("binaryread", "rb", b"other contents") self.assertFileHandleBehaviorsMatch("binarywrite", "wb", b"other contents") self.assertFileHandleBehaviorsMatch("binaryappend", "ab", b"other contents") self.assertFileHandleBehaviorsMatch("read", "rb", "other contents") self.assertFileHandleBehaviorsMatch("write", "wb", "other contents") self.assertFileHandleBehaviorsMatch("append", "ab", "other contents") # binary cannot have encoding self.assertFileHandleOpenBehaviorsMatch("read", "rb", encoding="enc") self.assertFileHandleOpenBehaviorsMatch("write", mode="wb", encoding="enc") self.assertFileHandleOpenBehaviorsMatch("append", "ab", encoding="enc") # text can have encoding self.assertFileHandleOpenBehaviorsMatch("read", "r", encoding="utf-8") self.assertFileHandleOpenBehaviorsMatch("write", "w", encoding="utf-8") self.assertFileHandleOpenBehaviorsMatch("append", "a", encoding="utf-8") def test_directory_permissions(self): self._create_test_file("d", "a") self._create_test_file("f", "a/write") self._create_test_file("d", "b") self._create_test_file("f", "b/write") self._create_test_file("d", "b/stat_dir") for path, mode in [("b", 0o555), ("b/stat_dir", 0o111)]: real_path, fake_path = self._paths(path) os.chmod(real_path, mode) self.fake_os.chmod(fake_path, mode) try: self.assertFileHandleOpenBehaviorsMatch("a/write", "w", encoding="utf8") self.assertFileHandleOpenBehaviorsMatch("b/write", "w", encoding="utf8") self.assertAllOsBehaviorsMatch("b/stat_dir") finally: for path in ["b", "b/stat_dir"]: real_path, fake_path = self._paths(path) os.chmod(real_path, 0o777) self.fake_os.chmod(fake_path, 0o777) def main(_): unittest.main() if __name__ == "__main__": unittest.main()	29.98 KB	2026-01-20 12:58
📄 fake_legacy_modules_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import unittest from pyfakefs.fake_filesystem_unittest import TestCase from pyfakefs.fake_legacy_modules import FakeScanDirModule, FakePathlib2Module from pyfakefs.legacy_packages import pathlib2, scandir from pyfakefs.tests.fake_os_test import FakeScandirTest from pyfakefs.tests.fake_pathlib_test import ( FakePathlibInitializationTest, FakePathlibPathFileOperationTest, FakePathlibFileObjectPropertyTest, FakePathlibUsageInOsFunctionsTest, ) class DeprecationWarningTest(TestCase): def setUp(self): self.setUpPyfakefs() @unittest.skipIf(scandir is None, "The scandir package is not installed") def test_scandir_warning(self): FakeScanDirModule.has_warned = False with self.assertWarns(DeprecationWarning): scandir.scandir("/") @unittest.skipIf(pathlib2 is None, "The pathlib2 package is not installed") def test_pathlib2_warning(self): FakePathlib2Module.has_warned = False with self.assertWarns(DeprecationWarning): pathlib2.Path("/foo") @unittest.skipIf(scandir is None, "The scandir package is not installed") class FakeScandirPackageTest(FakeScandirTest): def used_scandir(self): import pyfakefs.fake_legacy_modules def fake_scan_dir(p): return pyfakefs.fake_legacy_modules.FakeScanDirModule( self.filesystem ).scandir(p) return fake_scan_dir def test_path_like(self): unittest.skip("Path-like objects not available in scandir package") class RealScandirPackageTest(FakeScandirPackageTest): def used_scandir(self): from scandir import scandir return scandir def use_real_fs(self): return True @unittest.skipIf(pathlib2 is None, "The pathlib2 package is not installed") class FakePathlib2InitializationTest(FakePathlibInitializationTest): def used_pathlib(self): return pathlib2 class RealPathlib2InitializationTest(FakePathlib2InitializationTest): def use_real_fs(self): return True @unittest.skipIf(pathlib2 is None, "The pathlib2 package is not installed") class FakePathlib2FileObjectPropertyTest(FakePathlibFileObjectPropertyTest): def used_pathlib(self): return pathlib2 class RealPathlib2FileObjectPropertyTest(FakePathlib2FileObjectPropertyTest): def use_real_fs(self): return True @unittest.skipIf(pathlib2 is None, "The pathlib2 package is not installed") class FakePathlib2PathFileOperationTest(FakePathlibPathFileOperationTest): def used_pathlib(self): return pathlib2 def test_is_junction(self): unittest.skip("is_junction not available in pathlib2") class RealPathlibPath2FileOperationTest(FakePathlib2PathFileOperationTest): def use_real_fs(self): return True @unittest.skipIf(pathlib2 is None, "The pathlib2 package is not installed") class FakePathlib2UsageInOsFunctionsTest(FakePathlibUsageInOsFunctionsTest): def used_pathlib(self): return pathlib2 class RealPathlib2UsageInOsFunctionsTest(FakePathlib2UsageInOsFunctionsTest): def use_real_fs(self): return True if __name__ == "__main__": unittest.main(verbosity=2)	3.66 KB	2026-01-20 12:58
📄 fake_open_test.py # # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unit tests for fake_open.FakeOsModule.""" import errno import io import os import stat import sys import time import unittest from pyfakefs import fake_filesystem, helpers from pyfakefs.helpers import is_root, IS_PYPY, get_locale_encoding from pyfakefs.fake_io import FakeIoModule from pyfakefs.fake_filesystem_unittest import PatchMode, Patcher from pyfakefs.tests.skipped_pathlib import read_open from pyfakefs.tests.test_utils import RealFsTestCase, skip_if_symlink_not_supported class FakeFileOpenTestBase(RealFsTestCase): def setUp(self): super().setUp() if self.use_real_fs(): self.open = io.open else: self.fake_io_module = FakeIoModule(self.filesystem) self.open = self.fake_io_module.open def path_separator(self): return "!" class FakeFileOpenTest(FakeFileOpenTestBase): def setUp(self): super().setUp() self.orig_time = time.time def tearDown(self): super().tearDown() time.time = self.orig_time def test_open_no_parent_dir(self): """Expect raise when opening a file in a missing directory.""" file_path = self.make_path("foo", "bar.txt") self.assert_raises_os_error(errno.ENOENT, self.open, file_path, "w") def test_delete_on_close(self): self.skip_real_fs() file_dir = "boo" file_path = "boo!far" self.os.mkdir(file_dir) self.open = fake_filesystem.FakeFileOpen(self.filesystem, delete_on_close=True) with self.open(file_path, "w", encoding="utf8"): self.assertTrue(self.filesystem.exists(file_path)) self.assertFalse(self.filesystem.exists(file_path)) def test_no_delete_on_close_by_default(self): file_path = self.make_path("czar") with self.open(file_path, "w", encoding="utf8"): self.assertTrue(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(file_path)) def test_compatibility_of_with_statement(self): self.skip_real_fs() self.open = fake_filesystem.FakeFileOpen(self.filesystem, delete_on_close=True) file_path = "foo" self.assertFalse(self.os.path.exists(file_path)) with self.open(file_path, "w", encoding="utf8"): self.assertTrue(self.os.path.exists(file_path)) # After the 'with' statement, the close() method should have been # called. self.assertFalse(self.os.path.exists(file_path)) def test_unicode_contents(self): file_path = self.make_path("foo") # note that this will work only if the string can be represented # by the locale preferred encoding - which under Windows is # usually not UTF-8, but something like Latin1, depending on the locale text_fractions = "Ümläüts" try: with self.open(file_path, "w", encoding=get_locale_encoding()) as f: f.write(text_fractions) except UnicodeEncodeError: # see https://github.com/pytest-dev/pyfakefs/issues/623 self.skipTest("This test does not work with an ASCII locale") with self.open(file_path, encoding=get_locale_encoding()) as f: contents = f.read() self.assertEqual(contents, text_fractions) def test_byte_contents(self): file_path = self.make_path("foo") byte_fractions = b"\xe2\x85\x93 \xe2\x85\x94 \xe2\x85\x95 \xe2\x85\x96" with self.open(file_path, "wb") as f: f.write(byte_fractions) # the encoding has to be specified, otherwise the locale default # is used which can be different on different systems with self.open(file_path, encoding="utf-8") as f: contents = f.read() self.assertEqual(contents, byte_fractions.decode("utf-8")) def test_write_str_read_bytes(self): file_path = self.make_path("foo") str_contents = "Äsgül" try: with self.open(file_path, "w", encoding=get_locale_encoding()) as f: f.write(str_contents) with self.open(file_path, "rb") as f: contents = f.read() self.assertEqual(str_contents, contents.decode(get_locale_encoding())) except UnicodeError: # see https://github.com/pytest-dev/pyfakefs/issues/623 self.skipTest("This test does not work with an ASCII locale") def test_open_valid_file(self): contents = [ "I am he as\n", "you are he as\n", "you are me and\n", "we are all together\n", ] file_path = self.make_path("bar.txt") self.create_file(file_path, contents="".join(contents)) with self.open(file_path, encoding="utf8") as fake_file: self.assertEqual(contents, fake_file.readlines()) def test_open_valid_args(self): contents = [ "Bang bang Maxwell's silver hammer\n", "Came down on her head", ] file_path = self.make_path("abbey_road", "maxwell") self.create_file(file_path, contents="".join(contents)) with self.open(file_path, encoding="utf8", buffering=1) as f: self.assertEqual(contents, f.readlines()) with self.open( file_path, encoding="utf8", buffering=1, errors="strict", newline="\n", opener=None, ) as f: expected_contents = [ contents[0][:-1] + self.os.linesep, contents[1], ] self.assertEqual(expected_contents, f.readlines()) def test_open_valid_file_with_cwd(self): contents = [ "I am he as\n", "you are he as\n", "you are me and\n", "we are all together\n", ] file_path = self.make_path("bar.txt") self.create_file(file_path, contents="".join(contents)) self.os.chdir(self.base_path) with self.open(file_path, encoding="utf8") as f: self.assertEqual(contents, f.readlines()) def test_iterate_over_file(self): contents = [ "Bang bang Maxwell's silver hammer", "Came down on her head", ] file_path = self.make_path("abbey_road", "maxwell") self.create_file(file_path, contents="\n".join(contents)) with self.open(file_path, encoding="utf8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_next_over_file(self): contents = ["Live long\n", "and prosper\n"] result = [] file_path = self.make_path("foo.txt") self.create_file(file_path, contents="".join(contents)) with self.open(file_path, encoding="utf8") as fake_file: result.append(next(fake_file)) result.append(next(fake_file)) self.assertEqual(contents, result) def test_open_directory_error(self): directory_path = self.make_path("foo") self.os.mkdir(directory_path) if self.is_windows: self.assert_raises_os_error( errno.EACCES, self.open.__call__, directory_path ) else: self.assert_raises_os_error( errno.EISDIR, self.open.__call__, directory_path ) def test_create_file_with_write(self): contents = [ "Here comes the sun, little darlin'", "Here comes the sun, and I say,", "It's alright", ] file_dir = self.make_path("abbey_road") file_path = self.os.path.join(file_dir, "here_comes_the_sun") self.os.mkdir(file_dir) with self.open(file_path, "w", encoding="utf8") as fake_file: for line in contents: fake_file.write(line + "\n") with self.open(file_path, encoding="utf8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_create_file_with_append(self): contents = [ "Here comes the sun, little darlin'", "Here comes the sun, and I say,", "It's alright", ] file_dir = self.make_path("abbey_road") file_path = self.os.path.join(file_dir, "here_comes_the_sun") self.os.mkdir(file_dir) with self.open(file_path, "a", encoding="utf8") as fake_file: for line in contents: fake_file.write(line + "\n") with self.open(file_path, encoding="utf8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_exclusive_create_file_failure(self): skip_if_symlink_not_supported() file_path = self.make_path("bar") self.create_file(file_path) self.assert_raises_os_error(errno.EEXIST, self.open, file_path, "x") self.assert_raises_os_error(errno.EEXIST, self.open, file_path, "xb") def test_exclusive_create_file(self): file_dir = self.make_path("foo") file_path = self.os.path.join(file_dir, "bar") self.os.mkdir(file_dir) contents = "String contents" with self.open(file_path, "x", encoding="utf8") as fake_file: fake_file.write(contents) with self.open(file_path, encoding="utf8") as fake_file: self.assertEqual(contents, fake_file.read()) def test_exclusive_create_binary_file(self): file_dir = self.make_path("foo") file_path = self.os.path.join(file_dir, "bar") self.os.mkdir(file_dir) contents = b"Binary contents" with self.open(file_path, "xb") as fake_file: self.assertEqual("xb", fake_file.mode) fake_file.write(contents) with self.open(file_path, "rb") as fake_file: self.assertEqual("rb", fake_file.mode) self.assertEqual(contents, fake_file.read()) def test_overwrite_existing_file(self): file_path = self.make_path("overwrite") self.create_file(file_path, contents="To disappear") new_contents = [ "Only these lines", "should be in the file.", ] with self.open(file_path, "w", encoding="utf8") as fake_file: for line in new_contents: fake_file.write(line + "\n") with self.open(file_path, encoding="utf8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(new_contents, result) def test_append_existing_file(self): file_path = self.make_path("appendfile") contents = [ "Contents of original fileAppended contents", ] self.create_file(file_path, contents=contents[0]) with self.open(file_path, "a", encoding="utf8") as fake_file: for line in contents[1:]: fake_file.write(line + "\n") with self.open(file_path, encoding="utf8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_open_with_wplus(self): # set up file_path = self.make_path("wplus_file") self.create_file(file_path, contents="old contents") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "r", encoding="utf8") as fake_file: self.assertEqual("old contents", fake_file.read()) self.assertEqual("r", fake_file.mode) # actual tests with self.open(file_path, "w+", encoding="utf8") as fake_file: fake_file.write("new contents") fake_file.seek(0) self.assertTrue("new contents", fake_file.read()) self.assertEqual("w+", fake_file.mode) def test_open_with_wplus_binary(self): file_path = self.make_path("wplus_file_b") self.create_file(file_path, contents=b"old contents") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "rb") as fake_file: self.assertEqual(b"old contents", fake_file.read()) self.assertEqual("rb", fake_file.mode) # actual tests with self.open(file_path, "wb+") as fake_file: fake_file.write(b"new contents") fake_file.seek(0) self.assertTrue(b"new contents", fake_file.read()) self.assertEqual("rb+", fake_file.mode) def test_open_with_wplus_truncation(self): # set up file_path = self.make_path("wplus_file") self.create_file(file_path, contents="old contents") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "r", encoding="utf8") as fake_file: self.assertEqual("old contents", fake_file.read()) # actual tests with self.open(file_path, "w+", encoding="utf8") as fake_file: fake_file.seek(0) self.assertEqual("", fake_file.read()) self.assertEqual("w+", fake_file.mode) def test_open_with_append_flag(self): contents = [ "I am he as\n", "you are he as\n", "you are me and\n", "we are all together\n", ] additional_contents = ["These new lines\n", "like you a lot.\n"] file_path = self.make_path("appendfile") self.create_file(file_path, contents="".join(contents)) with self.open(file_path, "a", encoding="utf8") as fake_file: with self.assertRaises(io.UnsupportedOperation): fake_file.read(0) with self.assertRaises(io.UnsupportedOperation): fake_file.readline() self.assertEqual("a", fake_file.mode) expected_len = len("".join(contents)) expected_len += len(contents) * (len(self.os.linesep) - 1) self.assertEqual(expected_len, fake_file.tell()) fake_file.seek(0) self.assertEqual(0, fake_file.tell()) fake_file.writelines(additional_contents) with self.open(file_path, encoding="utf8") as fake_file: self.assertEqual(contents + additional_contents, fake_file.readlines()) def test_open_with_append_flag_binary(self): contents = b"Just some boring stuff... " additional_contents = b"some excitement added" file_path = self.make_path("append-binary") self.create_file(file_path, contents=contents) with self.open(file_path, "ab") as fake_file: with self.assertRaises(io.UnsupportedOperation): fake_file.read(0) self.assertEqual("ab", fake_file.mode) self.assertEqual(len(contents), fake_file.tell()) fake_file.seek(0) self.assertEqual(0, fake_file.tell()) fake_file.write(additional_contents) with self.open(file_path, "rb") as fake_file: self.assertEqual(contents + additional_contents, fake_file.read()) def check_append_with_aplus(self): file_path = self.make_path("aplus_file") self.create_file(file_path, contents="old contents") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "r", encoding="utf8") as fake_file: self.assertEqual("old contents", fake_file.read()) if self.filesystem: # need to recreate FakeFileOpen for OS specific initialization self.open = fake_filesystem.FakeFileOpen( self.filesystem, delete_on_close=True ) with self.open(file_path, "a+", encoding="utf8") as fake_file: self.assertEqual("a+", fake_file.mode) self.assertEqual(12, fake_file.tell()) fake_file.write("new contents") self.assertEqual(24, fake_file.tell()) fake_file.seek(0) self.assertEqual("old contentsnew contents", fake_file.read()) def test_append_with_aplus_mac_os(self): self.check_macos_only() self.check_append_with_aplus() def test_append_with_aplus_linux_windows(self): self.check_linux_and_windows() self.check_append_with_aplus() def test_append_with_aplus_read_with_loop(self): # set up file_path = self.make_path("aplus_file") self.create_file(file_path, contents="old contents") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "r", encoding="utf8") as fake_file: self.assertEqual("old contents", fake_file.read()) # actual tests with self.open(file_path, "a+", encoding="utf8") as fake_file: fake_file.seek(0) fake_file.write("new contents") fake_file.seek(0) for line in fake_file: self.assertEqual("old contentsnew contents", line) def test_read_empty_file_with_aplus(self): file_path = self.make_path("aplus_file") with self.open(file_path, "a+", encoding="utf8") as fake_file: self.assertEqual("", fake_file.read()) def test_read_empty_file_with_aplus_binary(self): file_path = self.make_path("aplus_file") with self.open(file_path, "ab+") as fake_file: self.assertEqual(b"", fake_file.read()) self.assertEqual("ab+", fake_file.mode) def test_read_with_rplus(self): # set up file_path = self.make_path("rplus_file") self.create_file(file_path, contents="old contents here") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "r", encoding="utf8") as fake_file: self.assertEqual("old contents here", fake_file.read()) # actual tests with self.open(file_path, "r+", encoding="utf8") as fake_file: self.assertEqual("old contents here", fake_file.read()) self.assertEqual("r+", fake_file.mode) fake_file.seek(0) fake_file.write("new contents") fake_file.seek(0) self.assertEqual("new contents here", fake_file.read()) def test_read_with_rplus_binary(self): file_path = self.make_path("rplus_binary") self.create_file(file_path, contents=b"old contents here") self.assertTrue(self.os.path.exists(file_path)) with self.open(file_path, "rb") as fake_file: self.assertEqual(b"old contents here", fake_file.read()) with self.open(file_path, "rb+") as fake_file: self.assertEqual(b"old contents here", fake_file.read()) self.assertEqual("rb+", fake_file.mode) fake_file.seek(0) fake_file.write(b"new contents") fake_file.seek(0) self.assertEqual(b"new contents here", fake_file.read()) def create_with_permission(self, file_path, perm_bits): self.create_file(file_path) self.os.chmod(file_path, perm_bits) if perm_bits & helpers.PERM_READ: st = self.os.stat(file_path) self.assert_mode_equal(perm_bits, st.st_mode) self.assertTrue(st.st_mode & stat.S_IFREG) self.assertFalse(st.st_mode & stat.S_IFDIR) def test_open_flags700(self): # set up self.check_posix_only() file_path = self.make_path("target_file") self.create_with_permission(file_path, 0o700) # actual tests self.open(file_path, "r", encoding="utf8").close() self.open(file_path, "w", encoding="utf8").close() self.open(file_path, "w+", encoding="utf8").close() with self.assertRaises(ValueError): self.open(file_path, "INV", encoding="utf8") def test_open_flags400(self): # set up self.check_posix_only() file_path = self.make_path("target_file") self.create_with_permission(file_path, 0o400) # actual tests self.open(file_path, "r", encoding="utf8").close() if not is_root(): self.assert_raises_os_error(errno.EACCES, self.open, file_path, "w") self.assert_raises_os_error(errno.EACCES, self.open, file_path, "w+") else: self.open(file_path, "w", encoding="utf8").close() self.open(file_path, "w+", encoding="utf8").close() def test_open_flags200(self): # set up self.check_posix_only() file_path = self.make_path("target_file") self.create_with_permission(file_path, 0o200) # actual tests self.open(file_path, "w", encoding="utf8").close() if not is_root(): with self.assertRaises(OSError): self.open(file_path, "r", encoding="utf8") with self.assertRaises(OSError): self.open(file_path, "w+", encoding="utf8") else: self.open(file_path, "r", encoding="utf8").close() self.open(file_path, "w+", encoding="utf8").close() def test_open_flags100(self): # set up self.check_posix_only() file_path = self.make_path("target_file") self.create_with_permission(file_path, 0o100) # actual tests if not is_root(): with self.assertRaises(OSError): self.open(file_path, "r", encoding="utf8") with self.assertRaises(OSError): self.open(file_path, "w", encoding="utf8") with self.assertRaises(OSError): self.open(file_path, "w+", encoding="utf8") else: self.open(file_path, "r", encoding="utf8").close() self.open(file_path, "w", encoding="utf8").close() self.open(file_path, "w+", encoding="utf8").close() def test_follow_link_read(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "baz") target = self.make_path("tarJAY") target_contents = "real baz contents" self.create_file(target, contents=target_contents) self.create_symlink(link_path, target) self.assert_equal_paths(target, self.os.readlink(link_path)) fh = self.open(link_path, "r", encoding="utf8") got_contents = fh.read() fh.close() self.assertEqual(target_contents, got_contents) def test_follow_link_write(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "TBD") target = self.make_path("tarJAY") target_contents = "real baz contents" self.create_symlink(link_path, target) self.assertFalse(self.os.path.exists(target)) with self.open(link_path, "w", encoding="utf8") as fh: fh.write(target_contents) with self.open(target, "r", encoding="utf8") as fh: got_contents = fh.read() self.assertEqual(target_contents, got_contents) def test_follow_intra_path_link_write(self): # Test a link in the middle of of a file path. skip_if_symlink_not_supported() link_path = self.os.path.join( self.base_path, "foo", "build", "local_machine", "output", "1" ) target = self.make_path("tmp", "output", "1") self.create_dir(self.make_path("tmp", "output")) self.create_symlink( self.os.path.join(self.base_path, "foo", "build", "local_machine"), self.make_path("tmp"), ) self.assertFalse(self.os.path.exists(link_path)) self.assertFalse(self.os.path.exists(target)) target_contents = "real baz contents" with self.open(link_path, "w", encoding="utf8") as fh: fh.write(target_contents) with self.open(target, "r", encoding="utf8") as fh: got_contents = fh.read() self.assertEqual(target_contents, got_contents) def test_open_raises_on_symlink_loop(self): # Regression test for #274 self.check_posix_only() file_dir = self.make_path("foo") self.os.mkdir(file_dir) file_path = self.os.path.join(file_dir, "baz") self.os.symlink(file_path, file_path) self.assert_raises_os_error(errno.ELOOP, self.open, file_path) def test_file_descriptors_for_different_files(self): first_path = self.make_path("some_file1") self.create_file(first_path, contents="contents here1") second_path = self.make_path("some_file2") self.create_file(second_path, contents="contents here2") third_path = self.make_path("some_file3") self.create_file(third_path, contents="contents here3") with self.open(first_path, encoding="utf8") as fake_file1: with self.open(second_path, encoding="utf8") as fake_file2: with self.open(third_path, encoding="utf8") as fake_file3: fileno2 = fake_file2.fileno() self.assertGreater(fileno2, fake_file1.fileno()) self.assertGreater(fake_file3.fileno(), fileno2) def test_file_descriptors_for_the_same_file_are_different(self): first_path = self.make_path("some_file1") self.create_file(first_path, contents="contents here1") second_path = self.make_path("some_file2") self.create_file(second_path, contents="contents here2") with self.open(first_path, encoding="utf8") as fake_file1: with self.open(second_path, encoding="utf8") as fake_file2: with self.open(first_path, encoding="utf8") as fake_file1a: fileno2 = fake_file2.fileno() self.assertNotEqual(fileno2, fake_file1.fileno()) self.assertNotEqual(fake_file1a.fileno(), fileno2) def test_reused_file_descriptors_do_not_affect_others(self): first_path = self.make_path("some_file1") self.create_file(first_path, contents="contents here1") second_path = self.make_path("some_file2") self.create_file(second_path, contents="contents here2") third_path = self.make_path("some_file3") self.create_file(third_path, contents="contents here3") with self.open(first_path, "r", encoding="utf8") as fake_file1: with self.open(second_path, "r", encoding="utf8") as fake_file2: fake_file3 = self.open(third_path, "r", encoding="utf8") fake_file1a = self.open(first_path, "r", encoding="utf8") fileno1 = fake_file1.fileno() fileno2 = fake_file2.fileno() fileno3 = fake_file3.fileno() fileno4 = fake_file1a.fileno() with self.open(second_path, "r", encoding="utf8") as fake_file2: with self.open(first_path, "r", encoding="utf8") as fake_file1b: self.assertEqual(fileno1, fake_file2.fileno()) self.assertEqual(fileno2, fake_file1b.fileno()) self.assertEqual(fileno3, fake_file3.fileno()) self.assertEqual(fileno4, fake_file1a.fileno()) fake_file3.close() fake_file1a.close() def test_intertwined_read_write(self): file_path = self.make_path("some_file") self.create_file(file_path) with self.open(file_path, "a", encoding="utf8") as writer: with self.open(file_path, "r", encoding="utf8") as reader: writes = [ "hello", "world\n", "somewhere\nover", "the\n", "rainbow", ] reads = [] # when writes are flushes, they are piped to the reader for write in writes: writer.write(write) writer.flush() reads.append(reader.read()) reader.flush() self.assertEqual(writes, reads) writes = ["nothing", "to\nsee", "here"] reads = [] # when writes are not flushed, the reader doesn't read # anything new for write in writes: writer.write(write) reads.append(reader.read()) self.assertEqual(["" for _ in writes], reads) def test_intertwined_read_write_python3_str(self): file_path = self.make_path("some_file") self.create_file(file_path) with self.open(file_path, "a", encoding="utf-8") as writer: with self.open(file_path, "r", encoding="utf-8") as reader: writes = ["привет", "мир\n", "где-то\nза", "радугой"] reads = [] # when writes are flushes, they are piped to the reader for write in writes: writer.write(write) writer.flush() reads.append(reader.read()) reader.flush() self.assertEqual(writes, reads) writes = ["ничего", "не\nвидно"] reads = [] # when writes are not flushed, the reader doesn't # read anything new for write in writes: writer.write(write) reads.append(reader.read()) self.assertEqual(["" for _ in writes], reads) def test_open_io_errors(self): file_path = self.make_path("some_file") self.create_file(file_path) with self.open(file_path, "a", encoding="utf8") as fh: with self.assertRaises(OSError): fh.read() with self.assertRaises(OSError): fh.readlines() with self.open(file_path, "w", encoding="utf8") as fh: with self.assertRaises(OSError): fh.read() with self.assertRaises(OSError): fh.readlines() with self.open(file_path, "r", encoding="utf8") as fh: with self.assertRaises(OSError): fh.truncate() with self.assertRaises(OSError): fh.write("contents") with self.assertRaises(OSError): fh.writelines(["con", "tents"]) def _iterator_open(mode): with self.open(file_path, mode, encoding="utf8") as f: for _ in f: pass with self.assertRaises(OSError): _iterator_open("w") with self.assertRaises(OSError): _iterator_open("a") def test_open_raises_io_error_if_parent_is_file_posix(self): self.check_posix_only() file_path = self.make_path("bar") self.create_file(file_path) file_path = self.os.path.join(file_path, "baz") self.assert_raises_os_error(errno.ENOTDIR, self.open, file_path, "w") def test_open_raises_io_error_if_parent_is_file_windows(self): self.check_windows_only() file_path = self.make_path("bar") self.create_file(file_path) file_path = self.os.path.join(file_path, "baz") self.assert_raises_os_error(errno.ENOENT, self.open, file_path, "w") def check_open_with_trailing_sep(self, error_nr): # regression test for #362 path = self.make_path("foo") + self.os.path.sep self.assert_raises_os_error(error_nr, self.open, path, "w") def test_open_with_trailing_sep_linux(self): self.check_linux_only() self.check_open_with_trailing_sep(errno.EISDIR) def test_open_with_trailing_sep_macos(self): self.check_macos_only() self.check_open_with_trailing_sep(errno.ENOENT) def test_open_with_trailing_sep_windows(self): self.check_windows_only() self.check_open_with_trailing_sep(errno.EINVAL) def test_can_read_from_block_device(self): self.skip_real_fs() device_path = "device" self.filesystem.create_file(device_path, stat.S_IFBLK \| helpers.PERM_ALL) with self.open(device_path, "r", encoding="utf8") as fh: self.assertEqual("", fh.read()) def test_truncate_flushes_contents(self): # Regression test for #285 file_path = self.make_path("baz") self.create_file(file_path) with self.open(file_path, "w", encoding="utf8") as f0: f0.write("test") f0.truncate() self.assertEqual(4, self.os.path.getsize(file_path)) def test_update_other_instances_of_same_file_on_flush(self): # Regression test for #302 file_path = self.make_path("baz") with self.open(file_path, "w", encoding="utf8") as f0: with self.open(file_path, "w", encoding="utf8") as f1: f0.write("test") f0.truncate() f1.flush() self.assertEqual(4, self.os.path.getsize(file_path)) def test_getsize_after_truncate(self): # Regression test for #412 file_path = self.make_path("foo") with self.open(file_path, "a", encoding="utf8") as f: f.write("a") f.seek(0) f.truncate() f.write("b") f.truncate() self.assertEqual(1, self.os.path.getsize(file_path)) self.assertEqual(1, self.os.stat(file_path).st_size) def test_st_size_after_truncate(self): # Regression test for #412 file_path = self.make_path("foo") with self.open(file_path, "a", encoding="utf8") as f: f.write("a") f.truncate() f.write("b") f.truncate() self.assertEqual(2, self.os.stat(file_path).st_size) def test_that_read_over_end_does_not_reset_position(self): # Regression test for #286 file_path = self.make_path("baz") self.create_file(file_path) with self.open(file_path, encoding="utf8") as f0: f0.seek(2) f0.read() self.assertEqual(2, f0.tell()) def test_accessing_closed_file_raises(self): # Regression test for #275, #280 if self.is_pypy: raise unittest.SkipTest("Different exceptions with PyPy") file_path = self.make_path("foo") self.create_file(file_path, contents=b"test") fake_file = self.open(file_path, "r", encoding="utf8") fake_file.close() with self.assertRaises(ValueError): fake_file.read(1) with self.assertRaises(ValueError): fake_file.write("a") with self.assertRaises(ValueError): fake_file.readline() with self.assertRaises(ValueError): fake_file.truncate() with self.assertRaises(ValueError): fake_file.tell() with self.assertRaises(ValueError): fake_file.seek(1) with self.assertRaises(ValueError): fake_file.flush() def test_accessing_open_file_with_another_handle_raises(self): # Regression test for #282 if self.is_pypy: raise unittest.SkipTest("Different exceptions with PyPy") file_path = self.make_path("foo") f0 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) fake_file = self.open(file_path, "r", encoding="utf8") fake_file.close() with self.assertRaises(ValueError): fake_file.read(1) with self.assertRaises(ValueError): fake_file.write("a") self.os.close(f0) def test_tell_flushes_under_mac_os(self): # Regression test for #288 self.check_macos_only() file_path = self.make_path("foo") with self.open(file_path, "w", encoding="utf8") as f0: f0.write("test") self.assertEqual(4, f0.tell()) self.assertEqual(4, self.os.path.getsize(file_path)) def test_tell_flushes_in_python3(self): # Regression test for #288 self.check_linux_and_windows() file_path = self.make_path("foo") with self.open(file_path, "w", encoding="utf8") as f0: f0.write("test") self.assertEqual(4, f0.tell()) self.assertEqual(4, self.os.path.getsize(file_path)) def test_read_flushes_under_posix(self): # Regression test for #278 self.check_posix_only() file_path = self.make_path("foo") with self.open(file_path, "a+", encoding="utf8") as f0: f0.write("test") self.assertEqual("", f0.read()) self.assertEqual(4, self.os.path.getsize(file_path)) def test_read_flushes_under_windows_in_python3(self): # Regression test for #278 self.check_windows_only() file_path = self.make_path("foo") with self.open(file_path, "w+", encoding="utf8") as f0: f0.write("test") f0.read() self.assertEqual(4, self.os.path.getsize(file_path)) def test_seek_flushes(self): # Regression test for #290 file_path = self.make_path("foo") with self.open(file_path, "w", encoding="utf8") as f0: f0.write("test") self.assertEqual(0, self.os.path.getsize(file_path)) f0.seek(3) self.assertEqual(4, self.os.path.getsize(file_path)) def test_truncate_flushes(self): # Regression test for #291 file_path = self.make_path("foo") with self.open(file_path, "a", encoding="utf8") as f0: f0.write("test") self.assertEqual(0, self.os.path.getsize(file_path)) f0.truncate() self.assertEqual(4, self.os.path.getsize(file_path)) def check_seek_outside_and_truncate_sets_size(self, mode): # Regression test for #294 and #296 file_path = self.make_path("baz") with self.open(file_path, mode, encoding="utf8") as f0: f0.seek(1) f0.truncate() self.assertEqual(1, f0.tell()) self.assertEqual(1, self.os.path.getsize(file_path)) f0.seek(1) self.assertEqual(1, self.os.path.getsize(file_path)) self.assertEqual(1, self.os.path.getsize(file_path)) def test_seek_outside_and_truncate_sets_size_in_write_mode(self): # Regression test for #294 self.check_seek_outside_and_truncate_sets_size("w") def test_seek_outside_and_truncate_sets_size_in_append_mode(self): # Regression test for #295 self.check_seek_outside_and_truncate_sets_size("a") def test_closed(self): file_path = self.make_path("foo") f = self.open(file_path, "w", encoding="utf8") self.assertFalse(f.closed) f.close() self.assertTrue(f.closed) f = self.open(file_path, encoding="utf8") self.assertFalse(f.closed) f.close() self.assertTrue(f.closed) def test_closing_closed_file_does_nothing(self): # Regression test for #299 file_path = self.make_path("baz") f0 = self.open(file_path, "w", encoding="utf8") f0.close() with self.open(file_path, encoding="utf8") as f1: # would close f1 if not handled f0.close() self.assertEqual("", f1.read()) def test_closing_file_with_different_close_mode(self): self.skip_real_fs() filename = self.make_path("test.txt") fd = self.os.open(filename, os.O_CREAT \| os.O_RDWR) file_obj = self.filesystem.get_object(filename) with self.open(fd, "wb", closefd=False) as fp: fp.write(b"test") self.assertEqual("wb", fp.mode) self.assertTrue(self.filesystem.has_open_file(file_obj)) self.os.close(fd) self.assertFalse(self.filesystem.has_open_file(file_obj)) def test_truncate_flushes_zeros(self): # Regression test for #301 file_path = self.make_path("baz") with self.open(file_path, "w", encoding="utf8") as f0: with self.open(file_path, encoding="utf8") as f1: f0.seek(1) f0.truncate() self.assertEqual("\0", f1.read()) def test_byte_filename(self): file_path = self.make_path(b"test") with self.open(file_path, "wb") as f: f.write(b"test") with self.open(file_path, "rb") as f: self.assertEqual(b"test", f.read()) def test_unicode_filename(self): file_path = self.make_path("тест") with self.open(file_path, "wb") as f: f.write(b"test") with self.open(file_path, "rb") as f: self.assertEqual(b"test", f.read()) def test_write_devnull(self): for mode in ("r+", "w", "w+", "a", "a+"): with self.open(self.os.devnull, mode, encoding="utf8") as f: f.write("test") with self.open(self.os.devnull, encoding="utf8") as f: self.assertEqual("", f.read()) def test_utf16_text(self): # regression test for #574 file_path = self.make_path("foo") with self.open(file_path, "w", encoding="utf-16") as f: assert f.write("1") == 1 with self.open(file_path, "a", encoding="utf-16") as f: assert f.write("2") == 1 with self.open(file_path, "r", encoding="utf-16") as f: text = f.read() assert text == "12" class RealFileOpenTest(FakeFileOpenTest): def use_real_fs(self): return True class FakeFileOpenWithOpenerTest(FakeFileOpenTestBase): def opener(self, path, flags): return self.os.open(path, flags) def test_use_opener_with_read(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.open(file_path, encoding="utf8", opener=self.opener) as f: assert f.read() == "test" with self.assertRaises(OSError): f.write("foo") def test_no_opener_with_read(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.open(file_path, encoding="utf8") as f: assert f.read() == "test" with self.assertRaises(OSError): f.write("foo") def test_use_opener_with_read_plus(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.open(file_path, "r+", encoding="utf8", opener=self.opener) as f: assert f.read() == "test" assert f.write("bar") == 3 with self.open(file_path, encoding="utf8") as f: assert f.read() == "testbar" def test_use_opener_with_write(self): file_path = self.make_path("foo") self.create_file(file_path, contents="foo") with self.open(file_path, "w", encoding="utf8", opener=self.opener) as f: with self.assertRaises(OSError): f.read() assert f.write("bar") == 3 with self.open(file_path, encoding="utf8") as f: assert f.read() == "bar" def test_use_opener_with_write_plus(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.open(file_path, "w+", encoding="utf8", opener=self.opener) as f: assert f.read() == "" assert f.write("bar") == 3 with self.open(file_path, encoding="utf8") as f: assert f.read() == "bar" def test_use_opener_with_append(self): file_path = self.make_path("foo") self.create_file(file_path, contents="foo") with self.open(file_path, "a", encoding="utf8", opener=self.opener) as f: assert f.write("bar") == 3 with self.assertRaises(OSError): f.read() with self.open(file_path, encoding="utf8") as f: assert f.read() == "foobar" def test_use_opener_with_append_plus(self): file_path = self.make_path("foo") self.create_file(file_path, contents="foo") with self.open(file_path, "a+", encoding="utf8", opener=self.opener) as f: assert f.read() == "" assert f.write("bar") == 3 with self.open(file_path, encoding="utf8") as f: assert f.read() == "foobar" def test_use_opener_with_exclusive_write(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.assertRaises(OSError): self.open(file_path, "x", encoding="utf8", opener=self.opener) file_path = self.make_path("bar") with self.open(file_path, "x", encoding="utf8", opener=self.opener) as f: self.assertEqual("x", f.mode) assert f.write("bar") == 3 with self.assertRaises(OSError): f.read() with self.open(file_path, encoding="utf8") as f: assert f.read() == "bar" def test_use_opener_with_exclusive_plus(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") with self.assertRaises(OSError): self.open(file_path, "x+", encoding="utf8", opener=self.opener) file_path = self.make_path("bar") with self.open(file_path, "x+", encoding="utf8", opener=self.opener) as f: self.assertEqual("x+", f.mode) assert f.write("bar") == 3 assert f.read() == "" with self.open(file_path, encoding="utf8") as f: assert f.read() == "bar" class RealFileOpenWithOpenerTest(FakeFileOpenWithOpenerTest): def use_real_fs(self): return True @unittest.skipIf(sys.version_info < (3, 8), "open_code only present since Python 3.8") class FakeFilePatchedOpenCodeTest(FakeFileOpenTestBase): def setUp(self): super().setUp() if self.use_real_fs(): self.open_code = io.open_code else: self.filesystem.patch_open_code = PatchMode.ON self.open_code = self.fake_io_module.open_code def tearDown(self): if not self.use_real_fs(): self.filesystem.patch_open_code = False super().tearDown() @unittest.skipIf(IS_PYPY, "Different behavior in PyPy") def test_invalid_path(self): with self.assertRaises(TypeError): self.open_code(4) @unittest.skipIf(not IS_PYPY, "Different behavior in PyPy") def test_open_code_fd_pypy(self): file_path = self.make_path("foo") self.create_file(file_path, contents="test") fd = self.os.open(file_path, os.O_RDONLY) with self.open_code(fd) as f: assert f.read() == b"test" def test_byte_contents_open_code(self): byte_fractions = b"\xe2\x85\x93 \xe2\x85\x94 \xe2\x85\x95 \xe2\x85\x96" file_path = self.make_path("foo") self.create_file(file_path, contents=byte_fractions) with self.open_code(file_path) as f: contents = f.read() self.assertEqual(contents, byte_fractions) def test_open_code_in_real_fs(self): self.skip_real_fs() file_path = __file__ with self.assertRaises(OSError): self.open_code(file_path) class RealPatchedFileOpenCodeTest(FakeFilePatchedOpenCodeTest): def use_real_fs(self): return True @unittest.skipIf(sys.version_info < (3, 8), "open_code only present since Python 3.8") class FakeFileUnpatchedOpenCodeTest(FakeFileOpenTestBase): def setUp(self): super().setUp() if self.use_real_fs(): self.open_code = io.open_code else: self.open_code = self.fake_io_module.open_code @unittest.skipIf(IS_PYPY, "Different behavior in PyPy") def test_invalid_path(self): with self.assertRaises(TypeError): self.open_code(4) def test_open_code_in_real_fs(self): file_path = __file__ with self.open_code(file_path) as f: contents = f.read() self.assertTrue(len(contents) > 100) class RealUnpatchedFileOpenCodeTest(FakeFileUnpatchedOpenCodeTest): def use_real_fs(self): return True def test_byte_contents_open_code(self): byte_fractions = b"\xe2\x85\x93 \xe2\x85\x94 \xe2\x85\x95 \xe2\x85\x96" file_path = self.make_path("foo") self.create_file(file_path, contents=byte_fractions) with self.open_code(file_path) as f: contents = f.read() self.assertEqual(contents, byte_fractions) class BufferingModeTest(FakeFileOpenTestBase): def test_no_buffering(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "wb", buffering=0) as f: f.write(b"a" * 128) with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"a" * 128, x) def test_no_buffering_not_allowed_in_textmode(self): file_path = self.make_path("buffertest.txt") with self.assertRaises(ValueError): self.open(file_path, "w", encoding="utf8", buffering=0) def test_default_buffering_no_flush(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "wb") as f: f.write(b"a" * 2048) with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"", x) with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"a" * 2048, x) def test_default_buffering_flush(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "wb") as f: f.write(b"a" * 2048) f.flush() with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"a" * 2048, x) def test_writing_with_specific_buffer(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "wb", buffering=512) as f: f.write(b"a" * 500) with self.open(file_path, "rb") as r: x = r.read() # buffer not filled - not written self.assertEqual(0, len(x)) f.write(b"a" * 400) with self.open(file_path, "rb") as r: x = r.read() # buffer exceeded, but new buffer (400) not - previous written self.assertEqual(500, len(x)) f.write(b"a" * 100) with self.open(file_path, "rb") as r: x = r.read() # buffer not full (500) not written self.assertEqual(500, len(x)) f.write(b"a" * 100) with self.open(file_path, "rb") as r: x = r.read() # buffer exceeded (600) -> write previous # new buffer not full (100) - not written self.assertEqual(1000, len(x)) f.write(b"a" * 600) with self.open(file_path, "rb") as r: x = r.read() # new buffer exceeded (600) -> all written self.assertEqual(1700, len(x)) def test_writing_text_with_line_buffer(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "w", encoding="utf8", buffering=1) as f: f.write("test" * 100) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # no new line - not written self.assertEqual(0, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # new line - buffer written self.assertEqual(405, len(x)) f.write("test" * 10) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(405, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # new line - buffer written self.assertEqual(450, len(x)) def test_writing_large_text_with_line_buffer(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "w", encoding="utf8", buffering=1) as f: f.write("test" * 33000) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer larger than default - written self.assertEqual(132000, len(x)) f.write("test") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(132000, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # new line - buffer written self.assertEqual(132009, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # another new line - buffer written self.assertEqual(132014, len(x)) def test_writing_text_with_default_buffer(self): file_path = self.make_path("buffertest.txt") with self.open(file_path, "w", encoding="utf8") as f: f.write("test" * 5) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(0, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer exceeded, but new buffer (400) not - previous written self.assertEqual(0, len(x)) f.write("test" * 10) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(0, len(x)) f.write("\ntest") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() self.assertEqual(0, len(x)) def test_writing_text_with_specific_buffer(self): file_path = self.make_path("buffertest.txt") with self.open(file_path, "w", encoding="utf8", buffering=2) as f: f.write("a" * 8000) with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(0, len(x)) f.write("test") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer exceeded, but new buffer (400) not - previous written self.assertEqual(0, len(x)) f.write("test") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() # buffer not filled - not written self.assertEqual(0, len(x)) f.write("test") with self.open(file_path, "r", encoding="utf8") as r: x = r.read() self.assertEqual(0, len(x)) # with self.open(file_path, "r") as r: # x = r.read() # self.assertEqual(35, len(x)) def test_append_with_specific_buffer(self): file_path = self.make_path("buffertest.bin") with self.open(file_path, "wb", buffering=512) as f: f.write(b"a" * 500) with self.open(file_path, "ab", buffering=512) as f: f.write(b"a" * 500) with self.open(file_path, "rb") as r: x = r.read() # buffer not filled - not written self.assertEqual(500, len(x)) f.write(b"a" * 400) with self.open(file_path, "rb") as r: x = r.read() # buffer exceeded, but new buffer (400) not - previous written self.assertEqual(1000, len(x)) f.write(b"a" * 100) with self.open(file_path, "rb") as r: x = r.read() # buffer not full (500) not written self.assertEqual(1000, len(x)) f.write(b"a" * 100) with self.open(file_path, "rb") as r: x = r.read() # buffer exceeded (600) -> write previous # new buffer not full (100) - not written self.assertEqual(1500, len(x)) f.write(b"a" * 600) with self.open(file_path, "rb") as r: x = r.read() # new buffer exceeded (600) -> all written self.assertEqual(2200, len(x)) def test_failed_flush_does_not_truncate_file(self): # regression test for #548 self.skip_real_fs() # cannot set fs size in real fs self.filesystem.set_disk_usage(100) self.os.makedirs("foo") file_path = self.os.path.join("foo", "bar.txt") with self.open(file_path, "wb") as f: f.write(b"a" * 50) f.flush() with self.open(file_path, "rb") as r: x = r.read() self.assertTrue(x.startswith(b"a" * 50)) with self.assertRaises(OSError): f.write(b"b" * 200) f.flush() with self.open(file_path, "rb") as r: x = r.read() self.assertTrue(x.startswith(b"a" * 50)) f.truncate(50) def test_failed_write_does_not_truncate_file(self): # test the same with no buffering and no flush self.skip_real_fs() # cannot set fs size in real fs self.filesystem.set_disk_usage(100) self.os.makedirs("foo") file_path = self.os.path.join("foo", "bar.txt") with self.open(file_path, "wb", buffering=0) as f: f.write(b"a" * 50) with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"a" * 50, x) with self.assertRaises(OSError): f.write(b"b" * 200) with self.open(file_path, "rb") as r: x = r.read() self.assertEqual(b"a" * 50, x) def test_writing_over_buffer_end(self): # regression test for #1120 dir_path = self.make_path("foo") self.create_dir(dir_path) file_path = self.os.path.join(dir_path, "bar.txt") line_end_size = len(self.os.linesep) char_count = io.DEFAULT_BUFFER_SIZE // 256 - line_end_size for line_count in (255, 256, 257, 511, 512, 513): with self.open(file_path, "w", encoding="utf8") as f: for i in range(line_count): f.write("x" * char_count + "\n") with self.open(file_path, encoding="utf8") as f: lines = f.readlines() self.assertEqual(line_count, len(lines)) class RealBufferingTest(BufferingModeTest): def use_real_fs(self): return True class OpenFileWithEncodingTest(FakeFileOpenTestBase): """Tests that are similar to some open file tests above but using an explicit text encoding.""" def setUp(self): super().setUp() self.file_path = self.make_path("foo") def test_write_str_read_bytes(self): str_contents = "علي بابا" with self.open(self.file_path, "w", encoding="arabic") as f: f.write(str_contents) with self.open(self.file_path, "rb") as f: contents = f.read() self.assertEqual(str_contents, contents.decode("arabic")) def test_write_str_error_modes(self): str_contents = "علي بابا" with self.open(self.file_path, "w", encoding="cyrillic") as f: with self.assertRaises(UnicodeEncodeError): f.write(str_contents) with self.open( self.file_path, "w", encoding="ascii", errors="xmlcharrefreplace" ) as f: f.write(str_contents) with self.open(self.file_path, "r", encoding="ascii") as f: contents = f.read() self.assertEqual("علي بابا", contents) with self.open( self.file_path, "w", encoding="ascii", errors="namereplace" ) as f: f.write(str_contents) with self.open(self.file_path, "r", encoding="ascii") as f: contents = f.read() self.assertEqual( r"\N{ARABIC LETTER AIN}\N{ARABIC LETTER LAM}\N" r"{ARABIC LETTER YEH} \N{ARABIC LETTER BEH}\N" r"{ARABIC LETTER ALEF}\N{ARABIC LETTER BEH}" r"\N{ARABIC LETTER ALEF}", contents, ) def test_read_str_error_modes(self): str_contents = "علي بابا" with self.open(self.file_path, "w", encoding="arabic") as f: f.write(str_contents) # default strict encoding with self.open(self.file_path, encoding="ascii") as f: with self.assertRaises(UnicodeDecodeError): f.read() with self.open(self.file_path, encoding="ascii", errors="replace") as f: contents = f.read() self.assertNotEqual(str_contents, contents) with self.open( self.file_path, encoding="ascii", errors="backslashreplace" ) as f: contents = f.read() self.assertEqual(r"\xd9\xe4\xea \xc8\xc7\xc8\xc7", contents) def test_write_and_read_str(self): str_contents = "علي بابا" with self.open(self.file_path, "w", encoding="arabic") as f: f.write(str_contents) with self.open(self.file_path, "r", encoding="arabic") as f: contents = f.read() self.assertEqual(str_contents, contents) def test_create_file_with_append(self): contents = [ "Allons enfants de la Patrie,Le jour de gloire est arrivé!", "Contre nous de la tyrannie,", "L’étendard sanglant est levé.", ] with self.open(self.file_path, "a", encoding="utf-8") as fake_file: for line in contents: fake_file.write(line + "\n") with self.open(self.file_path, encoding="utf-8") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_append_existing_file(self): contents = [ "Оригинальное содержаниеДополнительное содержание", ] self.create_file(self.file_path, contents=contents[0], encoding="cyrillic") with self.open(self.file_path, "a", encoding="cyrillic") as fake_file: for line in contents[1:]: fake_file.write(line + "\n") with self.open(self.file_path, encoding="cyrillic") as fake_file: result = [line.rstrip() for line in fake_file] self.assertEqual(contents, result) def test_open_with_wplus(self): self.create_file( self.file_path, contents="старое содержание", encoding="cyrillic" ) with self.open(self.file_path, "r", encoding="cyrillic") as fake_file: self.assertEqual("старое содержание", fake_file.read()) with self.open(self.file_path, "w+", encoding="cyrillic") as fake_file: fake_file.write("новое содержание") fake_file.seek(0) self.assertTrue("новое содержание", fake_file.read()) def test_open_with_append_flag(self): contents = ["Калинка,\n", "калинка,\n", "калинка моя,\n"] additional_contents = ["В саду ягода-малинка,\n", "малинка моя.\n"] self.create_file( self.file_path, contents="".join(contents), encoding="cyrillic" ) with self.open(self.file_path, "a", encoding="cyrillic") as fake_file: with self.assertRaises(io.UnsupportedOperation): fake_file.read(0) with self.assertRaises(io.UnsupportedOperation): fake_file.readline() self.assertEqual(len("".join(contents)), fake_file.tell()) fake_file.seek(0) self.assertEqual(0, fake_file.tell()) fake_file.writelines(additional_contents) with self.open(self.file_path, encoding="cyrillic") as fake_file: self.assertEqual(contents + additional_contents, fake_file.readlines()) def test_append_with_aplus(self): self.create_file( self.file_path, contents="старое содержание", encoding="cyrillic" ) fake_file = self.open(self.file_path, "r", encoding="cyrillic") fake_file.close() with self.open(self.file_path, "a+", encoding="cyrillic") as fake_file: self.assertEqual(17, fake_file.tell()) fake_file.write("новое содержание") self.assertEqual(33, fake_file.tell()) fake_file.seek(0) self.assertEqual("старое содержаниеновое содержание", fake_file.read()) def test_read_with_rplus(self): self.create_file( self.file_path, contents="старое содержание здесь", encoding="cyrillic", ) fake_file = self.open(self.file_path, "r", encoding="cyrillic") fake_file.close() with self.open(self.file_path, "r+", encoding="cyrillic") as fake_file: self.assertEqual("старое содержание здесь", fake_file.read()) fake_file.seek(0) fake_file.write("новое содержание") fake_file.seek(0) self.assertEqual("новое содержание здесь", fake_file.read()) class OpenRealFileWithEncodingTest(OpenFileWithEncodingTest): def use_real_fs(self): return True class FakeFileOpenLineEndingTest(FakeFileOpenTestBase): def setUp(self): super().setUp() def test_read_default_newline_mode(self): file_path = self.make_path("some_file") for contents in (b"1\n2", b"1\r\n2", b"1\r2"): self.create_file(file_path, contents=contents) with self.open(file_path, mode="r", encoding="utf8") as f: self.assertEqual(["1\n", "2"], f.readlines()) with self.open(file_path, mode="r", encoding="utf8") as f: self.assertEqual("1\n2", f.read()) with self.open(file_path, mode="rb") as f: self.assertEqual(contents, f.read()) def test_write_universal_newline_mode(self): file_path = self.make_path("some_file") with self.open(file_path, "w", encoding="utf8") as f: f.write("1\n2") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1" + self.os.linesep.encode() + b"2", f.read()) with self.open(file_path, "w", encoding="utf8") as f: f.write("1\r\n2") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1\r" + self.os.linesep.encode() + b"2", f.read()) def test_read_with_newline_arg(self): file_path = self.make_path("some_file") file_contents = b"1\r\n2\n3\r4" self.create_file(file_path, contents=file_contents) with self.open(file_path, mode="r", encoding="utf8", newline="") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) with self.open(file_path, mode="r", encoding="utf8", newline="\r") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) with self.open(file_path, mode="r", encoding="utf8", newline="\n") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) with self.open(file_path, mode="r", encoding="utf8", newline="\r\n") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) def test_readlines_with_newline_arg(self): file_path = self.make_path("some_file") file_contents = b"1\r\n2\n3\r4" self.create_file(file_path, contents=file_contents) with self.open(file_path, mode="r", encoding="utf8", newline="") as f: self.assertEqual(["1\r\n", "2\n", "3\r", "4"], f.readlines()) with self.open(file_path, mode="r", encoding="utf8", newline="\r") as f: self.assertEqual(["1\r", "\n2\n3\r", "4"], f.readlines()) with self.open(file_path, mode="r", encoding="utf8", newline="\n") as f: self.assertEqual(["1\r\n", "2\n", "3\r4"], f.readlines()) with self.open(file_path, mode="r", encoding="utf8", newline="\r\n") as f: self.assertEqual(["1\r\n", "2\n3\r4"], f.readlines()) @unittest.skipIf(sys.version_info >= (3, 10), "U flag no longer supported") def test_read_with_ignored_universal_newlines_flag(self): file_path = self.make_path("some_file") file_contents = b"1\r\n2\n3\r4" self.create_file(file_path, contents=file_contents) with self.open(file_path, mode="r", encoding="utf8", newline="\r") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) with self.open(file_path, mode="r", encoding="utf8", newline="\r") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) with self.open(file_path, mode="U", encoding="utf8", newline="\r") as f: self.assertEqual("1\r\n2\n3\r4", f.read()) @unittest.skipIf(sys.version_info < (3, 11), "U flag still supported") def test_universal_newlines_flag_not_supported(self): file_path = self.make_path("some_file") file_contents = b"1\r\n2\n3\r4" self.create_file(file_path, contents=file_contents) with self.assertRaises(ValueError): self.open(file_path, mode="U", encoding="utf8", newline="\r") def test_write_with_newline_arg(self): file_path = self.make_path("some_file") with self.open(file_path, "w", encoding="utf8", newline="") as f: f.write("1\r\n2\n3\r4") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1\r\n2\n3\r4", f.read()) with self.open(file_path, "w", encoding="utf8", newline="\n") as f: f.write("1\r\n2\n3\r4") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1\r\n2\n3\r4", f.read()) with self.open(file_path, "w", encoding="utf8", newline="\r\n") as f: f.write("1\r\n2\n3\r4") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1\r\r\n2\r\n3\r4", f.read()) with self.open(file_path, "w", encoding="utf8", newline="\r") as f: f.write("1\r\n2\n3\r4") with self.open(file_path, mode="rb") as f: self.assertEqual(b"1\r\r2\r3\r4", f.read()) def test_binary_readline(self): file_path = self.make_path("some_file") file_contents = b"\x80\n\x80\r\x80\r\n\x80" def chunk_line(): px = 0 while px < len(file_contents): ix = file_contents.find(b"\n", px) if ix == -1: yield file_contents[px:] return yield file_contents[px : ix + 1] px = ix + 1 chunked_contents = list(chunk_line()) self.create_file(file_path, contents=file_contents) with self.open(file_path, mode="rb") as f: self.assertEqual(chunked_contents, list(f)) class RealFileOpenLineEndingTest(FakeFileOpenLineEndingTest): def use_real_fs(self): return True class FakeFileOpenLineEndingWithEncodingTest(FakeFileOpenTestBase): def setUp(self): super().setUp() def test_read_standard_newline_mode(self): file_path = self.make_path("some_file") for contents in ("раз\nдва", "раз\r\nдва", "раз\rдва"): self.create_file(file_path, contents=contents, encoding="cyrillic") with self.open(file_path, mode="r", encoding="cyrillic") as fake_file: self.assertEqual(["раз\n", "два"], fake_file.readlines()) with self.open(file_path, mode="r", encoding="cyrillic") as fake_file: self.assertEqual("раз\nдва", fake_file.read()) def test_write_universal_newline_mode(self): file_path = self.make_path("some_file") with self.open(file_path, "w", encoding="cyrillic") as f: f.write("раз\nдва") with self.open(file_path, mode="rb") as f: self.assertEqual( "раз".encode("cyrillic") + self.os.linesep.encode() + "два".encode("cyrillic"), f.read(), ) with self.open(file_path, "w", encoding="cyrillic") as f: f.write("раз\r\nдва") with self.open(file_path, mode="rb") as f: self.assertEqual( "раз\r".encode("cyrillic") + self.os.linesep.encode() + "два".encode("cyrillic"), f.read(), ) def test_read_with_newline_arg(self): file_path = self.make_path("some_file") file_contents = "раз\r\nдва\nтри\rчетыре" self.create_file(file_path, contents=file_contents, encoding="cyrillic") with self.open(file_path, mode="r", newline="", encoding="cyrillic") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре", f.read()) with self.open(file_path, mode="r", newline="\r", encoding="cyrillic") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре", f.read()) with self.open(file_path, mode="r", newline="\n", encoding="cyrillic") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре", f.read()) with self.open(file_path, mode="r", newline="\r\n", encoding="cyrillic") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре", f.read()) def test_readlines_with_newline_arg(self): file_path = self.make_path("some_file") file_contents = "раз\r\nдва\nтри\rчетыре" self.create_file(file_path, contents=file_contents, encoding="cyrillic") with self.open(file_path, mode="r", newline="", encoding="cyrillic") as f: self.assertEqual(["раз\r\n", "два\n", "три\r", "четыре"], f.readlines()) with self.open(file_path, mode="r", newline="\r", encoding="cyrillic") as f: self.assertEqual(["раз\r", "\nдва\nтри\r", "четыре"], f.readlines()) with self.open(file_path, mode="r", newline="\n", encoding="cyrillic") as f: self.assertEqual(["раз\r\n", "два\n", "три\rчетыре"], f.readlines()) with self.open(file_path, mode="r", newline="\r\n", encoding="cyrillic") as f: self.assertEqual(["раз\r\n", "два\nтри\rчетыре"], f.readlines()) def test_write_with_newline_arg(self): file_path = self.make_path("some_file") with self.open(file_path, "w", newline="", encoding="cyrillic") as f: f.write("раз\r\nдва\nтри\rчетыре") with self.open(file_path, mode="rb") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре".encode("cyrillic"), f.read()) with self.open(file_path, "w", newline="\n", encoding="cyrillic") as f: f.write("раз\r\nдва\nтри\rчетыре") with self.open(file_path, mode="rb") as f: self.assertEqual("раз\r\nдва\nтри\rчетыре".encode("cyrillic"), f.read()) with self.open(file_path, "w", newline="\r\n", encoding="cyrillic") as f: f.write("раз\r\nдва\nтри\rчетыре") with self.open(file_path, mode="rb") as f: self.assertEqual("раз\r\r\nдва\r\nтри\rчетыре".encode("cyrillic"), f.read()) with self.open(file_path, "w", newline="\r", encoding="cyrillic") as f: f.write("раз\r\nдва\nтри\rчетыре") with self.open(file_path, mode="rb") as f: self.assertEqual("раз\r\rдва\rтри\rчетыре".encode("cyrillic"), f.read()) class RealFileOpenLineEndingWithEncodingTest(FakeFileOpenLineEndingWithEncodingTest): def use_real_fs(self): return True class OpenWithFileDescriptorTest(FakeFileOpenTestBase): def test_open_with_file_descriptor(self): file_path = self.make_path("this", "file") self.create_file(file_path) fd = self.os.open(file_path, os.O_CREAT) self.assertEqual(fd, self.open(fd, "r", encoding="utf8").fileno()) def test_closefd_with_file_descriptor(self): file_path = self.make_path("this", "file") self.create_file(file_path) fd = self.os.open(file_path, os.O_CREAT) fh = self.open(fd, "r", encoding="utf8", closefd=False) fh.close() self.assertIsNotNone(self.filesystem.open_files[fd]) fh = self.open(fd, "r", encoding="utf8", closefd=True) fh.close() self.assertIsNone(self.filesystem.open_files[fd]) class OpenWithRealFileDescriptorTest(FakeFileOpenTestBase): def use_real_fs(self): return True class OpenWithFlagsTestBase(FakeFileOpenTestBase): def setUp(self): super().setUp() self.file_path = self.make_path("some_file") self.file_contents = None def open_file(self, mode): kwargs = {"mode": mode} if "b" not in mode: kwargs["encoding"] = "utf8" return self.open(self.file_path, kwargs) def open_file_and_seek(self, mode): fake_file = self.open(self.file_path, mode=mode) fake_file.seek(0, 2) return fake_file def write_and_reopen_file(self, fake_file, mode="r", encoding=None): fake_file.write(self.file_contents) fake_file.close() args = {"mode": mode} if encoding: args["encoding"] = encoding return self.open(self.file_path, args) class OpenWithBinaryFlagsTest(OpenWithFlagsTestBase): def setUp(self): super().setUp() self.file_contents = b"real binary contents: \x1f\x8b" self.create_file(self.file_path, contents=self.file_contents) def test_read_binary(self): with self.open_file("rb") as fake_file: self.assertEqual(self.file_contents, fake_file.read()) def test_write_binary(self): with self.open_file_and_seek("wb") as f: self.assertEqual(0, f.tell()) with self.write_and_reopen_file(f, mode="rb") as f1: self.assertEqual(self.file_contents, f1.read()) # Attempt to reopen the file in text mode with self.open_file("wb") as f2: with self.write_and_reopen_file( f2, mode="r", encoding="ascii" ) as f3: with self.assertRaises(UnicodeDecodeError): f3.read() def test_write_and_read_binary(self): with self.open_file_and_seek("w+b") as f: self.assertEqual(0, f.tell()) with self.write_and_reopen_file(f, mode="rb") as f1: self.assertEqual(self.file_contents, f1.read()) class RealOpenWithBinaryFlagsTest(OpenWithBinaryFlagsTest): def use_real_fs(self): return True class OpenWithTextModeFlagsTest(OpenWithFlagsTestBase): def setUp(self): super().setUp() self.setUpFileSystem() def setUpFileSystem(self): self.file_path = self.make_path("some_file") self.file_contents = b"two\r\nlines" self.original_contents = "two\r\nlines" self.converted_contents = "two\nlines" self.create_file(self.file_path, contents=self.file_contents) def test_read_text(self): """Test that text mode flag is ignored""" self.check_windows_only() with self.open_file("r") as f: self.assertEqual(self.converted_contents, f.read()) with self.open_file("rt") as f: self.assertEqual(self.converted_contents, f.read()) def test_mixed_text_and_binary_flags(self): with self.assertRaises(ValueError): self.open_file_and_seek("w+bt") class RealOpenWithTextModeFlagsTest(OpenWithTextModeFlagsTest): def use_real_fs(self): return True class OpenWithInvalidFlagsTest(FakeFileOpenTestBase): def test_capital_r(self): with self.assertRaises(ValueError): self.open("some_file", "R") def test_capital_w(self): with self.assertRaises(ValueError): self.open("some_file", "W") def test_capital_a(self): with self.assertRaises(ValueError): self.open("some_file", "A") def test_lower_u(self): with self.assertRaises(ValueError): self.open("some_file", "u") def test_lower_rw(self): with self.assertRaises(ValueError): self.open("some_file", "rw") class OpenWithInvalidFlagsRealFsTest(OpenWithInvalidFlagsTest): def use_real_fs(self): return True class ResolvePathTest(FakeFileOpenTestBase): def write_to_file(self, file_name): with self.open(file_name, "w", encoding="utf8") as fh: fh.write("x") def test_none_filepath_raises_type_error(self): with self.assertRaises(TypeError): self.open(None, "w", encoding="utf8") def test_empty_filepath_raises_io_error(self): with self.assertRaises(OSError): self.open("", "w", encoding="utf8") def test_normal_path(self): file_path = self.make_path("foo") self.write_to_file(file_path) self.assertTrue(self.os.path.exists(file_path)) def test_link_within_same_directory(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz") link_path = self.make_path("foo", "bar") self.create_symlink(link_path, "baz") self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) self.assertEqual(1, self.os.stat(final_target)[stat.ST_SIZE]) def test_link_to_sub_directory(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz", "bip") dir_path = self.make_path("foo", "baz") self.create_dir(dir_path) link_path = self.make_path("foo", "bar") target_path = self.os.path.join("baz", "bip") self.create_symlink(link_path, target_path) self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) self.assertEqual(1, self.os.stat(final_target)[stat.ST_SIZE]) self.assertTrue(self.os.path.exists(dir_path)) # Make sure that intermediate directory got created. self.assertTrue(self.os.stat(dir_path)[stat.ST_MODE] & stat.S_IFDIR) def test_link_to_parent_directory(self): skip_if_symlink_not_supported() final_target = self.make_path("baz", "bip") self.create_dir(self.make_path("foo")) self.create_dir(self.make_path("baz")) link_path = self.make_path("foo", "bar") self.create_symlink(link_path, self.os.path.join("..", "baz")) self.write_to_file(self.make_path("foo", "bar", "bip")) self.assertTrue(self.os.path.exists(final_target)) self.assertEqual(1, self.os.stat(final_target)[stat.ST_SIZE]) self.assertTrue(self.os.path.exists(link_path)) def test_link_to_absolute_path(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz", "bip") self.create_dir(self.make_path("foo", "baz")) link_path = self.make_path("foo", "bar") self.create_symlink(link_path, final_target) self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) def test_relative_links_work_after_chdir(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz", "bip") self.create_dir(self.make_path("foo", "baz")) link_path = self.make_path("foo", "bar") self.create_symlink(link_path, self.os.path.join(".", "baz", "bip")) if not self.is_windows: self.assert_equal_paths(final_target, self.os.path.realpath(link_path)) self.assertTrue(self.os.path.islink(link_path)) self.os.chdir(self.make_path("foo")) self.assert_equal_paths(self.make_path("foo"), self.os.getcwd()) self.assertTrue(self.os.path.islink("bar")) if not self.is_windows: self.assert_equal_paths(final_target, self.os.path.realpath("bar")) self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) def test_absolute_links_work_after_chdir(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz", "bip") self.create_dir(self.make_path("foo", "baz")) link_path = self.make_path("foo", "bar") self.create_symlink(link_path, final_target) if not self.is_windows: self.assert_equal_paths(final_target, self.os.path.realpath(link_path)) self.assertTrue(self.os.path.islink(link_path)) self.os.chdir(self.make_path("foo")) self.assert_equal_paths(self.make_path("foo"), self.os.getcwd()) self.assertTrue(self.os.path.islink("bar")) if not self.is_windows: self.assert_equal_paths(final_target, self.os.path.realpath("bar")) self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) def test_chdir_through_relative_link(self): self.check_posix_only() dir1_path = self.make_path("x", "foo") dir2_path = self.make_path("x", "bar") self.create_dir(dir1_path) self.create_dir(dir2_path) link_path = self.make_path("x", "foo", "bar") self.create_symlink(link_path, self.os.path.join("..", "bar")) self.assert_equal_paths(dir2_path, self.os.path.realpath(link_path)) self.os.chdir(dir1_path) self.assert_equal_paths(dir1_path, self.os.getcwd()) self.assert_equal_paths(dir2_path, self.os.path.realpath("bar")) self.os.chdir("bar") self.assert_equal_paths(dir2_path, self.os.getcwd()) def test_chdir_uses_open_fd_as_path(self): self.check_posix_only() if self.is_pypy: # unclear behavior with PyPi self.skip_real_fs() self.assert_raises_os_error([errno.ENOTDIR, errno.EBADF], self.os.chdir, 500) dir_path = self.make_path("foo", "bar") self.create_dir(dir_path) path_des = self.os.open(dir_path, os.O_RDONLY) self.os.chdir(path_des) self.os.close(path_des) self.assert_equal_paths(dir_path, self.os.getcwd()) def test_read_link_to_link(self): # Write into the final link target and read back from a file which will # point to that. skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar") self.create_symlink(link_path, "link") self.create_symlink(self.make_path("foo", "link"), "baz") self.write_to_file(self.make_path("foo", "baz")) fh = self.open(link_path, "r", encoding="utf8") self.assertEqual("x", fh.read()) def test_write_link_to_link(self): skip_if_symlink_not_supported() final_target = self.make_path("foo", "baz") link_path = self.make_path("foo", "bar") self.create_symlink(link_path, "link") self.create_symlink(self.make_path("foo", "link"), "baz") self.write_to_file(link_path) self.assertTrue(self.os.path.exists(final_target)) def test_multiple_links(self): skip_if_symlink_not_supported() self.os.makedirs(self.make_path("a", "link1", "c", "link2")) self.create_symlink(self.make_path("a", "b"), "link1") if not self.is_windows: self.assert_equal_paths( self.make_path("a", "link1"), self.os.path.realpath(self.make_path("a", "b")), ) self.assert_equal_paths( self.make_path("a", "link1", "c"), self.os.path.realpath(self.make_path("a", "b", "c")), ) link_path = self.make_path("a", "link1", "c", "d") self.create_symlink(link_path, "link2") self.assertTrue(self.os.path.exists(link_path)) self.assertTrue(self.os.path.exists(self.make_path("a", "b", "c", "d"))) final_target = self.make_path("a", "link1", "c", "link2", "e") self.assertFalse(self.os.path.exists(final_target)) self.write_to_file(self.make_path("a", "b", "c", "d", "e")) self.assertTrue(self.os.path.exists(final_target)) def test_utime_link(self): """os.utime() and os.stat() via symbolic link (issue #49)""" skip_if_symlink_not_supported() self.create_dir(self.make_path("foo", "baz")) target_path = self.make_path("foo", "baz", "bip") self.write_to_file(target_path) link_name = self.make_path("foo", "bar") self.create_symlink(link_name, target_path) self.os.utime(link_name, (1, 2)) st = self.os.stat(link_name) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) self.os.utime(link_name, (3, 4)) st = self.os.stat(link_name) self.assertEqual(3, st.st_atime) self.assertEqual(4, st.st_mtime) def test_too_many_links(self): self.check_posix_only() link_path = self.make_path("a", "loop") self.create_symlink(link_path, "loop") self.assertFalse(self.os.path.exists(link_path)) def test_that_drive_letters_are_preserved(self): self.check_windows_only() self.skip_real_fs() self.assertEqual("C:!foo!bar", self.filesystem.resolve_path("C:!foo!!bar")) def test_that_unc_paths_are_preserved(self): self.check_windows_only() self.skip_real_fs() self.assertEqual( "!!foo!bar!baz", self.filesystem.resolve_path("!!foo!bar!baz!!") ) class RealResolvePathTest(ResolvePathTest): def use_real_fs(self): return True class SkipOpenTest(unittest.TestCase): def test_open_in_skipped_module(self): with Patcher(additional_skip_names=["skipped_pathlib"]): contents = read_open("skipped_pathlib.py") self.assertTrue(contents.startswith("# Licensed under the Apache License")) if __name__ == "__main__": unittest.main()	89.06 KB	2026-01-20 12:58
📄 fake_os_test.py # # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unit tests for fake_os.FakeOsModule.""" import errno import os import stat import sys import unittest from pyfakefs import fake_filesystem, fake_os, fake_open, fake_file from pyfakefs.fake_filesystem import ( FakeFileOpen, is_root, set_uid, set_gid, ) from pyfakefs.helpers import IN_DOCKER, IS_PYPY, get_uid, get_gid, reset_ids from pyfakefs.tests.test_utils import ( TestCase, RealFsTestCase, skip_if_symlink_not_supported, ) class FakeOsModuleTestBase(RealFsTestCase): def setUp(self): super().setUp() self.umask = self.os.umask(0o022) def tearDown(self): self.os.umask(self.umask) def createTestFile(self, path): self.create_file(path) self.assertTrue(self.os.path.exists(path)) st = self.os.stat(path) # under Windows, the umask has no effect mode = 0o666 if self.is_windows_fs else 0o0644 self.assertEqual(mode, stat.S_IMODE(st.st_mode)) self.assertTrue(st.st_mode & stat.S_IFREG) self.assertFalse(st.st_mode & stat.S_IFDIR) def createTestDirectory(self, path): self.create_dir(path) self.assertTrue(self.os.path.exists(path)) st = self.os.stat(path) mode = 0o777 if self.is_windows_fs else 0o755 self.assertEqual(mode, stat.S_IMODE(st.st_mode)) self.assertFalse(st.st_mode & stat.S_IFREG) self.assertTrue(st.st_mode & stat.S_IFDIR) class FakeOsModuleTest(FakeOsModuleTestBase): def setUp(self): super().setUp() self.rwx = self.os.R_OK \| self.os.W_OK \| self.os.X_OK self.rw = self.os.R_OK \| self.os.W_OK def test_chdir(self): """chdir should work on a directory.""" directory = self.make_path("foo") self.create_dir(directory) self.os.chdir(directory) def test_chdir_fails_non_exist(self): """chdir should raise OSError if the target does not exist.""" directory = self.make_path("no", "such", "directory") self.assert_raises_os_error(errno.ENOENT, self.os.chdir, directory) def test_chdir_fails_non_directory(self): """chdir should raise OSError if the target is not a directory.""" filename = self.make_path("foo", "bar") self.create_file(filename) self.assert_raises_os_error(errno.ENOTDIR, self.os.chdir, filename) def test_consecutive_chdir(self): """Consecutive relative chdir calls should work.""" dir1 = self.make_path("foo") dir2 = "bar" full_dirname = self.os.path.join(dir1, dir2) self.create_dir(full_dirname) self.os.chdir(dir1) self.os.chdir(dir2) # use real path to handle symlink /var to /private/var in MacOs self.assertEqual( os.path.realpath(self.os.getcwd()), os.path.realpath(full_dirname) ) def test_backwards_chdir(self): """chdir into '..' should behave appropriately.""" # skipping real fs test - can't test root dir self.skip_real_fs() rootdir = self.os.getcwd() dirname = "foo" abs_dirname = self.os.path.abspath(dirname) self.filesystem.create_dir(dirname) self.os.chdir(dirname) self.assertEqual(abs_dirname, self.os.getcwd()) self.os.chdir("..") self.assertEqual(rootdir, self.os.getcwd()) self.os.chdir(self.os.path.join(dirname, "..")) self.assertEqual(rootdir, self.os.getcwd()) def test_get_cwd(self): # skipping real fs test - can't test root dir self.skip_real_fs() dirname = self.make_path("foo", "bar") self.create_dir(dirname) self.assertEqual(self.filesystem.root_dir_name, self.os.getcwd()) self.os.chdir(dirname) self.assertEqual(dirname, self.os.getcwd()) def test_listdir(self): self.assert_raises_os_error( errno.ENOENT, self.os.listdir, "non_existing/fake_dir" ) directory = self.make_path("xyzzy", "plugh") files = ["foo", "bar", "baz"] for f in files: self.create_file(self.os.path.join(directory, f)) files.sort() self.assertEqual(files, sorted(self.os.listdir(directory))) def test_listdir_uses_open_fd_as_path(self): self.check_posix_only() if os.listdir not in os.supports_fd: self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.listdir, 500) dir_path = self.make_path("xyzzy", "plugh") files = ["foo", "bar", "baz"] for f in files: self.create_file(self.os.path.join(dir_path, f)) files.sort() path_des = self.os.open(dir_path, os.O_RDONLY) self.assertEqual(files, sorted(self.os.listdir(path_des))) def test_listdir_returns_list(self): directory_root = self.make_path("xyzzy") self.os.mkdir(directory_root) directory = self.os.path.join(directory_root, "bug") self.os.mkdir(directory) self.create_file(self.make_path(directory, "foo")) self.assertEqual(["foo"], self.os.listdir(directory)) def test_listdir_on_symlink(self): skip_if_symlink_not_supported() directory = self.make_path("xyzzy") files = ["foo", "bar", "baz"] for f in files: self.create_file(self.make_path(directory, f)) self.create_symlink(self.make_path("symlink"), self.make_path("xyzzy")) files.sort() self.assertEqual(files, sorted(self.os.listdir(self.make_path("symlink")))) def test_listdir_error(self): file_path = self.make_path("foo", "bar", "baz") self.create_file(file_path) self.assert_raises_os_error(errno.ENOTDIR, self.os.listdir, file_path) def test_exists_current_dir(self): self.assertTrue(self.os.path.exists(".")) def test_listdir_current(self): files = ["foo", "bar", "baz"] for f in files: self.create_file(self.make_path(f)) files.sort() self.assertEqual(files, sorted(self.os.listdir(self.base_path))) def test_fdopen(self): file_path1 = self.make_path("some_file1") self.create_file(file_path1, contents="contents here1") with self.open(file_path1, "r", encoding="utf8") as fake_file1: fileno = fake_file1.fileno() fake_file2 = self.os.fdopen(fileno, encoding="utf8") self.assertNotEqual(fake_file2, fake_file1) with self.assertRaises(TypeError): self.os.fdopen(None) with self.assertRaises(TypeError): self.os.fdopen("a string") def test_out_of_range_fdopen(self): # test some file descriptor that is clearly out of range kwargs = {"encoding": "utf8"} self.assert_raises_os_error(errno.EBADF, self.os.fdopen, 500, kwargs) def test_closed_file_descriptor(self): first_path = self.make_path("some_file1") second_path = self.make_path("some_file2") third_path = self.make_path("some_file3") self.create_file(first_path, contents="contents here1") self.create_file(second_path, contents="contents here2") self.create_file(third_path, contents="contents here3") fake_file1 = self.open(first_path, "r", encoding="utf8") fake_file2 = self.open(second_path, "r", encoding="utf8") fake_file3 = self.open(third_path, "r", encoding="utf8") fileno1 = fake_file1.fileno() fileno2 = fake_file2.fileno() fileno3 = fake_file3.fileno() self.os.close(fileno2) self.assert_raises_os_error(errno.EBADF, self.os.close, fileno2) self.assertEqual(fileno1, fake_file1.fileno()) self.assertEqual(fileno3, fake_file3.fileno()) with self.os.fdopen(fileno1, encoding="utf8") as f: self.assertFalse(f is fake_file1) with self.os.fdopen(fileno3, encoding="utf8") as f: self.assertFalse(f is fake_file3) kwargs = {"encoding": "utf8"} self.assert_raises_os_error(errno.EBADF, self.os.fdopen, fileno2, kwargs) def test_fdopen_twice(self): # regression test for #997 file_path = self.make_path("some_file1") self.create_file(file_path, contents="contents here1") fake_file = self.open(file_path, "r", encoding="utf8") fd = fake_file.fileno() # note: we need to assign the files to objects, # otherwise the file will be closed immediately in the CPython implementation # note that this case is not (and will probably not be) handled in pyfakefs file1 = self.open(fd, encoding="utf8") # noqa: F841 file2 = self.open(fd, encoding="utf8") # noqa: F841 self.os.close(fd) def test_open_fd_write_mode_for_ro_file(self): # Create a writable file handle to a read-only file, see #967 file_path = self.make_path("file.txt") fd = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY, 0o555) with self.open(fd, "w", encoding="utf8") as out: out.write("hey") with self.open(file_path, encoding="utf8") as f: assert f.read() == "hey" self.os.chmod(file_path, 0o655) def test_open_fd_read_mode_for_ro_file(self): # Create a read-only handle to a read-only file, see #967 file_path = self.make_path("file.txt") fd = self.os.open(file_path, os.O_CREAT \| os.O_RDONLY, 0x555) # Attempt to open a write stream to the underlying file out = self.open(fd, "wb") out.flush() # Does not fail: The buffer is empty, so no write() # Fails: Tries to flush a non-empty buffer out.write(b"a") # file.write() may fail by an implicit flush! with self.assertRaises(OSError) as cm: out.flush() assert cm.exception.errno == errno.EBADF # Fails: Tries to flush() again with self.assertRaises(OSError) as cm: out.close() assert cm.exception.errno == errno.EBADF out.close() # Okay: The file is already closed self.os.chmod(file_path, 0o655) def test_fstat(self): directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path, contents="ABCDE") with self.open(file_path, encoding="utf8") as file_obj: fileno = file_obj.fileno() self.assertTrue(stat.S_IFREG & self.os.fstat(fileno)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.fstat(fileno).st_mode) self.assertEqual(5, self.os.fstat(fileno)[stat.ST_SIZE]) def test_stat(self): directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path, contents="ABCDE") self.assertTrue(stat.S_IFDIR & self.os.stat(directory)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path).st_mode) self.assertEqual(5, self.os.stat(file_path)[stat.ST_SIZE]) def test_st_blocks(self): self.check_posix_only() file_path = self.make_path("foo1") self.create_file(file_path, contents=b"") self.assertEqual(0, self.os.stat(file_path).st_blocks) file_path = self.make_path("foo2") self.create_file(file_path, contents=b"t") self.assertEqual(8, self.os.stat(file_path).st_blocks) file_path = self.make_path("foo3") self.create_file(file_path, contents=b"t" * 4095) self.assertEqual(8, self.os.stat(file_path).st_blocks) file_path = self.make_path("foo4") self.create_file(file_path, contents=b"t" * 4096) self.assertEqual(8, self.os.stat(file_path).st_blocks) file_path = self.make_path("foo5") self.create_file(file_path, contents=b"t" * 4097) self.assertEqual(16, self.os.stat(file_path).st_blocks) def test_no_st_blocks_in_windows(self): self.check_windows_only() file_path = self.make_path("foo") self.create_file(file_path, contents=b"") with self.assertRaises(AttributeError): self.os.stat(file_path).st_blocks def test_stat_with_unc_path(self): self.skip_real_fs() self.check_windows_only() directory = "//root/share/dir" file_path = self.os.path.join(directory, "plugh") self.create_file(file_path, contents="ABCDE") self.assertTrue(stat.S_IFDIR & self.os.stat(directory)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path).st_mode) self.assertEqual(5, self.os.stat(file_path)[stat.ST_SIZE]) def test_stat_with_drive(self): self.skip_real_fs() self.check_windows_only() directory = "C:/foo/dir" file_path = self.os.path.join(directory, "plugh") self.create_file(file_path, contents="ABCDE") self.assertTrue(stat.S_IFDIR & self.os.stat(directory)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path).st_mode) self.assertEqual(5, self.os.stat(file_path)[stat.ST_SIZE]) def test_stat_uses_open_fd_as_path(self): self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.stat, 5) file_path = self.make_path("foo", "bar") self.create_file(file_path) with self.open(file_path, encoding="utf8") as f: self.assertTrue(stat.S_IFREG & self.os.stat(f.filedes)[stat.ST_MODE]) def test_stat_no_follow_symlinks_posix(self): """Test that stat with follow_symlinks=False behaves like lstat.""" self.check_posix_only() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual( len(file_contents), self.os.stat(file_path, follow_symlinks=False)[stat.ST_SIZE], ) self.assertEqual( len(base_name), self.os.stat(link_path, follow_symlinks=False)[stat.ST_SIZE], ) def test_stat_no_follow_symlinks_windows(self): """Test that stat with follow_symlinks=False behaves like lstat.""" self.check_windows_only() skip_if_symlink_not_supported() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual( len(file_contents), self.os.stat(file_path, follow_symlinks=False)[stat.ST_SIZE], ) self.assertEqual( 0, self.os.stat(link_path, follow_symlinks=False)[stat.ST_SIZE] ) def test_lstat_size_posix(self): self.check_posix_only() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual(len(file_contents), self.os.lstat(file_path)[stat.ST_SIZE]) self.assertEqual(len(base_name), self.os.lstat(link_path)[stat.ST_SIZE]) def test_lstat_size_windows(self): self.check_windows_only() skip_if_symlink_not_supported() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual(len(file_contents), self.os.lstat(file_path)[stat.ST_SIZE]) self.assertEqual(0, self.os.lstat(link_path)[stat.ST_SIZE]) def test_lstat_trailing_sep(self): # regression test for #342 stat_result = self.os.lstat(self.base_path) self.assertEqual( stat_result, self.os.lstat(self.base_path + self.path_separator()) ) self.assertEqual( stat_result, self.os.lstat( self.base_path + self.path_separator() + self.path_separator() ), ) def test_stat_with_byte_string(self): stat_str = self.os.stat(self.base_path) base_path_bytes = self.base_path.encode("utf8") stat_bytes = self.os.stat(base_path_bytes) self.assertEqual(stat_bytes, stat_str) def test_lstat_with_byte_string(self): stat_str = self.os.lstat(self.base_path) base_path_bytes = self.base_path.encode("utf8") stat_bytes = self.os.lstat(base_path_bytes) self.assertEqual(stat_bytes, stat_str) def test_stat_with_current_dir(self): # regression test for #516 stat_result = self.os.stat(".") lstat_result = self.os.lstat(".") self.assertEqual(stat_result, lstat_result) def test_exists_with_trailing_sep(self): # regression test for #364 file_path = self.make_path("alpha") self.create_file(file_path) self.assertFalse(self.os.path.exists(file_path + self.os.sep)) def test_mkdir_with_trailing_sep(self): # regression test for #367 dir_path = self.make_path("foo") self.os.mkdir(dir_path + self.os.sep + self.os.sep) self.assertTrue(self.os.path.exists(dir_path)) def test_readlink_empty_path(self): self.check_posix_only() self.assert_raises_os_error(errno.ENOENT, self.os.readlink, "") def test_readlink_ending_with_sep_posix(self): # regression test for #359 self.check_posix_only() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assert_raises_os_error( errno.EINVAL, self.os.readlink, link_path + self.os.sep ) def test_lstat_symlink_with_trailing_sep_linux(self): # regression test for #366 self.check_linux_only() skip_if_symlink_not_supported() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) # used to raise self.assertTrue(self.os.lstat(link_path + self.os.sep).st_mode) def test_lstat_symlink_with_trailing_sep_macos(self): # regression test for #366 self.check_macos_only() skip_if_symlink_not_supported() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) # used to raise self.assertTrue(self.os.lstat(link_path + self.os.sep).st_mode) def test_readlink_ending_with_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assert_equal_paths( self.base_path, self.os.readlink(link_path + self.os.sep) ) def test_islink_with_trailing_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assertTrue(self.os.path.islink(link_path + self.os.path.sep)) def test_islink_with_trailing_sep_linux(self): self.check_linux_only() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assertFalse(self.os.path.islink(link_path + self.os.sep)) def test_islink_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assertFalse(self.os.path.islink(link_path + self.os.sep)) def test_getsize_raises_with_trailing_separator(self): file_path = self.make_path("bar") self.create_file(file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.path.getsize, file_path + self.os.sep ) def check_remove_link_ending_with_sep(self, error_nr): # regression test for #360 link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) self.assert_raises_os_error(error_nr, self.os.remove, link_path + self.os.sep) def test_remove_link_ending_with_sep_linux(self): self.check_linux_only() self.check_remove_link_ending_with_sep(errno.ENOTDIR) def test_remove_link_ending_with_sep_macos(self): self.check_macos_only() self.check_remove_link_ending_with_sep(errno.EPERM) def test_remove_link_ending_with_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_remove_link_ending_with_sep(errno.EACCES) def test_lstat_uses_open_fd_as_path(self): skip_if_symlink_not_supported() if os.lstat not in os.supports_fd: self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.lstat, 5) file_path = self.make_path("foo", "bar") link_path = self.make_path("foo", "link") file_contents = b"contents" self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, file_path) with self.open(file_path, encoding="utf8") as f: self.assertEqual(len(file_contents), self.os.lstat(f.filedes)[stat.ST_SIZE]) def test_stat_non_existent_file(self): # set up file_path = self.make_path("non", "existent", "file") self.assertFalse(self.os.path.exists(file_path)) # actual tests try: # Use try-catch to check exception attributes. self.os.stat(file_path) self.fail("Exception is expected.") # COV_NF_LINE except OSError as os_error: self.assertEqual(errno.ENOENT, os_error.errno) self.assertEqual(file_path, os_error.filename) def check_open_raises_with_trailing_separator(self, error_nr): file_path = self.make_path("bar") + self.os.sep self.assert_raises_os_error( error_nr, self.os.open, file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC, ) def test_open_raises_with_trailing_separator_linux(self): self.check_linux_only() self.check_open_raises_with_trailing_separator(errno.EISDIR) def test_open_raises_with_trailing_separator_macos(self): self.check_macos_only() self.check_open_raises_with_trailing_separator(errno.ENOENT) def test_open_raises_with_trailing_separator_windows(self): self.check_windows_only() self.check_open_raises_with_trailing_separator(errno.EINVAL) @unittest.skipIf(not hasattr(os, "O_DIRECTORY"), "opening directory not supported") def test_open_with_o_directory(self): self.check_posix_only() with self.assertRaises(FileNotFoundError): self.os.open("bogus", os.O_RDONLY \| os.O_DIRECTORY) file_path = self.make_path("file.txt") self.create_file(file_path, contents="foo") with self.assertRaises(NotADirectoryError): self.os.open(file_path, os.O_RDONLY \| os.O_DIRECTORY) dir_path = self.make_path("dir") self.create_dir(dir_path) with self.assertRaises(IsADirectoryError): self.os.open(dir_path, os.O_RDWR \| os.O_DIRECTORY) @unittest.skipIf(not hasattr(os, "O_NOFOLLOW"), "NOFOLLOW attribute not supported") def test_open_nofollow_symlink_raises(self): skip_if_symlink_not_supported() file_path = self.make_path("file.txt") self.create_file(file_path, contents="foo") link_path = self.make_path("link") self.create_symlink(link_path, file_path) with self.assertRaises(OSError) as cm: self.os.open(link_path, os.O_RDONLY \| os.O_NOFOLLOW) assert cm.exception.errno == errno.ELOOP @unittest.skipIf(not hasattr(os, "O_NOFOLLOW"), "NOFOLLOW attribute not supported") def test_open_nofollow_symlink_as_parent_works(self): skip_if_symlink_not_supported() dir_path = self.make_path("dir") self.create_dir(dir_path) link_path = self.make_path("link") self.create_symlink(link_path, dir_path) file_path = self.os.path.join(link_path, "file.txt") self.create_file(file_path, contents="foo") fd = self.os.open(file_path, os.O_RDONLY \| os.O_NOFOLLOW) self.assertGreater(fd, 0) self.os.close(fd) def test_lexists_with_trailing_separator_linux_windows(self): self.check_linux_and_windows() skip_if_symlink_not_supported() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assertFalse(self.os.path.lexists(file_path + self.os.sep)) def test_lexists_with_trailing_separator_macos(self): # regression test for #373 self.check_macos_only() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assertTrue(self.os.path.lexists(file_path + self.os.sep)) def test_islink_with_trailing_separator_linux_windows(self): self.check_linux_and_windows() skip_if_symlink_not_supported() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assertFalse(self.os.path.islink(file_path + self.os.sep)) def test_islink_with_trailing_separator_macos(self): # regression test for #373 self.check_macos_only() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assertTrue(self.os.path.islink(file_path + self.os.sep)) def test_isfile_with_trailing_separator_linux_windows(self): self.check_linux_and_windows() file_path = self.make_path("foo") self.create_file(file_path) self.assertFalse(self.os.path.isfile(file_path + self.os.sep)) def test_isfile_with_trailing_separator_macos(self): # regression test for #374 self.check_macos_only() file_path = self.make_path("foo") self.create_file(file_path) self.assertFalse(self.os.path.isfile(file_path + self.os.sep)) def test_isfile_not_readable_file(self): file_path = self.make_path("foo") self.create_file(file_path, perm=0) self.assertTrue(self.os.path.isfile(file_path)) def test_stat_with_trailing_separator(self): # regression test for #376 file_path = self.make_path("foo") self.create_file(file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.stat, file_path + self.os.sep ) def test_remove_with_trailing_separator(self): # regression test for #377 file_path = self.make_path("foo") self.create_file(file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.remove, file_path + self.os.sep ) def test_readlink(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "baz") target = self.make_path("tarJAY") self.create_symlink(link_path, target) self.assert_equal_paths(self.os.readlink(link_path), target) def check_readlink_raises_if_path_is_not_a_link(self): file_path = self.make_path("foo", "bar", "eleventyone") self.create_file(file_path) self.assert_raises_os_error(errno.EINVAL, self.os.readlink, file_path) def test_readlink_raises_if_path_is_not_a_link_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_readlink_raises_if_path_is_not_a_link() def test_readlink_raises_if_path_is_not_a_link_posix(self): self.check_posix_only() self.check_readlink_raises_if_path_is_not_a_link() def check_readlink_raises_if_path_has_file(self, error_subtype): self.create_file(self.make_path("a_file")) file_path = self.make_path("a_file", "foo") self.assert_raises_os_error(error_subtype, self.os.readlink, file_path) file_path = self.make_path("a_file", "foo", "bar") self.assert_raises_os_error(error_subtype, self.os.readlink, file_path) def test_readlink_raises_if_path_has_file_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_readlink_raises_if_path_has_file(errno.ENOENT) def test_readlink_raises_if_path_has_file_posix(self): self.check_posix_only() self.check_readlink_raises_if_path_has_file(errno.ENOTDIR) def test_readlink_raises_if_path_does_not_exist(self): skip_if_symlink_not_supported() self.assert_raises_os_error( errno.ENOENT, self.os.readlink, "/this/path/does/not/exist" ) def test_readlink_raises_if_path_is_none(self): skip_if_symlink_not_supported() with self.assertRaises(TypeError): self.os.readlink(None) def test_broken_symlink_with_trailing_separator_linux(self): self.check_linux_only() file_path = self.make_path("foo") link_path = self.make_path("link") self.os.symlink(file_path, link_path) self.assert_raises_os_error( errno.EEXIST, self.os.symlink, link_path + self.os.sep, link_path + self.os.sep, ) def test_broken_symlink_with_trailing_separator_macos(self): # regression test for #371 self.check_macos_only() file_path = self.make_path("foo") link_path = self.make_path("link") self.os.symlink(file_path, link_path) self.os.symlink(link_path + self.os.sep, link_path + self.os.sep) def test_broken_symlink_with_trailing_separator_windows(self): self.check_windows_only() skip_if_symlink_not_supported() file_path = self.make_path("foo") link_path = self.make_path("link") self.os.symlink(file_path, link_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.symlink, link_path + self.os.sep, link_path + self.os.sep, ) def test_circular_readlink_with_trailing_separator_linux(self): # Regression test for #372 self.check_linux_only() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assert_raises_os_error( errno.ELOOP, self.os.readlink, file_path + self.os.sep ) def test_circular_readlink_with_trailing_separator_macos(self): # Regression test for #372 self.check_macos_only() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.os.readlink(file_path + self.os.sep) def test_circular_readlink_with_trailing_separator_windows(self): # Regression test for #372 self.check_windows_only() skip_if_symlink_not_supported() file_path = self.make_path("foo") self.os.symlink(file_path, file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.readlink, file_path + self.os.sep ) def test_readlink_with_links_in_path(self): skip_if_symlink_not_supported() self.create_symlink( self.make_path("meyer", "lemon", "pie"), self.make_path("yum") ) self.create_symlink(self.make_path("geo", "metro"), self.make_path("meyer")) self.assert_equal_paths( self.make_path("yum"), self.os.readlink(self.make_path("geo", "metro", "lemon", "pie")), ) def test_readlink_with_chained_links_in_path(self): skip_if_symlink_not_supported() self.create_symlink( self.make_path("eastern", "european", "wolfhounds", "chase"), self.make_path("cats"), ) self.create_symlink( self.make_path("russian"), self.make_path("eastern", "european") ) self.create_symlink( self.make_path("dogs"), self.make_path("russian", "wolfhounds") ) self.assert_equal_paths( self.make_path("cats"), self.os.readlink(self.make_path("dogs", "chase")), ) def check_remove_dir(self, dir_error): directory = self.make_path("xyzzy") dir_path = self.os.path.join(directory, "plugh") self.create_dir(dir_path) self.assertTrue(self.os.path.exists(dir_path)) self.assert_raises_os_error(dir_error, self.os.remove, dir_path) self.assertTrue(self.os.path.exists(dir_path)) self.os.chdir(directory) self.assert_raises_os_error(dir_error, self.os.remove, dir_path) self.assertTrue(self.os.path.exists(dir_path)) self.assert_raises_os_error(errno.ENOENT, self.os.remove, "/plugh") def test_remove_dir_linux(self): self.check_linux_only() self.check_remove_dir(errno.EISDIR) def test_remove_dir_mac_os(self): self.check_macos_only() self.check_remove_dir(errno.EPERM) def test_remove_dir_windows(self): self.check_windows_only() self.check_remove_dir(errno.EACCES) def test_remove_dir_with_drive(self): # regression test for issue #337 self.check_windows_only() self.skip_real_fs() dir_path = self.os.path.join("C:", "test") self.filesystem.create_dir(dir_path) self.assert_raises_os_error(errno.EACCES, self.os.remove, dir_path) def test_remove_file(self): directory = self.make_path("zzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.os.remove(file_path) self.assertFalse(self.os.path.exists(file_path)) def test_remove_file_no_directory(self): directory = self.make_path("zzy") file_name = "plugh" file_path = self.os.path.join(directory, file_name) self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.os.chdir(directory) self.os.remove(file_name) self.assertFalse(self.os.path.exists(file_path)) def test_remove_file_with_read_permission_raises_in_windows(self): self.check_windows_only() self.skip_root() path = self.make_path("foo", "bar") self.create_file(path) self.os.chmod(path, 0o444) self.assert_raises_os_error(errno.EACCES, self.os.remove, path) self.os.chmod(path, 0o666) def test_remove_file_with_read_permission_shall_succeed_in_posix(self): self.check_posix_only() path = self.make_path("foo", "bar") self.create_file(path) self.os.chmod(path, 0o444) self.os.remove(path) self.assertFalse(self.os.path.exists(path)) def test_remove_file_without_parent_permission_raises_in_posix(self): self.check_posix_only() parent_dir = self.make_path("foo") path = self.os.path.join(parent_dir, "bar") self.create_file(path) self.os.chmod(parent_dir, 0o666) # missing execute permission if not is_root(): self.assert_raises_os_error(errno.EACCES, self.os.remove, path) else: self.os.remove(path) self.assertFalse(self.os.path.exists(path)) self.create_file(path) self.os.chmod(parent_dir, 0o555) # missing write permission if not is_root(): self.assert_raises_os_error(errno.EACCES, self.os.remove, path) else: self.os.remove(path) self.assertFalse(self.os.path.exists(path)) self.create_file(path) self.os.chmod(parent_dir, 0o333) self.os.remove(path) self.assertFalse(self.os.path.exists(path)) def test_remove_open_file_fails_under_windows(self): self.check_windows_only() path = self.make_path("foo", "bar") self.create_file(path) with self.open(path, "r", encoding="utf8"): self.assert_raises_os_error(errno.EACCES, self.os.remove, path) self.assertTrue(self.os.path.exists(path)) def test_remove_open_file_possible_under_posix(self): self.check_posix_only() path = self.make_path("foo", "bar") self.create_file(path) self.open(path, "r", encoding="utf8") self.os.remove(path) self.assertFalse(self.os.path.exists(path)) def test_remove_file_relative_path(self): self.skip_real_fs() original_dir = self.os.getcwd() directory = self.make_path("zzy") subdirectory = self.os.path.join(directory, "zzy") file_name = "plugh" file_path = self.os.path.join(directory, file_name) file_path_relative = self.os.path.join("..", file_name) self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.create_dir(subdirectory) self.assertTrue(self.os.path.exists(subdirectory)) self.os.chdir(subdirectory) self.os.remove(file_path_relative) self.assertFalse(self.os.path.exists(file_path_relative)) self.os.chdir(original_dir) self.assertFalse(self.os.path.exists(file_path)) def check_remove_dir_raises_error(self, dir_error): directory = self.make_path("zzy") self.create_dir(directory) self.assert_raises_os_error(dir_error, self.os.remove, directory) def test_remove_dir_raises_error_linux(self): self.check_linux_only() self.check_remove_dir_raises_error(errno.EISDIR) def test_remove_dir_raises_error_mac_os(self): self.check_macos_only() self.check_remove_dir_raises_error(errno.EPERM) def test_remove_dir_raises_error_windows(self): self.check_windows_only() self.check_remove_dir_raises_error(errno.EACCES) def test_remove_symlink_to_dir(self): skip_if_symlink_not_supported() directory = self.make_path("zzy") link = self.make_path("link_to_dir") self.create_dir(directory) self.os.symlink(directory, link) self.assertTrue(self.os.path.exists(directory)) self.assertTrue(self.os.path.exists(link)) self.os.remove(link) self.assertTrue(self.os.path.exists(directory)) self.assertFalse(self.os.path.exists(link)) def test_unlink_raises_if_not_exist(self): file_path = self.make_path("file", "does", "not", "exist") self.assertFalse(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.ENOENT, self.os.unlink, file_path) def test_rename_to_nonexistent_file(self): """Can rename a file to an unused name.""" directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents") self.assertTrue(self.os.path.exists(old_file_path)) self.assertFalse(self.os.path.exists(new_file_path)) self.os.rename(old_file_path, new_file_path) self.assertFalse(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.check_contents(new_file_path, "test contents") def test_rename_dir_to_symlink_posix(self): self.check_posix_only() link_path = self.make_path("link") dir_path = self.make_path("dir") link_target = self.os.path.join(dir_path, "link_target") self.create_dir(dir_path) self.os.symlink(link_target, link_path) self.assert_raises_os_error(errno.ENOTDIR, self.os.rename, dir_path, link_path) def test_rename_dir_to_symlink_windows(self): self.check_windows_only() skip_if_symlink_not_supported() link_path = self.make_path("link") dir_path = self.make_path("dir") link_target = self.os.path.join(dir_path, "link_target") self.create_dir(dir_path) self.os.symlink(link_target, link_path) self.assert_raises_os_error(errno.EEXIST, self.os.rename, dir_path, link_path) def test_rename_file_to_symlink(self): self.check_posix_only() link_path = self.make_path("file_link") file_path = self.make_path("file") self.os.symlink(file_path, link_path) self.create_file(file_path) self.os.rename(file_path, link_path) self.assertFalse(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(link_path)) self.assertTrue(self.os.path.isfile(link_path)) def test_rename_symlink_to_symlink(self): self.check_posix_only() base_path = self.make_path("foo", "bar") self.create_dir(base_path) link_path1 = self.os.path.join(base_path, "link1") link_path2 = self.os.path.join(base_path, "link2") self.os.symlink(base_path, link_path1) self.os.symlink(base_path, link_path2) self.os.rename(link_path1, link_path2) self.assertFalse(self.os.path.exists(link_path1)) self.assertTrue(self.os.path.exists(link_path2)) def test_rename_symlink_to_symlink_for_parent_raises(self): self.check_posix_only() dir_link = self.make_path("dir_link") dir_path = self.make_path("dir") dir_in_dir_path = self.os.path.join(dir_link, "inner_dir") self.create_dir(dir_path) self.os.symlink(dir_path, dir_link) self.create_dir(dir_in_dir_path) self.assert_raises_os_error( errno.EINVAL, self.os.rename, dir_path, dir_in_dir_path ) def check_rename_case_with_symlink(self, result): skip_if_symlink_not_supported() self.check_case_insensitive_fs() dir_path_lower = self.make_path("beta") self.create_dir(dir_path_lower) link_path = self.make_path("b") self.os.symlink(self.base_path, link_path) path1 = self.os.path.join(link_path, "Beta") dir_path_upper = self.make_path("Beta") self.os.rename(path1, dir_path_upper) self.assertEqual(result, sorted(self.os.listdir(self.base_path))) def test_rename_case_with_symlink_mac(self): # Regression test for #322 self.check_macos_only() self.check_rename_case_with_symlink(["b", "beta"]) def test_rename_case_with_symlink_windows(self): self.check_windows_only() self.check_rename_case_with_symlink(["Beta", "b"]) def test_recursive_rename_raises(self): self.check_posix_only() base_path = self.make_path("foo", "bar") self.create_dir(base_path) new_path = self.os.path.join(base_path, "new_dir") self.assert_raises_os_error(errno.EINVAL, self.os.rename, base_path, new_path) def test_rename_file_to_parent_dir_file(self): # Regression test for issue 230 dir_path = self.make_path("dir") self.create_dir(dir_path) file_path = self.make_path("old_file") new_file_path = self.os.path.join(dir_path, "new_file") self.create_file(file_path) self.os.rename(file_path, new_file_path) def test_rename_with_target_parent_file_raises_posix(self): self.check_posix_only() file_path = self.make_path("foo", "baz") self.create_file(file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, file_path, file_path + "/new" ) def test_rename_with_target_parent_file_raises_windows(self): self.check_windows_only() file_path = self.make_path("foo", "baz") self.create_file(file_path) self.assert_raises_os_error( errno.EINVAL, self.os.rename, file_path, self.os.path.join(file_path, "new"), ) def test_rename_symlink_to_source(self): self.check_posix_only() base_path = self.make_path("foo") link_path = self.os.path.join(base_path, "slink") file_path = self.os.path.join(base_path, "file") self.create_file(file_path) self.os.symlink(file_path, link_path) self.os.rename(link_path, file_path) self.assertFalse(self.os.path.exists(file_path)) def test_rename_symlink_to_dir_raises(self): self.check_posix_only() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "dir_link") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path, link_path) self.assert_raises_os_error(errno.EISDIR, self.os.rename, link_path, dir_path) def test_rename_broken_symlink(self): self.check_posix_only() base_path = self.make_path("foo") self.create_dir(base_path) link_path = self.os.path.join(base_path, "slink") file_path = self.os.path.join(base_path, "file") self.os.symlink(file_path, link_path) self.os.rename(link_path, file_path) self.assertFalse(self.os.path.exists(file_path)) self.assertTrue(self.os.path.lexists(file_path)) self.assertFalse(self.os.path.exists(link_path)) def test_rename_directory(self): """Can rename a directory to an unused name.""" for old_path, new_path in [("wxyyw", "xyzzy"), ("abccb", "cdeed")]: old_path = self.make_path(old_path) new_path = self.make_path(new_path) self.create_file(self.os.path.join(old_path, "plugh"), contents="test") self.assertTrue(self.os.path.exists(old_path)) self.assertFalse(self.os.path.exists(new_path)) self.os.rename(old_path, new_path) self.assertFalse(self.os.path.exists(old_path)) self.assertTrue(self.os.path.exists(new_path)) self.check_contents(self.os.path.join(new_path, "plugh"), "test") if not self.use_real_fs(): self.assertEqual(3, self.filesystem.get_object(new_path).st_nlink) def check_rename_directory_to_existing_file_raises(self, error_nr): dir_path = self.make_path("dir") file_path = self.make_path("file") self.create_dir(dir_path) self.create_file(file_path) self.assert_raises_os_error(error_nr, self.os.rename, dir_path, file_path) def test_rename_directory_to_existing_file_raises_posix(self): self.check_posix_only() self.check_rename_directory_to_existing_file_raises(errno.ENOTDIR) def test_rename_directory_to_existing_file_raises_windows(self): self.check_windows_only() self.check_rename_directory_to_existing_file_raises(errno.EEXIST) def test_rename_to_existing_directory_should_raise_under_windows(self): """Renaming to an existing directory raises OSError under Windows.""" self.check_windows_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("foo", "baz") self.create_dir(old_path) self.create_dir(new_path) self.assert_raises_os_error(errno.EEXIST, self.os.rename, old_path, new_path) def test_rename_to_a_hardlink_of_same_file_should_do_nothing(self): self.skip_real_fs_failure(skip_posix=False) skip_if_symlink_not_supported() file_path = self.make_path("dir", "file") self.create_file(file_path) link_path = self.make_path("link") self.os.link(file_path, link_path) self.os.rename(file_path, link_path) self.assertTrue(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(link_path)) def test_hardlink_works_with_symlink(self): skip_if_symlink_not_supported() base_path = self.make_path("foo") self.create_dir(base_path) symlink_path = self.os.path.join(base_path, "slink") self.os.symlink(base_path, symlink_path) file_path = self.os.path.join(base_path, "slink", "beta") self.create_file(file_path) link_path = self.os.path.join(base_path, "slink", "gamma") self.os.link(file_path, link_path) self.assertTrue(self.os.path.exists(link_path)) self.assertFalse(self.os.path.islink(link_path)) def test_replace_existing_directory_should_raise_under_windows(self): """Renaming to an existing directory raises OSError under Windows.""" self.check_windows_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("foo", "baz") self.create_dir(old_path) self.create_dir(new_path) self.assert_raises_os_error(errno.EACCES, self.os.replace, old_path, new_path) def test_rename_to_existing_directory_under_posix(self): """Renaming to an existing directory changes the existing directory under Posix.""" self.check_posix_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("xyzzy") self.create_dir(self.os.path.join(old_path, "sub")) self.create_dir(new_path) self.os.rename(old_path, new_path) self.assertTrue(self.os.path.exists(self.os.path.join(new_path, "sub"))) self.assertFalse(self.os.path.exists(old_path)) def test_rename_file_to_existing_directory_raises_under_posix(self): self.check_posix_only() file_path = self.make_path("foo", "bar", "baz") new_path = self.make_path("xyzzy") self.create_file(file_path) self.create_dir(new_path) self.assert_raises_os_error(errno.EISDIR, self.os.rename, file_path, new_path) def test_rename_to_existing_dir_under_posix_raises_if_not_empty(self): """Renaming to an existing directory changes the existing directory under Posix.""" self.check_posix_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("foo", "baz") self.create_dir(self.os.path.join(old_path, "sub")) self.create_dir(self.os.path.join(new_path, "sub")) # not testing specific subtype: # raises errno.ENOTEMPTY under Ubuntu 16.04, MacOS and pyfakefs # but raises errno.EEXIST at least under Ubunto 14.04 with self.assertRaises(OSError): self.os.rename(old_path, new_path) def test_rename_to_another_device_should_raise(self): """Renaming to another filesystem device raises OSError.""" self.skip_real_fs() self.filesystem.add_mount_point("/mount") old_path = "/foo/bar" new_path = "/mount/bar" self.filesystem.create_file(old_path) self.assert_raises_os_error(errno.EXDEV, self.os.rename, old_path, new_path) def test_rename_to_existent_file_posix(self): """Can rename a file to a used name under Unix.""" self.check_posix_only() directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.os.rename(old_file_path, new_file_path) self.assertFalse(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.check_contents(new_file_path, "test contents 1") def test_rename_to_existent_file_windows(self): """Renaming a file to a used name raises OSError under Windows.""" self.check_windows_only() directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.assert_raises_os_error( errno.EEXIST, self.os.rename, old_file_path, new_file_path ) def test_replace_to_existent_file(self): """Replaces an existing file (does not work with `rename()` under Windows).""" directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.os.replace(old_file_path, new_file_path) self.assertFalse(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.check_contents(new_file_path, "test contents 1") def test_rename_to_nonexistent_dir(self): """Can rename a file to a name in a nonexistent dir.""" directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "no_such_path", "plugh_new") self.create_file(old_file_path, contents="test contents") self.assertTrue(self.os.path.exists(old_file_path)) self.assertFalse(self.os.path.exists(new_file_path)) self.assert_raises_os_error( errno.ENOENT, self.os.rename, old_file_path, new_file_path ) self.assertTrue(self.os.path.exists(old_file_path)) self.assertFalse(self.os.path.exists(new_file_path)) self.check_contents(old_file_path, "test contents") def test_rename_nonexistent_file_should_raise_error(self): """Can't rename a file that doesn't exist.""" self.assert_raises_os_error( errno.ENOENT, self.os.rename, "nonexistent-foo", "doesn't-matter-bar", ) def test_rename_empty_dir(self): """Test a rename of an empty directory.""" directory = self.make_path("xyzzy") before_dir = self.os.path.join(directory, "empty") after_dir = self.os.path.join(directory, "unused") self.create_dir(before_dir) self.assertTrue(self.os.path.exists(self.os.path.join(before_dir, "."))) self.assertFalse(self.os.path.exists(after_dir)) self.os.rename(before_dir, after_dir) self.assertFalse(self.os.path.exists(before_dir)) self.assertTrue(self.os.path.exists(self.os.path.join(after_dir, "."))) def test_rename_symlink(self): self.check_posix_only() base_path = self.make_path("foo", "bar") self.create_dir(base_path) link_path = self.os.path.join(base_path, "link") self.os.symlink(base_path, link_path) file_path = self.os.path.join(link_path, "file") new_file_path = self.os.path.join(link_path, "new") self.create_file(file_path) self.os.rename(file_path, new_file_path) self.assertFalse(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(new_file_path)) def check_append_mode_tell_after_truncate(self, tell_result): file_path = self.make_path("baz") with self.open(file_path, "w", encoding="utf8") as f0: with self.open(file_path, "a", encoding="utf8") as f1: f1.write("abcde") f0.seek(2) f0.truncate() self.assertEqual(tell_result, f1.tell()) with self.open(file_path, mode="rb") as f: self.assertEqual(b"\0\0abcde", f.read()) def test_append_mode_tell_linux_windows(self): # Regression test for #300 self.check_linux_and_windows() self.check_append_mode_tell_after_truncate(7) def test_append_mode_tell_macos(self): # Regression test for #300 self.check_macos_only() self.check_append_mode_tell_after_truncate(7) def test_tell_after_seek_in_append_mode(self): # Regression test for #363 file_path = self.make_path("foo") with self.open(file_path, "a", encoding="utf8") as f: f.seek(1) self.assertEqual(1, f.tell()) def test_tell_after_seekback_in_append_mode(self): # Regression test for #414 file_path = self.make_path("foo") with self.open(file_path, "a", encoding="utf8") as f: f.write("aa") f.seek(1) self.assertEqual(1, f.tell()) def test_dir_with_trailing_sep_is_dir(self): # regression test for #387 self.assertTrue(self, self.os.path.isdir(self.base_path + self.os.sep)) def check_rename_dir_with_trailing_sep(self, error): dir_path = self.make_path("dir") + self.os.sep self.os.mkdir(dir_path) self.assert_raises_os_error(error, self.os.rename, dir_path, self.base_path) def test_rename_dir_with_trailing_sep_posix(self): # regression test for #406 self.check_posix_only() self.check_rename_dir_with_trailing_sep(errno.ENOTEMPTY) def test_rename_dir_with_trailing_sep_windows(self): self.check_windows_only() self.check_rename_dir_with_trailing_sep(errno.EEXIST) def test_rename_dir(self): """Test a rename of a directory.""" directory = self.make_path("xyzzy") before_dir = self.os.path.join(directory, "before") before_file = self.os.path.join(directory, "before", "file") after_dir = self.os.path.join(directory, "after") after_file = self.os.path.join(directory, "after", "file") self.create_dir(before_dir) self.create_file(before_file, contents="payload") self.assertTrue(self.os.path.exists(before_dir)) self.assertTrue(self.os.path.exists(before_file)) self.assertFalse(self.os.path.exists(after_dir)) self.assertFalse(self.os.path.exists(after_file)) self.os.rename(before_dir, after_dir) self.assertFalse(self.os.path.exists(before_dir)) self.assertFalse(self.os.path.exists(before_file)) self.assertTrue(self.os.path.exists(after_dir)) self.assertTrue(self.os.path.exists(after_file)) self.check_contents(after_file, "payload") def test_rename_preserves_stat(self): """Test if rename preserves mtime.""" self.check_posix_only() self.skip_real_fs() directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path) old_file = self.filesystem.get_object(old_file_path) old_file.st_mtime = old_file.st_mtime - 3600 self.os.chown(old_file_path, 200, 200) self.os.chmod(old_file_path, 0o222) self.create_file(new_file_path) new_file = self.filesystem.get_object(new_file_path) self.assertNotEqual(new_file.st_mtime, old_file.st_mtime) self.os.rename(old_file_path, new_file_path) new_file = self.filesystem.get_object(new_file_path) self.assertEqual(new_file.st_mtime, old_file.st_mtime) self.assertEqual(new_file.st_mode, old_file.st_mode) self.assertEqual(new_file.st_uid, old_file.st_uid) self.assertEqual(new_file.st_gid, old_file.st_gid) def test_rename_same_filenames(self): """Test renaming when old and new names are the same.""" directory = self.make_path("xyzzy") file_contents = "Spam eggs" file_path = self.os.path.join(directory, "eggs") self.create_file(file_path, contents=file_contents) self.os.rename(file_path, file_path) self.check_contents(file_path, file_contents) def test_rmdir(self): """Can remove a directory.""" directory = self.make_path("xyzzy") sub_dir = self.make_path("xyzzy", "abccd") other_dir = self.make_path("xyzzy", "cdeed") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.os.rmdir(directory) self.assertFalse(self.os.path.exists(directory)) self.create_dir(sub_dir) self.create_dir(other_dir) self.os.chdir(sub_dir) self.os.rmdir("../cdeed") self.assertFalse(self.os.path.exists(other_dir)) self.os.chdir("..") self.os.rmdir("abccd") self.assertFalse(self.os.path.exists(sub_dir)) def test_rmdir_raises_if_not_empty(self): """Raises an exception if the target directory is not empty.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.ENOTEMPTY, self.os.rmdir, directory) def check_rmdir_raises_if_not_directory(self, error_nr): """Raises an exception if the target is not a directory.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.ENOTDIR, self.os.rmdir, file_path) self.assert_raises_os_error(error_nr, self.os.rmdir, ".") def test_rmdir_raises_if_not_directory_posix(self): self.check_posix_only() self.check_rmdir_raises_if_not_directory(errno.EINVAL) def test_rmdir_raises_if_not_directory_windows(self): self.check_windows_only() self.check_rmdir_raises_if_not_directory(errno.EACCES) def test_rmdir_raises_if_not_exist(self): """Raises an exception if the target does not exist.""" directory = self.make_path("xyzzy") self.assertFalse(self.os.path.exists(directory)) self.assert_raises_os_error(errno.ENOENT, self.os.rmdir, directory) def test_rmdir_via_symlink(self): self.check_windows_only() skip_if_symlink_not_supported() base_path = self.make_path("foo", "bar") dir_path = self.os.path.join(base_path, "alpha") self.create_dir(dir_path) link_path = self.os.path.join(base_path, "beta") self.os.symlink(base_path, link_path) self.os.rmdir(link_path + "/alpha") self.assertFalse(self.os.path.exists(dir_path)) def remove_dirs_check(self, directory): self.assertTrue(self.os.path.exists(directory)) self.os.removedirs(directory) return not self.os.path.exists(directory) def test_removedirs(self): # no exception raised self.skip_real_fs() data = [ "test1", ("test1", "test2"), ("test1", "extra"), ("test1", "test2", "test3"), ] for directory in data: self.create_dir(self.make_path(directory)) self.assertTrue(self.os.path.exists(self.make_path(directory))) self.assert_raises_os_error( errno.ENOTEMPTY, self.remove_dirs_check, self.make_path(data[0]) ) self.assert_raises_os_error( errno.ENOTEMPTY, self.remove_dirs_check, self.make_path(data[1]) ) self.assertTrue(self.remove_dirs_check(self.make_path(data[3]))) self.assertTrue(self.os.path.exists(self.make_path(data[0]))) self.assertFalse(self.os.path.exists(self.make_path(data[1]))) self.assertTrue(self.os.path.exists(self.make_path(data[2]))) # Should raise because '/test1/extra' is all that is left, and # removedirs('/test1/extra') will eventually try to rmdir('/'). self.assert_raises_os_error( errno.EBUSY, self.remove_dirs_check, self.make_path(data[2]) ) # However, it will still delete '/test1') in the process. self.assertFalse(self.os.path.exists(self.make_path(data[0]))) self.create_dir(self.make_path("test1", "test2")) # Add this to the root directory to avoid raising an exception. self.filesystem.create_dir(self.make_path("test3")) self.assertTrue(self.remove_dirs_check(self.make_path("test1", "test2"))) self.assertFalse(self.os.path.exists(self.make_path("test1", "test2"))) self.assertFalse(self.os.path.exists(self.make_path("test1"))) def test_removedirs_raises_if_removing_root(self): """Raises exception if asked to remove '/'.""" self.skip_real_fs() self.os.rmdir(self.base_path) directory = self.os.path.splitdrive(self.base_path)[0] + self.os.path.sep self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EBUSY, self.os.removedirs, directory) def test_removedirs_raises_if_cascade_removing_root(self): """Raises exception if asked to remove '/' as part of a larger operation. All of other directories should still be removed, though. """ self.skip_real_fs() directory = self.make_path("foo", "bar") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EBUSY, self.os.removedirs, directory) head, unused_tail = self.os.path.split(directory) while self.os.path.splitdrive(head)[1] != self.os.path.sep: self.assertFalse(self.os.path.exists(directory)) head, unused_tail = self.os.path.split(head) def test_removedirs_with_trailing_slash(self): """removedirs works on directory names with trailing slashes.""" # separate this case from the removing-root-directory case self.create_dir(self.make_path("baz")) directory = self.make_path("foo", "bar") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.os.removedirs(directory) self.assertFalse(self.os.path.exists(directory)) def test_remove_dirs_with_top_symlink_fails(self): self.check_posix_only() dir_path = self.make_path("dir") dir_link = self.make_path("dir_link") self.create_dir(dir_path) self.os.symlink(dir_path, dir_link) self.assert_raises_os_error(errno.ENOTDIR, self.os.removedirs, dir_link) def test_remove_dirs_with_non_top_symlink_succeeds(self): self.check_posix_only() dir_path = self.make_path("dir") dir_link = self.make_path("dir_link") self.create_dir(dir_path) self.os.symlink(dir_path, dir_link) dir_in_dir = self.os.path.join(dir_link, "dir2") self.create_dir(dir_in_dir) self.os.removedirs(dir_in_dir) self.assertFalse(self.os.path.exists(dir_in_dir)) # ensure that the symlink is not removed self.assertTrue(self.os.path.exists(dir_link)) def test_mkdir(self): """mkdir can create a relative directory.""" self.skip_real_fs() directory = "xyzzy" self.assertFalse(self.filesystem.exists(directory)) self.os.mkdir(directory) self.assertTrue(self.filesystem.exists("/%s" % directory)) self.os.chdir(directory) self.os.mkdir(directory) self.assertTrue(self.filesystem.exists(f"/{directory}/{directory}")) self.os.chdir(directory) self.os.mkdir("../abccb") self.assertTrue(self.os.path.exists("/%s/abccb" % directory)) def test_mkdir_with_trailing_slash(self): """mkdir can create a directory named with a trailing slash.""" directory = self.make_path("foo") self.assertFalse(self.os.path.exists(directory)) self.os.mkdir(directory) self.assertTrue(self.os.path.exists(directory)) self.assertTrue(self.os.path.exists(self.make_path("foo"))) def test_mkdir_raises_if_empty_directory_name(self): """mkdir raises exception if creating directory named ''.""" directory = "" self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) def test_mkdir_raises_if_no_parent(self): """mkdir raises exception if parent directory does not exist.""" parent = "xyzzy" directory = f"{parent}/foo" self.assertFalse(self.os.path.exists(parent)) self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) def test_mkdir_raises_on_symlink_in_posix(self): self.check_posix_only() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "link_to_dir") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path, link_path) self.assert_raises_os_error(errno.ENOTDIR, self.os.rmdir, link_path) def test_mkdir_removes_symlink_in_windows(self): self.check_windows_only() skip_if_symlink_not_supported() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "link_to_dir") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path, link_path) self.os.rmdir(link_path) self.assertFalse(self.os.path.exists(link_path)) self.assertTrue(self.os.path.exists(dir_path)) def test_mkdir_raises_if_directory_exists(self): """mkdir raises exception if directory already exists.""" directory = self.make_path("xyzzy") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory) def test_mkdir_raises_if_file_exists(self): """mkdir raises exception if name already exists as a file.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, file_path) def check_mkdir_raises_if_parent_is_file(self, error_type): """mkdir raises exception if name already exists as a file.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assert_raises_os_error( error_type, self.os.mkdir, self.os.path.join(file_path, "ff") ) def test_mkdir_raises_if_parent_is_file_posix(self): self.check_posix_only() self.check_mkdir_raises_if_parent_is_file(errno.ENOTDIR) def test_mkdir_raises_if_parent_is_file_windows(self): self.check_windows_only() self.check_mkdir_raises_if_parent_is_file(errno.ENOENT) def test_mkdir_raises_with_slash_dot_posix(self): """mkdir raises exception if mkdir foo/. (trailing /.).""" self.check_posix_only() self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, self.os.sep + ".") directory = self.make_path("xyzzy", ".") self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) self.create_dir(self.make_path("xyzzy")) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory) def test_mkdir_raises_with_slash_dot_windows(self): """mkdir raises exception if mkdir foo/. (trailing /.).""" self.check_windows_only() self.assert_raises_os_error(errno.EACCES, self.os.mkdir, self.os.sep + ".") directory = self.make_path("xyzzy", ".") self.os.mkdir(directory) self.create_dir(self.make_path("xyzzy")) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory) def test_mkdir_raises_with_double_dots_posix(self): """mkdir raises exception if mkdir foo/foo2/../foo3.""" self.check_posix_only() self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, self.os.sep + "..") directory = self.make_path("xyzzy", "dir1", "dir2", "..", "..", "dir3") self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) self.create_dir(self.make_path("xyzzy")) self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) self.create_dir(self.make_path("xyzzy", "dir1")) self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) self.create_dir(self.make_path("xyzzy", "dir1", "dir2")) self.os.mkdir(directory) self.assertTrue(self.os.path.exists(directory)) directory = self.make_path("xyzzy", "dir1", "..") self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory) def test_mkdir_raises_with_double_dots_windows(self): """mkdir raises exception if mkdir foo/foo2/../foo3.""" self.check_windows_only() self.assert_raises_os_error(errno.EACCES, self.os.mkdir, self.os.sep + "..") directory = self.make_path("xyzzy", "dir1", "dir2", "..", "..", "dir3") self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory) self.create_dir(self.make_path("xyzzy")) self.os.mkdir(directory) self.assertTrue(self.os.path.exists(directory)) directory = self.make_path("xyzzy", "dir1", "..") self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory) def test_mkdir_raises_if_parent_is_read_only(self): """mkdir raises exception if parent is read only.""" self.check_posix_only() directory = self.make_path("a") self.os.mkdir(directory) # Change directory permissions to be read only. self.os.chmod(directory, 0o400) directory = self.make_path("a", "b") if not is_root(): self.assert_raises_os_error(errno.EACCES, self.os.mkdir, directory) else: self.os.mkdir(directory) self.assertTrue(self.os.path.exists(directory)) def test_mkdir_with_with_symlink_parent(self): self.check_posix_only() dir_path = self.make_path("foo", "bar") self.create_dir(dir_path) link_path = self.make_path("foo", "link") self.os.symlink(dir_path, link_path) new_dir = self.os.path.join(link_path, "new_dir") self.os.mkdir(new_dir) self.assertTrue(self.os.path.exists(new_dir)) def test_makedirs(self): """makedirs can create a directory even if parent does not exist.""" parent = self.make_path("xyzzy") directory = self.os.path.join(parent, "foo") self.assertFalse(self.os.path.exists(parent)) self.os.makedirs(directory) self.assertTrue(self.os.path.exists(directory)) def check_makedirs_raises_if_parent_is_file(self, error_type): """makedirs raises exception if a parent component exists as a file.""" file_path = self.make_path("xyzzy") directory = self.os.path.join(file_path, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(error_type, self.os.makedirs, directory) def test_makedirs_raises_if_parent_is_file_posix(self): self.check_posix_only() self.check_makedirs_raises_if_parent_is_file(errno.ENOTDIR) def test_makedirs_raises_if_parent_is_file_windows(self): self.check_windows_only() self.check_makedirs_raises_if_parent_is_file(errno.ENOENT) def test_makedirs_raises_if_parent_is_broken_link(self): self.check_posix_only() link_path = self.make_path("broken_link") self.os.symlink(self.make_path("bogus"), link_path) self.assert_raises_os_error( errno.ENOENT, self.os.makedirs, self.os.path.join(link_path, "newdir"), ) def test_makedirs_raises_if_parent_is_looping_link(self): skip_if_symlink_not_supported() link_path = self.make_path("link") link_target = self.os.path.join(link_path, "link") self.os.symlink(link_target, link_path) self.assert_raises_os_error(errno.EEXIST, self.os.makedirs, link_path) def test_makedirs_if_parent_is_symlink(self): self.check_posix_only() base_dir = self.make_path("foo", "bar") self.create_dir(base_dir) link_dir = self.os.path.join(base_dir, "linked") self.os.symlink(base_dir, link_dir) new_dir = self.os.path.join(link_dir, "f") self.os.makedirs(name=new_dir) self.assertTrue(self.os.path.exists(new_dir)) def test_makedirs_raises_if_access_denied(self): """makedirs raises exception if access denied.""" self.check_posix_only() directory = self.make_path("a") self.os.mkdir(directory) # Change directory permissions to be read only. self.os.chmod(directory, 0o400) directory = self.make_path("a", "b") if not is_root(): with self.assertRaises(OSError): self.os.makedirs(directory) else: self.os.makedirs(directory) self.assertTrue(self.os.path.exists(directory)) def test_makedirs_exist_ok(self): """makedirs uses the exist_ok argument""" directory = self.make_path("xyzzy", "foo") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EEXIST, self.os.makedirs, directory) self.os.makedirs(directory, exist_ok=True) self.assertTrue(self.os.path.exists(directory)) def test_makedirs_in_write_protected_dir(self): self.check_posix_only() directory = self.make_path("foo") self.os.mkdir(directory, mode=0o555) subdir = self.os.path.join(directory, "bar") if not is_root(): self.assert_raises_os_error( errno.EACCES, self.os.makedirs, subdir, exist_ok=True ) self.assert_raises_os_error( errno.EACCES, self.os.makedirs, subdir, exist_ok=False ) else: self.os.makedirs(subdir) self.assertTrue(self.os.path.exists(subdir)) def test_makedirs_raises_on_empty_path(self): self.assert_raises_os_error(errno.ENOENT, self.os.makedirs, "", exist_ok=False) self.assert_raises_os_error(errno.ENOENT, self.os.makedirs, "", exist_ok=True) def test_makedirs_with_relative_paths(self): # regression test for #987 path = self.make_path("base", "foo", "..", "bar") self.os.makedirs(path) self.assertTrue(self.os.path.isdir(self.make_path("base", "bar"))) self.assertTrue(self.os.path.isdir(self.make_path("base", "foo"))) self.assertFalse(self.os.path.isdir(self.make_path("base", "foo", "bar"))) # test fsync and fdatasync def test_fsync_raises_on_non_int(self): with self.assertRaises(TypeError): self.os.fsync("zero") def test_fdatasync_raises_on_non_int(self): self.check_linux_only() self.assertRaises(TypeError, self.os.fdatasync, "zero") def test_fsync_raises_on_invalid_fd(self): self.assert_raises_os_error(errno.EBADF, self.os.fsync, 500) def test_fdatasync_raises_on_invalid_fd(self): # No open files yet self.check_linux_only() self.assert_raises_os_error(errno.EINVAL, self.os.fdatasync, 0) self.assert_raises_os_error(errno.EBADF, self.os.fdatasync, 500) def test_fsync_pass_posix(self): self.check_posix_only() test_file_path = self.make_path("test_file") self.create_file(test_file_path, contents="dummy file contents") with self.open(test_file_path, "r", encoding="utf8") as test_file: test_fd = test_file.fileno() # Test that this doesn't raise anything self.os.fsync(test_fd) # And just for sanity, double-check that this still raises self.assert_raises_os_error(errno.EBADF, self.os.fsync, test_fd + 500) def test_fsync_pass_windows(self): self.check_windows_only() test_file_path = self.make_path("test_file") self.create_file(test_file_path, contents="dummy file contents") with self.open(test_file_path, "r+", encoding="utf8") as test_file: test_fd = test_file.fileno() # Test that this doesn't raise anything self.os.fsync(test_fd) # And just for sanity, double-check that this still raises self.assert_raises_os_error(errno.EBADF, self.os.fsync, test_fd + 500) with self.open(test_file_path, "r", encoding="utf8") as test_file: test_fd = test_file.fileno() self.assert_raises_os_error(errno.EBADF, self.os.fsync, test_fd) def test_fdatasync_pass(self): # setup self.check_linux_only() test_file_path = self.make_path("test_file") self.create_file(test_file_path, contents="dummy file contents") test_file = self.open(test_file_path, "r", encoding="utf8") test_fd = test_file.fileno() # Test that this doesn't raise anything self.os.fdatasync(test_fd) # And just for sanity, double-check that this still raises self.assert_raises_os_error(errno.EBADF, self.os.fdatasync, test_fd + 500) def test_access700(self): # set up self.check_posix_only() path = self.make_path("some_file") self.createTestFile(path) self.os.chmod(path, 0o700) self.assert_mode_equal(0o700, self.os.stat(path).st_mode) # actual tests self.assertTrue(self.os.access(path, self.os.F_OK)) self.assertTrue(self.os.access(path, self.os.R_OK)) self.assertTrue(self.os.access(path, self.os.W_OK)) self.assertTrue(self.os.access(path, self.os.X_OK)) self.assertTrue(self.os.access(path, self.rwx)) def test_access600(self): # set up self.check_posix_only() path = self.make_path("some_file") self.createTestFile(path) self.os.chmod(path, 0o600) self.assert_mode_equal(0o600, self.os.stat(path).st_mode) # actual tests self.assertTrue(self.os.access(path, self.os.F_OK)) self.assertTrue(self.os.access(path, self.os.R_OK)) self.assertTrue(self.os.access(path, self.os.W_OK)) self.assertFalse(self.os.access(path, self.os.X_OK)) self.assertFalse(self.os.access(path, self.rwx)) self.assertTrue(self.os.access(path, self.rw)) def test_access400(self): # set up self.check_posix_only() path = self.make_path("some_file") self.createTestFile(path) self.os.chmod(path, 0o400) self.assert_mode_equal(0o400, self.os.stat(path).st_mode) # actual tests self.assertTrue(self.os.access(path, self.os.F_OK)) self.assertTrue(self.os.access(path, self.os.R_OK)) self.assertFalse(self.os.access(path, self.os.X_OK)) self.assertFalse(self.os.access(path, self.rwx)) if is_root(): self.assertTrue(self.os.access(path, self.os.W_OK)) self.assertTrue(self.os.access(path, self.rw)) else: self.assertFalse(self.os.access(path, self.os.W_OK)) self.assertFalse(self.os.access(path, self.rw)) def test_access_symlink(self): skip_if_symlink_not_supported() self.skip_real_fs() path = self.make_path("some_file") self.createTestFile(path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, path) self.os.chmod(link_path, 0o400) # test file self.assertTrue(self.os.access(link_path, self.os.F_OK)) self.assertTrue(self.os.access(link_path, self.os.R_OK)) if is_root(): self.assertTrue(self.os.access(link_path, self.os.W_OK)) self.assertTrue(self.os.access(link_path, self.rw)) else: self.assertFalse(self.os.access(link_path, self.os.W_OK)) self.assertFalse(self.os.access(link_path, self.rw)) self.assertFalse(self.os.access(link_path, self.os.X_OK)) self.assertFalse(self.os.access(link_path, self.rwx)) # test link itself (default under Windows, follow_symlinks not supported) follow_symlinks = None if self.is_windows_fs else False self.assertTrue( self.os.access(link_path, self.os.F_OK, follow_symlinks=follow_symlinks) ) self.assertTrue( self.os.access(link_path, self.os.R_OK, follow_symlinks=follow_symlinks) ) self.assertTrue( self.os.access(link_path, self.os.W_OK, follow_symlinks=follow_symlinks) ) if not self.is_windows_fs: self.assertTrue( self.os.access(link_path, self.os.X_OK, follow_symlinks=False) ) self.assertTrue(self.os.access(link_path, self.rwx, follow_symlinks=False)) self.assertTrue( self.os.access(link_path, self.rw, follow_symlinks=follow_symlinks) ) def test_access_non_existent_file(self): # set up path = self.make_path("non", "existent", "file") self.assertFalse(self.os.path.exists(path)) # actual tests self.assertFalse(self.os.access(path, self.os.F_OK)) self.assertFalse(self.os.access(path, self.os.R_OK)) self.assertFalse(self.os.access(path, self.os.W_OK)) self.assertFalse(self.os.access(path, self.os.X_OK)) self.assertFalse(self.os.access(path, self.rwx)) self.assertFalse(self.os.access(path, self.rw)) def test_arguments_not_supported_under_windows(self): self.check_windows_only() path = self.make_path("foo", "bar") with self.assertRaises(NotImplementedError): self.os.access(path, self.os.F_OK, effective_ids=True) with self.assertRaises(NotImplementedError): self.os.access(path, self.os.F_OK, follow_symlinks=False) def test_chmod(self): # set up self.check_posix_only() self.skip_real_fs() path = self.make_path("some_file") self.createTestFile(path) # actual tests self.os.chmod(path, 0o6543) st = self.os.stat(path) self.assert_mode_equal(0o6543, st.st_mode) self.assertTrue(st.st_mode & stat.S_IFREG) self.assertFalse(st.st_mode & stat.S_IFDIR) def test_chmod_uses_open_fd_as_path(self): if sys.version_info < (3, 13): self.check_posix_only() self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.chmod, 5, 0o6543) path = self.make_path("some_file") self.createTestFile(path) with self.open(path, encoding="utf8") as f: st = self.os.stat(f.fileno()) # use a mode that will work under Windows self.os.chmod(f.filedes, 0o444) st = self.os.stat(path) self.assert_mode_equal(0o444, st.st_mode) # fchmod should work the same way self.os.fchmod(f.filedes, 0o666) st = self.os.stat(path) self.assert_mode_equal(0o666, st.st_mode) @unittest.skipIf( sys.version_info >= (3, 13), "also available under Windows since Python 3.13" ) def test_chmod_uses_open_fd_as_path_not_available_under_windows(self): self.check_windows_only() self.skip_real_fs() path = self.make_path("some_file") self.createTestFile(path) with self.open(path, encoding="utf8") as f: with self.assertRaises(TypeError): self.os.chmod(f.fileno(), 0o666) with self.assertRaises(AttributeError): self.os.fchmod(f.fileno(), 0o666) def test_chmod_follow_symlink(self): self.check_posix_only() path = self.make_path("some_file") self.createTestFile(path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, path) self.os.chmod(link_path, 0o6543) st = self.os.stat(link_path) self.assert_mode_equal(0o6543, st.st_mode) st = self.os.stat(link_path, follow_symlinks=False) # the exact mode depends on OS and Python version self.assertEqual(stat.S_IMODE(0o700), stat.S_IMODE(st.st_mode) & 0o700) def test_chmod_no_follow_symlink(self): if sys.version_info < (3, 13): self.check_posix_only() else: skip_if_symlink_not_supported() path = self.make_path("some_file") self.createTestFile(path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, path) if self.os.chmod not in self.os.supports_follow_symlinks or IS_PYPY: with self.assertRaises(NotImplementedError): self.os.chmod(link_path, 0o6543, follow_symlinks=False) else: self.os.chmod(link_path, 0o6543, follow_symlinks=False) st = self.os.stat(link_path) mode = 0o644 if self.is_macos else 0o666 self.assert_mode_equal(mode, st.st_mode) st = self.os.stat(link_path, follow_symlinks=False) mode = 0o444 if self.is_windows_fs else 0o6543 self.assert_mode_equal(mode, st.st_mode) def test_lchmod(self): """lchmod shall behave like chmod with follow_symlinks=True.""" self.check_posix_only() self.skip_real_fs() path = self.make_path("some_file") self.createTestFile(path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, path) self.os.lchmod(link_path, 0o6543) st = self.os.stat(link_path) self.assert_mode_equal(0o644, st.st_mode) st = self.os.lstat(link_path) self.assert_mode_equal(0o6543, st.st_mode) def test_chmod_dir(self): # set up self.check_posix_only() self.skip_real_fs() path = self.make_path("some_dir") self.createTestDirectory(path) # actual tests self.os.chmod(path, 0o1434) st = self.os.stat(path) self.assert_mode_equal(0o1434, st.st_mode) self.assertFalse(st.st_mode & stat.S_IFREG) self.assertTrue(st.st_mode & stat.S_IFDIR) def test_chmod_non_existent(self): # set up path = self.make_path("non", "existent", "file") self.assertFalse(self.os.path.exists(path)) # actual tests try: # Use try-catch to check exception attributes. self.os.chmod(path, 0o777) self.fail("Exception is expected.") # COV_NF_LINE except OSError as os_error: self.assertEqual(errno.ENOENT, os_error.errno) self.assertEqual(path, os_error.filename) def test_chown_existing_file(self): # set up self.skip_real_fs() file_path = self.make_path("some_file") self.create_file(file_path) # first set it make sure it's set self.os.chown(file_path, 100, 101) st = self.os.stat(file_path) self.assertEqual(st[stat.ST_UID], 100) self.assertEqual(st[stat.ST_GID], 101) # we can make sure it changed self.os.chown(file_path, 200, 201) st = self.os.stat(file_path) self.assertEqual(st[stat.ST_UID], 200) self.assertEqual(st[stat.ST_GID], 201) # setting a value to -1 leaves it unchanged self.os.chown(file_path, -1, -1) st = self.os.stat(file_path) self.assertEqual(st[stat.ST_UID], 200) self.assertEqual(st[stat.ST_GID], 201) def test_chown_uses_open_fd_as_path(self): self.check_posix_only() self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.chown, 5, 100, 101) file_path = self.make_path("foo", "bar") self.create_file(file_path) with self.open(file_path, encoding="utf8") as f: self.os.chown(f.filedes, 100, 101) st = self.os.stat(file_path) self.assertEqual(st[stat.ST_UID], 100) def test_chown_follow_symlink(self): self.skip_real_fs() file_path = self.make_path("some_file") self.create_file(file_path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, file_path) self.os.chown(link_path, 100, 101) st = self.os.stat(link_path) self.assertEqual(st[stat.ST_UID], 100) self.assertEqual(st[stat.ST_GID], 101) st = self.os.stat(link_path, follow_symlinks=False) self.assertNotEqual(st[stat.ST_UID], 100) self.assertNotEqual(st[stat.ST_GID], 101) def test_chown_no_follow_symlink(self): self.skip_real_fs() file_path = self.make_path("some_file") self.create_file(file_path) link_path = self.make_path("link_to_some_file") self.create_symlink(link_path, file_path) self.os.chown(link_path, 100, 101, follow_symlinks=False) st = self.os.stat(link_path) self.assertNotEqual(st[stat.ST_UID], 100) self.assertNotEqual(st[stat.ST_GID], 101) st = self.os.stat(link_path, follow_symlinks=False) self.assertEqual(st[stat.ST_UID], 100) self.assertEqual(st[stat.ST_GID], 101) def test_chown_bad_arguments(self): """os.chown() with bad args (Issue #30)""" self.check_posix_only() file_path = self.make_path("some_file") self.create_file(file_path) self.assertRaises(TypeError, self.os.chown, file_path, "username", -1) self.assertRaises(TypeError, self.os.chown, file_path, -1, "groupname") def test_chown_nonexisting_file_should_raise_os_error(self): self.check_posix_only() file_path = self.make_path("some_file") self.assertFalse(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.ENOENT, self.os.chown, file_path, 100, 100) def test_fail_add_entry_to_readonly_dir(self): # regression test for #959 self.check_posix_only() self.skip_real_fs() # cannot change owner to root if is_root(): self.skipTest("Non-root test only") # create directory owned by root with permissions 0o755 (rwxr-xr-x) ro_dir = self.make_path("readonly-dir") self.create_dir(ro_dir, perm=0o755) self.os.chown(ro_dir, 0, 0) # adding a new entry to the readonly subdirectory should fail with self.assertRaises(PermissionError): with self.open(f"{ro_dir}/file.txt", "w", encoding="utf8"): pass file_path = self.make_path("file.txt") self.create_file(file_path) with self.assertRaises(PermissionError): self.os.link(file_path, self.os.path.join(ro_dir, "file.txt")) def test_classify_directory_contents(self): """Directory classification should work correctly.""" root_directory = self.make_path("foo") test_directories = ["bar1", "baz2"] test_files = ["baz1", "bar2", "baz3"] self.create_dir(root_directory) for directory in test_directories: directory = self.os.path.join(root_directory, directory) self.create_dir(directory) for test_file in test_files: test_file = self.os.path.join(root_directory, test_file) self.create_file(test_file) test_directories.sort() test_files.sort() generator = self.os.walk(root_directory) root, dirs, files = next(generator) dirs.sort() files.sort() self.assertEqual(root_directory, root) self.assertEqual(test_directories, dirs) self.assertEqual(test_files, files) # os.mknod does not work under MacOS due to permission issues # so we test it under Linux only def test_mk_nod_can_create_a_file(self): self.check_linux_only() filename = self.make_path("foo") self.assertFalse(self.os.path.exists(filename)) self.os.mknod(filename) self.assertTrue(self.os.path.exists(filename)) self.assertEqual(stat.S_IFREG \| 0o600, self.os.stat(filename).st_mode) def test_mk_nod_raises_if_empty_file_name(self): self.check_linux_only() filename = "" self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mk_nod_raises_if_parent_dir_doesnt_exist(self): self.check_linux_only() parent = self.make_path("xyzzy") filename = self.os.path.join(parent, "foo") self.assertFalse(self.os.path.exists(parent)) self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mk_nod_raises_if_file_exists(self): self.check_linux_only() filename = self.make_path("tmp", "foo") self.create_file(filename) self.assertTrue(self.os.path.exists(filename)) self.assert_raises_os_error(errno.EEXIST, self.os.mknod, filename) def test_mk_nod_raises_if_filename_is_dot(self): self.check_linux_only() filename = self.make_path("tmp", ".") self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mk_nod_raises_if_filename_is_double_dot(self): self.check_linux_only() filename = self.make_path("tmp", "..") self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mknod_empty_tail_for_existing_file_raises(self): self.check_linux_only() filename = self.make_path("foo") self.create_file(filename) self.assertTrue(self.os.path.exists(filename)) self.assert_raises_os_error(errno.EEXIST, self.os.mknod, filename) def test_mknod_empty_tail_for_nonexistent_file_raises(self): self.check_linux_only() filename = self.make_path("tmp", "foo") self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mknod_raises_if_filename_is_empty_string(self): self.check_linux_only() filename = "" self.assert_raises_os_error(errno.ENOENT, self.os.mknod, filename) def test_mknod_raises_if_unsupported_options(self): self.check_posix_only() # behavior seems to have changed in ubuntu-20.04, version 20210606.1 # skipping real fs tests for now self.skip_real_fs() filename = "abcde" if not is_root(): self.assert_raises_os_error( errno.EPERM, self.os.mknod, filename, stat.S_IFCHR ) else: self.os.mknod(filename, stat.S_IFCHR) self.os.remove(filename) def test_mknod_raises_if_parent_is_not_a_directory(self): self.check_linux_only() filename1 = self.make_path("foo") self.create_file(filename1) self.assertTrue(self.os.path.exists(filename1)) filename2 = self.make_path("foo", "bar") self.assert_raises_os_error(errno.ENOTDIR, self.os.mknod, filename2) def test_symlink(self): skip_if_symlink_not_supported() file_path = self.make_path("foo", "bar", "baz") self.create_dir(self.make_path("foo", "bar")) self.os.symlink("bogus", file_path) self.assertTrue(self.os.path.lexists(file_path)) self.assertFalse(self.os.path.exists(file_path)) self.create_file(self.make_path("foo", "bar", "bogus")) self.assertTrue(self.os.path.lexists(file_path)) self.assertTrue(self.os.path.exists(file_path)) def test_symlink_on_nonexisting_path_raises(self): self.check_posix_only() dir_path = self.make_path("bar") link_path = self.os.path.join(dir_path, "bar") self.assert_raises_os_error(errno.ENOENT, self.os.symlink, link_path, link_path) self.assert_raises_os_error(errno.ENOENT, self.os.symlink, dir_path, link_path) def test_symlink_with_path_ending_with_sep_in_posix(self): self.check_posix_only() dir_path = self.make_path("dir") self.create_dir(dir_path) self.assert_raises_os_error( errno.EEXIST, self.os.symlink, self.base_path, dir_path + self.os.sep, ) dir_path = self.make_path("bar") self.assert_raises_os_error( errno.ENOENT, self.os.symlink, self.base_path, dir_path + self.os.sep, ) def test_symlink_with_path_ending_with_sep_in_windows(self): self.check_windows_only() skip_if_symlink_not_supported() dir_path = self.make_path("dir") self.create_dir(dir_path) self.assert_raises_os_error( errno.EEXIST, self.os.symlink, self.base_path, dir_path + self.os.sep, ) dir_path = self.make_path("bar") # does not raise under Windows self.os.symlink(self.base_path, dir_path + self.os.sep) def test_broken_symlink_with_trailing_sep_posix(self): # Regression test for #390 self.check_linux_only() path0 = self.make_path("foo") + self.os.sep self.assert_raises_os_error(errno.ENOENT, self.os.symlink, path0, path0) def test_broken_symlink_with_trailing_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path0 = self.make_path("foo") + self.os.sep self.assert_raises_os_error(errno.ENOTDIR, self.os.symlink, path0, path0) def test_rename_symlink_with_trailing_sep_linux(self): # Regression test for #391 self.check_linux_only() path = self.make_path("foo") self.os.symlink(self.base_path, path) self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, path + self.os.sep, self.base_path ) def test_rename_symlink_with_trailing_sep_macos(self): # Regression test for #391 self.check_macos_only() path = self.make_path("foo") self.os.symlink(self.base_path, path) self.os.rename(path + self.os.sep, self.base_path) def test_rename_symlink_with_trailing_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path = self.make_path("foo") self.os.symlink(self.base_path, path) self.assert_raises_os_error( errno.EEXIST, self.os.rename, path + self.os.sep, self.base_path ) def test_rename_symlink_to_other_case(self): # Regression test for #389 skip_if_symlink_not_supported() link_path = self.make_path("foo") self.os.symlink(self.base_path, link_path) link_to_link_path = self.make_path("BAR") self.os.symlink(link_path, link_to_link_path) new_link_to_link_path = self.os.path.join(link_path, "bar") self.os.rename(link_to_link_path, new_link_to_link_path) self.assertEqual(["bar", "foo"], sorted(self.os.listdir(new_link_to_link_path))) def create_broken_link_path_with_trailing_sep(self): # Regression tests for #396 skip_if_symlink_not_supported() link_path = self.make_path("link") target_path = self.make_path("target") self.os.symlink(target_path, link_path) link_path += self.os.sep return link_path def test_lstat_broken_link_with_trailing_sep_linux(self): self.check_linux_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOENT, self.os.lstat, link_path) def test_lstat_broken_link_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOENT, self.os.lstat, link_path) def test_lstat_broken_link_with_trailing_sep_windows(self): self.check_windows_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOTDIR, self.os.lstat, link_path) def test_mkdir_broken_link_with_trailing_sep_linux_windows(self): self.check_linux_and_windows() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, link_path) self.assert_raises_os_error(errno.EEXIST, self.os.makedirs, link_path) def test_mkdir_broken_link_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.create_broken_link_path_with_trailing_sep() self.os.mkdir(link_path) # no error def test_makedirs_broken_link_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.create_broken_link_path_with_trailing_sep() self.os.makedirs(link_path) # no error def test_remove_broken_link_with_trailing_sep_linux(self): self.check_linux_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOTDIR, self.os.remove, link_path) def test_remove_broken_link_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOENT, self.os.remove, link_path) def test_remove_broken_link_with_trailing_sep_windows(self): self.check_windows_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOTDIR, self.os.remove, link_path) def test_rename_broken_link_with_trailing_sep_linux(self): self.check_linux_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, link_path, self.make_path("target") ) def test_rename_broken_link_with_trailing_sep_macos(self): self.check_macos_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error( errno.ENOENT, self.os.rename, link_path, self.make_path("target") ) def test_rename_broken_link_with_trailing_sep_windows(self): self.check_windows_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, link_path, self.make_path("target") ) def test_readlink_broken_link_with_trailing_sep_posix(self): self.check_posix_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOENT, self.os.readlink, link_path) def test_readlink_broken_link_with_trailing_sep_windows(self): self.check_windows_only() link_path = self.create_broken_link_path_with_trailing_sep() self.assert_raises_os_error(errno.ENOTDIR, self.os.readlink, link_path) def test_islink_broken_link_with_trailing_sep(self): link_path = self.create_broken_link_path_with_trailing_sep() self.assertFalse(self.os.path.islink(link_path)) def test_lexists_broken_link_with_trailing_sep(self): link_path = self.create_broken_link_path_with_trailing_sep() self.assertFalse(self.os.path.lexists(link_path)) def test_rename_link_with_trailing_sep_to_self_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path = self.make_path("foo") self.os.symlink(self.base_path, path) self.os.rename(path + self.os.sep, path) # no error def test_rename_link_with_trailing_sep_to_self_posix(self): # Regression test for #395 self.check_posix_only() path = self.make_path("foo") self.os.symlink(self.base_path, path) self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, path + self.os.sep, path ) def check_open_broken_symlink_to_path_with_trailing_sep(self, error): # Regression tests for #397 skip_if_symlink_not_supported() target_path = self.make_path("target") + self.os.sep link_path = self.make_path("link") self.os.symlink(target_path, link_path) self.assert_raises_os_error(error, self.open, link_path, "a") self.assert_raises_os_error(error, self.open, link_path, "w") def test_open_broken_symlink_to_path_with_trailing_sep_linux(self): self.check_linux_only() self.check_open_broken_symlink_to_path_with_trailing_sep(errno.EISDIR) def test_open_broken_symlink_to_path_with_trailing_sep_macos(self): self.check_macos_only() self.check_open_broken_symlink_to_path_with_trailing_sep(errno.ENOENT) def test_open_broken_symlink_to_path_with_trailing_sep_windows(self): self.check_windows_only() self.check_open_broken_symlink_to_path_with_trailing_sep(errno.EINVAL) def test_link_path_ending_with_sep(self): # Regression tests for #399 skip_if_symlink_not_supported() file_path = self.make_path("foo") link_path = self.make_path("link") with self.open(file_path, "w", encoding="utf8"): self.assert_raises_os_error( errno.ENOTDIR, self.os.link, file_path + self.os.sep, link_path ) def test_link_to_path_ending_with_sep_posix(self): # regression test for #407 self.check_posix_only() path0 = self.make_path("foo") + self.os.sep path1 = self.make_path("bar") with self.open(path1, "w", encoding="utf8"): self.assert_raises_os_error(errno.ENOENT, self.os.link, path1, path0) def test_link_to_path_ending_with_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path0 = self.make_path("foo") + self.os.sep path1 = self.make_path("bar") with self.open(path1, "w", encoding="utf8"): self.os.link(path1, path0) self.assertTrue(self.os.path.exists(path1)) def test_rename_to_path_ending_with_sep(self): # Regression tests for #400 file_path = self.make_path("foo") with self.open(file_path, "w", encoding="utf8"): self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, file_path + self.os.sep, file_path ) def test_rmdir_link_with_trailing_sep_linux(self): self.check_linux_only() dir_path = self.make_path("foo") self.os.mkdir(dir_path) link_path = self.make_path("link") self.os.symlink(dir_path, link_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.rmdir, link_path + self.os.sep ) def test_rmdir_link_with_trailing_sep_macos(self): # Regression test for #398 self.check_macos_only() dir_path = self.make_path("foo") self.os.mkdir(dir_path) link_path = self.make_path("link") self.os.symlink(dir_path, link_path) self.os.rmdir(link_path + self.os.sep) self.assertFalse(self.os.path.exists(link_path)) def test_rmdir_link_with_trailing_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() dir_path = self.make_path("foo") self.os.mkdir(dir_path) link_path = self.make_path("link") self.os.symlink(dir_path, link_path) self.os.rmdir(link_path + self.os.sep) self.assertFalse(self.os.path.exists(link_path)) def test_readlink_circular_link_with_trailing_sep_linux(self): self.check_linux_only() path1 = self.make_path("foo") path0 = self.make_path("bar") self.os.symlink(path0, path1) self.os.symlink(path1, path0) self.assert_raises_os_error(errno.ELOOP, self.os.readlink, path0 + self.os.sep) def test_readlink_circular_link_with_trailing_sep_macos(self): # Regression test for #392 self.check_macos_only() path1 = self.make_path("foo") path0 = self.make_path("bar") self.os.symlink(path0, path1) self.os.symlink(path1, path0) self.assertEqual(path0, self.os.readlink(path0 + self.os.sep)) def test_readlink_circular_link_with_trailing_sep_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path1 = self.make_path("foo") path0 = self.make_path("bar") self.os.symlink(path0, path1) self.os.symlink(path1, path0) self.assert_raises_os_error( errno.ENOTDIR, self.os.readlink, path0 + self.os.sep ) # hard link related tests def test_link_bogus(self): # trying to create a link from a non-existent file should fail skip_if_symlink_not_supported() self.assert_raises_os_error( errno.ENOENT, self.os.link, "/nonexistent_source", "/link_dest" ) def test_link_delete(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") file2_path = self.make_path("test_file2") contents1 = "abcdef" # Create file self.create_file(file1_path, contents=contents1) # link to second file self.os.link(file1_path, file2_path) # delete first file self.os.unlink(file1_path) # assert that second file exists, and its contents are the same self.assertTrue(self.os.path.exists(file2_path)) with self.open(file2_path, encoding="utf8") as f: self.assertEqual(f.read(), contents1) def test_link_update(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") file2_path = self.make_path("test_file2") contents1 = "abcdef" contents2 = "ghijkl" # Create file and link self.create_file(file1_path, contents=contents1) self.os.link(file1_path, file2_path) # assert that the second file contains contents1 with self.open(file2_path, encoding="utf8") as f: self.assertEqual(f.read(), contents1) # update the first file with self.open(file1_path, "w", encoding="utf8") as f: f.write(contents2) # assert that second file contains contents2 with self.open(file2_path, encoding="utf8") as f: self.assertEqual(f.read(), contents2) def test_link_non_existent_parent(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") breaking_link_path = self.make_path("nonexistent", "test_file2") contents1 = "abcdef" # Create file and link self.create_file(file1_path, contents=contents1) # trying to create a link under a non-existent directory should fail self.assert_raises_os_error( errno.ENOENT, self.os.link, file1_path, breaking_link_path ) def test_link_is_existing_file(self): skip_if_symlink_not_supported() file_path = self.make_path("foo", "bar") self.create_file(file_path) self.assert_raises_os_error(errno.EEXIST, self.os.link, file_path, file_path) def test_link_target_is_dir_windows(self): self.check_windows_only() skip_if_symlink_not_supported() dir_path = self.make_path("foo", "bar") link_path = self.os.path.join(dir_path, "link") self.create_dir(dir_path) self.assert_raises_os_error(errno.EACCES, self.os.link, dir_path, link_path) def test_link_target_is_dir_posix(self): self.check_posix_only() dir_path = self.make_path("foo", "bar") link_path = self.os.path.join(dir_path, "link") self.create_dir(dir_path) self.assert_raises_os_error(errno.EPERM, self.os.link, dir_path, link_path) def test_link_count1(self): """Test that hard link counts are updated correctly.""" skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") file2_path = self.make_path("test_file2") file3_path = self.make_path("test_file3") self.create_file(file1_path) # initial link count should be one self.assertEqual(self.os.stat(file1_path).st_nlink, 1) self.os.link(file1_path, file2_path) # the count should be incremented for each hard link created self.assertEqual(self.os.stat(file1_path).st_nlink, 2) self.assertEqual(self.os.stat(file2_path).st_nlink, 2) # Check that the counts are all updated together self.os.link(file2_path, file3_path) self.assertEqual(self.os.stat(file1_path).st_nlink, 3) self.assertEqual(self.os.stat(file2_path).st_nlink, 3) self.assertEqual(self.os.stat(file3_path).st_nlink, 3) # Counts should be decremented when links are removed self.os.unlink(file3_path) self.assertEqual(self.os.stat(file1_path).st_nlink, 2) self.assertEqual(self.os.stat(file2_path).st_nlink, 2) # check that it gets decremented correctly again self.os.unlink(file1_path) self.assertEqual(self.os.stat(file2_path).st_nlink, 1) @unittest.skipIf(IS_PYPY, "follow_symlinks not supported in PyPi") def test_link_no_follow_symlink(self): skip_if_symlink_not_supported() target_path = self.make_path("target_path") self.create_file(target_path, contents="foo") symlink_path = self.make_path("symlink_to_file") self.create_symlink(symlink_path, target_path) link_path = self.make_path("link_to_symlink") self.os.link(symlink_path, link_path, follow_symlinks=False) self.assertTrue(self.os.path.islink(link_path)) @unittest.skipIf(not IS_PYPY, "follow_symlinks only not supported in PyPi") def test_link_follow_symlink_not_supported_inPypy(self): skip_if_symlink_not_supported() target_path = self.make_path("target_path") self.create_file(target_path, contents="foo") symlink_path = self.make_path("symlink_to_file") self.create_symlink(symlink_path, target_path) link_path = self.make_path("link_to_symlink") with self.assertRaises(OSError) as cm: self.os.link(symlink_path, link_path, follow_symlinks=False) self.assertEqual(errno.EINVAL, cm.exception.errno) def test_nlink_for_directories(self): self.skip_real_fs() self.create_dir(self.make_path("foo", "bar")) self.create_file(self.make_path("foo", "baz")) self.assertEqual( 2, self.filesystem.get_object(self.make_path("foo", "bar")).st_nlink, ) self.assertEqual(4, self.filesystem.get_object(self.make_path("foo")).st_nlink) self.create_file(self.make_path("foo", "baz2")) self.assertEqual(5, self.filesystem.get_object(self.make_path("foo")).st_nlink) def test_umask(self): self.check_posix_only() umask = self.os.umask(0o22) self.assertEqual(umask, self.os.umask(0o12)) self.os.umask(umask) def test_mkdir_umask_applied(self): """mkdir creates a directory with umask applied.""" self.check_posix_only() self.os.umask(0o22) dir1 = self.make_path("dir1") self.os.mkdir(dir1) self.assert_mode_equal(0o755, self.os.stat(dir1).st_mode) self.os.umask(0o67) dir2 = self.make_path("dir2") self.os.mkdir(dir2) self.assert_mode_equal(0o710, self.os.stat(dir2).st_mode) def test_makedirs_umask_applied(self): """makedirs creates a directories with umask applied.""" self.check_posix_only() umask = self.os.umask(0o22) self.os.makedirs(self.make_path("p1", "dir1")) self.assert_mode_equal(0o755, self.os.stat(self.make_path("p1")).st_mode) self.assert_mode_equal( 0o755, self.os.stat(self.make_path("p1", "dir1")).st_mode ) self.os.umask(0o67) self.os.makedirs(self.make_path("p2", "dir2")) self.assert_mode_equal(0o710, self.os.stat(self.make_path("p2")).st_mode) self.assert_mode_equal( 0o710, self.os.stat(self.make_path("p2", "dir2")).st_mode ) self.os.umask(umask) def test_mknod_umask_applied(self): """mkdir creates a device with umask applied.""" # skipping MacOs due to mknod permission issues self.check_linux_only() self.os.umask(0o22) node1 = self.make_path("nod1") self.os.mknod(node1, stat.S_IFREG \| 0o666) self.assert_mode_equal(0o644, self.os.stat(node1).st_mode) self.os.umask(0o27) node2 = self.make_path("nod2") self.os.mknod(node2, stat.S_IFREG \| 0o666) self.assert_mode_equal(0o640, self.os.stat(node2).st_mode) def test_open_umask_applied(self): """open creates a file with umask applied.""" self.check_posix_only() self.os.umask(0o22) file1 = self.make_path("file1") self.open(file1, "w", encoding="utf8").close() self.assert_mode_equal(0o644, self.os.stat(file1).st_mode) self.os.umask(0o27) file2 = self.make_path("file2") self.open(file2, "w", encoding="utf8").close() self.assert_mode_equal(0o640, self.os.stat(file2).st_mode) def test_open_pipe(self): read_fd, write_fd = self.os.pipe() self.os.close(read_fd) self.os.close(write_fd) def test_open_pipe_with_existing_fd(self): file1 = self.make_path("file1") fd = self.os.open(file1, os.O_CREAT) read_fd, write_fd = self.os.pipe() self.assertGreater(read_fd, fd) self.os.close(fd) self.os.close(read_fd) self.os.close(write_fd) def test_open_file_with_existing_pipe(self): read_fd, write_fd = self.os.pipe() file1 = self.make_path("file1") fd = self.os.open(file1, os.O_CREAT) self.assertGreater(fd, write_fd) self.os.close(read_fd) self.os.close(write_fd) self.os.close(fd) def test_read_write_pipe(self): read_fd, write_fd = self.os.pipe() self.assertEqual(4, self.os.write(write_fd, b"test")) self.assertEqual(b"test", self.os.read(read_fd, 4)) self.os.close(read_fd) self.os.close(write_fd) def test_open_existing_pipe(self): # create some regular files to ensure that real and fake fd # are out of sync (see #581) fds = [] for i in range(5): path = self.make_path("file" + str(i)) fds.append(self.os.open(path, os.O_CREAT)) file_path = self.make_path("file.txt") self.create_file(file_path) with self.open(file_path, encoding="utf8"): read_fd, write_fd = self.os.pipe() with self.open(write_fd, "wb") as f: self.assertEqual(4, f.write(b"test")) with self.open(read_fd, "rb") as f: self.assertEqual(b"test", f.read()) for fd in fds: self.os.close(fd) def test_write_to_pipe(self): read_fd, write_fd = self.os.pipe() self.os.write(write_fd, b"test") self.assertEqual(b"test", self.os.read(read_fd, 4)) self.os.close(read_fd) self.os.close(write_fd) @unittest.skipIf( sys.platform not in ("win32", "darwin", "linux"), "Pipe implementation may differ on other platforms", ) def test_write_to_read_fd(self): read_fd, write_fd = self.os.pipe() self.assert_raises_os_error(errno.EBADF, self.os.write, read_fd, b"test") self.os.close(read_fd) self.os.close(write_fd) def test_truncate(self): file_path = self.make_path("foo", "bar") self.create_file(file_path, contents="012345678901234567") self.os.truncate(file_path, 10) with self.open(file_path, encoding="utf8") as f: self.assertEqual("0123456789", f.read()) def test_truncate_non_existing(self): self.assert_raises_os_error(errno.ENOENT, self.os.truncate, "foo", 10) def test_truncate_to_larger(self): file_path = self.make_path("foo", "bar") self.create_file(file_path, contents="0123456789") fd = self.os.open(file_path, os.O_RDWR) self.os.truncate(fd, 20) self.assertEqual(20, self.os.stat(file_path).st_size) with self.open(file_path, encoding="utf8") as f: self.assertEqual("0123456789" + "\0" * 10, f.read()) def test_truncate_with_fd(self): if os.truncate not in os.supports_fd: self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.ftruncate, 50, 10) file_path = self.make_path("some_file") self.create_file(file_path, contents="01234567890123456789") fd = self.os.open(file_path, os.O_RDWR) self.os.truncate(fd, 10) self.assertEqual(10, self.os.stat(file_path).st_size) with self.open(file_path, encoding="utf8") as f: self.assertEqual("0123456789", f.read()) def test_ftruncate(self): if self.is_pypy: # not correctly supported self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.ftruncate, 50, 10) file_path = self.make_path("some_file") self.create_file(file_path, contents="0123456789012345") fd = self.os.open(file_path, os.O_RDWR) self.os.truncate(fd, 10) self.assertEqual(10, self.os.stat(file_path).st_size) with self.open(file_path, encoding="utf8") as f: self.assertEqual("0123456789", f.read()) def test_capabilities(self): """Make sure that the fake capabilities are the same as the real ones.""" self.assertEqual( self.os.stat in self.os.supports_follow_symlinks, os.stat in os.supports_follow_symlinks, ) self.assertEqual(self.os.stat in self.os.supports_fd, os.stat in os.supports_fd) self.assertEqual( self.os.stat in self.os.supports_dir_fd, os.stat in os.supports_dir_fd ) self.assertEqual( self.os.stat in self.os.supports_effective_ids, os.stat in os.supports_effective_ids, ) def test_dup(self): with self.assertRaises(OSError) as cm: self.os.dup(500) self.assertEqual(errno.EBADF, cm.exception.errno) file_path = self.make_path("test.txt") self.create_file(file_path, contents="heythere") fd1 = self.os.open(file_path, os.O_RDONLY) fd2 = self.os.dup(fd1) self.assertEqual(b"hey", self.os.read(fd1, 3)) self.assertEqual(b"there", self.os.read(fd1, 10)) self.os.close(fd2) self.os.close(fd1) def test_dup_uses_freed_fd(self): file_path1 = self.make_path("foo.txt") file_path2 = self.make_path("bar.txt") self.create_file(file_path1, contents="foo here") self.create_file(file_path2, contents="bar here") fd1 = self.os.open(file_path1, os.O_RDONLY) fd2 = self.os.open(file_path2, os.O_RDONLY) self.os.close(fd1) fd3 = self.os.dup(fd2) self.assertEqual(fd1, fd3) self.os.close(fd2) def test_dup2_uses_existing_fd(self): with self.assertRaises(OSError) as cm: self.os.dup2(500, 501) self.assertEqual(errno.EBADF, cm.exception.errno) file_path1 = self.make_path("foo.txt") file_path2 = self.make_path("bar.txt") self.create_file(file_path1, contents="foo here") self.create_file(file_path2, contents="bar here") fd1 = self.os.open(file_path1, os.O_RDONLY) fd2 = self.os.open(file_path2, os.O_RDONLY) self.assertEqual(b"bar", self.os.read(fd2, 3)) fd2 = self.os.dup2(fd1, fd2) self.assertEqual(b"foo", self.os.read(fd2, 3)) self.os.lseek(fd2, 0, 0) self.assertEqual(b"foo", self.os.read(fd1, 3)) self.os.close(fd2) def test_dup2_with_new_fd(self): file_path1 = self.make_path("foo.txt") file_path2 = self.make_path("bar.txt") self.create_file(file_path1) self.create_file(file_path2) fd1 = self.os.open(file_path1, os.O_RDONLY) fd2 = fd1 + 2 self.assertEqual(fd2, self.os.dup2(fd1, fd2)) fd3 = self.os.open(file_path2, os.O_RDONLY) fd4 = self.os.dup(fd3) self.os.close(fd4) self.os.close(fd2) # we have a free position before fd2 that is now filled self.assertEqual(fd1 + 1, fd3) self.assertEqual(fd1 + 3, fd4) @unittest.skipIf(sys.version_info < (3, 14), "Introduced in Python 3.14") def test_readinto(self): file_path = self.make_path("foo", "bar.txt") contents = b"Testing readinto" self.create_file(file_path, contents=contents) fd = self.os.open(file_path, os.O_RDONLY) try: buffer = bytearray(b"") self.assertEqual(0, self.os.readinto(fd, buffer)) buffer = bytearray(b" " * 20) self.assertEqual(len(contents), self.os.readinto(fd, buffer)) self.assertEqual(b"Testing readinto ", buffer) self.assertEqual(0, self.os.readinto(fd, buffer)) self.os.lseek(fd, 5, os.SEEK_SET) self.assertEqual(len(contents) - 5, self.os.readinto(fd, buffer)) self.assertEqual(b"ng readintodinto ", buffer) finally: self.os.close(fd) class RealOsModuleTest(FakeOsModuleTest): def use_real_fs(self): return True class FakeOsModuleTestCaseInsensitiveFS(FakeOsModuleTestBase): def setUp(self): super().setUp() self.check_case_insensitive_fs() self.rwx = self.os.R_OK \| self.os.W_OK \| self.os.X_OK self.rw = self.os.R_OK \| self.os.W_OK def test_chdir_fails_non_directory(self): """chdir should raise OSError if the target is not a directory.""" filename = self.make_path("foo", "bar") self.create_file(filename) filename1 = self.make_path("Foo", "Bar") self.assert_raises_os_error(errno.ENOTDIR, self.os.chdir, filename1) def test_listdir_returns_list(self): directory_root = self.make_path("xyzzy") self.os.mkdir(directory_root) directory = self.os.path.join(directory_root, "bug") self.os.mkdir(directory) directory_upper = self.make_path("XYZZY", "BUG") self.create_file(self.make_path(directory, "foo")) self.assertEqual(["foo"], self.os.listdir(directory_upper)) def test_listdir_on_symlink(self): skip_if_symlink_not_supported() directory = self.make_path("xyzzy") files = ["foo", "bar", "baz"] for f in files: self.create_file(self.make_path(directory, f)) self.create_symlink(self.make_path("symlink"), self.make_path("xyzzy")) files.sort() self.assertEqual(files, sorted(self.os.listdir(self.make_path("SymLink")))) def test_listdir_possible_without_exe_permission(self): # regression test for #960 self.check_posix_only() self.skip_root() directory = self.make_path("testdir") file_path = self.os.path.join(directory, "file.txt") self.create_file(file_path, contents="hey", perm=0o777) self.os.chmod(directory, 0o655) # rw-r-xr-x # We cannot create any files in the directory, because that requires # searching it another_file = self.make_path("file.txt") self.create_file(another_file, contents="hey") with self.assertRaises(PermissionError): self.os.link(another_file, self.os.path.join(directory, "link.txt")) # We can enumerate the directory using listdir and scandir: assert self.os.listdir(directory) == ["file.txt"] assert len(list(self.os.scandir(directory))) == 1 # We cannot read files inside of the directory, # even if we have read access to the file with self.assertRaises(PermissionError): self.os.stat(file_path) with self.assertRaises(PermissionError): with self.open(file_path, encoding="utf8") as f: f.read() def test_listdir_impossible_without_read_permission(self): # regression test for #960 self.check_posix_only() self.skip_root() directory = self.make_path("testdir") file_path = self.os.path.join(directory, "file.txt") self.create_file(file_path, contents="hey", perm=0o777) self.os.chmod(directory, 0o355) # -wxr-xr-x another_file = self.make_path("file.txt") self.create_file(another_file, contents="hey") self.os.link(another_file, self.os.path.join(directory, "link.txt")) # We cannot enumerate the directory using listdir or scandir: with self.assertRaises(PermissionError): self.os.listdir(directory) with self.assertRaises(PermissionError): self.os.scandir(directory) # we can access the file if we know the file name assert self.os.stat(file_path).st_mode & 0o777 == 0o755 with self.open(file_path, encoding="utf8") as f: assert f.read() == "hey" def test_stat(self): directory = self.make_path("xyzzy") directory1 = self.make_path("XYZZY") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path, contents="ABCDE") self.assertTrue(stat.S_IFDIR & self.os.stat(directory1)[stat.ST_MODE]) file_path1 = self.os.path.join(directory1, "Plugh") self.assertTrue(stat.S_IFREG & self.os.stat(file_path1)[stat.ST_MODE]) self.assertTrue(stat.S_IFREG & self.os.stat(file_path1).st_mode) self.assertEqual(5, self.os.stat(file_path1)[stat.ST_SIZE]) def test_stat_no_follow_symlinks_posix(self): """Test that stat with follow_symlinks=False behaves like lstat.""" self.check_posix_only() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual( len(file_contents), self.os.stat(file_path.upper(), follow_symlinks=False)[stat.ST_SIZE], ) self.assertEqual( len(base_name), self.os.stat(link_path.upper(), follow_symlinks=False)[stat.ST_SIZE], ) def test_lstat_posix(self): self.check_posix_only() directory = self.make_path("xyzzy") base_name = "plugh" file_contents = "frobozz" # Just make sure we didn't accidentally make our test data meaningless. self.assertNotEqual(len(base_name), len(file_contents)) file_path = self.os.path.join(directory, base_name) link_path = self.os.path.join(directory, "link") self.create_file(file_path, contents=file_contents) self.create_symlink(link_path, base_name) self.assertEqual( len(file_contents), self.os.lstat(file_path.upper())[stat.ST_SIZE] ) self.assertEqual(len(base_name), self.os.lstat(link_path.upper())[stat.ST_SIZE]) def test_readlink(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "baz") target = self.make_path("tarJAY") self.create_symlink(link_path, target) self.assert_equal_paths(self.os.readlink(link_path.upper()), target) def check_readlink_raises_if_path_not_a_link(self): file_path = self.make_path("foo", "bar", "eleventyone") self.create_file(file_path) self.assert_raises_os_error(errno.EINVAL, self.os.readlink, file_path.upper()) def test_readlink_raises_if_path_not_a_link_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_readlink_raises_if_path_not_a_link() def test_readlink_raises_if_path_not_a_link_posix(self): self.check_posix_only() self.check_readlink_raises_if_path_not_a_link() def check_readlink_raises_if_path_has_file(self, error_subtype): self.create_file(self.make_path("a_file")) file_path = self.make_path("a_file", "foo") self.assert_raises_os_error(error_subtype, self.os.readlink, file_path.upper()) file_path = self.make_path("a_file", "foo", "bar") self.assert_raises_os_error(error_subtype, self.os.readlink, file_path.upper()) def test_readlink_raises_if_path_has_file_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_readlink_raises_if_path_has_file(errno.ENOENT) def test_readlink_raises_if_path_has_file_posix(self): self.check_posix_only() self.check_readlink_raises_if_path_has_file(errno.ENOTDIR) def test_readlink_with_links_in_path(self): skip_if_symlink_not_supported() self.create_symlink( self.make_path("meyer", "lemon", "pie"), self.make_path("yum") ) self.create_symlink(self.make_path("geo", "metro"), self.make_path("Meyer")) self.assert_equal_paths( self.make_path("yum"), self.os.readlink(self.make_path("Geo", "Metro", "Lemon", "Pie")), ) def test_readlink_with_chained_links_in_path(self): skip_if_symlink_not_supported() self.create_symlink( self.make_path("eastern", "european", "wolfhounds", "chase"), self.make_path("cats"), ) self.create_symlink( self.make_path("russian"), self.make_path("Eastern", "European") ) self.create_symlink( self.make_path("dogs"), self.make_path("Russian", "Wolfhounds") ) self.assert_equal_paths( self.make_path("cats"), self.os.readlink(self.make_path("DOGS", "Chase")), ) def check_remove_dir(self, dir_error): directory = self.make_path("xyzzy") dir_path = self.os.path.join(directory, "plugh") self.create_dir(dir_path) dir_path = dir_path.upper() self.assertTrue(self.os.path.exists(dir_path.upper())) self.assert_raises_os_error(dir_error, self.os.remove, dir_path) self.assertTrue(self.os.path.exists(dir_path)) self.os.chdir(directory) self.assert_raises_os_error(dir_error, self.os.remove, dir_path) self.assertTrue(self.os.path.exists(dir_path)) self.assert_raises_os_error(errno.ENOENT, self.os.remove, "/Plugh") def test_remove_dir_mac_os(self): self.check_macos_only() self.check_remove_dir(errno.EPERM) def test_remove_dir_windows(self): self.check_windows_only() self.check_remove_dir(errno.EACCES) def test_remove_file(self): directory = self.make_path("zzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path.upper())) self.os.remove(file_path.upper()) self.assertFalse(self.os.path.exists(file_path)) def test_remove_file_no_directory(self): directory = self.make_path("zzy") file_name = "plugh" file_path = self.os.path.join(directory, file_name) self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.os.chdir(directory.upper()) self.os.remove(file_name.upper()) self.assertFalse(self.os.path.exists(file_path)) def test_remove_open_file_fails_under_windows(self): self.check_windows_only() path = self.make_path("foo", "bar") self.create_file(path) with self.open(path, "r", encoding="utf8"): self.assert_raises_os_error(errno.EACCES, self.os.remove, path.upper()) self.assertTrue(self.os.path.exists(path)) def test_remove_open_file_possible_under_posix(self): self.check_posix_only() path = self.make_path("foo", "bar") self.create_file(path) self.open(path, "r", encoding="utf8") self.os.remove(path.upper()) self.assertFalse(self.os.path.exists(path)) def test_remove_file_relative_path(self): self.skip_real_fs() original_dir = self.os.getcwd() directory = self.make_path("zzy") subdirectory = self.os.path.join(directory, "zzy") file_name = "plugh" file_path = self.os.path.join(directory, file_name) file_path_relative = self.os.path.join("..", file_name) self.create_file(file_path.upper()) self.assertTrue(self.os.path.exists(file_path)) self.create_dir(subdirectory) self.assertTrue(self.os.path.exists(subdirectory)) self.os.chdir(subdirectory.upper()) self.os.remove(file_path_relative.upper()) self.assertFalse(self.os.path.exists(file_path_relative)) self.os.chdir(original_dir.upper()) self.assertFalse(self.os.path.exists(file_path)) def check_remove_dir_raises_error(self, dir_error): directory = self.make_path("zzy") self.create_dir(directory) self.assert_raises_os_error(dir_error, self.os.remove, directory.upper()) def test_remove_dir_raises_error_mac_os(self): self.check_macos_only() self.check_remove_dir_raises_error(errno.EPERM) def test_remove_dir_raises_error_windows(self): self.check_windows_only() self.check_remove_dir_raises_error(errno.EACCES) def test_remove_symlink_to_dir(self): skip_if_symlink_not_supported() directory = self.make_path("zzy") link = self.make_path("link_to_dir") self.create_dir(directory) self.os.symlink(directory, link) self.assertTrue(self.os.path.exists(directory)) self.assertTrue(self.os.path.exists(link)) self.os.remove(link.upper()) self.assertTrue(self.os.path.exists(directory)) self.assertFalse(self.os.path.exists(link)) def test_rename_dir_to_symlink_posix(self): self.check_posix_only() link_path = self.make_path("link") dir_path = self.make_path("dir") link_target = self.os.path.join(dir_path, "link_target") self.create_dir(dir_path) self.os.symlink(link_target.upper(), link_path.upper()) self.assert_raises_os_error(errno.ENOTDIR, self.os.rename, dir_path, link_path) def test_rename_dir_to_symlink_windows(self): self.check_windows_only() skip_if_symlink_not_supported() link_path = self.make_path("link") dir_path = self.make_path("dir") link_target = self.os.path.join(dir_path, "link_target") self.create_dir(dir_path) self.os.symlink(link_target.upper(), link_path.upper()) self.assert_raises_os_error(errno.EEXIST, self.os.rename, dir_path, link_path) def test_rename_dir_to_existing_dir(self): # Regression test for #317 self.check_posix_only() dest_dir_path = self.make_path("Dest") # seems to behave differently under different MacOS versions self.skip_real_fs() new_dest_dir_path = self.make_path("dest") self.os.mkdir(dest_dir_path) source_dir_path = self.make_path("src") self.os.mkdir(source_dir_path) self.os.rename(source_dir_path, new_dest_dir_path) self.assertEqual(["dest"], self.os.listdir(self.base_path)) def test_rename_file_to_symlink(self): self.check_posix_only() link_path = self.make_path("file_link") file_path = self.make_path("file") self.os.symlink(file_path, link_path) self.create_file(file_path) self.os.rename(file_path.upper(), link_path) self.assertFalse(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(link_path.upper())) self.assertTrue(self.os.path.isfile(link_path.upper())) def test_rename_symlink_to_symlink(self): self.check_posix_only() base_path = self.make_path("foo", "bar") self.create_dir(base_path) link_path1 = self.os.path.join(base_path, "link1") link_path2 = self.os.path.join(base_path, "link2") self.os.symlink(base_path.upper(), link_path1) self.os.symlink(base_path, link_path2) self.os.rename(link_path1.upper(), link_path2.upper()) self.assertFalse(self.os.path.exists(link_path1)) self.assertTrue(self.os.path.exists(link_path2)) def test_rename_symlink_to_symlink_for_parent_raises(self): self.check_posix_only() dir_link = self.make_path("dir_link") dir_path = self.make_path("dir") dir_in_dir_path = self.os.path.join(dir_link, "inner_dir") self.create_dir(dir_path) self.os.symlink(dir_path.upper(), dir_link) self.create_dir(dir_in_dir_path) self.assert_raises_os_error( errno.EINVAL, self.os.rename, dir_path, dir_in_dir_path.upper() ) def test_rename_directory_to_linked_dir(self): # Regression test for #314 skip_if_symlink_not_supported() link_path = self.make_path("link") self.os.symlink(self.base_path, link_path) link_subdir = self.os.path.join(link_path, "dir") dir_path = self.make_path("Dir") self.os.mkdir(dir_path) self.os.rename(dir_path, link_subdir) self.assertEqual(["dir", "link"], sorted(self.os.listdir(self.base_path))) def test_recursive_rename_raises(self): self.check_posix_only() base_path = self.make_path("foo", "bar") self.create_dir(base_path) new_path = self.os.path.join(base_path, "new_dir") self.assert_raises_os_error( errno.EINVAL, self.os.rename, base_path.upper(), new_path ) def test_rename_with_target_parent_file_raises_posix(self): self.check_posix_only() file_path = self.make_path("foo", "baz") self.create_file(file_path) self.assert_raises_os_error( errno.ENOTDIR, self.os.rename, file_path, file_path.upper() + "/new", ) def test_rename_with_target_parent_file_raises_windows(self): self.check_windows_only() file_path = self.make_path("foo", "baz") self.create_file(file_path) self.assert_raises_os_error( errno.EINVAL, self.os.rename, file_path, self.os.path.join(file_path.upper(), "new"), ) def test_rename_looping_symlink(self): # Regression test for #315 skip_if_symlink_not_supported() path_lower = self.make_path("baz") path_upper = self.make_path("BAZ") self.os.symlink(path_lower, path_upper) self.os.rename(path_upper, path_lower) self.assertEqual(["baz"], self.os.listdir(self.base_path)) def test_rename_symlink_to_source(self): self.check_posix_only() base_path = self.make_path("foo") link_path = self.os.path.join(base_path, "slink") file_path = self.os.path.join(base_path, "file") self.create_file(file_path) self.os.symlink(file_path, link_path) self.os.rename(link_path.upper(), file_path.upper()) self.assertFalse(self.os.path.exists(file_path)) def test_rename_symlink_to_dir_raises(self): self.check_posix_only() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "dir_link") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path, link_path.upper()) self.assert_raises_os_error( errno.EISDIR, self.os.rename, link_path, dir_path.upper() ) def test_rename_broken_symlink(self): self.check_posix_only() base_path = self.make_path("foo") self.create_dir(base_path) link_path = self.os.path.join(base_path, "slink") file_path = self.os.path.join(base_path, "file") self.os.symlink(file_path.upper(), link_path) self.os.rename(link_path.upper(), file_path) self.assertFalse(self.os.path.exists(file_path)) self.assertTrue(self.os.path.lexists(file_path)) self.assertFalse(self.os.path.exists(link_path)) def test_change_case_in_case_insensitive_file_system(self): """Can use `rename()` to change filename case in a case-insensitive file system.""" old_file_path = self.make_path("fileName") new_file_path = self.make_path("FileNAME") self.create_file(old_file_path, contents="test contents") self.assertEqual(["fileName"], self.os.listdir(self.base_path)) self.os.rename(old_file_path, new_file_path) self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.assertEqual(["FileNAME"], self.os.listdir(self.base_path)) def test_rename_symlink_with_changed_case(self): # Regression test for #313 skip_if_symlink_not_supported() link_path = self.make_path("link") self.os.symlink(self.base_path, link_path) link_path = self.os.path.join(link_path, "link") link_path_upper = self.make_path("link", "LINK") self.os.rename(link_path_upper, link_path) def test_rename_directory(self): """Can rename a directory to an unused name.""" for old_path, new_path in [("wxyyw", "xyzzy"), ("abccb", "cdeed")]: old_path = self.make_path(old_path) new_path = self.make_path(new_path) self.create_file(self.os.path.join(old_path, "plugh"), contents="test") self.assertTrue(self.os.path.exists(old_path)) self.assertFalse(self.os.path.exists(new_path)) self.os.rename(old_path.upper(), new_path.upper()) self.assertFalse(self.os.path.exists(old_path)) self.assertTrue(self.os.path.exists(new_path)) self.check_contents(self.os.path.join(new_path, "plugh"), "test") if not self.use_real_fs(): self.assertEqual(3, self.filesystem.get_object(new_path).st_nlink) def check_rename_directory_to_existing_file_raises(self, error_nr): dir_path = self.make_path("dir") file_path = self.make_path("file") self.create_dir(dir_path) self.create_file(file_path) self.assert_raises_os_error( error_nr, self.os.rename, dir_path, file_path.upper() ) def test_rename_directory_to_existing_file_raises_posix(self): self.check_posix_only() self.check_rename_directory_to_existing_file_raises(errno.ENOTDIR) def test_rename_directory_to_existing_file_raises_windows(self): self.check_windows_only() self.check_rename_directory_to_existing_file_raises(errno.EEXIST) def test_rename_to_existing_directory_should_raise_under_windows(self): """Renaming to an existing directory raises OSError under Windows.""" self.check_windows_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("foo", "baz") self.create_dir(old_path) self.create_dir(new_path) self.assert_raises_os_error( errno.EEXIST, self.os.rename, old_path.upper(), new_path.upper() ) def test_rename_to_a_hardlink_of_same_file_should_do_nothing(self): self.skip_real_fs_failure(skip_posix=False) skip_if_symlink_not_supported() file_path = self.make_path("dir", "file") self.create_file(file_path) link_path = self.make_path("link") self.os.link(file_path.upper(), link_path) self.os.rename(file_path, link_path.upper()) self.assertTrue(self.os.path.exists(file_path)) self.assertTrue(self.os.path.exists(link_path)) def test_rename_with_incorrect_source_case(self): # Regression test for #308 base_path = self.make_path("foo") path0 = self.os.path.join(base_path, "bar") path1 = self.os.path.join(base_path, "Bar") self.create_dir(path0) self.os.rename(path1, path0) self.assertTrue(self.os.path.exists(path0)) def test_rename_symlink_to_other_case_does_nothing_in_mac_os(self): # Regression test for #318 self.check_macos_only() path0 = self.make_path("beta") self.os.symlink(self.base_path, path0) path0 = self.make_path("beta", "Beta") path1 = self.make_path("Beta") self.os.rename(path0, path1) self.assertEqual(["beta"], sorted(self.os.listdir(path0))) def test_rename_symlink_to_other_case_works_in_windows(self): self.check_windows_only() skip_if_symlink_not_supported() path0 = self.make_path("beta") self.os.symlink(self.base_path, path0) path0 = self.make_path("beta", "Beta") path1 = self.make_path("Beta") self.os.rename(path0, path1) self.assertEqual(["Beta"], sorted(self.os.listdir(path0))) def test_renames_creates_missing_dirs(self): old_path = self.make_path("foo.txt") self.create_file(old_path) new_path = self.make_path("new", "dir", "bar.txt") self.os.renames(old_path, new_path) self.assertTrue(self.os.path.exists(new_path)) self.assertFalse(self.os.path.exists(old_path)) def test_renames_removes_empty_dirs(self): old_base_path = self.make_path("old") old_path = self.make_path("old", "dir1", "dir2", "foo.txt") other_file = self.os.path.join(old_base_path, "foo.png") self.create_file(old_path) self.create_file(other_file) new_path = self.make_path("new", "bar.txt") self.os.renames(old_path, new_path) self.assertTrue(self.os.path.exists(new_path)) self.assertFalse(self.os.path.exists(old_path)) self.assertTrue(self.os.path.exists(old_base_path)) removed_path = self.os.path.join(old_base_path, "dir1") self.assertFalse(self.os.path.exists(removed_path)) def test_stat_with_mixed_case(self): # Regression test for #310 skip_if_symlink_not_supported() base_path = self.make_path("foo") path = self.os.path.join(base_path, "bar") self.create_dir(path) path = self.os.path.join(path, "Bar") self.os.symlink(base_path, path) path = self.os.path.join(path, "Bar") # used to raise self.os.stat(path) def test_hardlink_works_with_symlink(self): skip_if_symlink_not_supported() base_path = self.make_path("foo") self.create_dir(base_path) symlink_path = self.os.path.join(base_path, "slink") self.os.symlink(base_path.upper(), symlink_path) file_path = self.os.path.join(base_path, "slink", "beta") self.create_file(file_path) link_path = self.os.path.join(base_path, "Slink", "gamma") self.os.link(file_path, link_path) self.assertTrue(self.os.path.exists(link_path)) def test_replace_existing_directory_should_raise_under_windows(self): """Renaming to an existing directory raises OSError under Windows.""" self.check_windows_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("foo", "baz") self.create_dir(old_path) self.create_dir(new_path) self.assert_raises_os_error( errno.EACCES, self.os.replace, old_path, new_path.upper() ) def test_rename_to_existing_directory_under_posix(self): """Renaming to an existing directory changes the existing directory under Posix.""" self.check_posix_only() old_path = self.make_path("foo", "bar") new_path = self.make_path("xyzzy") self.create_dir(self.os.path.join(old_path, "sub")) self.create_dir(new_path) self.os.rename(old_path.upper(), new_path.upper()) self.assertTrue(self.os.path.exists(self.os.path.join(new_path, "sub"))) self.assertFalse(self.os.path.exists(old_path)) def test_rename_file_to_existing_directory_raises_under_posix(self): self.check_posix_only() file_path = self.make_path("foo", "bar", "baz") new_path = self.make_path("xyzzy") self.create_file(file_path) self.create_dir(new_path) self.assert_raises_os_error( errno.EISDIR, self.os.rename, file_path.upper(), new_path.upper() ) def test_rename_to_existent_file_posix(self): """Can rename a file to a used name under Unix.""" self.check_posix_only() directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.os.rename(old_file_path.upper(), new_file_path.upper()) self.assertFalse(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.check_contents(new_file_path, "test contents 1") def test_rename_to_existent_file_windows(self): """Renaming a file to a used name raises OSError under Windows.""" self.check_windows_only() directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.assert_raises_os_error( errno.EEXIST, self.os.rename, old_file_path.upper(), new_file_path.upper(), ) def test_replace_to_existent_file(self): """Replaces an existing file (does not work with `rename()` under Windows).""" directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "plugh_new") self.create_file(old_file_path, contents="test contents 1") self.create_file(new_file_path, contents="test contents 2") self.assertTrue(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.os.replace(old_file_path.upper(), new_file_path.upper()) self.assertFalse(self.os.path.exists(old_file_path)) self.assertTrue(self.os.path.exists(new_file_path)) self.check_contents(new_file_path, "test contents 1") def test_rename_to_nonexistent_dir(self): """Can rename a file to a name in a nonexistent dir.""" directory = self.make_path("xyzzy") old_file_path = self.os.path.join(directory, "plugh_old") new_file_path = self.os.path.join(directory, "no_such_path", "plugh_new") self.create_file(old_file_path, contents="test contents") self.assertTrue(self.os.path.exists(old_file_path)) self.assertFalse(self.os.path.exists(new_file_path)) self.assert_raises_os_error( errno.ENOENT, self.os.rename, old_file_path.upper(), new_file_path.upper(), ) self.assertTrue(self.os.path.exists(old_file_path)) self.assertFalse(self.os.path.exists(new_file_path)) self.check_contents(old_file_path, "test contents") def check_rename_case_only_with_symlink_parent(self): # Regression test for #319 self.os.symlink(self.base_path, self.make_path("link")) dir_upper = self.make_path("link", "Alpha") self.os.mkdir(dir_upper) dir_lower = self.make_path("alpha") self.os.rename(dir_upper, dir_lower) self.assertEqual(["alpha", "link"], sorted(self.os.listdir(self.base_path))) def test_rename_case_only_with_symlink_parent_windows(self): self.check_windows_only() skip_if_symlink_not_supported() self.check_rename_case_only_with_symlink_parent() def test_rename_case_only_with_symlink_parent_macos(self): self.check_macos_only() self.check_rename_case_only_with_symlink_parent() def test_rename_dir(self): """Test a rename of a directory.""" directory = self.make_path("xyzzy") before_dir = self.os.path.join(directory, "before") before_file = self.os.path.join(directory, "before", "file") after_dir = self.os.path.join(directory, "after") after_file = self.os.path.join(directory, "after", "file") self.create_dir(before_dir) self.create_file(before_file, contents="payload") self.assertTrue(self.os.path.exists(before_dir.upper())) self.assertTrue(self.os.path.exists(before_file.upper())) self.assertFalse(self.os.path.exists(after_dir.upper())) self.assertFalse(self.os.path.exists(after_file.upper())) self.os.rename(before_dir.upper(), after_dir) self.assertFalse(self.os.path.exists(before_dir.upper())) self.assertFalse(self.os.path.exists(before_file.upper())) self.assertTrue(self.os.path.exists(after_dir.upper())) self.assertTrue(self.os.path.exists(after_file.upper())) self.check_contents(after_file, "payload") def test_rename_same_filenames(self): """Test renaming when old and new names are the same.""" directory = self.make_path("xyzzy") file_contents = "Spam eggs" file_path = self.os.path.join(directory, "eggs") self.create_file(file_path, contents=file_contents) self.os.rename(file_path, file_path.upper()) self.check_contents(file_path, file_contents) def test_rmdir(self): """Can remove a directory.""" directory = self.make_path("xyzzy") sub_dir = self.make_path("xyzzy", "abccd") other_dir = self.make_path("xyzzy", "cdeed") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.os.rmdir(directory) self.assertFalse(self.os.path.exists(directory)) self.create_dir(sub_dir) self.create_dir(other_dir) self.os.chdir(sub_dir) self.os.rmdir("../CDEED") self.assertFalse(self.os.path.exists(other_dir)) self.os.chdir("..") self.os.rmdir("AbcCd") self.assertFalse(self.os.path.exists(sub_dir)) def test_rmdir_via_symlink(self): self.check_windows_only() skip_if_symlink_not_supported() base_path = self.make_path("foo", "bar") dir_path = self.os.path.join(base_path, "alpha") self.create_dir(dir_path) link_path = self.os.path.join(base_path, "beta") self.os.symlink(base_path, link_path) self.os.rmdir(link_path + "/Alpha") self.assertFalse(self.os.path.exists(dir_path)) def test_remove_dirs_with_non_top_symlink_succeeds(self): self.check_posix_only() dir_path = self.make_path("dir") dir_link = self.make_path("dir_link") self.create_dir(dir_path) self.os.symlink(dir_path, dir_link) dir_in_dir = self.os.path.join(dir_link, "dir2") self.create_dir(dir_in_dir) self.os.removedirs(dir_in_dir.upper()) self.assertFalse(self.os.path.exists(dir_in_dir)) # ensure that the symlink is not removed self.assertTrue(self.os.path.exists(dir_link)) def test_mkdir_raises_on_symlink_in_posix(self): self.check_posix_only() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "link_to_dir") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path.upper(), link_path.upper()) self.assert_raises_os_error(errno.ENOTDIR, self.os.rmdir, link_path) def test_mkdir_removes_symlink_in_windows(self): self.check_windows_only() skip_if_symlink_not_supported() base_path = self.make_path("foo", "bar") link_path = self.os.path.join(base_path, "link_to_dir") dir_path = self.os.path.join(base_path, "dir") self.create_dir(dir_path) self.os.symlink(dir_path.upper(), link_path.upper()) self.os.rmdir(link_path) self.assertFalse(self.os.path.exists(link_path)) self.assertTrue(self.os.path.exists(dir_path)) def test_mkdir_raises_if_directory_exists(self): """mkdir raises exception if directory already exists.""" directory = self.make_path("xyzzy") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, directory.upper()) def test_mkdir_raises_if_file_exists(self): """mkdir raises exception if name already exists as a file.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, file_path.upper()) def test_mkdir_raises_if_symlink_exists(self): # Regression test for #309 skip_if_symlink_not_supported() path1 = self.make_path("baz") self.os.symlink(path1, path1) path2 = self.make_path("Baz") self.assert_raises_os_error(errno.EEXIST, self.os.mkdir, path2) def check_mkdir_raises_if_parent_is_file(self, error_type): """mkdir raises exception if name already exists as a file.""" directory = self.make_path("xyzzy") file_path = self.os.path.join(directory, "plugh") self.create_file(file_path) self.assert_raises_os_error( error_type, self.os.mkdir, self.os.path.join(file_path.upper(), "ff"), ) def test_mkdir_raises_if_parent_is_file_posix(self): self.check_posix_only() self.check_mkdir_raises_if_parent_is_file(errno.ENOTDIR) def test_mkdir_raises_if_parent_is_file_windows(self): self.check_windows_only() self.check_mkdir_raises_if_parent_is_file(errno.ENOENT) def test_makedirs(self): """makedirs can create a directory even if parent does not exist.""" parent = self.make_path("xyzzy") directory = self.os.path.join(parent, "foo") self.assertFalse(self.os.path.exists(parent)) self.os.makedirs(directory.upper()) self.assertTrue(self.os.path.exists(directory)) def check_makedirs_raises_if_parent_is_file(self, error_type): """makedirs raises exception if a parent component exists as a file.""" file_path = self.make_path("xyzzy") directory = self.os.path.join(file_path, "plugh") self.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(error_type, self.os.makedirs, directory.upper()) def test_makedirs_raises_if_parent_is_file_posix(self): self.check_posix_only() self.check_makedirs_raises_if_parent_is_file(errno.ENOTDIR) def test_makedirs_raises_if_parent_is_file_windows(self): self.check_windows_only() self.check_makedirs_raises_if_parent_is_file(errno.ENOENT) def test_makedirs_raises_if_parent_is_broken_link(self): self.check_posix_only() link_path = self.make_path("broken_link") self.os.symlink(self.make_path("bogus"), link_path) self.assert_raises_os_error( errno.ENOENT, self.os.makedirs, self.os.path.join(link_path.upper(), "newdir"), ) def test_makedirs_exist_ok(self): """makedirs uses the exist_ok argument""" directory = self.make_path("xyzzy", "foo") self.create_dir(directory) self.assertTrue(self.os.path.exists(directory)) self.assert_raises_os_error(errno.EEXIST, self.os.makedirs, directory.upper()) self.os.makedirs(directory.upper(), exist_ok=True) self.assertTrue(self.os.path.exists(directory)) # test fsync and fdatasync def test_fsync_pass(self): test_file_path = self.make_path("test_file") self.create_file(test_file_path, contents="dummy file contents") test_file = self.open(test_file_path.upper(), "r+", encoding="utf8") test_fd = test_file.fileno() # Test that this doesn't raise anything self.os.fsync(test_fd) # And just for sanity, double-check that this still raises self.assert_raises_os_error(errno.EBADF, self.os.fsync, test_fd + 10) test_file.close() def test_chmod(self): # set up self.check_posix_only() self.skip_real_fs() path = self.make_path("some_file") self.createTestFile(path) # actual tests self.os.chmod(path.upper(), 0o6543) st = self.os.stat(path) self.assert_mode_equal(0o6543, st.st_mode) self.assertTrue(st.st_mode & stat.S_IFREG) self.assertFalse(st.st_mode & stat.S_IFDIR) def test_symlink(self): skip_if_symlink_not_supported() file_path = self.make_path("foo", "bar", "baz") self.create_dir(self.make_path("foo", "bar")) self.os.symlink("bogus", file_path.upper()) self.assertTrue(self.os.path.lexists(file_path)) self.assertFalse(self.os.path.exists(file_path)) self.create_file(self.make_path("Foo", "Bar", "Bogus")) self.assertTrue(self.os.path.lexists(file_path)) self.assertTrue(self.os.path.exists(file_path)) # hard link related tests def test_link_delete(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") file2_path = self.make_path("test_file2") contents1 = "abcdef" # Create file self.create_file(file1_path, contents=contents1) # link to second file self.os.link(file1_path.upper(), file2_path) # delete first file self.os.unlink(file1_path) # assert that second file exists, and its contents are the same self.assertTrue(self.os.path.exists(file2_path)) with self.open(file2_path.upper(), encoding="utf8") as f: self.assertEqual(f.read(), contents1) def test_link_is_existing_file(self): skip_if_symlink_not_supported() file_path = self.make_path("foo", "bar") self.create_file(file_path) self.assert_raises_os_error( errno.EEXIST, self.os.link, file_path.upper(), file_path.upper() ) def test_link_is_broken_symlink(self): # Regression test for #311 skip_if_symlink_not_supported() self.check_case_insensitive_fs() file_path = self.make_path("baz") self.create_file(file_path) path_lower = self.make_path("foo") self.os.symlink(path_lower, path_lower) path_upper = self.make_path("Foo") self.assert_raises_os_error(errno.EEXIST, self.os.link, file_path, path_upper) def test_link_with_changed_case(self): # Regression test for #312 skip_if_symlink_not_supported() self.check_case_insensitive_fs() link_path = self.make_path("link") self.os.symlink(self.base_path, link_path) link_path = self.os.path.join(link_path, "Link") self.assertTrue(self.os.lstat(link_path)) class RealOsModuleTestCaseInsensitiveFS(FakeOsModuleTestCaseInsensitiveFS): def use_real_fs(self): return True class FakeOsModuleTimeTest(FakeOsModuleTestBase): def test_chmod_st_ctime(self): with self.mock_time(start=200): file_path = "some_file" self.filesystem.create_file(file_path) self.assertTrue(self.os.path.exists(file_path)) st = self.os.stat(file_path) self.assertEqual(200, st.st_ctime) # tests self.os.chmod(file_path, 0o765) st = self.os.stat(file_path) self.assertEqual(220, st.st_ctime) def test_utime_sets_current_time_if_args_is_none(self): path = self.make_path("some_file") self.createTestFile(path) with self.mock_time(start=200): self.os.utime(path, times=None) st = self.os.stat(path) self.assertEqual(200, st.st_atime) self.assertEqual(200, st.st_mtime) def test_utime_sets_specified_time(self): # set up path = self.make_path("some_file") self.createTestFile(path) self.os.stat(path) # actual tests self.os.utime(path, times=(1, 2)) st = self.os.stat(path) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) def test_utime_dir(self): # set up path = "/some_dir" self.createTestDirectory(path) # actual tests self.os.utime(path, times=(1.0, 2.0)) st = self.os.stat(path) self.assertEqual(1.0, st.st_atime) self.assertEqual(2.0, st.st_mtime) def test_utime_follow_symlinks(self): path = self.make_path("some_file") self.createTestFile(path) link_path = "/link_to_some_file" self.filesystem.create_symlink(link_path, path) self.os.utime(link_path, times=(1, 2)) st = self.os.stat(link_path) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) def test_utime_no_follow_symlinks(self): path = self.make_path("some_file") self.createTestFile(path) link_path = "/link_to_some_file" self.filesystem.create_symlink(link_path, path) self.os.utime(link_path, times=(1, 2), follow_symlinks=False) st = self.os.stat(link_path) self.assertNotEqual(1, st.st_atime) self.assertNotEqual(2, st.st_mtime) st = self.os.stat(link_path, follow_symlinks=False) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) def test_utime_non_existent(self): path = "/non/existent/file" self.assertFalse(self.os.path.exists(path)) self.assert_raises_os_error(errno.ENOENT, self.os.utime, path, (1, 2)) def test_utime_invalid_times_arg_raises(self): path = "/some_dir" self.createTestDirectory(path) # the error message differs with different Python versions # we don't expect the same message here self.assertRaises(TypeError, self.os.utime, path, (1, 2, 3)) self.assertRaises(TypeError, self.os.utime, path, (1, "str")) def test_utime_sets_specified_time_in_ns(self): # set up path = self.make_path("some_file") self.createTestFile(path) self.os.stat(path) # actual tests self.os.utime(path, ns=(200000000, 400000000)) st = self.os.stat(path) self.assertEqual(0.2, st.st_atime) self.assertEqual(0.4, st.st_mtime) def test_utime_incorrect_ns_argument_raises(self): file_path = "some_file" self.filesystem.create_file(file_path) self.assertRaises(TypeError, self.os.utime, file_path, ns=200000000) self.assertRaises(TypeError, self.os.utime, file_path, ns=("a", "b")) self.assertRaises( ValueError, self.os.utime, file_path, times=(1, 2), ns=(100, 200) ) def test_utime_uses_open_fd_as_path(self): if os.utime not in os.supports_fd: self.skip_real_fs() self.assert_raises_os_error(errno.EBADF, self.os.utime, 5, (1, 2)) path = self.make_path("some_file") self.createTestFile(path) with FakeFileOpen(self.filesystem)(path, encoding="utf8") as f: self.os.utime(f.filedes, times=(1, 2)) st = self.os.stat(path) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) class FakeOsModuleLowLevelFileOpTest(FakeOsModuleTestBase): """Test low level functions `os.open()`, `os.read()` and `os.write()`.""" def test_open_read_only(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_RDONLY) self.assertEqual(b"contents", self.os.read(file_des, 8)) self.assert_raises_os_error(errno.EBADF, self.os.write, file_des, b"test") self.os.close(file_des) def test_open_read_only_write_zero_bytes_posix(self): self.check_posix_only() file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_RDONLY) self.assert_raises_os_error(errno.EBADF, self.os.write, file_des, b"test") self.os.close(file_des) def test_open_read_only_write_zero_bytes_windows(self): # under Windows, writing an empty string to a read only file # is not an error self.check_windows_only() file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_RDONLY) self.assertEqual(0, self.os.write(file_des, b"")) self.os.close(file_des) def test_open_write_only(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_WRONLY) self.assertEqual(4, self.os.write(file_des, b"test")) self.check_contents(file_path, b"testents") self.os.close(file_des) def test_open_write_only_raises_on_read(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_WRONLY) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.os.close(file_des) file_des = self.os.open(file_path, os.O_WRONLY \| os.O_TRUNC) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.os.close(file_des) file_path2 = self.make_path("file2") file_des = self.os.open(file_path2, os.O_CREAT \| os.O_WRONLY) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.os.close(file_des) file_des = self.os.open(file_path2, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.os.close(file_des) def test_open_write_only_read_zero_bytes_posix(self): self.check_posix_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 0) self.os.close(file_des) def test_open_write_only_read_zero_bytes_windows(self): # under Windows, reading 0 bytes from a write only file is not an error self.check_windows_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY) self.assertEqual(b"", self.os.read(file_des, 0)) self.os.close(file_des) def test_open_read_write(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_RDWR) self.assertEqual(4, self.os.write(file_des, b"test")) self.check_contents(file_path, b"testents") self.os.close(file_des) def test_open_create_is_read_only(self): file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_CREAT) self.assertEqual(b"", self.os.read(file_des, 1)) self.assert_raises_os_error(errno.EBADF, self.os.write, file_des, b"foo") self.os.close(file_des) def test_open_create_truncate_is_read_only(self): file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_CREAT \| os.O_TRUNC) self.assertEqual(b"", self.os.read(file_des, 1)) self.assert_raises_os_error(errno.EBADF, self.os.write, file_des, b"foo") self.os.close(file_des) def test_open_raises_if_does_not_exist(self): file_path = self.make_path("file1") self.assert_raises_os_error(errno.ENOENT, self.os.open, file_path, os.O_RDONLY) self.assert_raises_os_error(errno.ENOENT, self.os.open, file_path, os.O_WRONLY) self.assert_raises_os_error(errno.ENOENT, self.os.open, file_path, os.O_RDWR) def test_exclusive_open_raises_without_create_mode(self): self.skip_real_fs() file_path = self.make_path("file1") self.assertRaises(NotImplementedError, self.os.open, file_path, os.O_EXCL) self.assertRaises( NotImplementedError, self.os.open, file_path, os.O_EXCL \| os.O_WRONLY, ) self.assertRaises( NotImplementedError, self.os.open, file_path, os.O_EXCL \| os.O_RDWR ) self.assertRaises( NotImplementedError, self.os.open, file_path, os.O_EXCL \| os.O_TRUNC \| os.O_APPEND, ) def test_open_raises_if_parent_does_not_exist(self): path = self.make_path("alpha", "alpha") self.assert_raises_os_error( errno.ENOENT, self.os.open, path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC, ) def test_open_truncate(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_RDWR \| os.O_TRUNC) self.assertEqual(b"", self.os.read(file_des, 8)) self.assertEqual(4, self.os.write(file_des, b"test")) self.check_contents(file_path, b"test") self.os.close(file_des) @unittest.skipIf(not TestCase.is_windows, "O_TEMPORARY only present in Windows") def test_temp_file(self): file_path = self.make_path("file1") fd = self.os.open(file_path, os.O_CREAT \| os.O_RDWR \| os.O_TEMPORARY) self.assertTrue(self.os.path.exists(file_path)) self.os.close(fd) self.assertFalse(self.os.path.exists(file_path)) def test_open_append(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") file_des = self.os.open(file_path, os.O_WRONLY \| os.O_APPEND) self.assertEqual(4, self.os.write(file_des, b"test")) self.check_contents(file_path, b"contentstest") self.os.close(file_des) def test_open_create(self): file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_RDWR \| os.O_CREAT) self.assertTrue(self.os.path.exists(file_path)) self.assertEqual(4, self.os.write(file_des, b"test")) self.check_contents(file_path, "test") self.os.close(file_des) def test_can_read_after_create_exclusive(self): self.check_posix_only() path1 = self.make_path("alpha") file_des = self.os.open(path1, os.O_CREAT \| os.O_EXCL) self.assertEqual(b"", self.os.read(file_des, 0)) self.assert_raises_os_error(errno.EBADF, self.os.write, file_des, b"") self.os.close(file_des) def test_open_create_mode_posix(self): self.check_posix_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_WRONLY \| os.O_CREAT, 0o700) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.assertEqual(4, self.os.write(file_des, b"test")) self.assert_mode_equal(0o700, self.os.stat(file_path).st_mode) self.os.close(file_des) def test_open_create_mode_windows(self): self.check_windows_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_WRONLY \| os.O_CREAT, 0o700) self.assertTrue(self.os.path.exists(file_path)) self.assert_raises_os_error(errno.EBADF, self.os.read, file_des, 5) self.assertEqual(4, self.os.write(file_des, b"test")) self.assert_mode_equal(0o666, self.os.stat(file_path).st_mode) self.os.close(file_des) def testOpenCreateMode444Windows(self): self.check_windows_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_WRONLY \| os.O_CREAT, 0o442) self.assert_mode_equal(0o444, self.os.stat(file_path).st_mode) self.os.close(file_des) self.os.chmod(file_path, 0o666) def testOpenCreateMode666Windows(self): self.check_windows_only() file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_WRONLY \| os.O_CREAT, 0o224) self.assert_mode_equal(0o666, self.os.stat(file_path).st_mode) self.os.close(file_des) def test_open_exclusive(self): file_path = self.make_path("file1") file_des = self.os.open(file_path, os.O_RDWR \| os.O_EXCL \| os.O_CREAT) self.assertTrue(self.os.path.exists(file_path)) self.os.close(file_des) def test_open_exclusive_raises_if_file_exists(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"contents") self.assert_raises_os_error( errno.EEXIST, self.os.open, file_path, os.O_RDWR \| os.O_EXCL \| os.O_CREAT, ) self.assert_raises_os_error( errno.EEXIST, self.os.open, file_path, os.O_RDWR \| os.O_EXCL \| os.O_CREAT, ) def test_open_exclusive_raises_if_symlink_exists_in_posix(self): self.check_posix_only() link_path = self.make_path("link") link_target = self.make_path("link_target") self.os.symlink(link_target, link_path) self.assert_raises_os_error( errno.EEXIST, self.os.open, link_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC \| os.O_EXCL, ) def test_open_exclusive_if_symlink_exists_works_in_windows(self): self.check_windows_only() skip_if_symlink_not_supported() link_path = self.make_path("link") link_target = self.make_path("link_target") self.os.symlink(link_target, link_path) fd = self.os.open(link_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC \| os.O_EXCL) self.os.close(fd) def test_open_directory_raises_under_windows(self): self.check_windows_only() dir_path = self.make_path("dir") self.create_dir(dir_path) self.assert_raises_os_error(errno.EACCES, self.os.open, dir_path, os.O_RDONLY) self.assert_raises_os_error(errno.EACCES, self.os.open, dir_path, os.O_WRONLY) self.assert_raises_os_error(errno.EACCES, self.os.open, dir_path, os.O_RDWR) def test_open_directory_for_writing_raises_under_posix(self): self.check_posix_only() dir_path = self.make_path("dir") self.create_dir(dir_path) self.assert_raises_os_error(errno.EISDIR, self.os.open, dir_path, os.O_WRONLY) self.assert_raises_os_error(errno.EISDIR, self.os.open, dir_path, os.O_RDWR) def test_open_directory_read_only_under_posix(self): self.check_posix_only() self.skip_real_fs() dir_path = self.make_path("dir") self.create_dir(dir_path) file_des = self.os.open(dir_path, os.O_RDONLY) self.assertEqual(3, file_des) self.os.close(file_des) def test_opening_existing_directory_in_creation_mode(self): self.check_linux_only() dir_path = self.make_path("alpha") self.os.mkdir(dir_path) self.assert_raises_os_error(errno.EISDIR, self.os.open, dir_path, os.O_CREAT) def test_writing_to_existing_directory(self): self.check_macos_only() dir_path = self.make_path("alpha") self.os.mkdir(dir_path) fd = self.os.open(dir_path, os.O_CREAT) self.assert_raises_os_error(errno.EBADF, self.os.write, fd, b"") def test_opening_existing_directory_in_write_mode(self): self.check_posix_only() dir_path = self.make_path("alpha") self.os.mkdir(dir_path) self.assert_raises_os_error(errno.EISDIR, self.os.open, dir_path, os.O_WRONLY) def test_open_mode_posix(self): self.check_posix_only() self.skip_real_fs() file_path = self.make_path("baz") file_des = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) stat0 = self.os.fstat(file_des) # not a really good test as this replicates the code, # but we don't know the umask at the test system self.assertEqual(0o100777 & ~self.os._umask(), stat0.st_mode) self.os.close(file_des) def test_open_mode_windows(self): self.check_windows_only() file_path = self.make_path("baz") file_des = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) stat0 = self.os.fstat(file_des) self.assertEqual(0o100666, stat0.st_mode) self.os.close(file_des) def test_write_read(self): file_path = self.make_path("file1") self.create_file(file_path, contents=b"orig contents") new_contents = b"1234567890abcdef" with self.open(file_path, "wb") as fh: fileno = fh.fileno() self.assertEqual(len(new_contents), self.os.write(fileno, new_contents)) self.check_contents(file_path, new_contents) with self.open(file_path, "rb") as fh: fileno = fh.fileno() self.assertEqual(b"", self.os.read(fileno, 0)) self.assertEqual(new_contents[0:2], self.os.read(fileno, 2)) self.assertEqual(new_contents[2:10], self.os.read(fileno, 8)) self.assertEqual(new_contents[10:], self.os.read(fileno, 100)) self.assertEqual(b"", self.os.read(fileno, 10)) self.assert_raises_os_error(errno.EBADF, self.os.write, fileno, new_contents) self.assert_raises_os_error(errno.EBADF, self.os.read, fileno, 10) def test_write_from_different_f_ds(self): # Regression test for #211 file_path = self.make_path("baz") fd0 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) fd1 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) self.os.write(fd0, b"aaaa") self.os.write(fd1, b"bb") self.assertEqual(4, self.os.path.getsize(file_path)) self.check_contents(file_path, b"bbaa") self.os.close(fd1) self.os.close(fd0) def test_write_from_different_fds_with_append(self): # Regression test for #268 file_path = self.make_path("baz") fd0 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) fd1 = self.os.open(file_path, os.O_WRONLY \| os.O_APPEND) self.os.write(fd0, b"aaa") self.os.write(fd1, b"bbb") self.assertEqual(6, self.os.path.getsize(file_path)) self.check_contents(file_path, b"aaabbb") self.os.close(fd1) self.os.close(fd0) def test_read_only_read_after_write(self): # Regression test for #269 self.check_posix_only() file_path = self.make_path("foo", "bar", "baz") self.create_file(file_path, contents=b"test") fd0 = self.os.open(file_path, os.O_CREAT) fd1 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) self.assertEqual(b"", self.os.read(fd0, 0)) self.os.close(fd1) self.os.close(fd0) def test_read_after_closing_write_descriptor(self): # Regression test for #271 file_path = self.make_path("baz") fd0 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) fd1 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) fd2 = self.os.open(file_path, os.O_CREAT) self.os.write(fd1, b"abc") self.os.close(fd0) self.assertEqual(b"abc", self.os.read(fd2, 3)) self.os.close(fd2) self.os.close(fd1) def test_writing_behind_end_of_file(self): # Regression test for #273 file_path = self.make_path("baz") fd1 = self.os.open(file_path, os.O_CREAT) fd2 = self.os.open(file_path, os.O_RDWR) self.os.write(fd2, b"m") fd3 = self.os.open(file_path, os.O_CREAT \| os.O_WRONLY \| os.O_TRUNC) self.assertEqual(b"", self.os.read(fd2, 1)) self.os.write(fd2, b"m") self.assertEqual(b"\x00m", self.os.read(fd1, 2)) self.os.close(fd1) self.os.close(fd2) self.os.close(fd3) def test_devnull_posix(self): self.check_posix_only() # make sure os.devnull is correctly set after changing the filesystem self.setup_fake_fs() self.assertTrue(self.os.path.exists(self.os.devnull)) def test_devnull_windows(self): self.check_windows_only() # make sure os.devnull is correctly set after changing the filesystem self.setup_fake_fs() if sys.version_info < (3, 8): self.assertFalse(self.os.path.exists(self.os.devnull)) else: self.assertTrue(self.os.path.exists(self.os.devnull)) def test_write_devnull(self): fd = self.os.open(self.os.devnull, os.O_RDWR) self.assertEqual(4, self.os.write(fd, b"test")) self.assertEqual(b"", self.os.read(fd, 4)) self.os.close(fd) fd = self.os.open(self.os.devnull, os.O_RDONLY) self.assertEqual(b"", self.os.read(fd, 4)) self.os.close(fd) def test_sendfile_with_invalid_fd(self): self.check_linux_only() self.assert_raises_os_error(errno.EBADF, self.os.sendfile, 100, 101, 0, 100) src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDONLY) self.assert_raises_os_error(errno.EBADF, self.os.sendfile, fd2, fd1, 0, 4) def test_sendfile_no_offset(self): self.check_linux_only() src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDWR) self.os.sendfile(fd2, fd1, 0, 3) self.os.close(fd2) self.os.close(fd1) with self.open(dst_file_path, encoding="utf8") as f: self.assertEqual("tes", f.read()) def test_sendfile_with_offset(self): self.check_linux_only() src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDWR) self.os.sendfile(fd2, fd1, 4, 4) self.os.close(fd2) self.os.close(fd1) with self.open(dst_file_path, encoding="utf8") as f: self.assertEqual("cont", f.read()) def test_sendfile_twice(self): self.check_linux_only() src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDWR) self.os.sendfile(fd2, fd1, 4, 4) self.os.sendfile(fd2, fd1, 4, 4) self.os.close(fd2) self.os.close(fd1) with self.open(dst_file_path, encoding="utf8") as f: self.assertEqual("contcont", f.read()) def test_sendfile_offset_none(self): self.check_linux_only() src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDWR) self.os.sendfile(fd2, fd1, None, 4) self.os.sendfile(fd2, fd1, None, 3) self.os.close(fd2) self.os.close(fd1) with self.open(dst_file_path, encoding="utf8") as f: self.assertEqual("testcon", f.read()) @unittest.skipIf(not TestCase.is_macos, "Testing MacOs only behavior") def test_no_sendfile_to_regular_file_under_macos(self): src_file_path = self.make_path("foo") dst_file_path = self.make_path("bar") self.create_file(src_file_path, "testcontent") self.create_file(dst_file_path) fd1 = self.os.open(src_file_path, os.O_RDONLY) fd2 = self.os.open(dst_file_path, os.O_RDWR) # raises socket operation on non-socket self.assertRaises(OSError, self.os.sendfile, fd2, fd1, 0, 3) self.os.close(fd2) self.os.close(fd1) class RealOsModuleLowLevelFileOpTest(FakeOsModuleLowLevelFileOpTest): def use_real_fs(self): return True class FakeOsModuleWalkTest(FakeOsModuleTestBase): def assertWalkResults(self, expected, top, topdown=True, followlinks=False): # as the result of walk is unsorted, we have to check against # sorted results result = list( step for step in self.os.walk(top, topdown=topdown, followlinks=followlinks) ) result = sorted(result, key=lambda lst: lst[0]) expected = sorted(expected, key=lambda lst: lst[0]) self.assertEqual(len(expected), len(result)) for entry, expected_entry in zip(result, expected): self.assertEqual(expected_entry[0], entry[0]) self.assertEqual(expected_entry[1], sorted(entry[1])) self.assertEqual(expected_entry[2], sorted(entry[2])) def ResetErrno(self): """Reset the last seen errno.""" self.last_errno = False def StoreErrno(self, os_error): """Store the last errno we saw.""" self.last_errno = os_error.errno def GetErrno(self): """Return the last errno we saw.""" return self.last_errno def test_walk_top_down(self): """Walk down ordering is correct.""" base_dir = self.make_path("foo") self.create_file(self.os.path.join(base_dir, "1.txt")) self.create_file(self.os.path.join(base_dir, "bar1", "2.txt")) self.create_file(self.os.path.join(base_dir, "bar1", "baz", "3.txt")) self.create_file(self.os.path.join(base_dir, "bar2", "4.txt")) expected = [ (base_dir, ["bar1", "bar2"], ["1.txt"]), (self.os.path.join(base_dir, "bar1"), ["baz"], ["2.txt"]), (self.os.path.join(base_dir, "bar1", "baz"), [], ["3.txt"]), (self.os.path.join(base_dir, "bar2"), [], ["4.txt"]), ] self.assertWalkResults(expected, base_dir) def test_walk_bottom_up(self): """Walk up ordering is correct.""" base_dir = self.make_path("foo") self.create_file(self.os.path.join(base_dir, "bar1", "baz", "1.txt")) self.create_file(self.os.path.join(base_dir, "bar1", "2.txt")) self.create_file(self.os.path.join(base_dir, "bar2", "3.txt")) self.create_file(self.os.path.join(base_dir, "4.txt")) expected = [ (self.os.path.join(base_dir, "bar1", "baz"), [], ["1.txt"]), (self.os.path.join(base_dir, "bar1"), ["baz"], ["2.txt"]), (self.os.path.join(base_dir, "bar2"), [], ["3.txt"]), (base_dir, ["bar1", "bar2"], ["4.txt"]), ] self.assertWalkResults(expected, self.make_path("foo"), topdown=False) def test_walk_raises_if_non_existent(self): """Raises an exception when attempting to walk non-existent directory.""" directory = self.make_path("foo", "bar") self.assertEqual(False, self.os.path.exists(directory)) generator = self.os.walk(directory) self.assertRaises(StopIteration, next, generator) def test_walk_raises_if_not_directory(self): """Raises an exception when attempting to walk a non-directory.""" filename = self.make_path("foo", "bar") self.create_file(filename) generator = self.os.walk(filename) self.assertRaises(StopIteration, next, generator) def test_walk_calls_on_error_if_non_existent(self): """Calls onerror with correct errno when walking non-existent directory.""" self.ResetErrno() directory = self.make_path("foo", "bar") self.assertEqual(False, self.os.path.exists(directory)) # Calling os.walk on a non-existent directory should trigger # a call to the onerror method. # We do not actually care what, if anything, is returned. for _ in self.os.walk(directory, onerror=self.StoreErrno): pass self.assertTrue(self.GetErrno() in (errno.ENOTDIR, errno.ENOENT)) def test_walk_calls_on_error_if_not_directory(self): """Calls onerror with correct errno when walking non-directory.""" self.ResetErrno() filename = self.make_path("foobar") self.create_file(filename) self.assertEqual(True, self.os.path.exists(filename)) # Calling `os.walk` on a file should trigger a call to the # `onerror` method. # We do not actually care what, if anything, is returned. for _ in self.os.walk(filename, onerror=self.StoreErrno): pass self.assertTrue(self.GetErrno() in (errno.ENOTDIR, errno.EACCES)) def test_walk_skips_removed_directories(self): """Caller can modify list of directories to visit while walking.""" root = self.make_path("foo") visit = "visit" no_visit = "no_visit" self.create_file(self.os.path.join(root, "bar")) self.create_file(self.os.path.join(root, visit, "1.txt")) self.create_file(self.os.path.join(root, visit, "2.txt")) self.create_file(self.os.path.join(root, no_visit, "3.txt")) self.create_file(self.os.path.join(root, no_visit, "4.txt")) generator = self.os.walk(self.make_path("foo")) root_contents = next(generator) root_contents[1].remove(no_visit) visited_visit_directory = False for root, _dirs, _files in iter(generator): self.assertEqual(False, root.endswith(self.os.path.sep + no_visit)) if root.endswith(self.os.path.sep + visit): visited_visit_directory = True self.assertEqual(True, visited_visit_directory) def test_walk_followsymlink_disabled(self): self.check_posix_only() base_dir = self.make_path("foo") link_dir = self.make_path("linked") self.create_file(self.os.path.join(link_dir, "subfile")) self.create_file(self.os.path.join(base_dir, "bar", "baz")) self.create_file(self.os.path.join(base_dir, "bar", "xyzzy", "plugh")) self.create_symlink(self.os.path.join(base_dir, "created_link"), link_dir) expected = [ (base_dir, ["bar", "created_link"], []), (self.os.path.join(base_dir, "bar"), ["xyzzy"], ["baz"]), (self.os.path.join(base_dir, "bar", "xyzzy"), [], ["plugh"]), ] self.assertWalkResults(expected, base_dir, followlinks=False) expected = [(self.os.path.join(base_dir, "created_link"), [], ["subfile"])] self.assertWalkResults( expected, self.os.path.join(base_dir, "created_link"), followlinks=False, ) def test_walk_followsymlink_enabled(self): self.check_posix_only() base_dir = self.make_path("foo") link_dir = self.make_path("linked") self.create_file(self.os.path.join(link_dir, "subfile")) self.create_file(self.os.path.join(base_dir, "bar", "baz")) self.create_file(self.os.path.join(base_dir, "bar", "xyzzy", "plugh")) self.create_symlink( self.os.path.join(base_dir, "created_link"), self.os.path.join(link_dir), ) expected = [ (base_dir, ["bar", "created_link"], []), (self.os.path.join(base_dir, "bar"), ["xyzzy"], ["baz"]), (self.os.path.join(base_dir, "bar", "xyzzy"), [], ["plugh"]), (self.os.path.join(base_dir, "created_link"), [], ["subfile"]), ] self.assertWalkResults(expected, base_dir, followlinks=True) expected = [(self.os.path.join(base_dir, "created_link"), [], ["subfile"])] self.assertWalkResults( expected, self.os.path.join(base_dir, "created_link"), followlinks=True, ) def test_walk_linked_file_in_subdir(self): # regression test for #559 (tested for link on incomplete path) self.check_posix_only() # need to have a top-level link to reproduce the bug - skip real fs self.skip_real_fs() file_path = "/foo/bar/baz" self.create_file(file_path) self.create_symlink("bar", file_path) expected = [("/foo", ["bar"], []), ("/foo/bar", [], ["baz"])] self.assertWalkResults(expected, "/foo") def test_base_dirpath(self): # regression test for #512 file_path = self.make_path("foo", "bar", "baz") self.create_file(file_path) variants = [ self.make_path("foo", "bar"), self.make_path("foo", "..", "foo", "bar"), self.make_path("foo", "..", "foo", "bar") + self.os.path.sep * 3, self.make_path("foo") + self.os.path.sep * 3 + "bar", ] for base_dir in variants: for dirpath, _dirnames, _filenames in self.os.walk(base_dir): self.assertEqual(dirpath, base_dir) file_path = self.make_path("foo", "bar", "dir", "baz") self.create_file(file_path) for base_dir in variants: for dirpath, _dirnames, _filenames in self.os.walk(base_dir): self.assertTrue(dirpath.startswith(base_dir)) class RealOsModuleWalkTest(FakeOsModuleWalkTest): def use_real_fs(self): return True class FakeOsModuleDirFdTest(FakeOsModuleTestBase): def setUp(self): super().setUp() self.check_posix_only() if not self.use_real_fs(): # in the real OS, we test the option as is, in the fake OS # we test both the supported and unsupported option self.os.supports_dir_fd.clear() self.dir_fd_path = self.make_path("foo") self.create_dir(self.dir_fd_path) self.dir_fd = self.os.open(self.dir_fd_path, os.O_RDONLY) self.fname = "baz" self.fpath = self.os.path.join(self.dir_fd_path, self.fname) self.create_file(self.fpath) def add_supported_function(self, fct): if not self.use_real_fs(): self.os.supports_dir_fd.add(fct) def test_access(self): def os_access(): return self.os.access(self.fname, self.os.F_OK, dir_fd=self.dir_fd) if self.os.access not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_access() self.add_supported_function(self.os.access) if self.os.access in self.os.supports_dir_fd: self.assertTrue(os_access()) def test_chmod(self): def os_chmod(): self.os.chmod(self.fname, 0o6543, dir_fd=self.dir_fd) if self.os.chmod not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_chmod() self.add_supported_function(self.os.chmod) if self.os.chmod in self.os.supports_dir_fd: os_chmod() st = self.os.stat(self.fpath) self.assert_mode_equal(0o6543, st.st_mode) @unittest.skipIf(not hasattr(os, "chown"), "chown not on all platforms available") def test_chown(self): def os_chown(): self.os.chown(self.fname, 100, 101, dir_fd=self.dir_fd) self.skip_real_fs() if self.os.chown not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_chown() self.add_supported_function(self.os.chown) os_chown() st = self.os.stat(self.fpath) self.assertEqual(100, st[stat.ST_UID]) self.assertEqual(101, st[stat.ST_GID]) def test_link_src_fd(self): def os_link(): self.os.link(self.fname, link_dest, src_dir_fd=self.dir_fd) link_dest = self.make_path("bat") if self.os.link not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_link() self.add_supported_function(self.os.link) if self.os.link in self.os.supports_dir_fd: os_link() self.assertTrue(self.os.path.exists(link_dest)) def test_link_dst_fd(self): def os_link(): self.os.link(self.fpath, "bat", dst_dir_fd=self.dir_fd) if self.os.link not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_link() self.add_supported_function(self.os.link) if self.os.link in self.os.supports_dir_fd: os_link() link_path = self.os.path.join(self.dir_fd_path, "bat") self.assertTrue(self.os.path.exists(link_path)) def test_symlink(self): def os_symlink(): self.os.symlink(self.fpath, "bat", dir_fd=self.dir_fd) if self.os.symlink not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_symlink() self.add_supported_function(self.os.symlink) if self.os.symlink in self.os.supports_dir_fd: os_symlink() link_path = self.os.path.join(self.dir_fd_path, "bat") self.assertTrue(self.os.path.exists(link_path)) def test_readlink(self): def os_readlink(): return self.os.readlink("lemon/tree", dir_fd=self.dir_fd) link_dir = self.os.path.join(self.dir_fd_path, "lemon") self.create_dir(link_dir) self.create_symlink(self.os.path.join(link_dir, "tree"), self.fpath) if self.os.readlink not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_readlink() self.add_supported_function(self.os.readlink) if self.os.readlink in self.os.supports_dir_fd: self.assertEqual(self.fpath, os_readlink()) def test_stat(self): def os_stat(): return self.os.stat(self.fname, dir_fd=self.dir_fd) if self.os.stat not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_stat() self.add_supported_function(self.os.stat) if self.os.stat in self.os.supports_dir_fd: self.assertEqual(os_stat().st_mode, 0o100644) def test_lstat(self): st = self.os.lstat(self.fname, dir_fd=self.dir_fd) self.assertEqual(st.st_mode, 0o100644) def test_mkdir(self): def os_mkdir(): self.os.mkdir("newdir", dir_fd=self.dir_fd) newdir_path = self.os.path.join(self.dir_fd_path, "newdir") if self.os.mkdir not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_mkdir() self.add_supported_function(self.os.mkdir) if self.os.mkdir in self.os.supports_dir_fd: os_mkdir() self.assertTrue(self.os.path.exists(newdir_path)) def test_rmdir(self): def os_rmdir(): self.os.rmdir("dir", dir_fd=self.dir_fd) dir_path = self.os.path.join(self.dir_fd_path, "dir") self.create_dir(dir_path) self.assertTrue(self.os.path.exists(dir_path)) if self.os.rmdir not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_rmdir() self.add_supported_function(self.os.rmdir) if self.os.rmdir in self.os.supports_dir_fd: os_rmdir() self.assertFalse(self.os.path.exists(dir_path)) @unittest.skipIf(not hasattr(os, "mknod"), "mknod not on all platforms available") def test_mknod(self): def os_mknod(): self.os.mknod("newdir", dir_fd=self.dir_fd) if self.os.mknod not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_mknod() self.add_supported_function(self.os.mknod) if self.os.mknod in self.os.supports_dir_fd: if self.is_macos and sys.version_info >= (3, 13) and not is_root(): self.skipTest("Needs root rights under macos") os_mknod() newdir_path = self.os.path.join(self.dir_fd_path, "newdir") self.assertTrue(self.os.path.exists(newdir_path)) def test_rename_src_fd(self): def os_rename(): self.os.rename(self.fname, new_name, src_dir_fd=self.dir_fd) new_name = self.os.path.join(self.dir_fd_path, "batz") if self.os.rename not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_rename() self.add_supported_function(self.os.rename) if self.os.rename in self.os.supports_dir_fd: os_rename() self.assertTrue(self.os.path.exists(new_name)) def test_rename_dst_fd(self): def os_rename(): self.os.rename(self.fpath, "batz", dst_dir_fd=self.dir_fd) if self.os.rename not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_rename() self.add_supported_function(self.os.rename) if self.os.rename in self.os.supports_dir_fd: os_rename() new_path = self.os.path.join(self.dir_fd_path, "batz") self.assertTrue(self.os.path.exists(new_path)) def test_replace_src_fd(self): new_name = self.os.path.join(self.dir_fd_path, "batz") self.os.replace(self.fname, new_name, src_dir_fd=self.dir_fd) self.assertTrue(self.os.path.exists(new_name)) def test_replace_dst_fd(self): self.os.replace(self.fpath, "batz", dst_dir_fd=self.dir_fd) new_path = self.os.path.join(self.dir_fd_path, "batz") self.assertTrue(self.os.path.exists(new_path)) def test_remove(self): self.os.remove(self.fname, dir_fd=self.dir_fd) self.assertFalse(self.os.path.exists(self.fpath)) def test_unlink(self): def os_unlink(): self.os.unlink(self.fname, dir_fd=self.dir_fd) if self.os.unlink not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_unlink() self.add_supported_function(self.os.unlink) if self.os.unlink in self.os.supports_dir_fd: os_unlink() self.assertFalse(self.os.path.exists(self.fpath)) def test_utime(self): def os_utime(): self.os.utime(self.fname, times=(1, 2), dir_fd=self.dir_fd) if self.os.utime not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_utime() self.add_supported_function(self.os.utime) if self.os.utime in self.os.supports_dir_fd: os_utime() st = self.os.stat(self.fpath) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) def test_open(self): def os_open(): return self.os.open(self.fname, os.O_RDONLY, dir_fd=self.dir_fd) if self.os.open not in self.os.supports_dir_fd: with self.assertRaises(NotImplementedError): os_open() self.add_supported_function(self.os.open) if self.os.open in self.os.supports_dir_fd: self.assertLess(0, os_open()) class RealOsModuleDirFdTest(FakeOsModuleDirFdTest): def use_real_fs(self): return True class StatPropagationTest(TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator="/") self.os = fake_os.FakeOsModule(self.filesystem) self.open = fake_open.FakeFileOpen(self.filesystem) def test_file_size_updated_via_close(self): """test that file size gets updated via close().""" file_dir = "xyzzy" file_path = "xyzzy/close" content = "This is a test." self.os.mkdir(file_dir) fh = self.open(file_path, "w", encoding="utf8") self.assertEqual(0, self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual("", self.filesystem.get_object(file_path).contents) fh.write(content) self.assertEqual(0, self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual("", self.filesystem.get_object(file_path).contents) fh.close() self.assertEqual(len(content), self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual(content, self.filesystem.get_object(file_path).contents) def test_file_size_not_reset_after_close(self): file_dir = "xyzzy" file_path = "xyzzy/close" self.os.mkdir(file_dir) size = 1234 # The file has size, but no content. When the file is opened for # reading, its size should be preserved. self.filesystem.create_file(file_path, st_size=size) fh = self.open(file_path, "r", encoding="utf8") fh.close() self.assertEqual(size, self.open(file_path, "r", encoding="utf8").size()) def test_file_size_after_write(self): file_path = "test_file" original_content = "abcdef" original_size = len(original_content) self.filesystem.create_file(file_path, contents=original_content) added_content = "foo bar" expected_size = original_size + len(added_content) fh = self.open(file_path, "a", encoding="utf8") fh.write(added_content) self.assertEqual(original_size, fh.size()) fh.close() self.assertEqual( expected_size, self.open(file_path, "r", encoding="utf8").size() ) def test_large_file_size_after_write(self): file_path = "test_file" original_content = "abcdef" original_size = len(original_content) self.filesystem.create_file(file_path, st_size=original_size) added_content = "foo bar" fh = self.open(file_path, "a", encoding="utf8") self.assertRaises( fake_file.FakeLargeFileIoException, lambda: fh.write(added_content), ) def test_file_size_updated_via_flush(self): """test that file size gets updated via flush().""" file_dir = "xyzzy" file_name = "flush" file_path = self.os.path.join(file_dir, file_name) content = "This might be a test." self.os.mkdir(file_dir) fh = self.open(file_path, "w", encoding="utf8") self.assertEqual(0, self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual("", self.filesystem.get_object(file_path).contents) fh.write(content) self.assertEqual(0, self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual("", self.filesystem.get_object(file_path).contents) fh.flush() self.assertEqual(len(content), self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual(content, self.filesystem.get_object(file_path).contents) fh.close() self.assertEqual(len(content), self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual(content, self.filesystem.get_object(file_path).contents) def test_file_size_truncation(self): """test that file size gets updated via open().""" file_dir = "xyzzy" file_path = "xyzzy/truncation" content = "AAA content." # pre-create file with content self.os.mkdir(file_dir) fh = self.open(file_path, "w", encoding="utf8") fh.write(content) fh.close() self.assertEqual(len(content), self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual(content, self.filesystem.get_object(file_path).contents) # test file truncation fh = self.open(file_path, "w", encoding="utf8") self.assertEqual(0, self.os.stat(file_path)[stat.ST_SIZE]) self.assertEqual("", self.filesystem.get_object(file_path).contents) fh.close() class FakeScandirTest(FakeOsModuleTestBase): FILE_SIZE = 50 LINKED_FILE_SIZE = 10 def used_scandir(self): return self.os.scandir def setUp(self): super().setUp() self.supports_symlinks = not self.is_windows or not self.use_real_fs() self.scandir = self.used_scandir() self.directory = self.make_path("xyzzy", "plugh") link_dir = self.make_path("linked", "plugh") self.linked_file_path = self.os.path.join(link_dir, "file") self.linked_dir_path = self.os.path.join(link_dir, "dir") self.rel_linked_dir_path = self.os.path.join( "..", "..", "linked", "plugh", "dir" ) self.rel_linked_file_path = self.os.path.join( "..", "..", "linked", "plugh", "file" ) self.dir_path = self.os.path.join(self.directory, "dir") self.file_path = self.os.path.join(self.directory, "file") self.file_link_path = self.os.path.join(self.directory, "link_file") self.dir_link_path = self.os.path.join(self.directory, "link_dir") self.file_rel_link_path = self.os.path.join(self.directory, "rel_link_file") self.dir_rel_link_path = self.os.path.join(self.directory, "rel_link_dir") self.create_dir(self.dir_path) self.create_file(self.file_path, contents=b"b" * self.FILE_SIZE) if self.supports_symlinks: self.create_dir(self.linked_dir_path) self.create_file( self.linked_file_path, contents=b"a" * self.LINKED_FILE_SIZE ) self.create_symlink(self.dir_link_path, self.linked_dir_path) self.create_symlink(self.file_link_path, self.linked_file_path) self.create_symlink(self.dir_rel_link_path, self.rel_linked_dir_path) self.create_symlink(self.file_rel_link_path, self.rel_linked_file_path) # Changing the working directory below is to make sure relative paths # to the files and directories created above are reasonable. # Corner-cases about relative paths are better checked in tests created # for that purpose. # # WARNING: This is self.pretest_cwd and not self.cwd as the latter is # used by superclass RealFsTestCase. self.pretest_cwd = self.os.getcwd() self.os.chdir(self.base_path) self.dir_entries = list(self.do_scandir()) self.dir_entries.sort(key=lambda entry: entry.name) def tearDown(self): self.os.chdir(self.pretest_cwd) super().tearDown() def do_scandir(self): """Hook to override how scandir is called.""" return self.scandir(self.directory) def scandir_path(self): """Hook to override the expected scandir() path in DirEntry.path.""" return self.directory def test_paths(self): sorted_names = ["dir", "file"] if self.supports_symlinks: sorted_names.extend( ["link_dir", "link_file", "rel_link_dir", "rel_link_file"] ) self.assertEqual(len(sorted_names), len(self.dir_entries)) self.assertEqual(sorted_names, [entry.name for entry in self.dir_entries]) sorted_paths = [ self.os.path.join(self.scandir_path(), name) for name in sorted_names ] self.assertEqual(sorted_paths, [entry.path for entry in self.dir_entries]) def test_isfile(self): self.assertFalse(self.dir_entries[0].is_file()) self.assertTrue(self.dir_entries[1].is_file()) if self.supports_symlinks: self.assertFalse(self.dir_entries[2].is_file()) self.assertFalse(self.dir_entries[2].is_file(follow_symlinks=False)) self.assertTrue(self.dir_entries[3].is_file()) self.assertFalse(self.dir_entries[3].is_file(follow_symlinks=False)) self.assertFalse(self.dir_entries[4].is_file()) self.assertFalse(self.dir_entries[4].is_file(follow_symlinks=False)) self.assertTrue(self.dir_entries[5].is_file()) self.assertFalse(self.dir_entries[5].is_file(follow_symlinks=False)) def test_isdir(self): self.assertTrue(self.dir_entries[0].is_dir()) self.assertFalse(self.dir_entries[1].is_dir()) if self.supports_symlinks: self.assertTrue(self.dir_entries[2].is_dir()) self.assertFalse(self.dir_entries[2].is_dir(follow_symlinks=False)) self.assertFalse(self.dir_entries[3].is_dir()) self.assertFalse(self.dir_entries[3].is_dir(follow_symlinks=False)) self.assertTrue(self.dir_entries[4].is_dir()) self.assertFalse(self.dir_entries[4].is_dir(follow_symlinks=False)) self.assertFalse(self.dir_entries[5].is_dir()) self.assertFalse(self.dir_entries[5].is_dir(follow_symlinks=False)) def test_is_link(self): if self.supports_symlinks: self.assertFalse(self.dir_entries[0].is_symlink()) self.assertFalse(self.dir_entries[1].is_symlink()) self.assertTrue(self.dir_entries[2].is_symlink()) self.assertTrue(self.dir_entries[3].is_symlink()) self.assertTrue(self.dir_entries[4].is_symlink()) self.assertTrue(self.dir_entries[5].is_symlink()) def test_path_links_not_resolved(self): # regression test for #350 skip_if_symlink_not_supported() dir_path = self.make_path("A", "B", "C") self.os.makedirs(self.os.path.join(dir_path, "D")) link_path = self.make_path("A", "C") self.os.symlink(dir_path, link_path) self.assertEqual( [self.os.path.join(link_path, "D")], [f.path for f in self.scandir(link_path)], ) def test_inode(self): if self.use_real_fs(): if self.is_windows: self.skipTest("inode seems not to work in scandir module under Windows") if IN_DOCKER: self.skipTest("inode seems not to work in a Docker container") self.assertEqual( self.os.stat(self.dir_path).st_ino, self.dir_entries[0].inode() ) self.assertEqual( self.os.stat(self.file_path).st_ino, self.dir_entries[1].inode() ) if self.supports_symlinks: self.assertEqual( self.os.lstat(self.dir_link_path).st_ino, self.dir_entries[2].inode(), ) self.assertEqual( self.os.lstat(self.file_link_path).st_ino, self.dir_entries[3].inode(), ) self.assertEqual( self.os.lstat(self.dir_rel_link_path).st_ino, self.dir_entries[4].inode(), ) self.assertEqual( self.os.lstat(self.file_rel_link_path).st_ino, self.dir_entries[5].inode(), ) def test_scandir_none(self): result1 = [entry.path for entry in self.scandir(None)] result2 = [entry.path for entry in self.scandir(".")] self.assertEqual(result1, result2) def test_scandir_stat_nlink(self): # regression test for #350 stat_nlink = self.os.stat(self.file_path).st_nlink self.assertEqual(1, stat_nlink) dir_iter = self.scandir(self.directory) for item in dir_iter: if item.path == self.file_path: scandir_stat_nlink = item.stat().st_nlink if self.is_windows_fs: self.assertEqual(0, scandir_stat_nlink) else: self.assertEqual(1, scandir_stat_nlink) self.assertEqual(1, self.os.stat(self.file_path).st_nlink) @unittest.skipIf(not hasattr(os, "O_DIRECTORY"), "opening directory not supported") def test_scandir_with_fd(self): # regression test for #723 temp_dir = self.make_path("tmp", "dir") self.create_dir(temp_dir) self.create_file(self.os.path.join(temp_dir, "file1")) self.create_file(self.os.path.join(temp_dir, "file2")) self.create_dir(self.os.path.join(temp_dir, "subdir")) self.os.chdir(temp_dir) fd = self.os.open(temp_dir, flags=os.O_RDONLY \| os.O_DIRECTORY) children = [dir_entry.name for dir_entry in self.os.scandir(fd)] assert sorted(children) == ["file1", "file2", "subdir"] def test_file_removed_during_scandir(self): # regression test for #1051 dir_path = self.make_path("wls") file1_path = self.os.path.join(dir_path, "1.log") self.create_file(file1_path) file2_path = self.os.path.join(dir_path, "2.log") self.create_file(file2_path) with self.os.scandir(dir_path) as it: for entry in it: if entry.is_file(): self.os.remove(entry.path) assert not self.os.path.exists(file1_path) assert not self.os.path.exists(file2_path) def check_stat( self, absolute_symlink_expected_size, relative_symlink_expected_size ): self.assertEqual(self.FILE_SIZE, self.dir_entries[1].stat().st_size) if not self.is_windows_fs or sys.version_info < (3, 12): # behavior of st_ctime changed in 3.12, to be adapted later self.assertEqual( int(self.os.stat(self.dir_path).st_ctime), int(self.dir_entries[0].stat().st_ctime), ) if self.supports_symlinks: self.assertEqual(self.LINKED_FILE_SIZE, self.dir_entries[3].stat().st_size) self.assertEqual( absolute_symlink_expected_size, self.dir_entries[3].stat(follow_symlinks=False).st_size, ) self.assertEqual( int(self.os.stat(self.linked_dir_path).st_mtime), int(self.dir_entries[2].stat().st_mtime), ) self.assertEqual(self.LINKED_FILE_SIZE, self.dir_entries[5].stat().st_size) self.assertEqual( relative_symlink_expected_size, self.dir_entries[5].stat(follow_symlinks=False).st_size, ) self.assertEqual( int(self.os.stat(self.linked_dir_path).st_mtime), int(self.dir_entries[4].stat().st_mtime), ) @unittest.skipIf(TestCase.is_windows, "POSIX specific behavior") def test_stat_posix(self): self.check_stat(len(self.linked_file_path), len(self.rel_linked_file_path)) @unittest.skipIf(not TestCase.is_windows, "Windows specific behavior") def test_stat_windows(self): self.check_stat(0, 0) def test_index_access_to_stat_times_returns_int(self): if not self.is_windows_fs or sys.version_info < (3, 12): # behavior of st_ctime changed in 3.12, to be adapted later self.assertEqual( self.os.stat(self.dir_path)[stat.ST_CTIME], int(self.dir_entries[0].stat().st_ctime), ) if self.supports_symlinks: self.assertEqual( self.os.stat(self.linked_dir_path)[stat.ST_MTIME], int(self.dir_entries[2].stat().st_mtime), ) self.assertEqual( self.os.stat(self.linked_dir_path)[stat.ST_MTIME], int(self.dir_entries[4].stat().st_mtime), ) def test_stat_ino_dev(self): if self.supports_symlinks: file_stat = self.os.stat(self.linked_file_path) self.assertEqual(file_stat.st_ino, self.dir_entries[3].stat().st_ino) self.assertEqual(file_stat.st_dev, self.dir_entries[3].stat().st_dev) self.assertEqual(file_stat.st_ino, self.dir_entries[5].stat().st_ino) self.assertEqual(file_stat.st_dev, self.dir_entries[5].stat().st_dev) def test_path_like(self): self.assertTrue(isinstance(self.dir_entries[0], os.PathLike)) self.assertEqual( self.os.path.join(self.scandir_path(), "dir"), os.fspath(self.dir_entries[0]), ) self.assertEqual( self.os.path.join(self.scandir_path(), "file"), os.fspath(self.dir_entries[1]), ) def test_non_existing_dir(self): # behaves differently in different systems, so we skip the real fs test self.skip_real_fs() self.assert_raises_os_error(errno.ENOENT, self.scandir, "non_existing/fake_dir") class RealScandirTest(FakeScandirTest): def use_real_fs(self): return True class FakeScandirRelTest(FakeScandirTest): def scandir_path(self): # When scandir is called with a relative path, that relative path is # used in the path attribute of the DirEntry objects. return self.os.path.relpath(self.directory) def do_scandir(self): return self.scandir(self.os.path.relpath(self.directory)) class RealScandirRelTest(FakeScandirRelTest): def use_real_fs(self): return True @unittest.skipIf(TestCase.is_windows, "dir_fd not supported for os.scandir in Windows") class FakeScandirFdTest(FakeScandirTest): def tearDown(self): self.os.close(self.dir_fd) super().tearDown() def scandir_path(self): # When scandir is called with a filedescriptor, only the name of the # entry is returned in the path attribute of the DirEntry objects. return "" def do_scandir(self): self.dir_fd = self.os.open(self.directory, os.O_RDONLY) return self.scandir(self.dir_fd) class RealScandirFdTest(FakeScandirFdTest): def use_real_fs(self): return True class FakeScandirFdRelTest(FakeScandirFdTest): def do_scandir(self): self.dir_fd = self.os.open(self.os.path.relpath(self.directory), os.O_RDONLY) return self.scandir(self.dir_fd) class RealScandirFdRelTest(FakeScandirFdRelTest): def use_real_fs(self): return True class FakeExtendedAttributeTest(FakeOsModuleTestBase): def setUp(self): super().setUp() self.check_linux_only() self.dir_path = self.make_path("foo") self.file_path = self.os.path.join(self.dir_path, "bar") self.create_file(self.file_path) def test_empty_xattr(self): self.assertEqual([], self.os.listxattr(self.dir_path)) self.assertEqual([], self.os.listxattr(self.file_path)) def test_getxattr_raises_for_non_existing_file(self): with self.assertRaises(FileNotFoundError): self.os.getxattr("bogus_path", "test") def test_getxattr_raises_for_non_existing_attribute(self): with self.assertRaises(OSError) as cm: self.os.getxattr(self.file_path, "bogus") self.assertEqual(errno.ENODATA, cm.exception.errno) def test_setxattr(self): with self.assertRaises(TypeError): self.os.setxattr(self.file_path, "test", "value") with self.assertRaises(FileExistsError): self.os.setxattr(self.file_path, "test", b"value", self.os.XATTR_REPLACE) self.os.setxattr(self.file_path, "test", b"value") self.assertEqual(b"value", self.os.getxattr(self.file_path, "test")) with self.assertRaises(OSError) as cm: self.os.setxattr(self.file_path, "test", b"value", self.os.XATTR_CREATE) self.assertEqual(errno.ENODATA, cm.exception.errno) def test_removeattr(self): self.os.removexattr(self.file_path, "test") self.assertEqual([], self.os.listxattr(self.file_path)) self.os.setxattr(self.file_path, b"test", b"value") self.assertEqual(["test"], self.os.listxattr(self.file_path)) self.assertEqual(b"value", self.os.getxattr(self.file_path, "test")) self.os.removexattr(self.file_path, "test") self.assertEqual([], self.os.listxattr(self.file_path)) with self.assertRaises(OSError) as cm: self.os.getxattr(self.file_path, "test") self.assertEqual(errno.ENODATA, cm.exception.errno) def test_default_path(self): self.os.chdir(self.dir_path) self.os.setxattr(self.dir_path, b"test", b"value") self.assertEqual(["test"], self.os.listxattr()) self.assertEqual(b"value", self.os.getxattr(self.dir_path, "test")) class FakeOsUnreadableDirTest(FakeOsModuleTestBase): def setUp(self): if self.use_real_fs(): # unreadable dirs in Windows are only simulated # and cannot be created in the real OS using file system # functions only self.check_posix_only() super().setUp() self.dir_path = self.make_path("some_dir") self.file_path = self.os.path.join(self.dir_path, "some_file") self.create_file(self.file_path) self.chmod(self.dir_path, 0o000) def chmod(self, path, mode): if self.is_windows_fs: self.filesystem.chmod(path, mode, force_unix_mode=True) else: self.os.chmod(path, mode) def test_getuid(self): self.skip_real_fs() # won't change user in real fs self.check_posix_only() uid = self.os.getuid() set_uid(uid + 10) self.assertEqual(uid + 10, self.os.getuid()) self.assertEqual(uid + 10, get_uid()) reset_ids() self.assertEqual(uid, self.os.getuid()) def test_getgid(self): self.skip_real_fs() # won't change group in real fs self.check_posix_only() gid = self.os.getgid() set_gid(gid + 10) self.assertEqual(gid + 10, self.os.getgid()) self.assertEqual(gid + 10, get_gid()) reset_ids() self.assertEqual(gid, self.os.getgid()) def test_listdir_unreadable_dir(self): if not is_root(): self.assert_raises_os_error(errno.EACCES, self.os.listdir, self.dir_path) else: self.assertEqual(["some_file"], self.os.listdir(self.dir_path)) def test_listdir_user_readable_dir(self): self.chmod(self.dir_path, 0o600) self.assertEqual(["some_file"], self.os.listdir(self.dir_path)) self.chmod(self.dir_path, 0o000) def test_listdir_user_readable_dir_from_other_user(self): self.skip_real_fs() # won't change user in real fs self.check_posix_only() user_id = get_uid() set_uid(user_id + 1) dir_path = "/dir1" self.create_dir(dir_path, perm=0o600) self.assertTrue(self.os.path.exists(dir_path)) reset_ids() if not is_root(): with self.assertRaises(PermissionError): self.os.listdir(dir_path) else: self.assertEqual([], self.os.listdir(dir_path)) def test_listdir_group_readable_dir_from_other_user(self): self.skip_real_fs() # won't change user in real fs self.check_posix_only() set_uid(get_uid() + 1) dir_path = "/dir1" self.create_dir(dir_path, perm=0o660) self.assertTrue(self.os.path.exists(dir_path)) reset_ids() self.assertEqual([], self.os.listdir(dir_path)) def test_listdir_group_readable_dir_from_other_group(self): self.skip_real_fs() # won't change user in real fs self.check_posix_only() group_id = self.os.getgid() set_gid(group_id + 1) dir_path = "/dir1" self.create_dir(dir_path, perm=0o060) self.assertTrue(self.os.path.exists(dir_path)) set_gid(group_id) if not is_root(): with self.assertRaises(PermissionError): self.os.listdir(dir_path) else: self.assertEqual([], self.os.listdir(dir_path)) def test_listdir_other_readable_dir_from_other_group(self): self.check_posix_only() self.skip_real_fs() # won't change user in real fs dir_path = self.make_path("dir1") self.create_dir(dir_path, 0o004) set_uid(get_uid() + 1) set_gid(get_gid() + 1) self.assertTrue(self.os.path.exists(dir_path)) self.assertEqual([], self.os.listdir(dir_path)) reset_ids() def test_stat_unreadable_dir(self): self.assertEqual(0, self.os.stat(self.dir_path).st_mode & 0o666) def test_chmod_unreadable_dir(self): self.chmod(self.dir_path, 0o666) self.assertEqual(0o666, self.os.stat(self.dir_path).st_mode & 0o666) self.chmod(self.dir_path, 0o000) self.assertEqual(0, self.os.stat(self.dir_path).st_mode & 0o666) def test_stat_file_in_unreadable_dir(self): if not is_root(): self.assert_raises_os_error(errno.EACCES, self.os.stat, self.file_path) else: self.assertEqual(0, self.os.stat(self.file_path).st_size) def test_remove_unreadable_dir(self): self.check_posix_only() dir_path = self.make_path("dir1") self.create_dir(dir_path, perm=0o000) self.assertTrue(self.os.path.exists(dir_path)) self.os.rmdir(dir_path) self.assertFalse(self.os.path.exists(dir_path)) def test_remove_unreadable_dir_from_other_user(self): self.check_posix_only() self.skip_real_fs() # won't change user in real fs set_uid(get_uid() + 1) dir_path = "/dir1" self.create_dir(dir_path, perm=0o000) self.assertTrue(self.os.path.exists(dir_path)) reset_ids() if not is_root(): with self.assertRaises(PermissionError): self.os.rmdir(dir_path) self.assertTrue(self.os.path.exists(dir_path)) else: self.os.rmdir(dir_path) self.assertFalse(self.os.path.exists(dir_path)) class RealOsUnreadableDirTest(FakeOsUnreadableDirTest): def use_real_fs(self): return True	239.05 KB	2026-01-20 12:58
📄 fake_pathlib_test.py # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Unittests for fake_pathlib. As most of fake_pathlib is a wrapper around fake_filesystem methods, the tests are there mostly to ensure basic functionality. Note that many of the tests are directly taken from examples in the python docs. """ import contextlib import errno import os import pathlib import stat import sys import unittest from collections import namedtuple from unittest import mock from unittest.mock import patch from pyfakefs import fake_pathlib, fake_filesystem, fake_filesystem_unittest, fake_os from pyfakefs.fake_filesystem import OSType, FakeFilesystem from pyfakefs.fake_pathlib import FakePathlibModule from pyfakefs.helpers import IS_PYPY, is_root from pyfakefs.tests.skipped_pathlib import ( check_exists_pathlib, read_bytes_pathlib, read_pathlib, read_text_pathlib, ) from pyfakefs.tests.test_utils import RealFsTestMixin, skip_if_symlink_not_supported is_windows = sys.platform == "win32" class RealPathlibTestCase(fake_filesystem_unittest.TestCase, RealFsTestMixin): is_windows = sys.platform == "win32" def __init__(self, methodName="runTest"): fake_filesystem_unittest.TestCase.__init__(self, methodName) RealFsTestMixin.__init__(self) def used_pathlib(self): return pathlib def setUp(self): RealFsTestMixin.setUp(self) self.filesystem = None self.real_os = os if not self.use_real_fs(): self.setUpPyfakefs() self.filesystem = self.fs self.create_basepath() self.pathlib = self.used_pathlib() self.path = self.pathlib.Path self.os = os self.open = open def use_real_fs(self): return False def deprecation_warning_since_313(self): return ( contextlib.nullcontext() if sys.version_info < (3, 13) else self.assertWarns(DeprecationWarning) ) class FakePathlibInitializationTest(RealPathlibTestCase): def test_initialization_type(self): """Make sure tests for class type will work""" path = self.path("/test") if is_windows: self.assertTrue(isinstance(path, self.pathlib.WindowsPath)) self.assertTrue(isinstance(path, self.pathlib.PureWindowsPath)) self.assertTrue(self.pathlib.PurePosixPath()) # in fake fs, we allow to use the other OS implementation if self.use_real_fs(): with self.assertRaises(NotImplementedError): self.pathlib.PosixPath() else: self.assertTrue(self.pathlib.PosixPath()) else: self.assertTrue(isinstance(path, self.pathlib.PosixPath)) self.assertTrue(isinstance(path, self.pathlib.PurePosixPath)) self.assertTrue(self.pathlib.PureWindowsPath()) if self.use_real_fs(): with self.assertRaises(NotImplementedError): self.pathlib.WindowsPath() else: self.assertTrue(self.pathlib.WindowsPath()) def test_init_with_segments(self): """Basic initialization tests - taken from pathlib.Path documentation. """ self.assertEqual(self.path("/", "foo", "bar", "baz"), self.path("/foo/bar/baz")) self.assertEqual(self.path(), self.path(".")) self.assertEqual( self.path(self.path("foo"), self.path("bar")), self.path("foo/bar") ) self.assertEqual( self.path("/etc") / "init.d" / "reboot", self.path("/etc/init.d/reboot"), ) def test_init_collapse(self): """Tests for collapsing path during initialization. Taken from pathlib.PurePath documentation. """ self.assertEqual(self.path("foo//bar"), self.path("foo/bar")) self.assertEqual(self.path("foo/./bar"), self.path("foo/bar")) self.assertNotEqual(self.path("foo/../bar"), self.path("foo/bar")) self.assertEqual(self.path("/etc", "/usr", "lib64"), self.path("/usr/lib64")) def test_path_parts(self): sep = self.os.path.sep path = self.path(sep + self.os.path.join("foo", "bar", "setup.py")) self.assertEqual(path.parts, (sep, "foo", "bar", "setup.py")) self.assertEqual(path.drive, "") self.assertEqual(path.root, sep) self.assertEqual(path.anchor, sep) self.assertEqual(path.name, "setup.py") self.assertEqual(path.stem, "setup") self.assertEqual(path.suffix, ".py") self.assertEqual(path.parent, self.path(sep + self.os.path.join("foo", "bar"))) self.assertEqual( path.parents[0], self.path(sep + self.os.path.join("foo", "bar")) ) self.assertEqual(path.parents[1], self.path(sep + "foo")) self.assertEqual(path.parents[2], self.path(sep)) @unittest.skipIf(is_windows, "POSIX specific behavior") def test_is_absolute_posix(self): self.assertTrue(self.path("/a/b").is_absolute()) self.assertFalse(self.path("a/b").is_absolute()) self.assertFalse(self.path("d:/b").is_absolute()) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_is_absolute_windows(self): self.assertFalse(self.path("/a/b").is_absolute()) self.assertFalse(self.path("a/b").is_absolute()) self.assertTrue(self.path("d:/b").is_absolute()) class RealPathlibInitializationTest(FakePathlibInitializationTest): def use_real_fs(self): return True @unittest.skipIf(not is_windows, "Windows specific behavior") class FakePathlibInitializationWithDriveTest(RealPathlibTestCase): def test_init_with_segments(self): """Basic initialization tests - taken from pathlib.Path documentation""" self.assertEqual( self.path("c:/", "foo", "bar", "baz"), self.path("c:/foo/bar/baz") ) self.assertEqual(self.path(), self.path(".")) self.assertEqual( self.path(self.path("foo"), self.path("bar")), self.path("foo/bar") ) self.assertEqual( self.path("c:/Users") / "john" / "data", self.path("c:/Users/john/data"), ) def test_init_collapse(self): """Tests for collapsing path during initialization. Taken from pathlib.PurePath documentation. """ self.assertEqual(self.path("c:/Windows", "d:bar"), self.path("d:bar")) self.assertEqual( self.path("c:/Windows", "/Program Files"), self.path("c:/Program Files"), ) def test_path_parts(self): path = self.path(self.os.path.join("d:", "python scripts", "setup.py")) self.assertEqual(path.parts, ("d:", "python scripts", "setup.py")) self.assertEqual(path.drive, "d:") self.assertEqual(path.root, "") self.assertEqual(path.anchor, "d:") self.assertEqual(path.name, "setup.py") self.assertEqual(path.stem, "setup") self.assertEqual(path.suffix, ".py") self.assertEqual( path.parent, self.path(self.os.path.join("d:", "python scripts")) ) self.assertEqual( path.parents[0], self.path(self.os.path.join("d:", "python scripts")), ) self.assertEqual(path.parents[1], self.path("d:")) @unittest.skipIf(not is_windows, "Windows-specific behavior") def test_is_absolute(self): self.assertTrue(self.path("c:/a/b").is_absolute()) self.assertFalse(self.path("/a/b").is_absolute()) self.assertFalse(self.path("c:").is_absolute()) self.assertTrue(self.path("//some/share").is_absolute()) class RealPathlibInitializationWithDriveTest(FakePathlibInitializationWithDriveTest): def use_real_fs(self): return True class FakePathlibPurePathTest(RealPathlibTestCase): """Tests functionality present in PurePath class.""" def test_is_reserved_posix(self): self.check_posix_only() with self.deprecation_warning_since_313(): self.assertFalse(self.path("/dev").is_reserved()) self.assertFalse(self.path("/").is_reserved()) self.assertFalse(self.path("COM1").is_reserved()) self.assertFalse(self.path("nul.txt").is_reserved()) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_is_reserved_windows(self): self.check_windows_only() with self.deprecation_warning_since_313(): self.assertFalse(self.path("/dev").is_reserved()) self.assertFalse(self.path("/").is_reserved()) self.assertTrue(self.path("COM1").is_reserved()) self.assertTrue(self.path("nul.txt").is_reserved()) def test_joinpath(self): self.assertEqual(self.path("/etc").joinpath("passwd"), self.path("/etc/passwd")) self.assertEqual( self.path("/etc").joinpath(self.path("passwd")), self.path("/etc/passwd"), ) self.assertEqual( self.path("/foo").joinpath("bar", "baz"), self.path("/foo/bar/baz") ) def test_joinpath_drive(self): self.check_windows_only() self.assertEqual( self.path("c:").joinpath("/Program Files"), self.path("c:/Program Files"), ) def test_match(self): self.assertTrue(self.path("a/b.py").match(".py")) self.assertTrue(self.path("/a/b/c.py").match("b/.py")) self.assertFalse(self.path("/a/b/c.py").match("a/.py")) self.assertTrue(self.path("/a.py").match("/.py")) self.assertFalse(self.path("a/b.py").match("/.py")) def test_relative_to(self): self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) with self.assertRaises(ValueError): self.path("passwd").relative_to("/usr") @unittest.skipIf(sys.version_info < (3, 9), "is_relative_to new in Python 3.9") def test_is_relative_to(self): path = self.path("/etc/passwd") self.assertTrue(path.is_relative_to("/etc")) self.assertFalse(path.is_relative_to("/src")) def test_with_name(self): self.check_windows_only() self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_name("setup.py"), self.path("c:/Downloads/setup.py"), ) with self.assertRaises(ValueError): self.path("c:/").with_name("setup.py") def test_with_suffix(self): self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_suffix(".bz2"), self.path("c:/Downloads/pathlib.tar.bz2"), ) self.assertEqual( self.path("README").with_suffix(".txt"), self.path("README.txt") ) class RealPathlibPurePathTest(FakePathlibPurePathTest): def use_real_fs(self): return True class FakePathlibPurePosixPathTest(RealPathlibTestCase): def setUp(self): super().setUp() self.path = self.pathlib.PurePosixPath def test_is_reserved(self): with self.deprecation_warning_since_313(): self.assertFalse(self.path("/dev").is_reserved()) self.assertFalse(self.path("/").is_reserved()) self.assertFalse(self.path("COM1").is_reserved()) self.assertFalse(self.path("nul.txt").is_reserved()) def test_joinpath(self): self.assertEqual(self.path("/etc").joinpath("passwd"), self.path("/etc/passwd")) self.assertEqual( self.path("/etc").joinpath(self.path("passwd")), self.path("/etc/passwd"), ) self.assertEqual( self.path("/foo").joinpath("bar", "baz"), self.path("/foo/bar/baz") ) self.assertEqual( self.path("c:").joinpath("/Program Files"), self.path("/Program Files"), ) def test_match(self): self.assertTrue(self.path("a/b.py").match(".py")) self.assertTrue(self.path("/a/b/c.py").match("b/.py")) self.assertFalse(self.path("/a/b/c.py").match("a/.py")) self.assertTrue(self.path("/a.py").match("/.py")) self.assertFalse(self.path("a/b.py").match("/.py")) def test_relative_to(self): self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) with self.assertRaises(ValueError): self.path("passwd").relative_to("/usr") @unittest.skipIf(sys.version_info < (3, 9), "is_relative_to new in Python 3.9") def test_is_relative_to(self): path = self.path("/etc/passwd") self.assertTrue(path.is_relative_to("/etc")) self.assertFalse(path.is_relative_to("/src")) def test_with_name(self): self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_name("setup.py"), self.path("c:/Downloads/setup.py"), ) self.assertEqual(self.path("c:/").with_name("setup.py"), self.path("setup.py")) def test_with_suffix(self): self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_suffix(".bz2"), self.path("c:/Downloads/pathlib.tar.bz2"), ) self.assertEqual( self.path("README").with_suffix(".txt"), self.path("README.txt") ) def test_to_string(self): self.assertEqual(str(self.path("/usr/bin/ls")), "/usr/bin/ls") self.assertEqual(str(self.path("usr") / "bin" / "ls"), "usr/bin/ls") class RealPathlibPurePosixPathTest(FakePathlibPurePosixPathTest): def use_real_fs(self): return True class FakePathlibPureWindowsPathTest(RealPathlibTestCase): def setUp(self): super().setUp() self.path = self.pathlib.PureWindowsPath def test_is_reserved(self): with self.deprecation_warning_since_313(): self.assertFalse(self.path("/dev").is_reserved()) self.assertFalse(self.path("/").is_reserved()) self.assertTrue(self.path("COM1").is_reserved()) self.assertTrue(self.path("nul.txt").is_reserved()) def test_joinpath(self): self.assertEqual(self.path("/etc").joinpath("passwd"), self.path("/etc/passwd")) self.assertEqual( self.path("/etc").joinpath(self.path("passwd")), self.path("/etc/passwd"), ) self.assertEqual( self.path("/foo").joinpath("bar", "baz"), self.path("/foo/bar/baz") ) self.assertEqual( self.path("c:").joinpath("/Program Files"), self.path("c:/Program Files"), ) def test_match(self): self.assertTrue(self.path("a/b.py").match(".py")) self.assertTrue(self.path("/a/b/c.py").match("b/.py")) self.assertFalse(self.path("/a/b/c.py").match("a/.py")) self.assertTrue(self.path("/a.py").match("/.py")) self.assertFalse(self.path("a/b.py").match("/.py")) def test_relative_to(self): self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) self.assertEqual( self.path("/etc/passwd").relative_to("/"), self.path("etc/passwd") ) with self.assertRaises(ValueError): self.path("passwd").relative_to("/usr") @unittest.skipIf(sys.version_info < (3, 9), "is_relative_to new in Python 3.9") def test_is_relative_to(self): path = self.path("/etc/passwd") self.assertTrue(path.is_relative_to("/etc")) self.assertFalse(path.is_relative_to("/src")) def test_with_name(self): self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_name("setup.py"), self.path("c:/Downloads/setup.py"), ) with self.assertRaises(ValueError): self.path("c:/").with_name("setup.py") def test_with_suffix(self): self.assertEqual( self.path("c:/Downloads/pathlib.tar.gz").with_suffix(".bz2"), self.path("c:/Downloads/pathlib.tar.bz2"), ) self.assertEqual( self.path("README").with_suffix(".txt"), self.path("README.txt") ) def test_to_string(self): self.assertEqual(str(self.path("/usr/bin/ls")), "\\usr\\bin\\ls") self.assertEqual( str(self.path("c:/Windows/System32/ntoskrnl.exe")), "c:\\Windows\\System32\\ntoskrnl.exe", ) self.assertEqual(str(self.path("usr") / "bin" / "ls"), "usr\\bin\\ls") self.assertEqual( str(self.path("C:/") / "Windows" / "System32" / "ntoskrnl.exe"), "C:\\Windows\\System32\\ntoskrnl.exe", ) class RealPathlibPureWindowsPathTest(FakePathlibPureWindowsPathTest): def use_real_fs(self): return True class FakePathlibFileObjectPropertyTest(RealPathlibTestCase): def setUp(self): super().setUp() self.umask = self.os.umask(0o022) self.file_path = self.make_path("home", "jane", "test.py") self.create_file(self.file_path, contents=b"a" 100) self.create_dir(self.make_path("home", "john")) try: skip_if_symlink_not_supported() except unittest.SkipTest: return self.create_symlink(self.make_path("john"), self.make_path("home", "john")) self.file_link_path = self.make_path("test.py") self.create_symlink(self.file_link_path, self.file_path) self.create_symlink( self.make_path("broken_dir_link"), self.make_path("home", "none") ) self.create_symlink( self.make_path("broken_file_link"), self.make_path("home", "none", "test.py"), ) def tearDown(self): self.os.umask(self.umask) def test_exists(self): skip_if_symlink_not_supported() self.assertTrue(self.path(self.file_path).exists()) self.assertTrue(self.path(self.make_path("home", "jane")).exists()) self.assertFalse(self.path(self.make_path("home", "jane", "test")).exists()) self.assertTrue(self.path(self.make_path("john")).exists()) self.assertTrue(self.path(self.file_link_path).exists()) self.assertFalse(self.path(self.make_path("broken_dir_link")).exists()) self.assertFalse(self.path(self.make_path("broken_file_link")).exists()) def test_is_dir(self): skip_if_symlink_not_supported() self.assertFalse(self.path(self.file_path).is_dir()) self.assertTrue(self.path(self.make_path("home/jane")).is_dir()) self.assertTrue(self.path(self.make_path("john")).is_dir()) self.assertFalse(self.path(self.file_link_path).is_dir()) self.assertFalse(self.path(self.make_path("broken_dir_link")).is_dir()) self.assertFalse(self.path(self.make_path("broken_file_link")).is_dir()) def test_is_file(self): skip_if_symlink_not_supported() self.assertTrue(self.path(self.make_path("home/jane/test.py")).is_file()) self.assertFalse(self.path(self.make_path("home/jane")).is_file()) self.assertFalse(self.path(self.make_path("john")).is_file()) self.assertTrue(self.path(self.file_link_path).is_file()) self.assertFalse(self.path(self.make_path("broken_dir_link")).is_file()) self.assertFalse(self.path(self.make_path("broken_file_link")).is_file()) def test_is_symlink(self): skip_if_symlink_not_supported() self.assertFalse(self.path(self.make_path("home/jane/test.py")).is_symlink()) self.assertFalse(self.path(self.make_path("home/jane")).is_symlink()) self.assertTrue(self.path(self.make_path("john")).is_symlink()) self.assertTrue(self.path(self.file_link_path).is_symlink()) self.assertTrue(self.path(self.make_path("broken_dir_link")).is_symlink()) self.assertTrue(self.path(self.make_path("broken_file_link")).is_symlink()) def test_stat(self): skip_if_symlink_not_supported() file_stat = self.os.stat(self.file_path) stat_result = self.path(self.file_link_path).stat() self.assertFalse(stat_result.st_mode & stat.S_IFDIR) self.assertTrue(stat_result.st_mode & stat.S_IFREG) self.assertEqual(stat_result.st_ino, file_stat.st_ino) self.assertEqual(stat_result.st_size, 100) self.assertEqual(stat_result.st_mtime, file_stat.st_mtime) self.assertEqual(stat_result[stat.ST_MTIME], int(file_stat.st_mtime)) def check_lstat(self, expected_size): skip_if_symlink_not_supported() link_stat = self.os.lstat(self.file_link_path) stat_result = self.path(self.file_link_path).lstat() self.assertTrue(stat_result.st_mode & stat.S_IFREG) self.assertTrue(stat_result.st_mode & stat.S_IFLNK) self.assertEqual(stat_result.st_ino, link_stat.st_ino) self.assertEqual(stat_result.st_size, expected_size) self.assertEqual(stat_result.st_mtime, link_stat.st_mtime) @unittest.skipIf(is_windows, "POSIX specific behavior") def test_lstat_posix(self): self.check_lstat(len(self.file_path)) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_lstat_windows(self): skip_if_symlink_not_supported() self.check_lstat(0) @unittest.skipIf(is_windows, "POSIX specific behavior") def test_chmod(self): self.check_posix_only() file_stat = self.os.stat(self.file_path) self.assertEqual(file_stat.st_mode, stat.S_IFREG \| 0o644) link_stat = self.os.lstat(self.file_link_path) # we get stat.S_IFLNK \| 0o755 under MacOs mode = 0o755 if self.is_macos else 0o777 self.assertEqual(link_stat.st_mode, stat.S_IFLNK \| mode) def test_lchmod(self): skip_if_symlink_not_supported() file_stat = self.os.stat(self.file_path) link_stat = self.os.lstat(self.file_link_path) if not hasattr(self.real_os, "lchmod"): with self.assertRaises(NotImplementedError): self.path(self.file_link_path).lchmod(0o444) else: self.path(self.file_link_path).lchmod(0o444) mode = 0o666 if is_windows else 0o644 self.assertEqual(file_stat.st_mode, stat.S_IFREG \| mode) # the exact mode depends on OS and Python version mode_mask = 0o600 if self.is_windows_fs else 0o700 self.assertEqual(link_stat.st_mode & 0o777700, stat.S_IFLNK \| mode_mask) @unittest.skipIf( sys.version_info < (3, 10), "follow_symlinks argument new in Python 3.10", ) def test_chmod_no_followsymlinks(self): skip_if_symlink_not_supported() file_stat = self.os.stat(self.file_path) link_stat = self.os.lstat(self.file_link_path) if self.os.chmod not in self.os.supports_follow_symlinks or IS_PYPY: with self.assertRaises(NotImplementedError): self.path(self.file_link_path).chmod(0o444, follow_symlinks=False) else: self.path(self.file_link_path).chmod(0o444, follow_symlinks=False) mode = 0o666 if is_windows else 0o644 self.assertEqual(file_stat.st_mode, stat.S_IFREG \| mode) # the exact mode depends on OS and Python version mode_mask = 0o600 if self.is_windows_fs else 0o700 self.assertEqual(link_stat.st_mode & 0o777700, stat.S_IFLNK \| mode_mask) def test_resolve(self): self.create_dir(self.make_path("antoine", "docs")) self.create_file(self.make_path("antoine", "setup.py")) self.os.chdir(self.make_path("antoine")) # use real path to handle symlink /var to /private/var in macOS self.assert_equal_paths( self.path().resolve(), self.path(self.os.path.realpath(self.make_path("antoine"))), ) self.assert_equal_paths( self.path(self.os.path.join("docs", "..", "setup.py")).resolve(), self.path(self.os.path.realpath(self.make_path("antoine", "setup.py"))), ) def test_stat_file_in_unreadable_dir(self): self.check_posix_only() dir_path = self.make_path("some_dir") file_path = self.os.path.join(dir_path, "some_file") self.create_file(file_path) self.os.chmod(dir_path, 0o000) if not is_root(): self.assert_raises_os_error(errno.EACCES, self.path(file_path).stat) else: self.assertEqual(0, self.path(file_path).stat().st_size) def test_iterdir_in_unreadable_dir(self): self.check_posix_only() dir_path = self.make_path("some_dir") file_path = self.os.path.join(dir_path, "some_file") self.create_file(file_path) self.os.chmod(dir_path, 0o000) if not is_root(): if sys.version_info >= (3, 13): self.assert_raises_os_error(errno.EACCES, self.path(dir_path).iterdir) else: it = self.path(dir_path).iterdir() self.assert_raises_os_error(errno.EACCES, list, it) else: it = self.path(dir_path).iterdir() path = str(list(it)[0]) self.assertTrue(path.endswith("some_file")) def test_iterdir_and_glob_without_exe_permission(self): # regression test for #960 self.check_posix_only() self.skip_root() directory = self.path(self.make_path("testdir")) file_path = directory / "file.txt" self.create_file(file_path, contents="hey", perm=0o777) directory.chmod(0o655) # rw-r-xr-x # We cannot create any files in the directory, because that requires # searching it another_file = self.path(self.make_path("file.txt")) self.create_file(another_file, contents="hey") with self.assertRaises(PermissionError): self.os.link(another_file, directory / "link.txt") # We can enumerate the directory using iterdir and glob: assert len(list(directory.iterdir())) == 1 assert list(directory.iterdir())[0] == file_path assert len(list(directory.glob(".txt"))) == 1 assert list(directory.glob(".txt"))[0] == file_path # We cannot read files inside the directory, # even if we have read access to the file with self.assertRaises(PermissionError): file_path.stat() with self.assertRaises(PermissionError): file_path.read_text(encoding="utf8") def test_iterdir_impossible_without_read_permission(self): # regression test for #960 self.check_posix_only() self.skip_root() directory = self.path(self.make_path("testdir")) file_path = directory / "file.txt" self.create_file(file_path, contents="hey", perm=0o777) directory.chmod(0o355) # -wxr-xr-x # We cannot enumerate the directory using iterdir: with self.assertRaises(PermissionError): list(directory.iterdir()) # glob does not find the file assert len(list(directory.glob(".txt"))) == 0 # we can access the file if we know the file name assert file_path.stat().st_mode & 0o777 == 0o755 assert file_path.read_text(encoding="utf8") == "hey" def test_resolve_nonexisting_file(self): path = self.path(self.make_path("/path", "to", "file", "this can not exist")) self.assertEqual(path, path.resolve()) def test_cwd(self): dir_path = self.make_path("jane") self.create_dir(dir_path) self.os.chdir(dir_path) self.assert_equal_paths( self.path.cwd(), self.path(self.os.path.realpath(dir_path)) ) @unittest.skipIf( sys.platform != "win32" or sys.version_info < (3, 8), "Windows specific test" ) @patch.dict(os.environ, {"USERPROFILE": r"C:\Users\John"}) def test_expanduser_windows(self): self.assertEqual( self.path("~").expanduser(), self.path("C:/Users/John"), ) @unittest.skipIf(sys.platform == "win32", "Posix specific test") @patch.dict(os.environ, {"HOME": "/home/john"}) def test_expanduser_posix(self): self.assertEqual(self.path("~").expanduser(), self.path("/home/john")) @unittest.skipIf( sys.platform != "win32" or sys.version_info < (3, 8), "Windows specific test" ) @patch.dict(os.environ, {"USERPROFILE": r"C:\Users\John"}) def test_home_windows(self): self.assertEqual( self.path(self.path("C:/Users/John")), self.path.home(), ) @unittest.skipIf(sys.platform == "win32", "Posix specific test") @patch.dict(os.environ, {"HOME": "/home/john"}) def test_home_posix(self): self.assertEqual(self.path("/home/john"), self.path.home()) class RealPathlibFileObjectPropertyTest(FakePathlibFileObjectPropertyTest): def use_real_fs(self): return True class FakePathlibPathFileOperationTest(RealPathlibTestCase): """Tests methods related to file and directory handling.""" def test_exists(self): skip_if_symlink_not_supported() self.create_file(self.make_path("home", "jane", "test.py")) self.create_dir(self.make_path("home", "john")) self.create_symlink(self.make_path("john"), self.make_path("home", "john")) self.create_symlink(self.make_path("none"), self.make_path("home", "none")) self.assertTrue(self.path(self.make_path("home", "jane", "test.py")).exists()) self.assertTrue(self.path(self.make_path("home", "jane")).exists()) self.assertTrue(self.path(self.make_path("john")).exists()) self.assertFalse(self.path(self.make_path("none")).exists()) self.assertFalse(self.path(self.make_path("home", "jane", "test")).exists()) def test_open(self): self.create_dir(self.make_path("foo")) with self.assertRaises(OSError): self.path(self.make_path("foo", "bar.txt")).open(encoding="utf8") self.path(self.make_path("foo", "bar.txt")).open("w", encoding="utf8").close() self.assertTrue(self.os.path.exists(self.make_path("foo", "bar.txt"))) def test_read_text(self): self.create_file(self.make_path("text_file"), contents="foo") file_path = self.path(self.make_path("text_file")) self.assertEqual(file_path.read_text(encoding="utf8"), "foo") @unittest.skipIf( sys.version_info < (3, 12), "is_junction method new in Python 3.12", ) def test_is_junction(self): self.create_file(self.make_path("text_file"), contents="foo") file_path = self.path(self.make_path("text_file")) self.assertFalse(file_path.is_junction()) def test_read_text_with_encoding(self): self.create_file( self.make_path("text_file"), contents="ерунда", encoding="cyrillic" ) file_path = self.path(self.make_path("text_file")) self.assertEqual(file_path.read_text(encoding="cyrillic"), "ерунда") def test_write_text(self): path_name = self.make_path("text_file") file_path = self.path(path_name) file_path.write_text("foo", encoding="utf8") self.assertTrue(self.os.path.exists(path_name)) self.check_contents(path_name, "foo") def test_write_text_with_encoding(self): path_name = self.make_path("text_file") file_path = self.path(path_name) file_path.write_text("ανοησίες", encoding="greek") self.assertTrue(self.os.path.exists(path_name)) self.check_contents(path_name, "ανοησίες".encode("greek")) @unittest.skipIf(sys.version_info < (3, 10), "newline argument new in Python 3.10") def test_write_with_newline_arg(self): path = self.path(self.make_path("some_file")) path.write_text("1\r\n2\n3\r4", newline="", encoding="utf8") self.check_contents(path, b"1\r\n2\n3\r4") path.write_text("1\r\n2\n3\r4", newline="\n", encoding="utf8") self.check_contents(path, b"1\r\n2\n3\r4") path.write_text("1\r\n2\n3\r4", newline="\r\n", encoding="utf8") self.check_contents(path, b"1\r\r\n2\r\n3\r4") path.write_text("1\r\n2\n3\r4", newline="\r", encoding="utf8") self.check_contents(path, b"1\r\r2\r3\r4") def test_read_bytes(self): path_name = self.make_path("binary_file") self.create_file(path_name, contents=b"Binary file contents") file_path = self.path(path_name) self.assertEqual(file_path.read_bytes(), b"Binary file contents") def test_write_bytes(self): path_name = self.make_path("binary_file") file_path = self.path(path_name) file_path.write_bytes(b"Binary file contents") self.assertTrue(self.os.path.exists(path_name)) self.check_contents(path_name, b"Binary file contents") def test_rename(self): file_name = self.make_path("foo", "bar.txt") self.create_file(file_name, contents="test") new_file_name = self.make_path("foo", "baz.txt") self.path(file_name).rename(new_file_name) self.assertFalse(self.os.path.exists(file_name)) self.check_contents(new_file_name, "test") def test_replace(self): self.create_file(self.make_path("foo", "bar.txt"), contents="test") self.create_file(self.make_path("bar", "old.txt"), contents="replaced") self.path(self.make_path("bar", "old.txt")).replace( self.make_path("foo", "bar.txt") ) self.assertFalse(self.os.path.exists(self.make_path("bar", "old.txt"))) self.check_contents(self.make_path("foo", "bar.txt"), "replaced") def test_unlink(self): file_path = self.make_path("foo", "bar.txt") self.create_file(file_path, contents="test") self.assertTrue(self.os.path.exists(file_path)) self.path(file_path).unlink() self.assertFalse(self.os.path.exists(file_path)) def test_touch_non_existing(self): self.create_dir(self.make_path("foo")) file_name = self.make_path("foo", "bar.txt") self.path(file_name).touch(mode=0o444) self.check_contents(file_name, "") self.assertTrue(self.os.stat(file_name).st_mode, stat.S_IFREG \| 0o444) self.os.chmod(file_name, mode=0o666) def test_touch_existing(self): file_name = self.make_path("foo", "bar.txt") self.create_file(file_name, contents="test") file_path = self.path(file_name) self.assert_raises_os_error(errno.EEXIST, file_path.touch, exist_ok=False) file_path.touch() self.check_contents(file_name, "test") def test_samefile(self): file_name = self.make_path("foo", "bar.txt") self.create_file(file_name) file_name2 = self.make_path("foo", "baz.txt") self.create_file(file_name2) with self.assertRaises(OSError): self.path(self.make_path("foo", "other")).samefile( self.make_path("foo", "other.txt") ) path = self.path(file_name) other_name = self.make_path("foo", "other.txt") with self.assertRaises(OSError): path.samefile(other_name) with self.assertRaises(OSError): path.samefile(self.path(other_name)) self.assertFalse(path.samefile(file_name2)) self.assertFalse(path.samefile(self.path(file_name2))) self.assertTrue(path.samefile(self.make_path("foo", "..", "foo", "bar.txt"))) self.assertTrue( path.samefile(self.path(self.make_path("foo", "..", "foo", "bar.txt"))) ) def test_symlink_to(self): skip_if_symlink_not_supported() file_name = self.make_path("foo", "bar.txt") self.create_file(file_name) link_name = self.make_path("link_to_bar") path = self.path(link_name) path.symlink_to(file_name) self.assertTrue(self.os.path.exists(link_name)) self.assertTrue(path.is_symlink()) @unittest.skipIf(sys.version_info < (3, 8), "link_to new in Python 3.8") @unittest.skipIf(sys.version_info >= (3, 12), "link_to removed in Python 3.12") def test_link_to(self): skip_if_symlink_not_supported() file_name = self.make_path("foo", "bar.txt") self.create_file(file_name) self.assertEqual(1, self.os.stat(file_name).st_nlink) link_name = self.make_path("link_to_bar") path = self.path(file_name) path.link_to(link_name) self.assertTrue(self.os.path.exists(link_name)) self.assertFalse(path.is_symlink()) self.assertEqual(2, self.os.stat(file_name).st_nlink) @unittest.skipIf(sys.version_info < (3, 10), "hardlink_to new in Python 3.10") def test_hardlink_to(self): file_name = self.make_path("foo", "bar.txt") self.create_file(file_name) self.assertEqual(1, self.os.stat(file_name).st_nlink) link_path = self.path(self.make_path("link_to_bar")) path = self.path(file_name) link_path.hardlink_to(path) self.assertTrue(self.os.path.exists(link_path)) self.assertFalse(path.is_symlink()) self.assertEqual(2, self.os.stat(file_name).st_nlink) @unittest.skipIf(sys.version_info < (3, 9), "readlink new in Python 3.9") def test_readlink(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "baz") target = self.make_path("tarJAY") self.create_symlink(link_path, target) path = self.path(link_path) self.assert_equal_paths(path.readlink(), self.path(target)) def test_mkdir(self): dir_name = self.make_path("foo", "bar") self.assert_raises_os_error(errno.ENOENT, self.path(dir_name).mkdir) self.path(dir_name).mkdir(parents=True) self.assertTrue(self.os.path.exists(dir_name)) self.assert_raises_os_error(errno.EEXIST, self.path(dir_name).mkdir) def test_mkdir_exist_ok(self): dir_name = self.make_path("foo", "bar") self.create_dir(dir_name) self.path(dir_name).mkdir(exist_ok=True) file_name = self.os.path.join(dir_name, "baz") self.create_file(file_name) self.assert_raises_os_error( errno.EEXIST, self.path(file_name).mkdir, exist_ok=True ) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_mkdir_with_automount_unc_path(self): self.skip_real_fs() self.path(r"\\test\unc\foo").mkdir(parents=True) self.assertTrue(self.path(r"\\test\unc\foo").exists()) @unittest.skipIf(not is_windows, "Windows specific behavior") def test_mkdir_with_automount_drive(self): self.skip_real_fs() self.path(r"d:\foo\bar").mkdir(parents=True) self.assertTrue(self.path(r"d:\foo\bar").exists()) def test_rmdir(self): dir_name = self.make_path("foo", "bar") self.create_dir(dir_name) self.path(dir_name).rmdir() self.assertFalse(self.os.path.exists(dir_name)) self.assertTrue(self.os.path.exists(self.make_path("foo"))) self.create_file(self.make_path("foo", "baz")) with self.assertRaises(OSError): self.path(self.make_path("foo")).rmdir() self.assertTrue(self.os.path.exists(self.make_path("foo"))) def test_iterdir(self): self.create_file(self.make_path("foo", "bar", "file1")) self.create_file(self.make_path("foo", "bar", "file2")) self.create_file(self.make_path("foo", "bar", "file3")) path = self.path(self.make_path("foo", "bar")) contents = [entry for entry in path.iterdir()] self.assertEqual(3, len(contents)) self.assertIn(self.path(self.make_path("foo", "bar", "file2")), contents) def test_glob(self): self.create_file(self.make_path("foo", "setup.py")) self.create_file(self.make_path("foo", "all_tests.py")) self.create_file(self.make_path("foo", "README.md")) self.create_file(self.make_path("foo", "setup.pyc")) path = self.path(self.make_path("foo")) self.assertEqual( [ self.path(self.make_path("foo", "all_tests.py")), self.path(self.make_path("foo", "setup.py")), ], sorted(path.glob(".py")), ) def test_glob_dir(self): # regression test for #1239 root_dir = self.path(self.make_path("root")) test_file = self.make_path(root_dir, "foo", "bar.txt") self.create_file(test_file) self.assertEqual([root_dir / "foo"], list(root_dir.glob("foo"))) def test_glob_case_windows(self): self.check_windows_only() self.create_file(self.make_path("foo", "setup.py")) self.create_file(self.make_path("foo", "all_tests.PY")) self.create_file(self.make_path("foo", "README.md")) self.create_file(self.make_path("foo", "example.Py")) path = self.path(self.make_path("foo")) self.assertEqual( [ self.path(self.make_path("foo", "all_tests.PY")), self.path(self.make_path("foo", "example.Py")), self.path(self.make_path("foo", "setup.py")), ], sorted(path.glob(".py")), ) def test_glob_case_posix(self): self.check_posix_only() if sys.platform == "win32" and sys.version_info < (3, 12): self.skipTest(reason="Ignoring inconsistent path delimiters") self.create_file(self.make_path("foo", "setup.py")) self.create_file(self.make_path("foo", "all_tests.PY")) self.create_file(self.make_path("foo", "README.md")) self.create_file(self.make_path("foo", "example.Py")) path = self.path(self.make_path("foo")) self.assertEqual( sorted(path.glob(".py")), [self.path(self.make_path("foo", "setup.py"))], ) class RealPathlibPathFileOperationTest(FakePathlibPathFileOperationTest): def use_real_fs(self): return True class FakePathlibUsageInOsFunctionsTest(RealPathlibTestCase): """Test that many `os` / `os.path` functions accept a path-like object. The functionality of these functions is tested elsewhere, we just check that they accept a fake path object as an argument. """ def test_join(self): dir1 = "foo" dir2 = "bar" dir3 = self.os.path.join(dir1, dir2) self.assertEqual(dir3, self.os.path.join(self.path(dir1), dir2)) self.assertEqual(dir3, self.os.path.join(dir1, self.path(dir2))) self.assertEqual(dir3, self.os.path.join(self.path(dir1), self.path(dir2))) def test_normcase(self): dir1 = self.make_path("Foo", "Bar", "Baz") self.assertEqual( self.os.path.normcase(dir1), self.os.path.normcase(self.path(dir1)) ) def test_normpath(self): dir1 = self.make_path("foo", "bar", "..", "baz") self.assertEqual( self.os.path.normpath(dir1), self.os.path.normpath(self.path(dir1)) ) def test_realpath(self): dir1 = self.make_path("foo", "bar", "..", "baz") self.assertEqual( self.os.path.realpath(dir1), self.os.path.realpath(self.path(dir1)) ) def test_relpath(self): path_foo = self.make_path("path", "to", "foo") path_bar = self.make_path("path", "to", "bar") rel_path = self.os.path.relpath(path_foo, path_bar) self.assertEqual(rel_path, self.os.path.relpath(self.path(path_foo), path_bar)) self.assertEqual(rel_path, self.os.path.relpath(path_foo, self.path(path_bar))) self.assertEqual( rel_path, self.os.path.relpath(self.path(path_foo), self.path(path_bar)), ) def test_split(self): dir1 = self.make_path("Foo", "Bar", "Baz") self.assertEqual(self.os.path.split(dir1), self.os.path.split(self.path(dir1))) def test_splitdrive(self): dir1 = self.make_path("C:", "Foo", "Bar", "Baz") self.assertEqual( self.os.path.splitdrive(dir1), self.os.path.splitdrive(self.path(dir1)), ) def test_abspath(self): dir1 = self.make_path("foo", "bar", "..", "baz") self.assertEqual( self.os.path.abspath(dir1), self.os.path.abspath(self.path(dir1)) ) def test_exists(self): dir1 = self.make_path("foo", "bar", "..", "baz") self.assertEqual( self.os.path.exists(dir1), self.os.path.exists(self.path(dir1)) ) def test_lexists(self): dir1 = self.make_path("foo", "bar", "..", "baz") self.assertEqual( self.os.path.lexists(dir1), self.os.path.lexists(self.path(dir1)) ) def test_expanduser(self): dir1 = self.os.path.join("~", "foo") self.assertEqual( self.os.path.expanduser(dir1), self.os.path.expanduser(self.path(dir1)), ) def test_getmtime(self): self.skip_real_fs() dir1 = self.make_path("foo", "bar1.txt") path_obj = self.filesystem.create_file(dir1) path_obj._st_mtime = 24 self.assertEqual( self.os.path.getmtime(dir1), self.os.path.getmtime(self.path(dir1)) ) def test_getctime(self): self.skip_real_fs() dir1 = self.make_path("foo", "bar1.txt") path_obj = self.filesystem.create_file(dir1) path_obj.st_ctime = 42 self.assertEqual( self.os.path.getctime(dir1), self.os.path.getctime(self.path(dir1)) ) def test_getatime(self): self.skip_real_fs() dir1 = self.make_path("foo", "bar1.txt") path_obj = self.filesystem.create_file(dir1) path_obj.st_atime = 11 self.assertEqual( self.os.path.getatime(dir1), self.os.path.getatime(self.path(dir1)) ) def test_getsize(self): path = self.make_path("foo", "bar", "baz") self.create_file(path, contents="1234567") self.assertEqual( self.os.path.getsize(path), self.os.path.getsize(self.path(path)) ) def test_isabs(self): path = self.make_path("foo", "bar", "..", "baz") self.assertEqual(self.os.path.isabs(path), self.os.path.isabs(self.path(path))) def test_isfile(self): path = self.make_path("foo", "bar", "baz") self.create_file(path) self.assertEqual( self.os.path.isfile(path), self.os.path.isfile(self.path(path)) ) def test_isfile_not_readable(self): path = self.make_path("foo", "bar", "baz") self.create_file(path, perm=0) self.assertEqual( self.os.path.isfile(path), self.os.path.isfile(self.path(path)) ) def test_islink(self): path = self.make_path("foo", "bar", "baz") self.create_file(path) self.assertEqual( self.os.path.islink(path), self.os.path.islink(self.path(path)) ) def test_isdir(self): path = self.make_path("foo", "bar", "baz") self.create_file(path) self.assertEqual(self.os.path.isdir(path), self.os.path.isdir(self.path(path))) def test_ismount(self): path = self.os.path.sep self.assertEqual( self.os.path.ismount(path), self.os.path.ismount(self.path(path)) ) def test_access(self): path = self.make_path("foo", "bar", "baz") self.create_file(path, contents="1234567") self.assertEqual( self.os.access(path, os.R_OK), self.os.access(self.path(path), os.R_OK), ) def test_chdir(self): path = self.make_path("foo", "bar", "baz") self.create_dir(path) self.os.chdir(self.path(path)) # use real path to handle symlink /var to /private/var in MacOs self.assert_equal_paths(self.os.path.realpath(path), self.os.getcwd()) def test_chmod(self): path = self.make_path("some_file") self.create_file(path) self.os.chmod(self.path(path), 0o444) self.assertEqual(stat.S_IMODE(0o444), stat.S_IMODE(self.os.stat(path).st_mode)) self.os.chmod(self.path(path), 0o666) def test_link(self): skip_if_symlink_not_supported() file1_path = self.make_path("test_file1") file2_path = self.make_path("test_file2") self.create_file(file1_path) self.os.link(self.path(file1_path), file2_path) self.assertTrue(self.os.path.exists(file2_path)) self.os.unlink(file2_path) self.os.link(self.path(file1_path), self.path(file2_path)) self.assertTrue(self.os.path.exists(file2_path)) self.os.unlink(file2_path) self.os.link(file1_path, self.path(file2_path)) self.assertTrue(self.os.path.exists(file2_path)) def test_listdir(self): path = self.make_path("foo", "bar") self.create_dir(path) self.create_file(path + "baz.txt") self.assertEqual(self.os.listdir(path), self.os.listdir(self.path(path))) def test_mkdir(self): path = self.make_path("foo") self.os.mkdir(self.path(path)) self.assertTrue(self.os.path.exists(path)) def test_makedirs(self): path = self.make_path("foo", "bar") self.os.makedirs(self.path(path)) self.assertTrue(self.os.path.exists(path)) @unittest.skipIf( is_windows and sys.version_info < (3, 8), "os.readlink does not to support path-like objects " "under Windows before Python 3.8", ) def test_readlink(self): skip_if_symlink_not_supported() link_path = self.make_path("foo", "bar", "baz") target = self.make_path("tarJAY") self.create_symlink(link_path, target) self.assert_equal_paths(self.os.readlink(self.path(link_path)), target) @unittest.skipIf( is_windows and sys.version_info < (3, 8), "os.readlink does not to support path-like objects " "under Windows before Python 3.8", ) def test_readlink_bytes(self): skip_if_symlink_not_supported() link_path = self.make_path(b"foo", b"bar", b"baz") target = self.make_path(b"tarJAY") self.create_symlink(link_path, target) self.assert_equal_paths(self.os.readlink(self.path(link_path)), target) def test_remove(self): path = self.make_path("test.txt") self.create_file(path) self.os.remove(self.path(path)) self.assertFalse(self.os.path.exists(path)) def test_rename(self): path1 = self.make_path("test1.txt") path2 = self.make_path("test2.txt") self.create_file(path1) self.os.rename(self.path(path1), path2) self.assertTrue(self.os.path.exists(path2)) self.os.rename(self.path(path2), self.path(path1)) self.assertTrue(self.os.path.exists(path1)) def test_replace(self): path1 = self.make_path("test1.txt") path2 = self.make_path("test2.txt") self.create_file(path1) self.os.replace(self.path(path1), path2) self.assertTrue(self.os.path.exists(path2)) self.os.replace(self.path(path2), self.path(path1)) self.assertTrue(self.os.path.exists(path1)) def test_rmdir(self): path = self.make_path("foo", "bar") self.create_dir(path) self.os.rmdir(self.path(path)) self.assertFalse(self.os.path.exists(path)) def test_scandir(self): directory = self.make_path("xyzzy", "plugh") self.create_dir(directory) self.create_file(self.os.path.join(directory, "test.txt")) dir_entries = [entry for entry in self.os.scandir(self.path(directory))] self.assertEqual(1, len(dir_entries)) def test_symlink(self): skip_if_symlink_not_supported() file_path = self.make_path("test_file1") link_path = self.make_path("link") self.create_file(file_path) self.os.symlink(self.path(file_path), link_path) self.assertTrue(self.os.path.exists(link_path)) self.os.remove(link_path) self.os.symlink(self.path(file_path), self.path(link_path)) self.assertTrue(self.os.path.exists(link_path)) def test_stat(self): path = self.make_path("foo", "bar", "baz") self.create_file(path, contents="1234567") self.assertEqual(self.os.stat(path), self.path(path).stat()) @unittest.skipIf(sys.version_info < (3, 10), "New in Python 3.10") def test_stat_follow_symlinks(self): self.check_posix_only() directory = self.make_path("foo") base_name = "bar" file_path = self.path(self.os.path.join(directory, base_name)) link_path = self.path(self.os.path.join(directory, "link")) contents = "contents" self.create_file(file_path, contents=contents) self.create_symlink(link_path, base_name) self.assertEqual( len(contents), link_path.stat(follow_symlinks=True)[stat.ST_SIZE] ) self.assertEqual( len(base_name), link_path.stat(follow_symlinks=False)[stat.ST_SIZE] ) def test_utime(self): path = self.make_path("some_file") self.create_file(path, contents="test") self.os.utime(self.path(path), times=(1, 2)) st = self.os.stat(path) self.assertEqual(1, st.st_atime) self.assertEqual(2, st.st_mtime) def test_truncate(self): path = self.make_path("some_file") self.create_file(path, contents="test_test") self.os.truncate(self.path(path), length=4) st = self.os.stat(path) self.assertEqual(4, st.st_size) @unittest.skipIf(sys.platform == "win32", "no pwd and grp modules in Windows") def test_owner_and_group_posix(self): path = self.make_path("some_file") self.create_file(path) self.assertTrue(self.path(path).owner()) self.assertTrue(self.path(path).group()) @unittest.skipIf(sys.platform == "win32", "no pwd and grp modules in Windows") def test_changed_owner_and_group(self): def fake_getpwuid(uid): if uid == 42: user_struct = namedtuple("user", "pw_name, pw_uid") user_struct.pw_name = "NewUser" return user_struct raise KeyError def fake_getgrgid(uid): if uid == 5: group_struct = namedtuple("group", "gr_name, gr_gid") group_struct.gr_name = "NewGroup" return group_struct raise KeyError self.skip_real_fs() path = self.make_path("some_file") self.create_file(path) self.os.chown(path, 42, 5) with mock.patch("pwd.getpwuid", fake_getpwuid): with mock.patch("grp.getgrgid", fake_getgrgid): self.assertEqual("NewUser", self.path(path).owner()) self.assertEqual("NewGroup", self.path(path).group()) def test_owner_and_group_windows(self): self.check_windows_only() path = self.make_path("some_file") self.create_file(path) with self.assertRaises(NotImplementedError): self.path(path).owner() with self.assertRaises(NotImplementedError): self.path(path).group() @unittest.skipIf(sys.version_info < (3, 14), "copy() is new in Python 3.14") def test_copy_new_file(self): source_path = self.path(self.make_path("some_file")) target_path = self.make_path("some_other_file") self.create_file(source_path, contents="test") target = source_path.copy(target_path) self.assertEqual(target_path, str(target)) self.assertTrue(target.exists()) self.assertEqual("test", target.read_text()) @unittest.skipIf(sys.version_info < (3, 14), "copy() is new in Python 3.14") def test_copy_to_existing_file(self): source_path = self.path(self.make_path("some_file")) target_path = self.make_path("some_other_file") self.create_file(source_path, contents="foo") self.create_file(target_path, contents="bar") target = source_path.copy(target_path) self.assertEqual(target_path, str(target)) self.assertTrue(source_path.exists()) self.assertTrue(target.exists()) self.assertEqual("foo", target.read_text()) @unittest.skipIf(sys.version_info < (3, 14), "copy() is new in Python 3.14") def test_copy_directory(self): source_path = self.path(self.make_path("some_dir")) self.create_file(source_path / "foo", contents="foo") self.create_file(source_path / "bar", contents="bar") self.create_dir(source_path / "dir") target_path = self.make_path("new_dir") target = source_path.copy(target_path) self.assertEqual(target_path, str(target)) self.assertTrue(source_path.exists()) self.assertTrue(target.exists()) self.assertTrue((target / "foo").exists()) self.assertEqual("foo", (target / "foo").read_text()) self.assertEqual("bar", (target / "bar").read_text()) @unittest.skipIf(sys.version_info < (3, 14), "copy_into() is new in Python 3.14") def test_copy_into(self): source_dir = self.path(self.make_path("some_dir")) source_path = source_dir / "foo" self.create_file(source_path, contents="foo") target_path = self.path(self.make_path("new_dir")) self.create_dir(target_path) target = source_path.copy_into(target_path) self.assertTrue(source_path.exists()) self.assertTrue(target.exists()) self.assertEqual(str(target_path / "foo"), str(target)) self.assertEqual("foo", target.read_text()) @unittest.skipIf(sys.version_info < (3, 14), "move() is new in Python 3.14") def test_move_file(self): source_path = self.path(self.make_path("some_file")) target_path = self.make_path("some_other_file") self.create_file(source_path, contents="test") target = source_path.move(target_path) self.assertEqual(target_path, str(target)) self.assertFalse(source_path.exists()) self.assertTrue(target.exists()) self.assertEqual("test", target.read_text()) @unittest.skipIf(sys.version_info < (3, 14), "move() is new in Python 3.14") def test_move_to_existing_file(self): source_path = self.path(self.make_path("some_file")) target_path = self.make_path("some_other_file") self.create_file(source_path, contents="foo") self.create_file(target_path, contents="bar") target = source_path.move(target_path) self.assertEqual(target_path, str(target)) self.assertFalse(source_path.exists()) self.assertTrue(target.exists()) self.assertEqual("foo", target.read_text()) @unittest.skipIf(sys.version_info < (3, 14), "move() is new in Python 3.14") def test_move_directory(self): source_path = self.path(self.make_path("some_dir")) self.create_file(source_path / "foo", contents="foo") self.create_file(source_path / "bar", contents="bar") self.create_dir(source_path / "dir") target_path = self.make_path("new_dir") target = source_path.move(target_path) self.assertEqual(target_path, str(target)) self.assertFalse(source_path.exists()) self.assertTrue(target.exists()) self.assertTrue((target / "foo").exists()) self.assertEqual("foo", (target / "foo").read_text()) self.assertEqual("bar", (target / "bar").read_text()) @unittest.skipIf(sys.version_info < (3, 14), "move_into() is new in Python 3.14") def test_move_into(self): source_dir = self.path(self.make_path("some_dir")) source_path = source_dir / "foo" self.create_file(source_path, contents="foo") target_path = self.path(self.make_path("new_dir")) self.create_dir(target_path) target = source_path.move_into(target_path) self.assertFalse(source_path.exists()) self.assertTrue(target.exists()) self.assertEqual(str(target_path / "foo"), str(target)) self.assertEqual("foo", target.read_text()) def test_walk(self): """Regression test for #915 - walk results shall be strings.""" base_dir = self.make_path("foo") base_path = self.path(base_dir) self.create_dir(base_path) self.create_file(base_path / "1.txt") self.create_file(base_path / "bar" / "2.txt") result = list(step for step in self.os.walk(base_path)) assert len(result) == 2 assert result[0] == (base_dir, ["bar"], ["1.txt"]) assert result[1] == (self.os.path.join(base_dir, "bar"), [], ["2.txt"]) class RealPathlibUsageInOsFunctionsTest(FakePathlibUsageInOsFunctionsTest): def use_real_fs(self): return True class FakeFilesystemPathLikeObjectTest(unittest.TestCase): def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem() self.pathlib = fake_pathlib.FakePathlibModule(self.filesystem) self.os = fake_os.FakeOsModule(self.filesystem) def test_create_dir_with_pathlib_path(self): dir_path_string = "foo/bar/baz" dir_path = self.pathlib.Path(dir_path_string) self.filesystem.create_dir(dir_path) self.assertTrue(self.os.path.exists(dir_path_string)) self.assertEqual( stat.S_IFDIR, self.os.stat(dir_path_string).st_mode & stat.S_IFDIR ) def test_create_file_with_pathlib_path(self): file_path_string = "foo/bar/baz" file_path = self.pathlib.Path(file_path_string) self.filesystem.create_file(file_path) self.assertTrue(self.os.path.exists(file_path_string)) self.assertEqual( stat.S_IFREG, self.os.stat(file_path_string).st_mode & stat.S_IFREG ) def test_create_symlink_with_pathlib_path(self): file_path = self.pathlib.Path("foo/bar/baz") link_path_string = "foo/link" link_path = self.pathlib.Path(link_path_string) self.filesystem.create_symlink(link_path, file_path) self.assertTrue(self.os.path.lexists(link_path_string)) self.assertEqual( stat.S_IFLNK, self.os.lstat(link_path_string).st_mode & stat.S_IFLNK, ) def test_add_existing_real_file_with_pathlib_path(self): real_file_path_string = os.path.abspath(__file__) real_file_path = self.pathlib.Path(real_file_path_string) self.filesystem.add_real_file(real_file_path) fake_filepath_string = real_file_path_string.replace(os.sep, self.os.sep) self.assertTrue(self.os.path.exists(fake_filepath_string)) self.assertEqual( stat.S_IFREG, self.os.stat(fake_filepath_string).st_mode & stat.S_IFREG, ) def test_add_existing_real_directory_with_pathlib_path(self): real_dirpath_string = os.path.dirname(os.path.abspath(__file__)) real_dir_path = self.pathlib.Path(real_dirpath_string) self.filesystem.add_real_directory(real_dir_path) fake_dirpath_string = real_dirpath_string.replace(os.sep, self.os.sep) self.assertTrue(self.os.path.exists(fake_dirpath_string)) self.assertEqual( stat.S_IFDIR, self.os.stat(fake_dirpath_string).st_mode & stat.S_IFDIR, ) class FakeFilesystemChmodTest(fake_filesystem_unittest.TestCase): def setUp(self) -> None: self.setUpPyfakefs() @unittest.skipIf(sys.platform != "win32", "Windows specific test") def test_is_file_for_unreadable_dir_windows(self): self.fs.os = OSType.WINDOWS if is_root(): self.skipTest("Test only valid for non-root user") path = pathlib.Path("/foo/bar") self.fs.create_file(path) # normal chmod does not really set the mode to 0 self.fs.chmod("/foo", 0o000) self.assertTrue(path.is_file()) # but it does in forced UNIX mode self.fs.chmod("/foo", 0o000, force_unix_mode=True) with self.assertRaises(PermissionError): path.is_file() class FakePathlibModulePurePathTest(fake_filesystem_unittest.TestCase): def test_windows_pure_path_parsing_backslash(self): path = r"C:\Windows\cmd.exe" pure_result = pathlib.PureWindowsPath(path).stem self.assertEqual("cmd", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, fake_pathlib.FakePathlibModule.PureWindowsPath(path).stem ) self.assertEqual(pure_result, pathlib.PureWindowsPath(path).stem) def test_windows_pure_path_parsing_forward_slash(self): path = r"C:/Windows/cmd.exe" pure_result = pathlib.PureWindowsPath(path).stem self.assertEqual("cmd", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, fake_pathlib.FakePathlibModule.PureWindowsPath(path).stem ) self.assertEqual(pure_result, pathlib.PureWindowsPath(path).stem) def test_posix_pure_path_parsing(self): path = r"/bin/bash" pure_result = pathlib.PurePosixPath(path).stem self.assertEqual("bash", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, fake_pathlib.FakePathlibModule.PurePosixPath(path).stem ) self.assertEqual(pathlib.PurePosixPath(path).stem, pure_result) def test_windows_pure_path_str_backslash(self): path = r"C:\Windows\cmd.exe" pure_result = str(pathlib.PureWindowsPath(path)) self.assertEqual(r"C:\Windows\cmd.exe", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, str(fake_pathlib.FakePathlibModule.PureWindowsPath(path)) ) self.assertEqual(str(pathlib.PureWindowsPath(path)), pure_result) def test_windows_pure_path_str_forward_slash(self): path = "C:/Windows/cmd.exe" pure_result_win = str(pathlib.PureWindowsPath(path)) self.assertEqual(r"C:\Windows\cmd.exe", pure_result_win) pure_result_posix_stem = str(pathlib.PurePosixPath(path).stem) self.assertEqual("cmd", pure_result_posix_stem) self.setUpPyfakefs() self.assertEqual( pure_result_win, str(fake_pathlib.FakePathlibModule.PureWindowsPath(path)) ) self.assertEqual(pure_result_win, str(pathlib.PureWindowsPath(path))) self.assertEqual(pure_result_posix_stem, pathlib.PurePosixPath(path).stem) def test_posix_pure_path_str_backslash(self): path = r"\bin\bash" pure_result = str(pathlib.PurePosixPath(path)) self.assertEqual(r"\bin\bash", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, str(fake_pathlib.FakePathlibModule.PurePosixPath(path)) ) self.assertEqual(pure_result, str(pathlib.PurePosixPath(path))) def test_posix_pure_path_str_forward_slash(self): path = "/bin/bash" pure_result = str(pathlib.PurePosixPath(path)) self.assertEqual(r"/bin/bash", pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, str(fake_pathlib.FakePathlibModule.PurePosixPath(path)) ) self.assertEqual(pure_result, str(pathlib.PurePosixPath(path))) def check_posix_pure_path_is_absolute(self, path, expected_result): pure_result = pathlib.PurePosixPath(path).is_absolute() self.assertEqual(expected_result, pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, fake_pathlib.FakePathlibModule.PurePosixPath(path).is_absolute(), ) self.assertEqual(pure_result, pathlib.PurePosixPath(path).is_absolute()) def test_posix_pure_path_is_absolute_for_absolute_path(self): self.check_posix_pure_path_is_absolute("/bin/bash", expected_result=True) def test_posix_pure_path_is_absolute_for_local_path(self): self.check_posix_pure_path_is_absolute("bin/bash", expected_result=False) def test_posix_pure_path_is_absolute_for_relative_path(self): self.check_posix_pure_path_is_absolute("../bin/bash", expected_result=False) def check_windows_pure_path_is_absolute(self, path, expected_result): pure_result = pathlib.PureWindowsPath(path).is_absolute() self.assertEqual(expected_result, pure_result) self.setUpPyfakefs() self.assertEqual( pure_result, fake_pathlib.FakePathlibModule.PureWindowsPath(path).is_absolute(), ) self.assertEqual(pure_result, pathlib.PureWindowsPath(path).is_absolute()) def test_windows_pure_path_is_absolute_for_absolute_path(self): self.check_windows_pure_path_is_absolute("C:/Windows/cmd.exe", True) def test_windows_pure_path_is_absolute_for_local_path(self): self.check_windows_pure_path_is_absolute("./cmd.exe", expected_result=False) def test_windows_pure_path_is_absolute_for_relative_path(self): self.check_windows_pure_path_is_absolute("../cmd.exe", expected_result=False) class FakePathlibModulePurePathTestWindows(FakePathlibModulePurePathTest): def setUpPyfakefs(self, kwargs): super().setUpPyfakefs(kwargs) self.fs.os = OSType.WINDOWS class FakePathlibModulePurePathTestMacos(FakePathlibModulePurePathTest): def setUpPyfakefs(self, kwargs): super().setUpPyfakefs(kwargs) self.fs.os = OSType.MACOS class FakePathlibModulePurePathTestLinux(FakePathlibModulePurePathTest): def setUpPyfakefs(self, kwargs): super().setUpPyfakefs(kwargs) self.fs.os = OSType.LINUX class SkipPathlibTest(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs(additional_skip_names=["skipped_pathlib"]) def test_open_in_skipped_module(self): # regression test for #1012 contents = read_pathlib("skipped_pathlib.py") self.assertTrue(contents.startswith("# Licensed under the Apache License")) def test_read_text_in_skipped_module(self): # regression test for #1012 contents = read_text_pathlib("skipped_pathlib.py") self.assertTrue(contents.startswith("# Licensed under the Apache License")) def test_read_bytes_in_skipped_module(self): # regression test for #1012 contents = read_bytes_pathlib("skipped_pathlib.py") self.assertTrue(contents.startswith(b"# Licensed under the Apache License")) @unittest.skipIf( IS_PYPY and sys.version_info < (3, 8), "Ignoring error in outdated version" ) def test_exists(self): self.assertTrue(check_exists_pathlib()) class InstantiatedPathlibTest(unittest.TestCase): def test_instantiated_pathlib(self): fake_fs = FakeFilesystem() fake_pathlib_module = FakePathlibModule(fake_fs) top_level_dirs = list(fake_pathlib_module.Path("/").iterdir()) self.assertEqual(0, len(top_level_dirs)) if __name__ == "__main__": unittest.main(verbosity=2)	70.21 KB	2026-01-20 12:58
📄 fake_stat_time_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unit tests for file timestamp updates.""" import time import unittest from collections import namedtuple from pyfakefs.tests.test_utils import RealFsTestCase FileTime = namedtuple("FileTime", "st_ctime, st_atime, st_mtime") class FakeStatTestBase(RealFsTestCase): def setUp(self): super().setUp() # we disable the tests for MacOS to avoid very long builds due # to the 1s time resolution - we know that the functionality is # similar to Linux self.check_linux_and_windows() self.file_path = self.make_path("some_file") # MacOS has a timestamp resolution of 1 second self.sleep_time = 1.1 if self.is_macos else 0.01 self.mode = "" def stat_time(self, path): stat = self.os.stat(path) if self.use_real_fs(): # sleep a bit so in the next call the time has changed time.sleep(self.sleep_time) else: # calling time.time() advances mocked time time.time() return FileTime( st_ctime=stat.st_ctime, st_atime=stat.st_atime, st_mtime=stat.st_mtime, ) def assertLessExceptWindows(self, time1, time2): if self.is_windows_fs: self.assertLessEqual(time1, time2) else: self.assertLess(time1, time2) def assertLessExceptPosix(self, time1, time2): if self.is_windows_fs: self.assertLess(time1, time2) else: self.assertEqual(time1, time2) def open_close_new_file(self): with self.mock_time(): with self.open(self.file_path, self.mode, encoding="utf8"): created = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return created, closed def open_write_close_new_file(self): with self.mock_time(): with self.open(self.file_path, self.mode, encoding="utf8") as f: created = self.stat_time(self.file_path) f.write("foo") written = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return created, written, closed def open_close(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, self.mode, encoding="utf8"): opened = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, closed def open_write_close(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, self.mode, encoding="utf8") as f: opened = self.stat_time(self.file_path) f.write("foo") written = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, written, closed def open_flush_close(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, self.mode, encoding="utf8") as f: opened = self.stat_time(self.file_path) f.flush() flushed = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, flushed, closed def open_write_flush(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, self.mode, encoding="utf8") as f: opened = self.stat_time(self.file_path) f.write("foo") written = self.stat_time(self.file_path) f.flush() flushed = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, written, flushed, closed def open_read_flush(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, "r", encoding="utf8") as f: opened = self.stat_time(self.file_path) f.read() read = self.stat_time(self.file_path) f.flush() flushed = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, read, flushed, closed def open_read_close_new_file(self): with self.mock_time(): with self.open(self.file_path, self.mode, encoding="utf8") as f: created = self.stat_time(self.file_path) f.read() read = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return created, read, closed def open_read_close(self): with self.mock_time(): self.create_file(self.file_path) before = self.stat_time(self.file_path) with self.open(self.file_path, self.mode, encoding="utf8") as f: opened = self.stat_time(self.file_path) f.read() read = self.stat_time(self.file_path) closed = self.stat_time(self.file_path) return before, opened, read, closed def check_open_close_new_file(self): """ When a file is created on opening and closed again, no timestamps are updated on close. """ created, closed = self.open_close_new_file() self.assertEqual(created.st_ctime, closed.st_ctime) self.assertEqual(created.st_atime, closed.st_atime) self.assertEqual(created.st_mtime, closed.st_mtime) def check_open_write_close_new_file(self): """ When a file is created on opening, st_ctime is updated under Posix, and st_mtime is updated on close. """ created, written, closed = self.open_write_close_new_file() self.assertEqual(created.st_ctime, written.st_ctime) self.assertLessExceptWindows(written.st_ctime, closed.st_ctime) self.assertEqual(created.st_atime, written.st_atime) self.assertLessEqual(written.st_atime, closed.st_atime) self.assertEqual(created.st_mtime, written.st_mtime) self.assertLess(written.st_mtime, closed.st_mtime) def check_open_close_w_mode(self): """ When an existing file is opened with 'w' or 'w+' mode, st_ctime (Posix only) and st_mtime are updated on open (truncating), but not on close. """ before, opened, closed = self.open_close() self.assertLessExceptWindows(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, closed.st_ctime) self.assertLessEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, closed.st_atime) self.assertLess(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, closed.st_mtime) def check_open_close_non_w_mode(self): """ When an existing file is opened with any mode other than 'w' or 'w+', no timestamps are updated. """ before, opened, closed = self.open_close() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, closed.st_mtime) def check_open_write_close_w_mode(self): """ When an existing file is opened with 'w' or 'w+' mode and is then written to, st_ctime (Posix only) and st_mtime are updated on open (truncating) and again on close (flush), but not when written to. """ before, opened, written, closed = self.open_write_close() self.assertLessExceptWindows(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, written.st_ctime) self.assertLessExceptWindows(written.st_ctime, closed.st_ctime) self.assertLessEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, written.st_atime) self.assertLessEqual(written.st_atime, closed.st_atime) self.assertLess(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, written.st_mtime) self.assertLess(written.st_mtime, closed.st_mtime) def check_open_flush_close_w_mode(self): """ When an existing file is opened with 'w' or 'w+' mode (truncating), st_ctime (Posix only) and st_mtime are updated. No updates are done on flush or close. """ before, opened, flushed, closed = self.open_flush_close() self.assertLessExceptWindows(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, flushed.st_ctime) self.assertEqual(flushed.st_ctime, closed.st_ctime) self.assertLessEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, flushed.st_atime) self.assertEqual(flushed.st_atime, closed.st_atime) self.assertLess(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, flushed.st_mtime) self.assertEqual(flushed.st_mtime, closed.st_mtime) def check_open_flush_close_non_w_mode(self): """ When an existing file is opened with any mode other than 'w' or 'w+', flushed and closed, no timestamps are updated. """ before, opened, flushed, closed = self.open_flush_close() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, flushed.st_ctime) self.assertEqual(flushed.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, flushed.st_atime) self.assertEqual(flushed.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, flushed.st_mtime) self.assertEqual(flushed.st_mtime, closed.st_mtime) def check_open_read_close_non_w_mode(self): """ Reading from a file opened with 'r', 'r+', or 'a+' mode updates st_atime under Posix. """ before, opened, read, closed = self.open_read_close() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, read.st_ctime) self.assertEqual(read.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertLessEqual(opened.st_atime, read.st_atime) self.assertEqual(read.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, read.st_mtime) self.assertEqual(read.st_mtime, closed.st_mtime) def check_open_read_close_new_file(self): """ When a file is created with 'w+' or 'a+' mode and then read from, st_atime is updated under Posix. """ created, read, closed = self.open_read_close_new_file() self.assertEqual(created.st_ctime, read.st_ctime) self.assertEqual(read.st_ctime, closed.st_ctime) self.assertLessEqual(created.st_atime, read.st_atime) self.assertEqual(read.st_atime, closed.st_atime) self.assertEqual(created.st_mtime, read.st_mtime) self.assertEqual(read.st_mtime, closed.st_mtime) def check_open_write_close_non_w_mode(self): """ When an existing file is opened with 'a', 'a+' or 'r+' mode and is then written to, st_ctime (Posix only) and st_mtime are updated close (flush), but not on opening or when written to. """ before, opened, written, closed = self.open_write_close() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, written.st_ctime) self.assertLessExceptWindows(written.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, written.st_atime) self.assertLessEqual(written.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, written.st_mtime) self.assertLess(written.st_mtime, closed.st_mtime) def check_open_write_flush_close_w_mode(self): """ When an existing file is opened with 'w' or 'w+' mode and is then written to, st_ctime (Posix only) and st_mtime are updated on open (truncating). Under Posix, st_mtime is updated on flush, under Windows, on close instead. """ before, opened, written, flushed, closed = self.open_write_flush() self.assertLessEqual(before.st_ctime, opened.st_ctime) self.assertLessEqual(written.st_ctime, flushed.st_ctime) self.assertEqual(opened.st_ctime, written.st_ctime) self.assertEqual(flushed.st_ctime, closed.st_ctime) self.assertLessEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, written.st_atime) self.assertLessEqual(written.st_atime, flushed.st_atime) self.assertLessEqual(flushed.st_atime, closed.st_atime) self.assertLess(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, written.st_mtime) self.assertLessExceptWindows(written.st_mtime, flushed.st_mtime) self.assertLessEqual(flushed.st_mtime, closed.st_mtime) def check_open_write_flush_close_non_w_mode(self): """ When an existing file is opened with 'a', 'a+' or 'r+' mode and is then written to, st_ctime and st_mtime are updated on flush under Posix. Under Windows, only st_mtime is updated on close instead. """ before, opened, written, flushed, closed = self.open_write_flush() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, written.st_ctime) self.assertLessExceptWindows(written.st_ctime, flushed.st_ctime) self.assertEqual(flushed.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertEqual(opened.st_atime, written.st_atime) self.assertLessEqual(written.st_atime, flushed.st_atime) self.assertLessEqual(flushed.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, written.st_mtime) self.assertLessExceptWindows(written.st_mtime, flushed.st_mtime) self.assertLessEqual(flushed.st_mtime, closed.st_mtime) class TestFakeModeW(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "w" def test_open_close_new_file(self): self.check_open_close_new_file() def test_open_write_close_new_file(self): self.check_open_write_close_new_file() def test_open_close(self): self.check_open_close_w_mode() def test_open_write_close(self): self.check_open_write_close_w_mode() def test_open_flush_close(self): self.check_open_flush_close_w_mode() def test_open_write_flush_close(self): self.check_open_write_flush_close_w_mode() def test_read_raises(self): with self.open(self.file_path, "w", encoding="utf8") as f: with self.assertRaises(OSError): f.read() class TestRealModeW(TestFakeModeW): def use_real_fs(self): return True class TestFakeModeWPlus(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "w+" def test_open_close_new_file(self): self.check_open_close_new_file() def test_open_write_close_new_file(self): self.check_open_write_close_new_file() def test_open_read_close_new_file(self): self.check_open_read_close_new_file() def test_open_close(self): self.check_open_close_w_mode() def test_open_write_close(self): self.check_open_write_close_w_mode() def test_open_read_close(self): """ When an existing file is opened with 'w+' mode and is then written to, st_ctime (Posix only) and st_mtime are updated on open (truncating) and again on close (flush). Under Posix, st_atime is updated on read. """ before, opened, read, closed = self.open_read_close() self.assertLessExceptWindows(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, read.st_ctime) self.assertEqual(read.st_ctime, closed.st_ctime) self.assertLessEqual(before.st_atime, opened.st_atime) self.assertLessEqual(opened.st_atime, read.st_atime) self.assertEqual(read.st_atime, closed.st_atime) self.assertLess(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, read.st_mtime) self.assertEqual(read.st_mtime, closed.st_mtime) def test_open_flush_close(self): self.check_open_flush_close_w_mode() def test_open_write_flush_close(self): self.check_open_write_flush_close_w_mode() class TestRealModeWPlus(TestFakeModeWPlus): def use_real_fs(self): return True class TestFakeModeA(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "a" def test_open_close_new_file(self): self.check_open_close_new_file() def test_open_write_close_new_file(self): self.check_open_write_close_new_file() def test_open_close(self): self.check_open_close_non_w_mode() def test_open_write_close(self): self.check_open_write_close_non_w_mode() def test_open_flush_close(self): self.check_open_flush_close_non_w_mode() def test_open_write_flush_close(self): self.check_open_write_flush_close_non_w_mode() def test_read_raises(self): with self.open(self.file_path, "a", encoding="utf8") as f: with self.assertRaises(OSError): f.read() class TestRealModeA(TestFakeModeA): def use_real_fs(self): return True class TestFakeModeAPlus(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "a+" def test_open_close_new_file(self): self.check_open_close_new_file() def test_open_write_close_new_file(self): self.check_open_write_close_new_file() def test_open_read_close_new_file(self): self.check_open_read_close_new_file() def test_open_close(self): self.check_open_close_non_w_mode() def test_open_write_close(self): self.check_open_write_close_non_w_mode() def test_open_read_close(self): self.check_open_read_close_non_w_mode() def test_open_flush_close(self): self.check_open_flush_close_non_w_mode() def test_open_write_flush_close(self): self.check_open_write_flush_close_non_w_mode() class TestRealModeAPlus(TestFakeModeAPlus): def use_real_fs(self): return True class TestFakeModeR(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "r" def test_open_close(self): self.check_open_close_non_w_mode() def test_open_read_close(self): self.check_open_read_close_non_w_mode() def test_open_flush_close(self): self.check_open_flush_close_non_w_mode() def test_open_read_flush_close(self): """ When an existing file is opened with 'r' mode, read, flushed and closed, st_atime is updated after reading under Posix. """ before, opened, read, flushed, closed = self.open_read_flush() self.assertEqual(before.st_ctime, opened.st_ctime) self.assertEqual(opened.st_ctime, read.st_ctime) self.assertEqual(read.st_ctime, flushed.st_ctime) self.assertEqual(flushed.st_ctime, closed.st_ctime) self.assertEqual(before.st_atime, opened.st_atime) self.assertLessEqual(opened.st_atime, read.st_atime) self.assertEqual(read.st_atime, flushed.st_atime) self.assertEqual(flushed.st_atime, closed.st_atime) self.assertEqual(before.st_mtime, opened.st_mtime) self.assertEqual(opened.st_mtime, read.st_mtime) self.assertEqual(read.st_mtime, flushed.st_mtime) self.assertEqual(flushed.st_mtime, closed.st_mtime) def test_open_not_existing_raises(self): with self.assertRaises(OSError): with self.open(self.file_path, "r"): pass class TestRealModeR(TestFakeModeR): def use_real_fs(self): return True class TestFakeModeRPlus(FakeStatTestBase): def setUp(self): super().setUp() self.mode = "r+" def test_open_close(self): self.check_open_close_non_w_mode() def test_open_write_close(self): self.check_open_write_close_non_w_mode() def test_open_read_close(self): self.check_open_read_close_non_w_mode() def test_open_flush_close(self): self.check_open_flush_close_non_w_mode() def test_open_write_flush_close(self): self.check_open_write_flush_close_non_w_mode() def test_open_not_existing_raises(self): with self.assertRaises(OSError): with self.open(self.file_path, "r+"): pass class TestRealModeRPlus(TestFakeModeRPlus): def use_real_fs(self): return True if __name__ == "__main__": unittest.main()	21.83 KB	2026-01-20 12:58
📄 fake_tempfile_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests that ensure that the `tempfile` module works with `fake_filesystem` if using `Patcher` (via `fake_filesystem_unittest`). """ import os import stat import tempfile import unittest from pyfakefs import fake_filesystem_unittest class FakeTempfileModuleTest(fake_filesystem_unittest.TestCase): """Test the 'tempfile' module with the fake file system.""" def setUp(self): self.setUpPyfakefs() def test_named_temporary_file(self): obj = tempfile.NamedTemporaryFile() self.assertTrue(self.fs.get_object(obj.name)) obj.close() with self.assertRaises(OSError): self.fs.get_object(obj.name) def test_named_temporary_file_no_delete(self): obj = tempfile.NamedTemporaryFile(delete=False) obj.write(b"foo") obj.close() file_obj = self.fs.get_object(obj.name) contents = file_obj.contents self.assertEqual("foo", contents) obj = tempfile.NamedTemporaryFile(mode="w", encoding="utf8", delete=False) obj.write("foo") obj.close() file_obj = self.fs.get_object(obj.name) self.assertEqual("foo", file_obj.contents) def test_mkstemp(self): next_fd = len(self.fs.open_files) temporary = tempfile.mkstemp() self.assertEqual(2, len(temporary)) self.assertTrue( temporary[1].startswith(os.path.join(tempfile.gettempdir(), "tmp")) ) self.assertEqual(next_fd, temporary[0]) self.assertTrue(self.fs.exists(temporary[1])) mode = 0o666 if self.fs.is_windows_fs else 0o600 self.assertEqual(self.fs.get_object(temporary[1]).st_mode, stat.S_IFREG \| mode) fh = os.fdopen(temporary[0], "w+b") self.assertEqual(temporary[0], fh.fileno()) def test_mkstemp_dir(self): """test tempfile.mkstemp(dir=).""" # expect fail: /dir does not exist with self.assertRaises(OSError): tempfile.mkstemp(dir="/dir") # expect pass: /dir exists self.fs.create_dir("/dir") next_fd = len(self.fs.open_files) temporary = tempfile.mkstemp(dir="/dir") self.assertEqual(2, len(temporary)) self.assertEqual(next_fd, temporary[0]) self.assertTrue( temporary[1].startswith(os.path.join(self.fs.root_dir_name, "dir", "tmp")) ) self.assertTrue(self.fs.exists(temporary[1])) mode = 0o666 if self.fs.is_windows_fs else 0o600 self.assertEqual(self.fs.get_object(temporary[1]).st_mode, stat.S_IFREG \| mode) def test_mkdtemp(self): dirname = tempfile.mkdtemp() self.assertTrue(dirname) self.assertTrue(self.fs.exists(dirname)) self.assertEqual(self.fs.get_object(dirname).st_mode, stat.S_IFDIR \| 0o700) def test_temporary_directory(self): with tempfile.TemporaryDirectory() as tmpdir: self.assertTrue(tmpdir) self.assertTrue(self.fs.exists(tmpdir)) self.assertEqual(self.fs.get_object(tmpdir).st_mode, stat.S_IFDIR \| 0o700) def test_temporary_file(self): with tempfile.TemporaryFile() as f: f.write(b"test") f.seek(0) self.assertEqual(b"test", f.read()) def test_temporay_file_with_dir(self): with self.assertRaises(FileNotFoundError): tempfile.TemporaryFile(dir="/parent") os.mkdir("/parent") with tempfile.TemporaryFile() as f: f.write(b"test") f.seek(0) self.assertEqual(b"test", f.read()) if __name__ == "__main__": unittest.main()	4.1 KB	2026-01-20 12:58
📁 fixtures	-	2026-03-21 15:45
📄 import_as_example.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Example module that is used for testing modules that import file system modules to be patched under another name. """ import os as my_os import pathlib import sys from builtins import open as bltn_open from io import open as io_open from os import path from os import stat from os import stat as my_stat from os.path import exists, isfile, isdir, islink from os.path import exists as my_exists from pathlib import Path def check_if_exists1(filepath): # test patching module imported under other name return my_os.path.exists(filepath) def check_if_exists2(filepath): # tests patching path imported from os return path.exists(filepath) def check_if_exists3(filepath): # tests patching Path imported from pathlib return Path(filepath).exists() def check_if_exists4(filepath, file_exists=my_os.path.exists): return file_exists(filepath) def check_if_exists5(filepath): # tests patching `exists` imported from os.path return exists(filepath) def check_if_exists6(filepath): # tests patching `exists` imported from os.path as other name return my_exists(filepath) def check_if_exists7(filepath): # tests patching pathlib return pathlib.Path(filepath).exists() def check_if_isfile(filepath): # tests patching `isfile` imported from os.path return isfile(filepath) def check_if_isdir(filepath): # tests patching `isdir` imported from os.path return isdir(filepath) def check_if_islink(filepath): # tests patching `islink` imported from os.path return islink(filepath) def file_stat1(filepath): # tests patching `stat` imported from os return stat(filepath) def file_stat2(filepath): # tests patching `stat` imported from os as other name return my_stat(filepath) def system_stat(filepath): if sys.platform == "win32": from nt import stat as system_stat else: from posix import stat as system_stat return system_stat(filepath) def file_contents1(filepath): with bltn_open(filepath, encoding="utf8") as f: return f.read() def file_contents2(filepath): with io_open(filepath, encoding="utf8") as f: return f.read() def exists_this_file(): """Returns True in real fs only""" return exists(__file__) def open_this_file(): """Works only in real fs""" with open(__file__, encoding="utf8"): pass def return_this_file_path(): """Works only in real fs""" return Path(__file__) class TestDefaultArg: def check_if_exists(self, filepath, file_exists=my_os.path.exists): # this is a similar case as in the tempfile implementation under Posix return file_exists(filepath)	3.16 KB	2026-01-20 12:58
📄 logsio.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Example module that is used for a regression test where a module with a name ending with "io" was skipped from patching (see #569). """ def file_contents(path): """Return the contents of the given path as byte array.""" with open(path, "rb") as f: return f.read()	832 B	2026-01-20 12:58
📄 mox3_stubout_example.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Example module that is used for testing the functionality of :py:class`pyfakefs.mox_stubout.StubOutForTesting`. """ import datetime import math import os def check_if_exists(filepath): return os.path.exists(filepath) def fabs(x): return math.fabs(x) def tomorrow(): return datetime.date.today() + datetime.timedelta(days=1)	893 B	2026-01-20 12:58
📄 mox3_stubout_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unit tests for mox3_stubout.""" import datetime import math import os import unittest from os import path from pyfakefs import mox3_stubout from pyfakefs.tests import mox3_stubout_example class NoPanicMath: real_math = math @staticmethod def fabs(_x): return 42 def __getattr__(self, name): """Forwards any unfaked calls to the standard module.""" return getattr(self.real_math, name) class ExistingPath: real_path = path @staticmethod def exists(_path): return True def __getattr__(self, name): """Forwards any unfaked calls to the standard module.""" return getattr(self.real_path, name) class GroundhogDate(datetime.date): @classmethod def today(cls): return datetime.date(1993, 2, 2) class StubOutForTestingTest(unittest.TestCase): def setUp(self): super().setUp() self.stubber = mox3_stubout.StubOutForTesting() def test_stubout_method_with_set(self): non_existing_path = "non_existing_path" self.assertFalse(mox3_stubout_example.check_if_exists(non_existing_path)) self.stubber.set(os.path, "exists", lambda x: True) self.assertTrue(mox3_stubout_example.check_if_exists(non_existing_path)) self.stubber.unset_all() self.assertFalse(mox3_stubout_example.check_if_exists(non_existing_path)) def test_stubout_class_with_set(self): self.assertGreater(mox3_stubout_example.tomorrow().year, 2000) self.stubber.set(datetime, "date", GroundhogDate) self.assertEqual(mox3_stubout_example.tomorrow(), datetime.date(1993, 2, 3)) self.stubber.unset_all() self.assertGreater(mox3_stubout_example.tomorrow().year, 2000) def test_stubout_module_with_set(self): self.assertEqual(10, mox3_stubout_example.fabs(-10)) self.stubber.set(mox3_stubout_example, "math", NoPanicMath) self.assertEqual(42, mox3_stubout_example.fabs(-10)) self.stubber.unset_all() self.assertEqual(10, mox3_stubout_example.fabs(-10)) def test_set_raise_if_unknown_attribute(self): self.assertRaises( AttributeError, self.stubber.set, os.path, "exists_not", lambda x: True, ) self.assertRaises( AttributeError, self.stubber.set, datetime, "tomorrow", GroundhogDate, ) self.assertRaises( AttributeError, self.stubber.set, mox3_stubout_example, "math1", NoPanicMath, ) def test_stubout_method_with_smart_set(self): non_existing_path = "non_existing_path" self.stubber.smart_set(os.path, "exists", lambda x: True) self.assertTrue(mox3_stubout_example.check_if_exists(non_existing_path)) self.stubber.smart_unset_all() self.assertFalse(mox3_stubout_example.check_if_exists(non_existing_path)) def test_stubout_class_with_smart_set(self): self.stubber.smart_set(datetime, "date", GroundhogDate) self.assertEqual(mox3_stubout_example.tomorrow(), datetime.date(1993, 2, 3)) self.stubber.smart_unset_all() self.assertGreater(mox3_stubout_example.tomorrow().year, 2000) def test_stubout_module_with_smart_set(self): self.assertEqual(10, mox3_stubout_example.fabs(-10)) self.stubber.smart_set(mox3_stubout_example, "math", NoPanicMath) self.assertEqual(42, mox3_stubout_example.fabs(-10)) self.stubber.smart_unset_all() self.assertEqual(10, mox3_stubout_example.fabs(-10)) def test_stubout_submodule_with_smart_set(self): # this one does not work with Set non_existing_path = "non_existing_path" self.assertFalse(mox3_stubout_example.check_if_exists(non_existing_path)) self.stubber.smart_set(os, "path", ExistingPath) self.assertTrue(mox3_stubout_example.check_if_exists(non_existing_path)) self.stubber.smart_unset_all() self.assertFalse(mox3_stubout_example.check_if_exists(non_existing_path)) def test_smart_set_raise_if_unknown_attribute(self): self.assertRaises( AttributeError, self.stubber.smart_set, os.path, "exists_not", lambda x: True, ) self.assertRaises( AttributeError, self.stubber.smart_set, datetime, "tomorrow", GroundhogDate, ) self.assertRaises( AttributeError, self.stubber.smart_set, mox3_stubout_example, "math1", NoPanicMath, ) if __name__ == "__main__": unittest.main()	5.21 KB	2026-01-20 12:58
📄 patched_packages_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Provides patches for some commonly used modules that enable them to work with pyfakefs. """ import os import sys import unittest from pyfakefs import fake_filesystem_unittest from pyfakefs.helpers import IS_PYPY try: import pandas as pd except ImportError: pd = None try: import xlrd except ImportError: xlrd = None try: import openpyxl except ImportError: openpyxl = None @unittest.skipIf( IS_PYPY and sys.version_info < (3, 8), "Has a problem with older PyPy versions" ) class TestPatchedPackages(fake_filesystem_unittest.TestCase): def setUp(self): self.setUpPyfakefs() if pd is not None: def test_read_csv(self): path = "/foo/bar.csv" self.fs.create_file(path, contents="1,2,3,4") df = pd.read_csv(path) assert (df.columns == ["1", "2", "3", "4"]).all() def test_read_table(self): path = "/foo/bar.csv" self.fs.create_file(path, contents="1\|2\|3\|4") df = pd.read_table(path, delimiter="\|") assert (df.columns == ["1", "2", "3", "4"]).all() if pd is not None and xlrd is not None: def test_read_excel(self): path = "/foo/bar.xlsx" src_path = os.path.dirname(os.path.abspath(__file__)) src_path = os.path.join(src_path, "fixtures", "excel_test.xlsx") # map the file into another location to be sure that # the real fs is not used self.fs.add_real_file(src_path, target_path=path) df = pd.read_excel(path) assert (df.columns == [1, 2, 3, 4]).all() if pd is not None and openpyxl is not None: def test_write_excel(self): self.fs.create_dir("/foo") path = "/foo/bar.xlsx" df = pd.DataFrame([[0, 1, 2, 3]]) with pd.ExcelWriter(path) as writer: df.to_excel(writer) df = pd.read_excel(path) assert (df.columns == ["Unnamed: 0", 0, 1, 2, 3]).all()	2.51 KB	2026-01-20 12:58
📄 performance_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Shall provide tests to check performance overhead of pyfakefs.""" import os import time import unittest from pyfakefs.fake_filesystem_unittest import TestCase from pyfakefs.helpers import IS_PYPY if os.environ.get("TEST_PERFORMANCE"): class SetupPerformanceTest(TestCase): @classmethod def setUpClass(cls) -> None: cls.start_time = time.time() @classmethod def tearDownClass(cls) -> None: cls.elapsed_time = time.time() - cls.start_time print( "Elapsed time per test for cached setup: {:.3f} ms".format( cls.elapsed_time * 10 ) ) def setUp(self) -> None: self.setUpPyfakefs() class SetupNoCachePerformanceTest(TestCase): @classmethod def setUpClass(cls) -> None: cls.start_time = time.time() @classmethod def tearDownClass(cls) -> None: cls.elapsed_time = time.time() - cls.start_time print( "Elapsed time per test for uncached setup: {:.3f} ms".format( cls.elapsed_time * 10 ) ) def setUp(self) -> None: self.setUpPyfakefs(use_cache=False) @unittest.skipIf(IS_PYPY, "PyPy times are not comparable") class TimePerformanceTest(TestCase): """Make sure performance degradation in setup is noticed. The numbers are related to the CI builds and may fail in local builds. """ def test_cached_time(self): self.assertLess(SetupPerformanceTest.elapsed_time, 0.18) def test_uncached_time(self): self.assertLess(SetupNoCachePerformanceTest.elapsed_time, 4) def test_setup(self): pass for n in range(100): test_name = "test_" + str(n) setattr(SetupPerformanceTest, test_name, test_setup) test_name = "test_nocache" + str(n) setattr(SetupNoCachePerformanceTest, test_name, test_setup) if __name__ == "__main__": unittest.main()	2.56 KB	2026-01-20 12:58
📄 skipped_pathlib.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Provides functions for testing additional_skip_names functionality. """ import os from pathlib import Path def read_pathlib(file_name): return (Path(__file__).parent / file_name).open("r", encoding="utf8").read() def read_text_pathlib(file_name): return (Path(__file__).parent / file_name).read_text(encoding="utf8") def read_bytes_pathlib(file_name): return (Path(__file__).parent / file_name).read_bytes() def check_exists_pathlib(): return os.path.exists(__file__) and Path(__file__).exists() def read_open(file_name): with open(os.path.join(os.path.dirname(__file__), file_name), encoding="utf8") as f: return f.read()	1.18 KB	2026-01-20 12:58
📄 test_utils.py # Copyright 2009 Google Inc. All Rights Reserved. # Copyright 2015-2017 John McGehee # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Disable attribute errors - attributes not be found in mixin (shall be cleaned up...) # pytype: disable=attribute-error """Common helper classes used in tests, or as test class base.""" import os import platform import shutil import stat import sys import tempfile import unittest from contextlib import contextmanager from unittest import mock from pyfakefs import fake_filesystem, fake_open, fake_os from pyfakefs.helpers import is_byte_string, to_string, is_root class DummyTime: """Mock replacement for time.time. Increases returned time on access.""" def __init__(self, curr_time, increment): self.current_time = curr_time self.increment = increment def __call__(self, args, kwargs): current_time = self.current_time self.current_time += self.increment return current_time class DummyMock: def start(self): pass def stop(self): pass def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): pass def time_mock(start=200, step=20): return mock.patch("pyfakefs.helpers.now", DummyTime(start, step)) class TestCase(unittest.TestCase): """Test base class with some convenience methods and attributes""" is_windows = sys.platform == "win32" is_cygwin = sys.platform == "cygwin" is_macos = sys.platform == "darwin" def assert_mode_equal(self, expected, actual): return self.assertEqual(stat.S_IMODE(expected), stat.S_IMODE(actual)) @contextmanager def raises_os_error(self, subtype): try: yield self.fail("No exception was raised, OSError expected") except OSError as exc: if isinstance(subtype, list): self.assertIn(exc.errno, subtype) else: self.assertEqual(subtype, exc.errno) def skip_if_symlink_not_supported(): """If called at test start, tests are skipped if symlinks are not supported.""" if TestCase.is_windows and not is_root(): raise unittest.SkipTest("Symlinks under Windows need admin privileges") class RealFsTestMixin: """Test mixin to allow tests to run both in the fake filesystem and in the real filesystem. To run tests in the real filesystem, a new test class can be derived from the test class testing the fake filesystem which overwrites `use_real_fs()` to return `True`. All tests in the real file system operate inside the local temp path. In order to make a test able to run in the real FS, it must not use the fake filesystem functions directly. For access to `os` and `open`, the respective attributes must be used, which point either to the native or to the fake modules. A few convenience methods allow to compose paths, create files and directories. """ def __init__(self): self.filesystem = None self.open = open self.os = os self.base_path = None def setUp(self): if not os.environ.get("TEST_REAL_FS"): self.skip_real_fs() if self.use_real_fs(): self.base_path = tempfile.mkdtemp() def tearDown(self): if self.use_real_fs(): self.os.chdir(os.path.dirname(self.base_path)) shutil.rmtree(self.base_path, ignore_errors=True) os.chdir(self.cwd) @property def is_windows_fs(self): return TestCase.is_windows def set_windows_fs(self, value): if self.filesystem is not None: self.filesystem._is_windows_fs = value if value: self.filesystem._is_macos = False self.create_basepath() @property def is_macos(self): return TestCase.is_macos @property def is_pypy(self): return platform.python_implementation() == "PyPy" def use_real_fs(self): """Return True if the real file system shall be tested.""" return False def setUpFileSystem(self): pass def path_separator(self): """Can be overwritten to use a specific separator in the fake filesystem.""" if self.use_real_fs(): return os.path.sep return "/" def check_windows_only(self): """If called at test start, the real FS test is executed only under Windows, and the fake filesystem test emulates a Windows system. """ if self.use_real_fs(): if not TestCase.is_windows: raise unittest.SkipTest("Testing Windows specific functionality") else: self.set_windows_fs(True) def check_linux_only(self): """If called at test start, the real FS test is executed only under Linux, and the fake filesystem test emulates a Linux system. """ if self.use_real_fs(): if TestCase.is_macos or TestCase.is_windows: raise unittest.SkipTest("Testing Linux specific functionality") else: self.set_windows_fs(False) self.filesystem._is_macos = False def check_macos_only(self): """If called at test start, the real FS test is executed only under MacOS, and the fake filesystem test emulates a MacOS system. """ if self.use_real_fs(): if not TestCase.is_macos: raise unittest.SkipTest("Testing MacOS specific functionality") else: self.set_windows_fs(False) self.filesystem._is_macos = True def check_linux_and_windows(self): """If called at test start, the real FS test is executed only under Linux and Windows, and the fake filesystem test emulates a Linux system under MacOS. """ if self.use_real_fs(): if TestCase.is_macos: raise unittest.SkipTest("Testing non-MacOs functionality") else: self.filesystem._is_macos = False def check_case_insensitive_fs(self): """If called at test start, the real FS test is executed only in a case-insensitive FS (e.g. Windows or MacOS), and the fake filesystem test emulates a case-insensitive FS under the running OS. """ if self.use_real_fs(): if not TestCase.is_macos and not TestCase.is_windows: raise unittest.SkipTest( "Testing case insensitive specific functionality" ) else: self.filesystem.is_case_sensitive = False def check_case_sensitive_fs(self): """If called at test start, the real FS test is executed only in a case-sensitive FS (e.g. under Linux), and the fake file system test emulates a case-sensitive FS under the running OS. """ if self.use_real_fs(): if TestCase.is_macos or TestCase.is_windows: raise unittest.SkipTest("Testing case sensitive specific functionality") else: self.filesystem.is_case_sensitive = True def check_posix_only(self): """If called at test start, the real FS test is executed only under Linux and MacOS, and the fake filesystem test emulates a Linux system under Windows. """ if self.use_real_fs(): if TestCase.is_windows: raise unittest.SkipTest("Testing Posix specific functionality") else: self.set_windows_fs(False) @staticmethod def skip_root(): """Skips the test if run as root.""" if is_root(): raise unittest.SkipTest("Test only valid for non-root user") def skip_real_fs(self): """If called at test start, no real FS test is executed.""" if self.use_real_fs(): raise unittest.SkipTest("Only tests fake FS") def skip_real_fs_failure( self, skip_windows=True, skip_posix=True, skip_macos=True, skip_linux=True, ): """If called at test start, no real FS test is executed for the given conditions. This is used to mark tests that do not pass correctly under certain systems and shall eventually be fixed. """ if True: if self.use_real_fs() and ( TestCase.is_windows and skip_windows or not TestCase.is_windows and skip_macos and skip_linux or TestCase.is_macos and skip_macos or not TestCase.is_windows and not TestCase.is_macos and skip_linux or not TestCase.is_windows and skip_posix ): raise unittest.SkipTest( "Skipping because FakeFS does not match real FS" ) def make_path(self, args): """Create a path with the given component(s). A base path is prepended to the path which represents a temporary directory in the real FS, and a fixed path in the fake filesystem. Always use to compose absolute paths for tests also running in the real FS. """ if isinstance(args[0], (list, tuple)): path = self.base_path for arg in args[0]: path = self.os.path.join(path, to_string(arg)) return path args = [to_string(arg) for arg in args] return self.os.path.join(self.base_path, args) def create_dir(self, dir_path, perm=0o777, apply_umask=True): """Create the directory at `dir_path`, including subdirectories. `dir_path` shall be composed using `make_path()`. """ if not dir_path: return existing_path = dir_path components = [] while existing_path and not self.os.path.exists(existing_path): existing_path, component = self.os.path.split(existing_path) if not component and existing_path: # existing path is a drive or UNC root if not self.os.path.exists(existing_path): self.filesystem.add_mount_point(existing_path) break components.insert(0, component) for component in components: existing_path = self.os.path.join(existing_path, component) self.os.mkdir(existing_path) self.os.chmod(existing_path, 0o777) if apply_umask: umask = self.os.umask(0o022) perm &= ~umask self.os.umask(umask) self.os.chmod(dir_path, perm) def create_file( self, file_path, contents=None, encoding=None, perm=0o666, apply_umask=True ): """Create the given file at `file_path` with optional contents, including subdirectories. `file_path` shall be composed using `make_path()`. """ self.create_dir(self.os.path.dirname(file_path)) mode = "wb" if encoding is not None or is_byte_string(contents) else "w" kwargs = {"mode": mode} if encoding is not None and contents is not None: contents = contents.encode(encoding) if mode == "w": kwargs["encoding"] = "utf8" with self.open(file_path, kwargs) as f: if contents is not None: f.write(contents) if apply_umask: umask = self.os.umask(0o022) perm &= ~umask self.os.umask(umask) self.os.chmod(file_path, perm) def create_symlink(self, link_path, target_path): """Create the path at `link_path`, and a symlink to this path at `target_path`. `link_path` shall be composed using `make_path()`. """ self.create_dir(self.os.path.dirname(link_path)) self.os.symlink(target_path, link_path) def check_contents(self, file_path, contents): """Compare `contents` with the contents of the file at `file_path`. Asserts equality. """ mode = "rb" if is_byte_string(contents) else "r" kwargs = {"mode": mode} if mode == "r": kwargs["encoding"] = "utf8" with self.open(file_path, kwargs) as f: self.assertEqual(contents, f.read()) def create_basepath(self): """Create the path used as base path in `make_path`.""" if self.filesystem is not None: old_base_path = self.base_path self.base_path = self.filesystem.path_separator + "basepath" if self.filesystem.is_windows_fs: self.base_path = "C:" + self.base_path if old_base_path != self.base_path: if old_base_path is not None: self.filesystem.reset() if not self.filesystem.exists(self.base_path): self.filesystem.create_dir(self.base_path) if old_base_path is not None: self.setUpFileSystem() def assert_equal_paths(self, actual, expected): if self.is_windows: actual = str(actual).replace("\\\\?\\", "") expected = str(expected).replace("\\\\?\\", "") if os.name == "nt" and self.use_real_fs(): # work around a problem that the user name, but not the full # path is shown as the short name self.assertEqual( self.path_with_short_username(actual), self.path_with_short_username(expected), ) else: self.assertEqual(actual, expected) elif self.is_macos: self.assertEqual( str(actual).replace("/private/var/", "/var/"), str(expected).replace("/private/var/", "/var/"), ) else: self.assertEqual(actual, expected) @staticmethod def path_with_short_username(path): components = path.split(os.sep) if len(components) >= 3: components[2] = components[2][:6].upper() + "~1" return os.sep.join(components) def mock_time(self, start=200, step=20): if not self.use_real_fs(): return time_mock(start, step) return DummyMock() def assert_raises_os_error(self, subtype, expression, args, *kwargs): """Asserts that a specific subtype of OSError is raised.""" try: expression(args, **kwargs) self.fail("No exception was raised, OSError expected") except OSError as exc: if isinstance(subtype, list): self.assertIn(exc.errno, subtype) else: self.assertEqual(subtype, exc.errno) class RealFsTestCase(TestCase, RealFsTestMixin): """Can be used as base class for tests also running in the real file system.""" def __init__(self, methodName="runTest"): TestCase.__init__(self, methodName) RealFsTestMixin.__init__(self) def setUp(self): RealFsTestMixin.setUp(self) self.cwd = os.getcwd() if not self.use_real_fs(): self.filesystem = fake_filesystem.FakeFilesystem( path_separator=self.path_separator() ) self.setup_fake_fs() self.setUpFileSystem() def setup_fake_fs(self): if not self.use_real_fs(): self.open = fake_open.FakeFileOpen(self.filesystem) self.os = fake_os.FakeOsModule(self.filesystem) self.create_basepath() def tearDown(self): RealFsTestMixin.tearDown(self) @property def is_windows_fs(self): if self.use_real_fs(): return self.is_windows return self.filesystem.is_windows_fs @property def is_macos(self): if self.use_real_fs(): return TestCase.is_macos return self.filesystem.is_macos	16.06 KB	2026-01-20 12:58

Edit File:

Terminal