← Back
Editing: 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
Save File
Cancel