| # -*- coding: utf-8 -*- |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """ |
| Unittests for fake_pathlib. |
| As most of fake_pathlib is a wrapper around fake_filesystem methods, the tests |
| are there mostly to ensure basic functionality. |
| Note that many of the tests are directly taken from examples in the |
| python docs. |
| """ |
| |
| import errno |
| import os |
| import pathlib |
| import stat |
| import sys |
| import unittest |
| |
| from pyfakefs.fake_filesystem import is_root |
| |
| from pyfakefs import fake_pathlib, fake_filesystem |
| from pyfakefs.helpers import IS_PYPY |
| from pyfakefs.tests.test_utils import RealFsTestCase |
| |
| is_windows = sys.platform == 'win32' |
| |
| |
| class RealPathlibTestCase(RealFsTestCase): |
| def __init__(self, methodName='runTest'): |
| super(RealPathlibTestCase, self).__init__(methodName) |
| self.pathlib = pathlib |
| self.path = None |
| |
| def setUp(self): |
| super().setUp() |
| if not self.use_real_fs(): |
| self.pathlib = fake_pathlib.FakePathlibModule(self.filesystem) |
| self.path = self.pathlib.Path |
| |
| |
| class FakePathlibInitializationTest(RealPathlibTestCase): |
| def test_initialization_type(self): |
| """Make sure tests for class type will work""" |
| path = self.path('/test') |
| if is_windows: |
| self.assertTrue(isinstance(path, self.pathlib.WindowsPath)) |
| self.assertTrue(isinstance(path, self.pathlib.PureWindowsPath)) |
| self.assertTrue(self.pathlib.PurePosixPath()) |
| # in fake fs, we allow to use the other OS implementation |
| if self.use_real_fs(): |
| with self.assertRaises(NotImplementedError): |
| self.pathlib.PosixPath() |
| else: |
| self.assertTrue(self.pathlib.PosixPath()) |
| else: |
| self.assertTrue(isinstance(path, self.pathlib.PosixPath)) |
| self.assertTrue(isinstance(path, self.pathlib.PurePosixPath)) |
| self.assertTrue(self.pathlib.PureWindowsPath()) |
| if self.use_real_fs(): |
| with self.assertRaises(NotImplementedError): |
| self.pathlib.WindowsPath() |
| else: |
| self.assertTrue(self.pathlib.WindowsPath()) |
| |
| def test_init_with_segments(self): |
| """Basic initialization tests - taken from pathlib.Path documentation |
| """ |
| self.assertEqual(self.path('/', 'foo', 'bar', 'baz'), |
| self.path('/foo/bar/baz')) |
| self.assertEqual(self.path(), self.path('.')) |
| self.assertEqual(self.path(self.path('foo'), self.path('bar')), |
| self.path('foo/bar')) |
| self.assertEqual(self.path('/etc') / 'init.d' / 'reboot', |
| self.path('/etc/init.d/reboot')) |
| |
| def test_init_collapse(self): |
| """Tests for collapsing path during initialization. |
| Taken from pathlib.PurePath documentation. |
| """ |
| self.assertEqual(self.path('foo//bar'), self.path('foo/bar')) |
| self.assertEqual(self.path('foo/./bar'), self.path('foo/bar')) |
| self.assertNotEqual(self.path('foo/../bar'), self.path('foo/bar')) |
| self.assertEqual(self.path('/etc', '/usr', 'lib64'), |
| self.path('/usr/lib64')) |
| |
| def test_path_parts(self): |
| sep = self.os.path.sep |
| path = self.path(sep + self.os.path.join('foo', 'bar', 'setup.py')) |
| self.assertEqual(path.parts, (sep, 'foo', 'bar', 'setup.py')) |
| self.assertEqual(path.drive, '') |
| self.assertEqual(path.root, sep) |
| self.assertEqual(path.anchor, sep) |
| self.assertEqual(path.name, 'setup.py') |
| self.assertEqual(path.stem, 'setup') |
| self.assertEqual(path.suffix, '.py') |
| self.assertEqual(path.parent, |
| self.path(sep + self.os.path.join('foo', 'bar'))) |
| self.assertEqual(path.parents[0], |
| self.path(sep + self.os.path.join('foo', 'bar'))) |
| self.assertEqual(path.parents[1], self.path(sep + 'foo')) |
| self.assertEqual(path.parents[2], self.path(sep)) |
| |
| @unittest.skipIf(is_windows, 'POSIX specific behavior') |
| def test_is_absolute_posix(self): |
| self.assertTrue(self.path('/a/b').is_absolute()) |
| self.assertFalse(self.path('a/b').is_absolute()) |
| self.assertFalse(self.path('d:/b').is_absolute()) |
| |
| @unittest.skipIf(not is_windows, 'Windows specific behavior') |
| def test_is_absolute_windows(self): |
| self.assertFalse(self.path('/a/b').is_absolute()) |
| self.assertFalse(self.path('a/b').is_absolute()) |
| self.assertTrue(self.path('d:/b').is_absolute()) |
| |
| |
| class RealPathlibInitializationTest(FakePathlibInitializationTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| @unittest.skipIf(not is_windows, 'Windows specific behavior') |
| class FakePathlibInitializationWithDriveTest(RealPathlibTestCase): |
| def test_init_with_segments(self): |
| """Basic initialization tests - taken from pathlib.Path |
| documentation""" |
| self.assertEqual(self.path('c:/', 'foo', 'bar', 'baz'), |
| self.path('c:/foo/bar/baz')) |
| self.assertEqual(self.path(), self.path('.')) |
| self.assertEqual(self.path(self.path('foo'), self.path('bar')), |
| self.path('foo/bar')) |
| self.assertEqual(self.path('c:/Users') / 'john' / 'data', |
| self.path('c:/Users/john/data')) |
| |
| def test_init_collapse(self): |
| """Tests for collapsing path during initialization. |
| Taken from pathlib.PurePath documentation. |
| """ |
| self.assertEqual(self.path('c:/Windows', 'd:bar'), |
| self.path('d:bar')) |
| self.assertEqual(self.path('c:/Windows', '/Program Files'), |
| self.path('c:/Program Files')) |
| |
| def test_path_parts(self): |
| path = self.path( |
| self.os.path.join('d:', 'python scripts', 'setup.py')) |
| self.assertEqual(path.parts, ('d:', 'python scripts', 'setup.py')) |
| self.assertEqual(path.drive, 'd:') |
| self.assertEqual(path.root, '') |
| self.assertEqual(path.anchor, 'd:') |
| self.assertEqual(path.name, 'setup.py') |
| self.assertEqual(path.stem, 'setup') |
| self.assertEqual(path.suffix, '.py') |
| self.assertEqual(path.parent, |
| self.path( |
| self.os.path.join('d:', 'python scripts'))) |
| self.assertEqual(path.parents[0], |
| self.path( |
| self.os.path.join('d:', 'python scripts'))) |
| self.assertEqual(path.parents[1], self.path('d:')) |
| |
| @unittest.skipIf(not is_windows, 'Windows-specifc behavior') |
| def test_is_absolute(self): |
| self.assertTrue(self.path('c:/a/b').is_absolute()) |
| self.assertFalse(self.path('/a/b').is_absolute()) |
| self.assertFalse(self.path('c:').is_absolute()) |
| self.assertTrue(self.path('//some/share').is_absolute()) |
| |
| |
| class RealPathlibInitializationWithDriveTest( |
| FakePathlibInitializationWithDriveTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| class FakePathlibPurePathTest(RealPathlibTestCase): |
| """Tests functionality present in PurePath class.""" |
| |
| @unittest.skipIf(is_windows, 'POSIX specific behavior') |
| def test_is_reserved_posix(self): |
| self.assertFalse(self.path('/dev').is_reserved()) |
| self.assertFalse(self.path('/').is_reserved()) |
| self.assertFalse(self.path('COM1').is_reserved()) |
| self.assertFalse(self.path('nul.txt').is_reserved()) |
| |
| @unittest.skipIf(not is_windows, 'Windows specific behavior') |
| def test_is_reserved_windows(self): |
| self.check_windows_only() |
| self.assertFalse(self.path('/dev').is_reserved()) |
| self.assertFalse(self.path('/').is_reserved()) |
| self.assertTrue(self.path('COM1').is_reserved()) |
| self.assertTrue(self.path('nul.txt').is_reserved()) |
| |
| def test_joinpath(self): |
| self.assertEqual(self.path('/etc').joinpath('passwd'), |
| self.path('/etc/passwd')) |
| self.assertEqual(self.path('/etc').joinpath(self.path('passwd')), |
| self.path('/etc/passwd')) |
| self.assertEqual(self.path('/foo').joinpath('bar', 'baz'), |
| self.path('/foo/bar/baz')) |
| |
| def test_joinpath_drive(self): |
| self.check_windows_only() |
| self.assertEqual(self.path('c:').joinpath('/Program Files'), |
| self.path('c:/Program Files')) |
| |
| def test_match(self): |
| self.assertTrue(self.path('a/b.py').match('*.py')) |
| self.assertTrue(self.path('/a/b/c.py').match('b/*.py')) |
| self.assertFalse(self.path('/a/b/c.py').match('a/*.py')) |
| self.assertTrue(self.path('/a.py').match('/*.py')) |
| self.assertFalse(self.path('a/b.py').match('/*.py')) |
| |
| def test_relative_to(self): |
| self.assertEqual(self.path('/etc/passwd').relative_to('/'), |
| self.path('etc/passwd')) |
| self.assertEqual(self.path('/etc/passwd').relative_to('/'), |
| self.path('etc/passwd')) |
| with self.assertRaises(ValueError): |
| self.path('passwd').relative_to('/usr') |
| |
| @unittest.skipIf(sys.version_info < (3, 9), |
| 'is_relative_to new in Python 3.9') |
| def test_is_relative_to(self): |
| path = self.path('/etc/passwd') |
| self.assertTrue(path.is_relative_to('/etc')) |
| self.assertFalse(path.is_relative_to('/src')) |
| |
| def test_with_name(self): |
| self.check_windows_only() |
| self.assertEqual( |
| self.path('c:/Downloads/pathlib.tar.gz').with_name('setup.py'), |
| self.path('c:/Downloads/setup.py')) |
| with self.assertRaises(ValueError): |
| self.path('c:/').with_name('setup.py') |
| |
| def test_with_suffix(self): |
| self.assertEqual( |
| self.path('c:/Downloads/pathlib.tar.gz').with_suffix('.bz2'), |
| self.path('c:/Downloads/pathlib.tar.bz2')) |
| self.assertEqual(self.path('README').with_suffix('.txt'), |
| self.path('README.txt')) |
| |
| |
| class RealPathlibPurePathTest(FakePathlibPurePathTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| class FakePathlibFileObjectPropertyTest(RealPathlibTestCase): |
| def setUp(self): |
| super(FakePathlibFileObjectPropertyTest, self).setUp() |
| self.file_path = self.make_path('home', 'jane', 'test.py') |
| self.create_file(self.file_path, contents=b'a' * 100) |
| self.create_dir(self.make_path('home', 'john')) |
| try: |
| self.skip_if_symlink_not_supported() |
| except unittest.SkipTest: |
| return |
| self.create_symlink(self.make_path('john'), |
| self.make_path('home', 'john')) |
| self.file_link_path = self.make_path('test.py') |
| self.create_symlink(self.file_link_path, self.file_path) |
| self.create_symlink(self.make_path('broken_dir_link'), |
| self.make_path('home', 'none')) |
| self.create_symlink(self.make_path('broken_file_link'), |
| self.make_path('home', 'none', 'test.py')) |
| |
| def test_exists(self): |
| self.skip_if_symlink_not_supported() |
| self.assertTrue(self.path(self.file_path).exists()) |
| self.assertTrue(self.path( |
| self.make_path('home', 'jane')).exists()) |
| self.assertFalse(self.path( |
| self.make_path('home', 'jane', 'test')).exists()) |
| self.assertTrue(self.path( |
| self.make_path('john')).exists()) |
| self.assertTrue(self.path( |
| self.file_link_path).exists()) |
| self.assertFalse(self.path( |
| self.make_path('broken_dir_link')).exists()) |
| self.assertFalse(self.path( |
| self.make_path('broken_file_link')).exists()) |
| |
| def test_is_dir(self): |
| self.skip_if_symlink_not_supported() |
| self.assertFalse(self.path( |
| self.file_path).is_dir()) |
| self.assertTrue(self.path( |
| self.make_path('home/jane')).is_dir()) |
| self.assertTrue(self.path( |
| self.make_path('john')).is_dir()) |
| self.assertFalse(self.path( |
| self.file_link_path).is_dir()) |
| self.assertFalse(self.path( |
| self.make_path('broken_dir_link')).is_dir()) |
| self.assertFalse(self.path( |
| self.make_path('broken_file_link')).is_dir()) |
| |
| def test_is_file(self): |
| self.skip_if_symlink_not_supported() |
| self.assertTrue(self.path( |
| self.make_path('home/jane/test.py')).is_file()) |
| self.assertFalse(self.path( |
| self.make_path('home/jane')).is_file()) |
| self.assertFalse(self.path( |
| self.make_path('john')).is_file()) |
| self.assertTrue(self.path( |
| self.file_link_path).is_file()) |
| self.assertFalse(self.path( |
| self.make_path('broken_dir_link')).is_file()) |
| self.assertFalse(self.path( |
| self.make_path('broken_file_link')).is_file()) |
| |
| def test_is_symlink(self): |
| self.skip_if_symlink_not_supported() |
| self.assertFalse(self.path( |
| self.make_path('home/jane/test.py')).is_symlink()) |
| self.assertFalse(self.path( |
| self.make_path('home/jane')).is_symlink()) |
| self.assertTrue(self.path( |
| self.make_path('john')).is_symlink()) |
| self.assertTrue(self.path( |
| self.file_link_path).is_symlink()) |
| self.assertTrue(self.path( |
| self.make_path('broken_dir_link')).is_symlink()) |
| self.assertTrue(self.path( |
| self.make_path('broken_file_link')).is_symlink()) |
| |
| def test_stat(self): |
| self.skip_if_symlink_not_supported() |
| file_stat = self.os.stat(self.file_path) |
| |
| stat_result = self.path(self.file_link_path).stat() |
| self.assertFalse(stat_result.st_mode & stat.S_IFDIR) |
| self.assertTrue(stat_result.st_mode & stat.S_IFREG) |
| self.assertEqual(stat_result.st_ino, file_stat.st_ino) |
| self.assertEqual(stat_result.st_size, 100) |
| self.assertEqual(stat_result.st_mtime, file_stat.st_mtime) |
| self.assertEqual(stat_result[stat.ST_MTIME], |
| int(file_stat.st_mtime)) |
| |
| def check_lstat(self, expected_size): |
| self.skip_if_symlink_not_supported() |
| link_stat = self.os.lstat(self.file_link_path) |
| |
| stat_result = self.path(self.file_link_path).lstat() |
| self.assertTrue(stat_result.st_mode & stat.S_IFREG) |
| self.assertTrue(stat_result.st_mode & stat.S_IFLNK) |
| self.assertEqual(stat_result.st_ino, link_stat.st_ino) |
| self.assertEqual(stat_result.st_size, expected_size) |
| self.assertEqual(stat_result.st_mtime, link_stat.st_mtime) |
| |
| @unittest.skipIf(is_windows, 'POSIX specific behavior') |
| def test_lstat_posix(self): |
| self.check_lstat(len(self.file_path)) |
| |
| @unittest.skipIf(not is_windows, 'Windows specific behavior') |
| def test_lstat_windows(self): |
| self.skip_if_symlink_not_supported() |
| self.check_lstat(0) |
| |
| @unittest.skipIf(is_windows, 'Linux specific behavior') |
| def test_chmod(self): |
| self.check_linux_only() |
| file_stat = self.os.stat(self.file_path) |
| self.assertEqual(file_stat.st_mode, stat.S_IFREG | 0o666) |
| link_stat = self.os.lstat(self.file_link_path) |
| # we get stat.S_IFLNK | 0o755 under MacOs |
| self.assertEqual(link_stat.st_mode, stat.S_IFLNK | 0o777) |
| |
| def test_lchmod(self): |
| self.skip_if_symlink_not_supported() |
| file_stat = self.os.stat(self.file_path) |
| link_stat = self.os.lstat(self.file_link_path) |
| if not hasattr(os, "lchmod"): |
| with self.assertRaises(NotImplementedError): |
| self.path(self.file_link_path).lchmod(0o444) |
| else: |
| self.path(self.file_link_path).lchmod(0o444) |
| self.assertEqual(file_stat.st_mode, stat.S_IFREG | 0o666) |
| # the exact mode depends on OS and Python version |
| self.assertEqual(link_stat.st_mode & 0o777700, |
| stat.S_IFLNK | 0o700) |
| |
| @unittest.skipIf(sys.version_info < (3, 10), |
| "follow_symlinks argument new in Python 3.10") |
| def test_chmod_no_followsymlinks(self): |
| self.skip_if_symlink_not_supported() |
| file_stat = self.os.stat(self.file_path) |
| link_stat = self.os.lstat(self.file_link_path) |
| if os.chmod not in os.supports_follow_symlinks or IS_PYPY: |
| with self.assertRaises(NotImplementedError): |
| self.path(self.file_link_path).chmod(0o444, |
| follow_symlinks=False) |
| else: |
| self.path(self.file_link_path).chmod(0o444, follow_symlinks=False) |
| self.assertEqual(file_stat.st_mode, stat.S_IFREG | 0o666) |
| # the exact mode depends on OS and Python version |
| self.assertEqual(link_stat.st_mode & 0o777700, |
| stat.S_IFLNK | 0o700) |
| |
| def test_resolve(self): |
| self.create_dir(self.make_path('antoine', 'docs')) |
| self.create_file(self.make_path('antoine', 'setup.py')) |
| self.os.chdir(self.make_path('antoine')) |
| # use real path to handle symlink /var to /private/var in MacOs |
| self.assert_equal_paths(self.path().resolve(), |
| self.path(self.os.path.realpath( |
| self.make_path('antoine')))) |
| self.assert_equal_paths( |
| self.path( |
| self.os.path.join('docs', '..', 'setup.py')).resolve(), |
| self.path( |
| self.os.path.realpath( |
| self.make_path('antoine', 'setup.py')))) |
| |
| def test_stat_file_in_unreadable_dir(self): |
| self.check_posix_only() |
| dir_path = self.make_path('some_dir') |
| file_path = self.os.path.join(dir_path, 'some_file') |
| self.create_file(file_path) |
| self.os.chmod(dir_path, 0o000) |
| if not is_root(): |
| self.assert_raises_os_error( |
| errno.EACCES, self.path(file_path).stat) |
| else: |
| self.assertEqual(0, self.path(file_path).stat().st_size) |
| |
| def test_iterdir_in_unreadable_dir(self): |
| self.check_posix_only() |
| dir_path = self.make_path('some_dir') |
| file_path = self.os.path.join(dir_path, 'some_file') |
| self.create_file(file_path) |
| self.os.chmod(dir_path, 0o000) |
| iter = self.path(dir_path).iterdir() |
| if not is_root(): |
| self.assert_raises_os_error(errno.EACCES, list, iter) |
| else: |
| path = str(list(iter)[0]) |
| self.assertTrue(path.endswith('some_file')) |
| |
| def test_resolve_nonexisting_file(self): |
| path = self.path( |
| self.make_path('/path', 'to', 'file', 'this can not exist')) |
| self.assertEqual(path, path.resolve()) |
| |
| def test_cwd(self): |
| dir_path = self.make_path('jane') |
| self.create_dir(dir_path) |
| self.os.chdir(dir_path) |
| self.assert_equal_paths(self.path.cwd(), |
| self.path(self.os.path.realpath(dir_path))) |
| |
| def test_expanduser(self): |
| if is_windows: |
| self.assertEqual(self.path('~').expanduser(), |
| self.path( |
| os.environ['USERPROFILE'].replace('\\', |
| '/'))) |
| else: |
| self.assertEqual(self.path('~').expanduser(), |
| self.path(os.environ['HOME'])) |
| |
| def test_home(self): |
| if is_windows: |
| self.assertEqual(self.path( |
| os.environ['USERPROFILE'].replace('\\', '/')), |
| self.path.home()) |
| else: |
| self.assertEqual(self.path(os.environ['HOME']), |
| self.path.home()) |
| |
| |
| class RealPathlibFileObjectPropertyTest(FakePathlibFileObjectPropertyTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| class FakePathlibPathFileOperationTest(RealPathlibTestCase): |
| """Tests methods related to file and directory handling.""" |
| |
| def test_exists(self): |
| self.skip_if_symlink_not_supported() |
| self.create_file(self.make_path('home', 'jane', 'test.py')) |
| self.create_dir(self.make_path('home', 'john')) |
| self.create_symlink( |
| self.make_path('john'), self.make_path('home', 'john')) |
| self.create_symlink( |
| self.make_path('none'), self.make_path('home', 'none')) |
| |
| self.assertTrue( |
| self.path(self.make_path('home', 'jane', 'test.py')).exists()) |
| self.assertTrue(self.path(self.make_path('home', 'jane')).exists()) |
| self.assertTrue(self.path(self.make_path('john')).exists()) |
| self.assertFalse(self.path(self.make_path('none')).exists()) |
| self.assertFalse( |
| self.path(self.make_path('home', 'jane', 'test')).exists()) |
| |
| def test_open(self): |
| self.create_dir(self.make_path('foo')) |
| with self.assertRaises(OSError): |
| self.path(self.make_path('foo', 'bar.txt')).open() |
| self.path(self.make_path('foo', 'bar.txt')).open('w').close() |
| self.assertTrue( |
| self.os.path.exists(self.make_path('foo', 'bar.txt'))) |
| |
| def test_read_text(self): |
| self.create_file(self.make_path('text_file'), contents='foo') |
| file_path = self.path(self.make_path('text_file')) |
| self.assertEqual(file_path.read_text(), 'foo') |
| |
| def test_read_text_with_encoding(self): |
| self.create_file(self.make_path('text_file'), |
| contents='ерунда', encoding='cyrillic') |
| file_path = self.path(self.make_path('text_file')) |
| self.assertEqual(file_path.read_text(encoding='cyrillic'), |
| 'ерунда') |
| |
| def test_write_text(self): |
| path_name = self.make_path('text_file') |
| file_path = self.path(path_name) |
| file_path.write_text(str('foo')) |
| self.assertTrue(self.os.path.exists(path_name)) |
| self.check_contents(path_name, 'foo') |
| |
| def test_write_text_with_encoding(self): |
| path_name = self.make_path('text_file') |
| file_path = self.path(path_name) |
| file_path.write_text('ανοησίες', encoding='greek') |
| self.assertTrue(self.os.path.exists(path_name)) |
| self.check_contents(path_name, 'ανοησίες'.encode('greek')) |
| |
| @unittest.skipIf(sys.version_info < (3, 10), |
| "newline argument new in Python 3.10") |
| def test_write_with_newline_arg(self): |
| path = self.path(self.make_path('some_file')) |
| path.write_text('1\r\n2\n3\r4', newline='') |
| self.check_contents(path, b'1\r\n2\n3\r4') |
| path.write_text('1\r\n2\n3\r4', newline='\n') |
| self.check_contents(path, b'1\r\n2\n3\r4') |
| path.write_text('1\r\n2\n3\r4', newline='\r\n') |
| self.check_contents(path, b'1\r\r\n2\r\n3\r4') |
| path.write_text('1\r\n2\n3\r4', newline='\r') |
| self.check_contents(path, b'1\r\r2\r3\r4') |
| |
| def test_read_bytes(self): |
| path_name = self.make_path('binary_file') |
| self.create_file(path_name, contents=b'Binary file contents') |
| file_path = self.path(path_name) |
| self.assertEqual(file_path.read_bytes(), b'Binary file contents') |
| |
| def test_write_bytes(self): |
| path_name = self.make_path('binary_file') |
| file_path = self.path(path_name) |
| file_path.write_bytes(b'Binary file contents') |
| self.assertTrue(self.os.path.exists(path_name)) |
| self.check_contents(path_name, b'Binary file contents') |
| |
| def test_rename(self): |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name, contents='test') |
| new_file_name = self.make_path('foo', 'baz.txt') |
| self.path(file_name).rename(new_file_name) |
| self.assertFalse(self.os.path.exists(file_name)) |
| self.check_contents(new_file_name, 'test') |
| |
| def test_replace(self): |
| self.create_file(self.make_path('foo', 'bar.txt'), contents='test') |
| self.create_file(self.make_path('bar', 'old.txt'), |
| contents='replaced') |
| self.path(self.make_path('bar', 'old.txt')).replace( |
| self.make_path('foo', 'bar.txt')) |
| self.assertFalse( |
| self.os.path.exists(self.make_path('bar', 'old.txt'))) |
| self.check_contents(self.make_path('foo', 'bar.txt'), 'replaced') |
| |
| def test_unlink(self): |
| file_path = self.make_path('foo', 'bar.txt') |
| self.create_file(file_path, contents='test') |
| self.assertTrue(self.os.path.exists(file_path)) |
| self.path(file_path).unlink() |
| self.assertFalse(self.os.path.exists(file_path)) |
| |
| def test_touch_non_existing(self): |
| self.create_dir(self.make_path('foo')) |
| file_name = self.make_path('foo', 'bar.txt') |
| self.path(file_name).touch(mode=0o444) |
| self.check_contents(file_name, '') |
| self.assertTrue(self.os.stat(file_name).st_mode, |
| stat.S_IFREG | 0o444) |
| self.os.chmod(file_name, mode=0o666) |
| |
| def test_touch_existing(self): |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name, contents='test') |
| file_path = self.path(file_name) |
| self.assert_raises_os_error( |
| errno.EEXIST, file_path.touch, exist_ok=False) |
| file_path.touch() |
| self.check_contents(file_name, 'test') |
| |
| def test_samefile(self): |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name) |
| file_name2 = self.make_path('foo', 'baz.txt') |
| self.create_file(file_name2) |
| with self.assertRaises(OSError): |
| self.path(self.make_path('foo', 'other')).samefile( |
| self.make_path('foo', 'other.txt')) |
| path = self.path(file_name) |
| other_name = self.make_path('foo', 'other.txt') |
| with self.assertRaises(OSError): |
| path.samefile(other_name) |
| with self.assertRaises(OSError): |
| path.samefile(self.path(other_name)) |
| self.assertFalse(path.samefile(file_name2)) |
| self.assertFalse(path.samefile(self.path(file_name2))) |
| self.assertTrue( |
| path.samefile(self.make_path('foo', '..', 'foo', 'bar.txt'))) |
| self.assertTrue(path.samefile( |
| self.path(self.make_path('foo', '..', 'foo', 'bar.txt')))) |
| |
| def test_symlink_to(self): |
| self.skip_if_symlink_not_supported() |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name) |
| link_name = self.make_path('link_to_bar') |
| path = self.path(link_name) |
| path.symlink_to(file_name) |
| self.assertTrue(self.os.path.exists(link_name)) |
| self.assertTrue(path.is_symlink()) |
| |
| @unittest.skipIf(sys.version_info < (3, 8), |
| 'link_to new in Python 3.8') |
| def test_link_to(self): |
| self.skip_if_symlink_not_supported() |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name) |
| self.assertEqual(1, self.os.stat(file_name).st_nlink) |
| link_name = self.make_path('link_to_bar') |
| path = self.path(file_name) |
| path.link_to(link_name) |
| self.assertTrue(self.os.path.exists(link_name)) |
| self.assertFalse(path.is_symlink()) |
| self.assertEqual(2, self.os.stat(file_name).st_nlink) |
| |
| @unittest.skipIf(sys.version_info < (3, 10), |
| 'hardlink_to new in Python 3.10') |
| def test_hardlink_to(self): |
| self.skip_if_symlink_not_supported() |
| file_name = self.make_path('foo', 'bar.txt') |
| self.create_file(file_name) |
| self.assertEqual(1, self.os.stat(file_name).st_nlink) |
| link_path = self.path(self.make_path('link_to_bar')) |
| path = self.path(file_name) |
| link_path.hardlink_to(path) |
| self.assertTrue(self.os.path.exists(link_path)) |
| self.assertFalse(path.is_symlink()) |
| self.assertEqual(2, self.os.stat(file_name).st_nlink) |
| |
| @unittest.skipIf(sys.version_info < (3, 9), |
| 'readlink new in Python 3.9') |
| def test_readlink(self): |
| self.skip_if_symlink_not_supported() |
| link_path = self.make_path('foo', 'bar', 'baz') |
| target = self.make_path('tarJAY') |
| self.create_symlink(link_path, target) |
| path = self.path(link_path) |
| self.assert_equal_paths(path.readlink(), self.path(target)) |
| |
| def test_mkdir(self): |
| dir_name = self.make_path('foo', 'bar') |
| self.assert_raises_os_error(errno.ENOENT, |
| self.path(dir_name).mkdir) |
| self.path(dir_name).mkdir(parents=True) |
| self.assertTrue(self.os.path.exists(dir_name)) |
| self.assert_raises_os_error(errno.EEXIST, |
| self.path(dir_name).mkdir) |
| |
| def test_mkdir_exist_ok(self): |
| dir_name = self.make_path('foo', 'bar') |
| self.create_dir(dir_name) |
| self.path(dir_name).mkdir(exist_ok=True) |
| file_name = self.os.path.join(dir_name, 'baz') |
| self.create_file(file_name) |
| self.assert_raises_os_error(errno.EEXIST, |
| self.path(file_name).mkdir, |
| exist_ok=True) |
| |
| def test_rmdir(self): |
| dir_name = self.make_path('foo', 'bar') |
| self.create_dir(dir_name) |
| self.path(dir_name).rmdir() |
| self.assertFalse(self.os.path.exists(dir_name)) |
| self.assertTrue(self.os.path.exists(self.make_path('foo'))) |
| self.create_file(self.make_path('foo', 'baz')) |
| with self.assertRaises(OSError): |
| self.path(self.make_path('foo')).rmdir() |
| self.assertTrue(self.os.path.exists(self.make_path('foo'))) |
| |
| def test_iterdir(self): |
| self.create_file(self.make_path('foo', 'bar', 'file1')) |
| self.create_file(self.make_path('foo', 'bar', 'file2')) |
| self.create_file(self.make_path('foo', 'bar', 'file3')) |
| path = self.path(self.make_path('foo', 'bar')) |
| contents = [entry for entry in path.iterdir()] |
| self.assertEqual(3, len(contents)) |
| self.assertIn(self.path(self.make_path('foo', 'bar', 'file2')), |
| contents) |
| |
| def test_glob(self): |
| self.create_file(self.make_path('foo', 'setup.py')) |
| self.create_file(self.make_path('foo', 'all_tests.py')) |
| self.create_file(self.make_path('foo', 'README.md')) |
| self.create_file(self.make_path('foo', 'setup.pyc')) |
| path = self.path(self.make_path('foo')) |
| self.assertEqual(sorted(path.glob('*.py')), |
| [self.path(self.make_path('foo', 'all_tests.py')), |
| self.path(self.make_path('foo', 'setup.py'))]) |
| |
| @unittest.skipIf(not is_windows, 'Windows specific test') |
| def test_glob_case_windows(self): |
| self.create_file(self.make_path('foo', 'setup.py')) |
| self.create_file(self.make_path('foo', 'all_tests.PY')) |
| self.create_file(self.make_path('foo', 'README.md')) |
| self.create_file(self.make_path('foo', 'example.Py')) |
| path = self.path(self.make_path('foo')) |
| self.assertEqual(sorted(path.glob('*.py')), |
| [self.path(self.make_path('foo', 'all_tests.PY')), |
| self.path(self.make_path('foo', 'example.Py')), |
| self.path(self.make_path('foo', 'setup.py'))]) |
| |
| @unittest.skipIf(is_windows, 'Posix specific test') |
| def test_glob_case_posix(self): |
| self.check_posix_only() |
| self.create_file(self.make_path('foo', 'setup.py')) |
| self.create_file(self.make_path('foo', 'all_tests.PY')) |
| self.create_file(self.make_path('foo', 'README.md')) |
| self.create_file(self.make_path('foo', 'example.Py')) |
| path = self.path(self.make_path('foo')) |
| self.assertEqual(sorted(path.glob('*.py')), |
| [self.path(self.make_path('foo', 'setup.py'))]) |
| |
| |
| class RealPathlibPathFileOperationTest(FakePathlibPathFileOperationTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| @unittest.skipIf(sys.version_info < (3, 6), |
| 'path-like objects new in Python 3.6') |
| class FakePathlibUsageInOsFunctionsTest(RealPathlibTestCase): |
| """Test that many os / os.path functions accept a path-like object |
| since Python 3.6. The functionality of these functions is tested |
| elsewhere, we just check that they accept a fake path object as an |
| argument. |
| """ |
| |
| def test_join(self): |
| dir1 = 'foo' |
| dir2 = 'bar' |
| dir = self.os.path.join(dir1, dir2) |
| self.assertEqual(dir, self.os.path.join(self.path(dir1), dir2)) |
| self.assertEqual(dir, self.os.path.join(dir1, self.path(dir2))) |
| self.assertEqual(dir, |
| self.os.path.join(self.path(dir1), |
| self.path(dir2))) |
| |
| def test_normcase(self): |
| dir1 = self.make_path('Foo', 'Bar', 'Baz') |
| self.assertEqual(self.os.path.normcase(dir1), |
| self.os.path.normcase(self.path(dir1))) |
| |
| def test_normpath(self): |
| dir1 = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.normpath(dir1), |
| self.os.path.normpath(self.path(dir1))) |
| |
| def test_realpath(self): |
| dir1 = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.realpath(dir1), |
| self.os.path.realpath(self.path(dir1))) |
| |
| def test_relpath(self): |
| path_foo = self.make_path('path', 'to', 'foo') |
| path_bar = self.make_path('path', 'to', 'bar') |
| rel_path = self.os.path.relpath(path_foo, path_bar) |
| self.assertEqual(rel_path, |
| self.os.path.relpath(self.path(path_foo), |
| path_bar)) |
| self.assertEqual(rel_path, |
| self.os.path.relpath(path_foo, |
| self.path(path_bar))) |
| self.assertEqual(rel_path, |
| self.os.path.relpath(self.path(path_foo), |
| self.path(path_bar))) |
| |
| def test_split(self): |
| dir1 = self.make_path('Foo', 'Bar', 'Baz') |
| self.assertEqual(self.os.path.split(dir1), |
| self.os.path.split(self.path(dir1))) |
| |
| def test_splitdrive(self): |
| dir1 = self.make_path('C:', 'Foo', 'Bar', 'Baz') |
| self.assertEqual(self.os.path.splitdrive(dir1), |
| self.os.path.splitdrive(self.path(dir1))) |
| |
| def test_abspath(self): |
| dir1 = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.abspath(dir1), |
| self.os.path.abspath(self.path(dir1))) |
| |
| def test_exists(self): |
| dir1 = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.exists(dir1), |
| self.os.path.exists(self.path(dir1))) |
| |
| def test_lexists(self): |
| dir1 = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.lexists(dir1), |
| self.os.path.lexists(self.path(dir1))) |
| |
| def test_expanduser(self): |
| dir1 = self.os.path.join('~', 'foo') |
| self.assertEqual(self.os.path.expanduser(dir1), |
| self.os.path.expanduser(self.path(dir1))) |
| |
| def test_getmtime(self): |
| self.skip_real_fs() |
| dir1 = self.make_path('foo', 'bar1.txt') |
| path_obj = self.filesystem.create_file(dir1) |
| path_obj._st_mtime = 24 |
| self.assertEqual(self.os.path.getmtime(dir1), |
| self.os.path.getmtime(self.path(dir1))) |
| |
| def test_getctime(self): |
| self.skip_real_fs() |
| dir1 = self.make_path('foo', 'bar1.txt') |
| path_obj = self.filesystem.create_file(dir1) |
| path_obj.st_ctime = 42 |
| self.assertEqual(self.os.path.getctime(dir1), |
| self.os.path.getctime(self.path(dir1))) |
| |
| def test_getatime(self): |
| self.skip_real_fs() |
| dir1 = self.make_path('foo', 'bar1.txt') |
| path_obj = self.filesystem.create_file(dir1) |
| path_obj.st_atime = 11 |
| self.assertEqual(self.os.path.getatime(dir1), |
| self.os.path.getatime(self.path(dir1))) |
| |
| def test_getsize(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path, contents='1234567') |
| self.assertEqual(self.os.path.getsize(path), |
| self.os.path.getsize(self.path(path))) |
| |
| def test_isabs(self): |
| path = self.make_path('foo', 'bar', '..', 'baz') |
| self.assertEqual(self.os.path.isabs(path), |
| self.os.path.isabs(self.path(path))) |
| |
| def test_isfile(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path) |
| self.assertEqual(self.os.path.isfile(path), |
| self.os.path.isfile(self.path(path))) |
| |
| def test_isfile_not_readable(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path, perm=0) |
| self.assertEqual(self.os.path.isfile(path), |
| self.os.path.isfile(self.path(path))) |
| |
| def test_islink(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path) |
| self.assertEqual(self.os.path.islink(path), |
| self.os.path.islink(self.path(path))) |
| |
| def test_isdir(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path) |
| self.assertEqual(self.os.path.isdir(path), |
| self.os.path.isdir(self.path(path))) |
| |
| def test_ismount(self): |
| path = self.os.path.sep |
| self.assertEqual(self.os.path.ismount(path), |
| self.os.path.ismount(self.path(path))) |
| |
| def test_access(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path, contents='1234567') |
| self.assertEqual(self.os.access(path, os.R_OK), |
| self.os.access(self.path(path), os.R_OK)) |
| |
| def test_chdir(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_dir(path) |
| self.os.chdir(self.path(path)) |
| # use real path to handle symlink /var to /private/var in MacOs |
| self.assert_equal_paths(self.os.path.realpath(path), self.os.getcwd()) |
| |
| def test_chmod(self): |
| path = self.make_path('some_file') |
| self.create_file(path) |
| self.os.chmod(self.path(path), 0o444) |
| self.assertEqual(stat.S_IMODE(0o444), |
| stat.S_IMODE(self.os.stat(path).st_mode)) |
| self.os.chmod(self.path(path), 0o666) |
| |
| def test_link(self): |
| self.skip_if_symlink_not_supported() |
| file1_path = self.make_path('test_file1') |
| file2_path = self.make_path('test_file2') |
| self.create_file(file1_path) |
| self.os.link(self.path(file1_path), file2_path) |
| self.assertTrue(self.os.path.exists(file2_path)) |
| self.os.unlink(file2_path) |
| self.os.link(self.path(file1_path), self.path(file2_path)) |
| self.assertTrue(self.os.path.exists(file2_path)) |
| self.os.unlink(file2_path) |
| self.os.link(file1_path, self.path(file2_path)) |
| self.assertTrue(self.os.path.exists(file2_path)) |
| |
| def test_listdir(self): |
| path = self.make_path('foo', 'bar') |
| self.create_dir(path) |
| self.create_file(path + 'baz.txt') |
| self.assertEqual(self.os.listdir(path), |
| self.os.listdir(self.path(path))) |
| |
| def test_mkdir(self): |
| path = self.make_path('foo') |
| self.os.mkdir(self.path(path)) |
| self.assertTrue(self.os.path.exists(path)) |
| |
| def test_makedirs(self): |
| path = self.make_path('foo', 'bar') |
| self.os.makedirs(self.path(path)) |
| self.assertTrue(self.os.path.exists(path)) |
| |
| @unittest.skipIf(is_windows, 'os.readlink seems not to support ' |
| 'path-like objects under Windows') |
| def test_readlink(self): |
| link_path = self.make_path('foo', 'bar', 'baz') |
| target = self.make_path('tarJAY') |
| self.create_symlink(link_path, target) |
| self.assertEqual(self.os.readlink(self.path(link_path)), target) |
| |
| def test_remove(self): |
| path = self.make_path('test.txt') |
| self.create_file(path) |
| self.os.remove(self.path(path)) |
| self.assertFalse(self.os.path.exists(path)) |
| |
| def test_rename(self): |
| path1 = self.make_path('test1.txt') |
| path2 = self.make_path('test2.txt') |
| self.create_file(path1) |
| self.os.rename(self.path(path1), path2) |
| self.assertTrue(self.os.path.exists(path2)) |
| self.os.rename(self.path(path2), self.path(path1)) |
| self.assertTrue(self.os.path.exists(path1)) |
| |
| def test_replace(self): |
| path1 = self.make_path('test1.txt') |
| path2 = self.make_path('test2.txt') |
| self.create_file(path1) |
| self.os.replace(self.path(path1), path2) |
| self.assertTrue(self.os.path.exists(path2)) |
| self.os.replace(self.path(path2), self.path(path1)) |
| self.assertTrue(self.os.path.exists(path1)) |
| |
| def test_rmdir(self): |
| path = self.make_path('foo', 'bar') |
| self.create_dir(path) |
| self.os.rmdir(self.path(path)) |
| self.assertFalse(self.os.path.exists(path)) |
| |
| def test_scandir(self): |
| directory = self.make_path('xyzzy', 'plugh') |
| self.create_dir(directory) |
| self.create_file(self.os.path.join(directory, 'test.txt')) |
| dir_entries = [entry for entry in |
| self.os.scandir(self.path(directory))] |
| self.assertEqual(1, len(dir_entries)) |
| |
| def test_symlink(self): |
| self.skip_if_symlink_not_supported() |
| file_path = self.make_path('test_file1') |
| link_path = self.make_path('link') |
| self.create_file(file_path) |
| self.os.symlink(self.path(file_path), link_path) |
| self.assertTrue(self.os.path.exists(link_path)) |
| self.os.remove(link_path) |
| self.os.symlink(self.path(file_path), self.path(link_path)) |
| self.assertTrue(self.os.path.exists(link_path)) |
| |
| def test_stat(self): |
| path = self.make_path('foo', 'bar', 'baz') |
| self.create_file(path, contents='1234567') |
| self.assertEqual(self.os.stat(path), self.path(path).stat()) |
| |
| @unittest.skipIf(sys.version_info < (3, 10), "New in Python 3.10") |
| def test_stat_follow_symlinks(self): |
| self.check_posix_only() |
| directory = self.make_path('foo') |
| base_name = 'bar' |
| file_path = self.path(self.os.path.join(directory, base_name)) |
| link_path = self.path(self.os.path.join(directory, 'link')) |
| contents = "contents" |
| self.create_file(file_path, contents=contents) |
| self.create_symlink(link_path, base_name) |
| self.assertEqual(len(contents), |
| link_path.stat(follow_symlinks=True)[stat.ST_SIZE]) |
| self.assertEqual(len(base_name), |
| link_path.stat(follow_symlinks=False)[stat.ST_SIZE]) |
| |
| def test_utime(self): |
| path = self.make_path('some_file') |
| self.create_file(path, contents='test') |
| self.os.utime(self.path(path), times=(1, 2)) |
| st = self.os.stat(path) |
| self.assertEqual(1, st.st_atime) |
| self.assertEqual(2, st.st_mtime) |
| |
| def test_truncate(self): |
| path = self.make_path('some_file') |
| self.create_file(path, contents='test_test') |
| self.os.truncate(self.path(path), length=4) |
| st = self.os.stat(path) |
| self.assertEqual(4, st.st_size) |
| |
| |
| class RealPathlibUsageInOsFunctionsTest(FakePathlibUsageInOsFunctionsTest): |
| def use_real_fs(self): |
| return True |
| |
| |
| @unittest.skipIf(sys.version_info < (3, 6), |
| 'Path-like objects new in Python 3.6') |
| class FakeFilesystemPathLikeObjectTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.filesystem = fake_filesystem.FakeFilesystem( |
| path_separator='/') |
| self.pathlib = fake_pathlib.FakePathlibModule(self.filesystem) |
| self.os = fake_filesystem.FakeOsModule(self.filesystem) |
| |
| def test_create_dir_with_pathlib_path(self): |
| dir_path_string = 'foo/bar/baz' |
| dir_path = self.pathlib.Path(dir_path_string) |
| self.filesystem.create_dir(dir_path) |
| self.assertTrue(self.os.path.exists(dir_path_string)) |
| self.assertEqual(stat.S_IFDIR, |
| self.os.stat( |
| dir_path_string).st_mode & stat.S_IFDIR) |
| |
| def test_create_file_with_pathlib_path(self): |
| file_path_string = 'foo/bar/baz' |
| file_path = self.pathlib.Path(file_path_string) |
| self.filesystem.create_file(file_path) |
| self.assertTrue(self.os.path.exists(file_path_string)) |
| self.assertEqual(stat.S_IFREG, |
| self.os.stat( |
| file_path_string).st_mode & stat.S_IFREG) |
| |
| def test_create_symlink_with_pathlib_path(self): |
| file_path = self.pathlib.Path('foo/bar/baz') |
| link_path_string = 'foo/link' |
| link_path = self.pathlib.Path(link_path_string) |
| self.filesystem.create_symlink(link_path, file_path) |
| self.assertTrue(self.os.path.lexists(link_path_string)) |
| self.assertEqual(stat.S_IFLNK, |
| self.os.lstat(link_path_string).st_mode & |
| stat.S_IFLNK) |
| |
| def test_add_existing_real_file_with_pathlib_path(self): |
| real_file_path_string = os.path.abspath(__file__) |
| real_file_path = self.pathlib.Path(real_file_path_string) |
| self.filesystem.add_real_file(real_file_path) |
| fake_filepath_string = real_file_path_string.replace( |
| os.sep, self.os.sep) |
| self.assertTrue(self.os.path.exists(fake_filepath_string)) |
| self.assertEqual(stat.S_IFREG, self.os.stat( |
| fake_filepath_string).st_mode & stat.S_IFREG) |
| |
| def test_add_existing_real_directory_with_pathlib_path(self): |
| real_dirpath_string = os.path.dirname(os.path.abspath(__file__)) |
| real_dir_path = self.pathlib.Path(real_dirpath_string) |
| self.filesystem.add_real_directory(real_dir_path) |
| fake_dirpath_string = real_dirpath_string.replace( |
| os.sep, self.os.sep) |
| self.assertTrue(self.os.path.exists(fake_dirpath_string)) |
| self.assertEqual(stat.S_IFDIR, self.os.stat( |
| fake_dirpath_string).st_mode & stat.S_IFDIR) |
| |
| |
| if __name__ == '__main__': |
| unittest.main(verbosity=2) |
