Docserver: make file_system a property of Create

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 os
 
 from appengine_wrappers import GetAppVersion
 from compiled_file_system import CompiledFileSystem
 from copy import deepcopy
@@ skipping 21 matching lines @@
     }
   },
   'extensions': {
     'activeTab.html': 'activeTab.html contents',
     'alarms.html': 'alarms.html contents'
   }
 }
 
 identity = lambda _, x: x
 
-def _CreateFactory():
-  return CompiledFileSystem.Factory(
-      TestFileSystem(deepcopy(_TEST_DATA)),
-      ObjectStoreCreator(start_empty=False,
-                         store_type=TestObjectStore,
-                         disable_wrappers=True))
+def _CreateTestObjects():

[Jeffrey Yasskin, 2013/10/14 18:52:31]

Instead of returning an obscure tuple, how about returning the Create() function
with 'fs' bound in:

def _CreateFactory():
  factory = CompiledFileSystem.Factory(
           ObjectStoreCreator(start_empty=False,
                              store_type=TestObjectStore,
                              disable_wrappers=True))
  return functools.partial(factory.Create, TestFileSystem(deepcopy(_TEST_DATA)))

[not at google - send to devlin, 2013/10/14 21:03:34]

Done.

+  '''Returns a tuple (CompiledFileSystem.Factory, FileSystem) configured for
+  this test.
+  '''
+  return (
+      CompiledFileSystem.Factory(
+          ObjectStoreCreator(start_empty=False,
+                             store_type=TestObjectStore,
+                             disable_wrappers=True)),
+      TestFileSystem(deepcopy(_TEST_DATA)))
 
 class CompiledFileSystemTest(unittest.TestCase):
   def testPopulateNamespace(self):
     def CheckNamespace(expected_file, expected_list, fs):
       self.assertEqual(expected_file, fs._file_object_store.namespace)
       self.assertEqual(expected_list, fs._list_object_store.namespace)
-    factory = _CreateFactory()
+    factory, fs = _CreateTestObjects()
     f = lambda x: x
     CheckNamespace(
         'class=CompiledFileSystem&'
             'category=CompiledFileSystemTest/TestFileSystem/file&'
             'app_version=%s' % GetAppVersion(),
         'class=CompiledFileSystem&'
             'category=CompiledFileSystemTest/TestFileSystem/list&'
             'app_version=%s' % GetAppVersion(),
-        factory.Create(f, CompiledFileSystemTest))
+        factory.Create(fs, f, CompiledFileSystemTest))
     CheckNamespace(
         'class=CompiledFileSystem&'
             'category=CompiledFileSystemTest/TestFileSystem/foo/file&'
             'app_version=%s' % GetAppVersion(),
         'class=CompiledFileSystem&'
             'category=CompiledFileSystemTest/TestFileSystem/foo/list&'
             'app_version=%s' % GetAppVersion(),
-        factory.Create(f, CompiledFileSystemTest, category='foo'))
+        factory.Create(fs, f, CompiledFileSystemTest, category='foo'))
 
   def testPopulateFromFile(self):
     def Sleepy(key, val):
       return '%s%s' % ('Z' * len(key), 'z' * len(val))
-    compiled_fs = _CreateFactory().Create(Sleepy, CompiledFileSystemTest)
+    factory, fs = _CreateTestObjects()
+    compiled_fs = factory.Create(fs, Sleepy, CompiledFileSystemTest)
     self.assertEqual('ZZZZZZZZzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('404.html').Get())
     self.assertEqual('ZZZZZZZZZZZZZZzzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('apps/a11y.html').Get())
     self.assertEqual('ZZZZZZZZZZZZZZZZZZZZZZZzzzzzzzzzzzzzzzzzz',
                      compiled_fs.GetFromFile('/apps/fakedir/file.html').Get())
 
   def testPopulateFromFileListing(self):
     def strip_ext(path, files):
       return [os.path.splitext(f)[0] for f in files]
 
-    compiled_fs = _CreateFactory().Create(strip_ext, CompiledFileSystemTest)
+    factory, fs = _CreateTestObjects()
+    compiled_fs = factory.Create(fs, strip_ext, CompiledFileSystemTest)
     expected_top_listing = [
       '404',
       'apps/a11y',
       'apps/about_apps',
       'apps/deepdir/deeper/deepest',
       'apps/deepdir/deepfile',
       'apps/fakedir/file',
       'extensions/activeTab',
       'extensions/alarms'
     ]
@@ skipping 23 matching lines @@
                      sorted(compiled_fs.GetFromFileListing(
                          'apps/deepdir/').Get()))
     self.assertEqual(['deepest'],
                      compiled_fs.GetFromFileListing(
                          '/apps/deepdir/deeper/').Get())
     self.assertEqual(['deepest'],
                      compiled_fs.GetFromFileListing(
                          'apps/deepdir/deeper/').Get())
 
   def testCaching(self):
-    compiled_fs = _CreateFactory().Create(identity, CompiledFileSystemTest)
+    factory, fs = _CreateTestObjects()
+    compiled_fs = factory.Create(fs, 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._obj['404.html'] = 'boom'
     compiled_fs._file_system._obj['apps']['fakedir']['boom.html'] = 'blam'
     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.IncrementStat()
     self.assertEqual('boom', compiled_fs.GetFromFile('404.html').Get())
     self.assertEqual(set(('file.html', 'boom.html')),
                      set(compiled_fs.GetFromFileListing('apps/fakedir').Get()))
 
   def testFailures(self):
-    compiled_fs = _CreateFactory().Create(identity, CompiledFileSystemTest)
+    factory, fs = _CreateTestObjects()
+    compiled_fs = factory.Create(fs, identity, CompiledFileSystemTest)
     self.assertRaises(FileNotFoundError,
                       compiled_fs.GetFromFile('405.html').Get)
     # TODO(kalman): would be nice to test this fails since apps/ is a dir.
     compiled_fs.GetFromFile('apps/')
     #self.assertRaises(SomeError, compiled_fs.GetFromFile, 'apps/')
     self.assertRaises(FileNotFoundError,
                       compiled_fs.GetFromFileListing('nodir/').Get)
     # TODO(kalman): likewise, not a FileNotFoundError.
     self.assertRaises(FileNotFoundError,
                       compiled_fs.GetFromFileListing('404.html').Get)
 
   def testCorrectFutureBehaviour(self):
     # Tests that the underlying FileSystem's Read Future has had Get() called
     # on it before the Future is resolved, but the underlying Future isn't
     # resolved until Get is.
     mock_fs = MockFileSystem(TestFileSystem(_TEST_DATA))
     compiled_fs = CompiledFileSystem.Factory(
-        mock_fs, ObjectStoreCreator.ForTest()).Create(
-            lambda path, contents: contents, type(self))
+        ObjectStoreCreator.ForTest()).Create(
+            mock_fs, lambda path, contents: contents, type(self))
 
     self.assertTrue(*mock_fs.CheckAndReset())
     future = compiled_fs.GetFromFile('404.html')
     self.assertTrue(*mock_fs.CheckAndReset(stat_count=1, read_count=1))
     future.Get()
     self.assertTrue(*mock_fs.CheckAndReset(read_resolve_count=1))
 
     future = compiled_fs.GetFromFileListing('apps/')
     # Current behaviour is to have read=2 and read_resolve=1 because the first
     # level is read eagerly, then all of the second is read (in parallel). If
@@ skipping 23 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))
 
 
 
 if __name__ == '__main__':
   unittest.main()