Linking AvailabilityFinder with APIDataSource and intro-table templates.

chrome/common/extensions/docs/server2/cron_servlet_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 unittest
 
 from appengine_wrappers import GetAppVersion
 from app_yaml_helper import AppYamlHelper
-from caching_file_system import CachingFileSystem
 from cron_servlet import CronServlet
 from empty_dir_file_system import EmptyDirFileSystem
 from host_file_system_creator import HostFileSystemCreator
 from local_file_system import LocalFileSystem
 from mock_file_system import MockFileSystem
 from servlet import Request
 from test_branch_utility import TestBranchUtility
 from test_file_system import TestFileSystem
 from test_util import EnableLogging
 
@@ skipping 29 matching lines @@
     self._app_version = app_version
 
 class CronServletTest(unittest.TestCase):
   @EnableLogging('info')
   def testEverything(self):
     # All these tests are dependent (see above comment) so lump everything in
     # the one test.
     delegate = _TestDelegate(
         lambda _, __: MockFileSystem(LocalFileSystem.Create()))
 
+    # A file system will be created for the server instance, and one
+    # will also be created by AvailabilityFinder for each version from trunk, to
+    # version 28 (dev), down to and including version 17. This amounts to 14
+    # total. The dev version is determined by the test data that
+    # TestBranchUtility has access to. Version 17 is where AvailabilityFinder
+    # halts during tests.
+    num_file_systems = 14

[epeterson, 2013/07/16 00:28:23]

This is a pretty magical number. I mean, anything with that much justification
is suspicious.

Now that an AvailabilityFinder instance is actually being called from
APIDataSource, extra file systems are being created.

So, 'num_file_systems' is determined by the data that the TestBranchUtility has
access to, which currently has 'dev' set as version 28. And AvailabilityFinder
goes down to version 17 before bailing because it can't find extension_api.json.
So that's 13 file systems (17-28 and trunk) plus another host file system for
the server instance.

TestBranchUtility could probably expose a method that calculates this
number (and there could be a nice explanative doc comment there), though I'm not
sure if this is a better idea than the test divergent primary_for_test flag,
which came up in the HostFileSystemCreator code review.

[not at google - send to devlin, 2013/07/16 22:25:00]

Ok maybe the answer here is just the test isn't meaningful anymore (at least,
the assertEqual(num_file_systems...) part).

So let's delete those.

Then this test could be something like:

response = CronServlet(Request.ForTest('trunk'), ...)
self.assertEqual(200, response.status)

# Save the file systems created, start with a fresh set for the next run.
first_run_file_systems = delegate.file_systems[:]
delegate.file_systems[:] = []

# When re-running....
response = CronServlet(Request.ForTest('trunk'), ...)
self.assertEqual(200, response.status)

self.assertEqual(len(first_run_file_systems), len(delegate.file_systems))
for i, second_run_file_system in enumerate(delegate.file_systems):
  self.assertTrue(*second_run_file_system.CheckAndReset(
      read_count=0,
      stat_count=first_run_file_systems[i].GetStatCount())

Does that seem ok?

[epeterson, 2013/07/17 23:48:23]

That seems ok.

     # Test that the cron runs successfully.
     response = CronServlet(Request.ForTest('trunk'),
                            delegate_for_test=delegate).Get()
-    self.assertEqual(1, len(delegate.file_systems))
+    self.assertEqual(num_file_systems, len(delegate.file_systems))
     self.assertEqual(200, response.status)
 
     # When re-running, all file systems should be Stat()d the same number of
     # times, but the second round shouldn't have been re-Read() since the
     # Stats haven't changed.
     response = CronServlet(Request.ForTest('trunk'),
                            delegate_for_test=delegate).Get()
-    self.assertEqual(2, len(delegate.file_systems))
-    self.assertTrue(*delegate.file_systems[1].CheckAndReset(
-        read_count=0,
-        stat_count=delegate.file_systems[0].GetStatCount()))
+    self.assertEqual(num_file_systems * 2, len(delegate.file_systems))
+    for x in range (0, num_file_systems):
+      self.assertTrue(*delegate.file_systems[x + num_file_systems]
+          .CheckAndReset(read_count=0,
+                         stat_count=delegate.file_systems[x].GetStatCount()))
 
   def testSafeRevision(self):
     test_data = {
       'docs': {
         'examples': {
           'examples.txt': 'examples.txt contents'
         },
         'server2': {
           'app.yaml': AppYamlHelper.GenerateAppYaml('2-0-8')
         },
@@ skipping 114 matching lines @@
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-1-0'),
                      file_systems[-1].ReadSingle(app_yaml_path))
     self.assertEqual('y u not update!',
                      file_systems[-1].ReadSingle(storage_html_path))
     self.assertEqual('important content!',
                      file_systems[-1].ReadSingle(static_txt_path))
 
 if __name__ == '__main__':
   unittest.main()