Docserver: Add more skip_not_found support and cache "not found"s

chrome/common/extensions/docs/server2/caching_file_system_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import os
 import sys
 import unittest
 
 from caching_file_system import CachingFileSystem
 from extensions_paths import SERVER2
-from file_system import  StatInfo
+from file_system import FileNotFoundError, StatInfo
 from local_file_system import LocalFileSystem
 from mock_file_system import MockFileSystem
 from object_store_creator import ObjectStoreCreator
 from test_file_system import TestFileSystem
 from test_object_store import TestObjectStore
 
 
 def _CreateLocalFs():
   return LocalFileSystem.Create(SERVER2, 'test_data', 'file_system/')
 
@@ skipping 129 matching lines @@
     file_system = create_empty_caching_fs()
     file_system._stat_object_store.Del('bob/bob0')
     future = file_system.ReadSingle('bob/bob0')
     self.assertTrue(*mock_fs.CheckAndReset(read_count=1))
     self.assertEqual('bob/bob0 contents', future.Get())
     self.assertTrue(*mock_fs.CheckAndReset(read_resolve_count=1, stat_count=1))
     self.assertEqual('bob/bob0 contents',
                      file_system.ReadSingle('bob/bob0').Get())
     self.assertTrue(*mock_fs.CheckAndReset())
 
+    file_system = create_empty_caching_fs()
+    future = file_system.ReadSingle('bob/no_file', skip_not_found=True)
+    self.assertTrue(*mock_fs.CheckAndReset(read_count=1))
+    self.assertEqual(None, future.Get())
+    self.assertTrue(*mock_fs.CheckAndReset(read_resolve_count=1, stat_count=1))
+    future = file_system.ReadSingle('bob/no_file', skip_not_found=True)
+    # There shouldn't be another read/stat from the file system;
+    # we know the file is not there.
+    self.assertTrue(*mock_fs.CheckAndReset())
+    future = file_system.ReadSingle('bob/no_file')
+    # Even though we cached information about non-existent files,
+    # trying to read one without specifiying skip_not_found should
+    # still raise an error.
+    self.assertRaises(FileNotFoundError, future.Get)

[not at google - send to devlin, 2014/08/26 20:59:34]

Nice tests. Is it possible to extend the test to check that incrementing the
stat for the directory will re-read the file? And that if the file happens to
appear, it picks it up?

[ahernandez, 2014/08/27 18:54:38]

I'm not sure I can do that, because Stat updates are not caught once they've
been cached -- there's even a test to verify that behavior.

[not at google - send to devlin, 2014/08/27 19:22:13]

Isn't this line 107 kinda?

[ahernandez, 2014/08/27 19:29:00]

That does increment the stat, but the stat_cache doesn't get updated, because it
already has a cached value for the directory. In fact, I think those tests are
kinda pointless because creating a new empty caching file system clears the
caches, so the resource would be re-fetched regardless of the stat, right?

[not at google - send to devlin, 2014/08/27 19:32:49]

Ah yes I think you're right, those tests are ... pointless. Ok. Perhaps the
intention was to re-use the object store. Whatevs.

+
   def testCachedStat(self):
     test_fs = TestFileSystem({
       'bob': {
         'bob0': 'bob/bob0 contents',
         'bob1': 'bob/bob1 contents'
       }
     })
     mock_fs = MockFileSystem(test_fs)
 
     file_system = self._CreateCachingFileSystem(mock_fs, start_empty=False)
@@ skipping 40 matching lines @@
         self.assertEqual(StatInfo(stat), file_system.Stat('bob/bob0'))
         self.assertEqual(StatInfo(stat), file_system.Stat('bob/bob0'))
         self.assertTrue(*mock_fs.CheckAndReset())
       run()
       run()
 
     run_expecting_stat('0')
     test_fs.IncrementStat()
     run_expecting_stat('1')
 
-    def testSkipNotFound(self):
-      caching_fs = self._CreateCachingFileSystem(TestFileSystem({
-        'bob': {
-          'bob0': 'bob/bob0 contents',
-          'bob1': 'bob/bob1 contents'
-        }
-      }))
-      def read_skip_not_found(paths):
-        return caching_fs.Read(paths, skip_not_found=True).Get()
-      self.assertEqual({}, read_skip_not_found(('grub',)))
-      self.assertEqual({}, read_skip_not_found(('bob/bob2',)))
-      self.assertEqual({
-        'bob/bob0': 'bob/bob0 contents',
-      }, read_skip_not_found(('bob/bob0', 'bob/bob2')))
+  def testSkipNotFound(self):

[ahernandez, 2014/08/26 20:08:37]

This test wasn't even running before because of improper indentation!

[not at google - send to devlin, 2014/08/26 20:59:34]

Oh man :\ good catch.

+    caching_fs = self._CreateCachingFileSystem(TestFileSystem({
+      'bob': {
+        'bob0': 'bob/bob0 contents',
+        'bob1': 'bob/bob1 contents'
+      }
+    }))
+    def read_skip_not_found(paths):
+      return caching_fs.Read(paths, skip_not_found=True).Get()
+    self.assertEqual({}, read_skip_not_found(('grub',)))
+    self.assertEqual({}, read_skip_not_found(('bob/bob2',)))
+    self.assertEqual({
+      'bob/bob0': 'bob/bob0 contents',
+    }, read_skip_not_found(('bob/bob0', 'bob/bob2')))
 
 
 if __name__ == '__main__':
   unittest.main()