Docserver: Add @Cache annotation to CompiledFileSystem

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

 #!/usr/bin/env python
 # Copyright 2013 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 functools
 import os
 
-from compiled_file_system import CompiledFileSystem
+from compiled_file_system import Cache, CompiledFileSystem
 from copy import deepcopy
 from environment import GetAppVersion
 from file_system import FileNotFoundError
 from mock_file_system import MockFileSystem
 from object_store_creator import ObjectStoreCreator
 from test_file_system import TestFileSystem
 from test_object_store import TestObjectStore
 import unittest
 
 _TEST_DATA = {
@@ skipping 60 matching lines @@
       return '%s%s' % ('Z' * len(key), 'z' * len(val))
     compiled_fs = _GetTestCompiledFsCreator()(Sleepy, CompiledFileSystemTest)
     self.assertEqual('ZZZZZZZZzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('404.html').Get())
     self.assertEqual('ZZZZZZZZZZZZZZzzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('apps/a11y.html').Get())
     self.assertEqual('ZZZZZZZZZZZZZZZZZZZZZZzzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('apps/fakedir/file.html').Get())
 
   def testPopulateFromFileListing(self):
-    def strip_ext(path, files):
+    def strip_ext(_, files):
       return [os.path.splitext(f)[0] for f in files]
     compiled_fs = _GetTestCompiledFsCreator()(strip_ext, CompiledFileSystemTest)
     expected_top_listing = [
       '404',
       'apps/a11y',
       'apps/about_apps',
       'apps/deepdir/deeper/deepest',
       'apps/deepdir/deepfile',
       'apps/fakedir/file',
       'extensions/activeTab',
@@ skipping 13 matching lines @@
     self.assertEqual(['file',],
                      compiled_fs.GetFromFileListing('apps/fakedir/').Get())
     self.assertEqual(['deeper/deepest', 'deepfile'],
                      sorted(compiled_fs.GetFromFileListing(
                          'apps/deepdir/').Get()))
     self.assertEqual(['deepest'],
                      compiled_fs.GetFromFileListing(
                          'apps/deepdir/deeper/').Get())
 
   def testCaching(self):
-    compiled_fs = _GetTestCompiledFsCreator()(identity, CompiledFileSystemTest)
+    compiled_fs = _GetTestCompiledFsCreator()(Cache(identity),
+                                              CompiledFileSystemTest)
     self.assertEqual('404.html contents',
                      compiled_fs.GetFromFile('404.html').Get())
     self.assertEqual(set(('file.html',)),
                      set(compiled_fs.GetFromFileListing('apps/fakedir/').Get()))
 
     compiled_fs._file_system._path_values['404.html'] = 'boom'
     compiled_fs._file_system._path_values['apps/fakedir/'] = [
         'file.html', 'boom.html']
     self.assertEqual('404.html contents',
                      compiled_fs.GetFromFile('404.html').Get())
@@ skipping 62 matching lines @@
     self.assertTrue(*mock_fs.CheckAndReset(stat_count=1,
                                            read_count=2,
                                            read_resolve_count=1))
     future.Get()
     self.assertTrue(*mock_fs.CheckAndReset(read_count=2, read_resolve_count=3))
 
   def testSkipNotFound(self):
     mock_fs = MockFileSystem(TestFileSystem(_TEST_DATA))
     compiled_fs = CompiledFileSystem.Factory(
         ObjectStoreCreator.ForTest()).Create(
-            mock_fs, lambda path, contents: contents, type(self))
+            mock_fs, Cache(lambda path, contents: contents), type(self))
 
     future = compiled_fs.GetFromFile('no_file', skip_not_found=True)
     # If the file doesn't exist, then the file system is not read.
     self.assertTrue(*mock_fs.CheckAndReset(read_count=1, stat_count=1))
     self.assertEqual(None, future.Get())
     self.assertTrue(*mock_fs.CheckAndReset(read_resolve_count=1))
     future = compiled_fs.GetFromFile('no_file', skip_not_found=True)
     self.assertTrue(*mock_fs.CheckAndReset(stat_count=1))
     self.assertEqual(None, future.Get())
     # The result for a non-existent file should still be cached.
     self.assertTrue(*mock_fs.CheckAndReset())
     future = compiled_fs.GetFromFile('no_file')
     self.assertRaises(FileNotFoundError, future.Get)
 
 
 if __name__ == '__main__':
   unittest.main()