| # Copyright 2009 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Test that FakeFilesystem calls work identically to a real filesystem.""" |
| # pylint: disable-all |
| |
| import os |
| import shutil |
| import sys |
| import tempfile |
| import time |
| import unittest |
| |
| from pyfakefs import fake_filesystem |
| from pyfakefs.helpers import IS_PYPY |
| |
| |
| def sep(path): |
| """Converts slashes in the path to the architecture's path seperator.""" |
| if isinstance(path, str): |
| return path.replace('/', os.sep) |
| return path |
| |
| |
| def _get_errno(raised_error): |
| if raised_error is not None: |
| try: |
| return raised_error.errno |
| except AttributeError: |
| pass |
| |
| |
| class TestCase(unittest.TestCase): |
| is_windows = sys.platform.startswith('win') |
| _FAKE_FS_BASE = sep('/fakefs') |
| |
| |
| class FakeFilesystemVsRealTest(TestCase): |
| def _paths(self, path): |
| """For a given path, return paths in the real and fake filesystems.""" |
| if not path: |
| return None, None |
| return (os.path.join(self.real_base, path), |
| os.path.join(self.fake_base, path)) |
| |
| def _create_test_file(self, file_type, path, contents=None): |
| """Create a dir, file, or link in both the real fs and the fake.""" |
| path = sep(path) |
| self._created_files.append([file_type, path, contents]) |
| real_path, fake_path = self._paths(path) |
| if file_type == 'd': |
| os.mkdir(real_path) |
| self.fake_os.mkdir(fake_path) |
| if file_type == 'f': |
| fh = open(real_path, 'w') |
| fh.write(contents or '') |
| fh.close() |
| fh = self.fake_open(fake_path, 'w') |
| fh.write(contents or '') |
| fh.close() |
| # b for binary file |
| if file_type == 'b': |
| fh = open(real_path, 'wb') |
| fh.write(contents or '') |
| fh.close() |
| fh = self.fake_open(fake_path, 'wb') |
| fh.write(contents or '') |
| fh.close() |
| # l for symlink, h for hard link |
| if file_type in ('l', 'h'): |
| real_target, fake_target = (contents, contents) |
| # If it begins with '/', make it relative to the base. You can't go |
| # creating files in / for the real file system. |
| if contents.startswith(os.sep): |
| real_target, fake_target = self._paths(contents[1:]) |
| if file_type == 'l': |
| os.symlink(real_target, real_path) |
| self.fake_os.symlink(fake_target, fake_path) |
| elif file_type == 'h': |
| os.link(real_target, real_path) |
| self.fake_os.link(fake_target, fake_path) |
| |
| def setUp(self): |
| # Base paths in the real and test file systems. We keep them different |
| # so that missing features in the fake don't fall through to the base |
| # operations and magically succeed. |
| tsname = 'fakefs.%s' % time.time() |
| self.cwd = os.getcwd() |
| # Fully expand the base_path - required on OS X. |
| self.real_base = os.path.realpath( |
| os.path.join(tempfile.gettempdir(), tsname)) |
| os.chdir(tempfile.gettempdir()) |
| if os.path.isdir(self.real_base): |
| shutil.rmtree(self.real_base) |
| os.mkdir(self.real_base) |
| self.fake_base = self._FAKE_FS_BASE |
| |
| # Make sure we can write to the physical testing temp directory. |
| self.assertTrue(os.access(self.real_base, os.W_OK)) |
| |
| self.fake_filesystem = fake_filesystem.FakeFilesystem() |
| self.fake_filesystem.create_dir(self.fake_base) |
| self.fake_os = fake_filesystem.FakeOsModule(self.fake_filesystem) |
| self.fake_open = fake_filesystem.FakeFileOpen(self.fake_filesystem) |
| self._created_files = [] |
| |
| os.chdir(self.real_base) |
| self.fake_os.chdir(self.fake_base) |
| |
| def tearDown(self): |
| # We have to remove all the files from the real FS. Doing the same for |
| # the fake FS is optional, but doing it is an extra sanity check. |
| os.chdir(tempfile.gettempdir()) |
| try: |
| rev_files = self._created_files[:] |
| rev_files.reverse() |
| for info in rev_files: |
| real_path, fake_path = self._paths(info[1]) |
| if info[0] == 'd': |
| try: |
| os.rmdir(real_path) |
| except OSError as e: |
| if 'Directory not empty' in e: |
| self.fail('Real path %s not empty: %s : %s' % ( |
| real_path, e, os.listdir(real_path))) |
| else: |
| raise |
| self.fake_os.rmdir(fake_path) |
| if info[0] == 'f' or info[0] == 'l': |
| os.remove(real_path) |
| self.fake_os.remove(fake_path) |
| finally: |
| shutil.rmtree(self.real_base) |
| os.chdir(self.cwd) |
| |
| def _compare_behaviors(self, method_name, path, real, fake, |
| method_returns_path=False): |
| """Invoke an os method in both real and fake contexts and compare |
| results. |
| |
| Invoke a real filesystem method with a path to a real file and invoke |
| a fake filesystem method with a path to a fake file and compare the |
| results. We expect some calls to throw Exceptions, so we catch those |
| and compare them. |
| |
| Args: |
| method_name: Name of method being tested, for use in |
| error messages. |
| path: potential path to a file in the real and fake file systems, |
| passing an empty tuple indicates that no arguments to pass |
| to method. |
| real: built-in system library or method from the built-in system |
| library which takes a path as an arg and returns some value. |
| fake: fake_filsystem object or method from a fake_filesystem class |
| which takes a path as an arg and returns some value. |
| method_returns_path: True if the method returns a path, and thus we |
| must compensate for expected difference between real and fake. |
| |
| Returns: |
| A description of the difference in behavior, or None. |
| """ |
| # pylint: disable=C6403 |
| |
| def _error_class(exc): |
| if exc: |
| if hasattr(exc, 'errno'): |
| return '{}({})'.format(exc.__class__.__name__, exc.errno) |
| return exc.__class__.__name__ |
| return 'None' |
| |
| real_err, real_value = self._get_real_value(method_name, path, real) |
| fake_err, fake_value = self._get_fake_value(method_name, path, fake) |
| |
| method_call = f'{method_name}' |
| method_call += '()' if path == () else '({path})' |
| # We only compare on the error class because the acutal error contents |
| # is almost always different because of the file paths. |
| if _error_class(real_err) != _error_class(fake_err): |
| if real_err is None: |
| return '%s: real version returned %s, fake raised %s' % ( |
| method_call, real_value, _error_class(fake_err)) |
| if fake_err is None: |
| return '%s: real version raised %s, fake returned %s' % ( |
| method_call, _error_class(real_err), fake_value) |
| return '%s: real version raised %s, fake raised %s' % ( |
| method_call, _error_class(real_err), _error_class(fake_err)) |
| real_errno = _get_errno(real_err) |
| fake_errno = _get_errno(fake_err) |
| if real_errno != fake_errno: |
| return '%s(%s): both raised %s, real errno %s, fake errno %s' % ( |
| method_name, path, _error_class(real_err), |
| real_errno, fake_errno) |
| # If the method is supposed to return a full path AND both values |
| # begin with the expected full path, then trim it off. |
| if method_returns_path: |
| if (real_value and fake_value |
| and real_value.startswith(self.real_base) |
| and fake_value.startswith(self.fake_base)): |
| real_value = real_value[len(self.real_base):] |
| fake_value = fake_value[len(self.fake_base):] |
| if real_value != fake_value: |
| return '%s: real return %s, fake returned %s' % ( |
| method_call, real_value, fake_value) |
| return None |
| |
| @staticmethod |
| def _get_fake_value(method_name, path, fake): |
| fake_value = None |
| fake_err = None |
| try: |
| fake_method = fake |
| if not callable(fake): |
| fake_method = getattr(fake, method_name) |
| args = [] if path == () else [path] |
| result = fake_method(*args) |
| if isinstance(result, bytes): |
| fake_value = result.decode() |
| else: |
| fake_value = str(result) |
| except Exception as e: # pylint: disable-msg=W0703 |
| fake_err = e |
| return fake_err, fake_value |
| |
| @staticmethod |
| def _get_real_value(method_name, path, real): |
| real_value = None |
| real_err = None |
| # Catching Exception below gives a lint warning, but it's what we need. |
| try: |
| args = [] if path == () else [path] |
| real_method = real |
| if not callable(real): |
| real_method = getattr(real, method_name) |
| result = real_method(*args) |
| if isinstance(result, bytes): |
| real_value = result.decode() |
| else: |
| real_value = str(result) |
| except Exception as e: # pylint: disable-msg=W0703 |
| real_err = e |
| return real_err, real_value |
| |
| def assertOsMethodBehaviorMatches(self, method_name, path, |
| method_returns_path=False): |
| """Invoke an os method in both real and fake contexts and compare. |
| |
| For a given method name (from the os module) and a path, compare the |
| behavior of the system provided module against the fake_filesystem |
| module. |
| We expect results and/or Exceptions raised to be identical. |
| |
| Args: |
| method_name: Name of method being tested. |
| path: potential path to a file in the real and fake file systems. |
| method_returns_path: True if the method returns a path, and thus we |
| must compensate for expected difference between real and fake. |
| |
| Returns: |
| A description of the difference in behavior, or None. |
| """ |
| path = sep(path) |
| return self._compare_behaviors(method_name, path, os, self.fake_os, |
| method_returns_path) |
| |
| def diff_open_method_behavior(self, method_name, path, mode, data, |
| method_returns_data=True): |
| """Invoke an open method in both real and fkae contexts and compare. |
| |
| Args: |
| method_name: Name of method being tested. |
| path: potential path to a file in the real and fake file systems. |
| mode: how to open the file. |
| data: any data to pass to the method. |
| method_returns_data: True if a method returns some sort of data. |
| |
| For a given method name (from builtin open) and a path, compare the |
| behavior of the system provided module against the fake_filesystem |
| module. |
| We expect results and/or Exceptions raised to be identical. |
| |
| Returns: |
| A description of the difference in behavior, or None. |
| """ |
| with open(path, mode) as real_fh: |
| with self.fake_open(path, mode) as fake_fh: |
| return self._compare_behaviors( |
| method_name, data, real_fh, fake_fh, method_returns_data) |
| |
| def diff_os_path_method_behavior(self, method_name, path, |
| method_returns_path=False): |
| """Invoke an os.path method in both real and fake contexts and compare. |
| |
| For a given method name (from the os.path module) and a path, compare |
| the behavior of the system provided module against the |
| fake_filesytem module. |
| We expect results and/or Exceptions raised to be identical. |
| |
| Args: |
| method_name: Name of method being tested. |
| path: potential path to a file in the real and fake file systems. |
| method_returns_path: True if the method returns a path, and thus we |
| must compensate for expected difference between real and fake. |
| |
| Returns: |
| A description of the difference in behavior, or None. |
| """ |
| return self._compare_behaviors(method_name, path, os.path, |
| self.fake_os.path, |
| method_returns_path) |
| |
| def assertOsPathMethodBehaviorMatches(self, method_name, path, |
| method_returns_path=False): |
| """Assert that an os.path behaves the same in both real and |
| fake contexts. |
| |
| Wraps DiffOsPathMethodBehavior, raising AssertionError if any |
| differences are reported. |
| |
| Args: |
| method_name: Name of method being tested. |
| path: potential path to a file in the real and fake file systems. |
| method_returns_path: True if the method returns a path, and thus we |
| must compensate for expected difference between real and fake. |
| |
| Raises: |
| AssertionError if there is any difference in behavior. |
| """ |
| path = sep(path) |
| diff = self.diff_os_path_method_behavior( |
| method_name, path, method_returns_path) |
| if diff: |
| self.fail(diff) |
| |
| def assertAllOsBehaviorsMatch(self, path): |
| path = sep(path) |
| os_method_names = [] if self.is_windows else ['readlink'] |
| os_method_names_no_args = ['getcwd'] |
| os_path_method_names = ['isabs', 'isdir'] |
| if not self.is_windows: |
| os_path_method_names += ['islink', 'lexists'] |
| if not self.is_windows or not IS_PYPY: |
| os_path_method_names += ['isfile', 'exists'] |
| |
| wrapped_methods = [ |
| ['access', self._access_real, self._access_fake], |
| ['stat.size', self._stat_size_real, self._stat_size_fake], |
| ['lstat.size', self._lstat_size_real, self._lstat_size_fake] |
| ] |
| |
| differences = [] |
| for method_name in os_method_names: |
| diff = self.assertOsMethodBehaviorMatches(method_name, path) |
| if diff: |
| differences.append(diff) |
| for method_name in os_method_names_no_args: |
| diff = self.assertOsMethodBehaviorMatches(method_name, (), |
| method_returns_path=True) |
| if diff: |
| differences.append(diff) |
| for method_name in os_path_method_names: |
| diff = self.diff_os_path_method_behavior(method_name, path) |
| if diff: |
| differences.append(diff) |
| for m in wrapped_methods: |
| diff = self._compare_behaviors(m[0], path, m[1], m[2]) |
| if diff: |
| differences.append(diff) |
| if differences: |
| self.fail('Behaviors do not match for %s:\n %s' % |
| (path, '\n '.join(differences))) |
| |
| def assertFileHandleBehaviorsMatch(self, path, mode, data): |
| path = sep(path) |
| write_method_names = ['write', 'writelines'] |
| read_method_names = ['read', 'readlines'] |
| other_method_names = ['truncate', 'flush', 'close'] |
| differences = [] |
| for method_name in write_method_names: |
| diff = self.diff_open_method_behavior( |
| method_name, path, mode, data) |
| if diff: |
| differences.append(diff) |
| for method_name in read_method_names + other_method_names: |
| diff = self.diff_open_method_behavior(method_name, path, mode, ()) |
| if diff: |
| differences.append(diff) |
| if differences: |
| self.fail('Behaviors do not match for %s:\n %s' % |
| (path, '\n '.join(differences))) |
| |
| def assertFileHandleOpenBehaviorsMatch(self, *args, **kwargs): |
| """Compare open() function invocation between real and fake. |
| |
| Runs open(*args, **kwargs) on both real and fake. |
| |
| Args: |
| *args: args to pass through to open() |
| **kwargs: kwargs to pass through to open(). |
| |
| Returns: |
| None. |
| |
| Raises: |
| AssertionError if underlying open() behavior differs from fake. |
| """ |
| real_err = None |
| fake_err = None |
| try: |
| with open(*args, **kwargs): |
| pass |
| except Exception as e: # pylint: disable-msg=W0703 |
| real_err = e |
| |
| try: |
| with self.fake_open(*args, **kwargs): |
| pass |
| except Exception as e: # pylint: disable-msg=W0703 |
| fake_err = e |
| |
| # default equal in case one is None and other is not. |
| is_exception_equal = (real_err == fake_err) |
| if real_err and fake_err: |
| # exception __eq__ doesn't evaluate equal ever, thus manual check. |
| is_exception_equal = (type(real_err) is type(fake_err) and |
| real_err.args == fake_err.args) |
| |
| if not is_exception_equal: |
| msg = ( |
| "Behaviors don't match on open with args %s & kwargs %s.\n" % |
| (args, kwargs)) |
| real_err_msg = 'Real open results in: %s\n' % repr(real_err) |
| fake_err_msg = 'Fake open results in: %s\n' % repr(fake_err) |
| self.fail(msg + real_err_msg + fake_err_msg) |
| |
| # Helpers for checks which are not straight method calls. |
| @staticmethod |
| def _access_real(path): |
| return os.access(path, os.R_OK) |
| |
| def _access_fake(self, path): |
| return self.fake_os.access(path, os.R_OK) |
| |
| def _stat_size_real(self, path): |
| real_path, unused_fake_path = self._paths(path) |
| # fake_filesystem.py does not implement stat().st_size for directories |
| if os.path.isdir(real_path): |
| return None |
| return os.stat(real_path).st_size |
| |
| def _stat_size_fake(self, path): |
| unused_real_path, fake_path = self._paths(path) |
| # fake_filesystem.py does not implement stat().st_size for directories |
| if self.fake_os.path.isdir(fake_path): |
| return None |
| return self.fake_os.stat(fake_path).st_size |
| |
| def _lstat_size_real(self, path): |
| real_path, unused_fake_path = self._paths(path) |
| if os.path.isdir(real_path): |
| return None |
| size = os.lstat(real_path).st_size |
| # Account for the difference in the lengths of the absolute paths. |
| if os.path.islink(real_path): |
| if os.readlink(real_path).startswith(os.sep): |
| size -= len(self.real_base) |
| return size |
| |
| def _lstat_size_fake(self, path): |
| unused_real_path, fake_path = self._paths(path) |
| # size = 0 |
| if self.fake_os.path.isdir(fake_path): |
| return None |
| size = self.fake_os.lstat(fake_path).st_size |
| # Account for the difference in the lengths of the absolute paths. |
| if self.fake_os.path.islink(fake_path): |
| if self.fake_os.readlink(fake_path).startswith(os.sep): |
| size -= len(self.fake_base) |
| return size |
| |
| def test_isabs(self): |
| # We do not have to create any files for isabs. |
| self.assertOsPathMethodBehaviorMatches('isabs', None) |
| self.assertOsPathMethodBehaviorMatches('isabs', '') |
| self.assertOsPathMethodBehaviorMatches('isabs', '/') |
| self.assertOsPathMethodBehaviorMatches('isabs', '/a') |
| self.assertOsPathMethodBehaviorMatches('isabs', 'a') |
| |
| def test_none_path(self): |
| self.assertAllOsBehaviorsMatch(None) |
| |
| def test_empty_path(self): |
| self.assertAllOsBehaviorsMatch('') |
| |
| def test_root_path(self): |
| self.assertAllOsBehaviorsMatch('/') |
| |
| def test_non_existant_file(self): |
| self.assertAllOsBehaviorsMatch('foo') |
| |
| def test_empty_file(self): |
| self._create_test_file('f', 'aFile') |
| self.assertAllOsBehaviorsMatch('aFile') |
| |
| def test_file_with_contents(self): |
| self._create_test_file('f', 'aFile', 'some contents') |
| self.assertAllOsBehaviorsMatch('aFile') |
| |
| def test_file_with_binary_contents(self): |
| self._create_test_file('b', 'aFile', b'some contents') |
| self.assertAllOsBehaviorsMatch('aFile') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_sym_link_to_empty_file(self): |
| self._create_test_file('f', 'aFile') |
| self._create_test_file('l', 'link_to_empty', 'aFile') |
| self.assertAllOsBehaviorsMatch('link_to_empty') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_hard_link_to_empty_file(self): |
| self._create_test_file('f', 'aFile') |
| self._create_test_file('h', 'link_to_empty', 'aFile') |
| self.assertAllOsBehaviorsMatch('link_to_empty') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_sym_link_to_real_file(self): |
| self._create_test_file('f', 'aFile', 'some contents') |
| self._create_test_file('l', 'link_to_file', 'aFile') |
| self.assertAllOsBehaviorsMatch('link_to_file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_hard_link_to_real_file(self): |
| self._create_test_file('f', 'aFile', 'some contents') |
| self._create_test_file('h', 'link_to_file', 'aFile') |
| self.assertAllOsBehaviorsMatch('link_to_file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_broken_sym_link(self): |
| self._create_test_file('l', 'broken_link', 'broken') |
| self._create_test_file('l', 'loop', '/a/loop') |
| self.assertAllOsBehaviorsMatch('broken_link') |
| |
| def test_file_in_a_folder(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('f', 'a/b/file', 'contents') |
| self.assertAllOsBehaviorsMatch('a/b/file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_absolute_sym_link_to_folder(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('f', 'a/b/file', 'contents') |
| self._create_test_file('l', 'a/link', '/a/b') |
| self.assertAllOsBehaviorsMatch('a/link/file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_link_to_folder_after_chdir(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('f', 'a/b/file', 'contents') |
| self._create_test_file('l', 'a/link', '/a/b') |
| |
| real_dir, fake_dir = self._paths('a/b') |
| os.chdir(real_dir) |
| self.fake_os.chdir(fake_dir) |
| self.assertAllOsBehaviorsMatch('file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_relative_sym_link_to_folder(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('f', 'a/b/file', 'contents') |
| self._create_test_file('l', 'a/link', 'b') |
| self.assertAllOsBehaviorsMatch('a/link/file') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_sym_link_to_parent(self): |
| # Soft links on HFS+ / OS X behave differently. |
| if os.uname()[0] != 'Darwin': |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('l', 'a/b/c', '..') |
| self.assertAllOsBehaviorsMatch('a/b/c') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_path_through_sym_link_to_parent(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('f', 'a/target', 'contents') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('l', 'a/b/c', '..') |
| self.assertAllOsBehaviorsMatch('a/b/c/target') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_sym_link_to_sibling_directory(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self._create_test_file('l', 'a/b/c', '../sibling_of_b') |
| self.assertAllOsBehaviorsMatch('a/b/c/target') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_sym_link_to_sibling_directory_non_existant_file(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self._create_test_file('l', 'a/b/c', '../sibling_of_b') |
| self.assertAllOsBehaviorsMatch('a/b/c/file_does_not_exist') |
| |
| @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows') |
| def test_broken_sym_link_to_sibling_directory(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self._create_test_file('l', 'a/b/c', '../broken_sibling_of_b') |
| self.assertAllOsBehaviorsMatch('a/b/c/target') |
| |
| def test_relative_path(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self.assertAllOsBehaviorsMatch('a/b/../sibling_of_b/target') |
| |
| def test_broken_relative_path(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self.assertAllOsBehaviorsMatch('a/b/../broken/target') |
| |
| def test_bad_relative_path(self): |
| self._create_test_file('d', 'a') |
| self._create_test_file('f', 'a/target', 'contents') |
| self._create_test_file('d', 'a/b') |
| self._create_test_file('d', 'a/sibling_of_b') |
| self._create_test_file('f', 'a/sibling_of_b/target', 'contents') |
| self.assertAllOsBehaviorsMatch('a/b/../broken/../target') |
| |
| def test_getmtime_nonexistant_path(self): |
| self.assertOsPathMethodBehaviorMatches('getmtime', 'no/such/path') |
| |
| def test_builtin_open_modes(self): |
| self._create_test_file('f', 'read', 'some contents') |
| self._create_test_file('f', 'write', 'some contents') |
| self._create_test_file('f', 'append', 'some contents') |
| self.assertFileHandleBehaviorsMatch('read', 'r', 'other contents') |
| self.assertFileHandleBehaviorsMatch('write', 'w', 'other contents') |
| self.assertFileHandleBehaviorsMatch('append', 'a', 'other contents') |
| self._create_test_file('f', 'readplus', 'some contents') |
| self._create_test_file('f', 'writeplus', 'some contents') |
| self.assertFileHandleBehaviorsMatch( |
| 'readplus', 'r+', 'other contents') |
| self.assertFileHandleBehaviorsMatch( |
| 'writeplus', 'w+', 'other contents') |
| self._create_test_file('b', 'binaryread', b'some contents') |
| self._create_test_file('b', 'binarywrite', b'some contents') |
| self._create_test_file('b', 'binaryappend', b'some contents') |
| self.assertFileHandleBehaviorsMatch( |
| 'binaryread', 'rb', b'other contents') |
| self.assertFileHandleBehaviorsMatch( |
| 'binarywrite', 'wb', b'other contents') |
| self.assertFileHandleBehaviorsMatch( |
| 'binaryappend', 'ab', b'other contents') |
| self.assertFileHandleBehaviorsMatch('read', 'rb', 'other contents') |
| self.assertFileHandleBehaviorsMatch('write', 'wb', 'other contents') |
| self.assertFileHandleBehaviorsMatch('append', 'ab', 'other contents') |
| |
| # binary cannot have encoding |
| self.assertFileHandleOpenBehaviorsMatch('read', 'rb', encoding='enc') |
| self.assertFileHandleOpenBehaviorsMatch( |
| 'write', mode='wb', encoding='enc') |
| self.assertFileHandleOpenBehaviorsMatch('append', 'ab', encoding='enc') |
| |
| # text can have encoding |
| self.assertFileHandleOpenBehaviorsMatch('read', 'r', encoding='utf-8') |
| self.assertFileHandleOpenBehaviorsMatch('write', 'w', encoding='utf-8') |
| self.assertFileHandleOpenBehaviorsMatch( |
| 'append', 'a', encoding='utf-8') |
| |
| |
| def main(_): |
| unittest.main() |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
