name : fake_filesystem_vs_real_test.py # Copyright 2009 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Test that FakeFilesystem calls work identically to a real filesystem.""" # pylint: disable-all import os import shutil import sys import tempfile import time import unittest from pyfakefs import fake_filesystem, fake_os, fake_open from pyfakefs.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 = "C:\\fakefs" if is_windows else "/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_os.FakeOsModule(self.fake_filesystem) self.fake_open = fake_open.FakeFileOpen(self.fake_filesystem) self._created_files = [] os.chdir(self.real_base) self.fake_os.chdir(self.fake_base) def tearDown(self): # We have to remove all the files from the real FS. Doing the same for # the fake FS is optional, but doing it is an extra sanity check. os.chdir(tempfile.gettempdir()) try: rev_files = self._created_files[:] rev_files.reverse() for info in rev_files: real_path, fake_path = self._paths(info[1]) if info[0] == "d": try: os.rmdir(real_path) except OSError as e: if "Directory not empty" in e: self.fail( "Real path %s not empty: %s : %s" % (real_path, e, os.listdir(real_path)) ) else: raise self.fake_os.rmdir(fake_path) if info[0] == "f" or info[0] == "l": os.remove(real_path) self.fake_os.remove(fake_path) finally: shutil.rmtree(self.real_base) os.chdir(self.cwd) def _compare_behaviors( self, method_name, path, real, fake, method_returns_path=False ): """Invoke an os method in both real and fake contexts and compare results. Invoke a real filesystem method with a path to a real file and invoke a fake filesystem method with a path to a fake file and compare the results. We expect some calls to throw Exceptions, so we catch those and compare them. Args: method_name: Name of method being tested, for use in error messages. path: potential path to a file in the real and fake file systems, passing an empty tuple indicates that no arguments to pass to method. real: built-in system library or method from the built-in system library which takes a path as an arg and returns some value. fake: fake_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()