Add side_effect option to fake files

pyfakefs/fake_filesystem.py

@@ -207,7 +207,8 @@ class FakeFile(object):
     )
 
     def __init__(self, name, st_mode=S_IFREG | PERM_DEF_FILE,
-                 contents=None, filesystem=None, encoding=None, errors=None):
+                 contents=None, filesystem=None, encoding=None, errors=None,
+                 side_effect=None):
         """
         Args:
             name: Name of the file/directory, without parent path information
@@ -220,12 +221,14 @@ def __init__(self, name, st_mode=S_IFREG | PERM_DEF_FILE,
             encoding: If contents is a unicode string, the encoding used
                 for serialization.
             errors: The error mode used for encoding/decoding errors.
+            side_effect: function handle that is executed when file is written,
+                must accept the file object as an argument.
         """
         # to be backwards compatible regarding argument order, we raise on None
         if filesystem is None:
             raise ValueError('filesystem shall not be None')
         self.filesystem = filesystem
-
+        self._side_effect = side_effect
         self.name = name
         self.stat_result = FakeStatResult(
             filesystem.is_windows_fs, time.time())
@@ -357,6 +360,7 @@ def _set_initial_contents(self, contents):
 
     def set_contents(self, contents, encoding=None):
         """Sets the file contents and size and increases the modification time.
+        Also executes the side_effects if available.
 
         Args:
           contents: (str, bytes, unicode) new content of file.
@@ -373,6 +377,8 @@ def set_contents(self, contents, encoding=None):
         current_time = time.time()
         self.st_ctime = current_time
         self.st_mtime = current_time
+        if self._side_effect is not None:
+            self._side_effect(self)
 
     @property
     def size(self):
@@ -520,7 +526,7 @@ class FakeFileFromRealFile(FakeFile):
     The contents of the file are read on demand only.
     """
 
-    def __init__(self, file_path, filesystem):
+    def __init__(self, file_path, filesystem, side_effect=None):
         """
         Args:
             file_path: Path to the existing file.
@@ -531,7 +537,8 @@ def __init__(self, file_path, filesystem):
             OSError: if the file already exists in the fake file system.
         """
         super(FakeFileFromRealFile, self).__init__(
-            name=os.path.basename(file_path), filesystem=filesystem)
+            name=os.path.basename(file_path), filesystem=filesystem,
+            side_effect=side_effect)
         self.contents_read = False
 
     @property
@@ -2252,7 +2259,8 @@ def create_dir(self, directory_path, perm_bits=PERM_DEF):
 
     def create_file(self, file_path, st_mode=S_IFREG | PERM_DEF_FILE,
                     contents='', st_size=None, create_missing_dirs=True,
-                    apply_umask=False, encoding=None, errors=None):
+                    apply_umask=False, encoding=None, errors=None,
+                    side_effect=None):
         """Create `file_path`, including all the parent directories along
         the way.
 
@@ -2272,6 +2280,8 @@ def create_file(self, file_path, st_mode=S_IFREG | PERM_DEF_FILE,
             encoding: If `contents` is a unicode string, the encoding used
                 for serialization.
             errors: The error mode used for encoding/decoding errors.
+            side_effect: function handle that is executed when file is written,
+                must accept the file object as an argument.
 
         Returns:
             The newly created FakeFile object.
@@ -2282,7 +2292,7 @@ def create_file(self, file_path, st_mode=S_IFREG | PERM_DEF_FILE,
         """
         return self.create_file_internally(
             file_path, st_mode, contents, st_size, create_missing_dirs,
-            apply_umask, encoding, errors)
+            apply_umask, encoding, errors, side_effect=side_effect)
 
     def add_real_file(self, source_path, read_only=True, target_path=None):
         """Create `file_path`, including all the parent directories along the
@@ -2411,7 +2421,8 @@ def create_file_internally(self, file_path,
                                contents='', st_size=None,
                                create_missing_dirs=True,
                                apply_umask=False, encoding=None, errors=None,
-                               read_from_real_fs=False, raw_io=False):
+                               read_from_real_fs=False, raw_io=False,
+                               side_effect=None):
         """Internal fake file creator that supports both normal fake files
         and fake files based on real files.
 
@@ -2432,6 +2443,8 @@ def create_file_internally(self, file_path,
             read_from_real_fs: if True, the contents are read from the real
                 file system on demand.
             raw_io: `True` if called from low-level API (`os.open`)
+            side_effect: function handle that is executed when file is written,
+                must accept the file object as an argument.
         """
         error_fct = self.raise_os_error if raw_io else self.raise_io_error
         file_path = self.make_string_path(file_path)
@@ -2455,10 +2468,12 @@ def create_file_internally(self, file_path,
         if apply_umask:
             st_mode &= ~self.umask
         if read_from_real_fs:
-            file_object = FakeFileFromRealFile(file_path, filesystem=self)
+            file_object = FakeFileFromRealFile(file_path, filesystem=self,
+                                               side_effect=side_effect)
         else:
             file_object = FakeFile(new_file, st_mode, filesystem=self,
-                                   encoding=encoding, errors=errors)
+                                   encoding=encoding, errors=errors,
+                                   side_effect=side_effect)
 
         self._last_ino += 1
         file_object.st_ino = self._last_ino

pyfakefs/tests/fake_filesystem_test.py

@@ -2035,5 +2035,36 @@ def test_add_existing_real_paths_read_write(self):
         self.check_writable_file(fake_file, real_file_path)
 
 
+class FileSideEffectTests(TestCase):
+    def side_effect(self):
+        test_case = self
+        test_case.side_effect_called = False
+
+        def __side_effect(file_object):
+            test_case.side_effect_called = True
+            test_case.side_effect_file_object_content = file_object.contents
+        return __side_effect
+
+    def setUp(self):
+        # use the real path separator to work with the real file system
+        self.filesystem = fake_filesystem.FakeFilesystem()
+        self.filesystem.create_file('/a/b/file_one',
+                                    side_effect=self.side_effect())
+
+    def test_side_effect_called(self):
+        fake_open = fake_filesystem.FakeFileOpen(self.filesystem)
+        self.side_effect_called = False
+        with fake_open('/a/b/file_one', 'w') as handle:
+            handle.write('foo')
+        self.assertTrue(self.side_effect_called)
+
+    def test_side_effect_file_object(self):
+        fake_open = fake_filesystem.FakeFileOpen(self.filesystem)
+        self.side_effect_called = False
+        with fake_open('/a/b/file_one', 'w') as handle:
+            handle.write('foo')
+        self.assertEquals(self.side_effect_file_object_content, 'foo')
+
+
 if __name__ == '__main__':
     unittest.main()