Docserver: Serve docs out of src/ not src/chrome/common/extensions. This allows

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 cron_servlet import CronServlet
 from empty_dir_file_system import EmptyDirFileSystem
+from extensions_paths import (
+    APP_YAML, CONTENT_PROVIDERS, EXTENSIONS, PUBLIC_TEMPLATES, SERVER2,
+    STATIC_DOCS)
 from github_file_system_provider import GithubFileSystemProvider
 from host_file_system_provider import HostFileSystemProvider
 from local_file_system import LocalFileSystem
 from mock_file_system import MockFileSystem
 from servlet import Request
-from svn_constants import JSON_PATH
 from test_branch_utility import TestBranchUtility
-from test_file_system import TestFileSystem
+from test_file_system import MoveTo, TestFileSystem
 from test_util import EnableLogging, ReadFile
 
+
 # NOTE(kalman): The ObjectStore created by the CronServlet is backed onto our
 # fake AppEngine memcache/datastore, so the tests aren't isolated. Of course,
 # if the host file systems have different identities, they will be, sort of.
 class _TestDelegate(CronServlet.Delegate):
   def __init__(self, create_file_system):
     self.file_systems = []
     # A callback taking a revision and returning a file system.
     self._create_file_system = create_file_system
     self._app_version = GetAppVersion()
 
@@ skipping 70 matching lines @@
         'templates': {
           'public': {
             'apps': {
               'storage.html': 'storage.html contents'
             },
             'extensions': {
               'storage.html': 'storage.html contents'
             },
           },
           'json': {
-            'content_providers.json': ReadFile('%s/content_providers.json' %
-                                               JSON_PATH),
+            'content_providers.json': ReadFile(CONTENT_PROVIDERS),
             'manifest.json': '{}',
             'permissions.json': '{}',
             'strings.json': '{}',
             'apps_sidenav.json': '{}',
             'extensions_sidenav.json': '{}',
           },
         }
       }
     }
 
     updates = []
 
     def app_yaml_update(version):
-      return {'docs': {'server2': {
+      return MoveTo(SERVER2, {
         'app.yaml': AppYamlHelper.GenerateAppYaml(version)
-      }}}
+      })
     def storage_html_update(update):
-      return {'docs': {'templates': {'public': {'apps': {
-        'storage.html': update
-      }}}}}
+      return MoveTo(PUBLIC_TEMPLATES, {
+        'apps': {'storage.html': update}
+      })
     def static_txt_update(update):
-      return {'docs': {'static': {
+      return MoveTo(STATIC_DOCS, {
         'static.txt': update
-      }}}
+      })
 
-    app_yaml_path = 'docs/server2/app.yaml'
-    storage_html_path = 'docs/templates/public/apps/storage.html'
-    static_txt_path = 'docs/static/static.txt'
+    storage_html_path = '%s/apps/storage.html' % PUBLIC_TEMPLATES
+    static_txt_path = '%s/static.txt' % STATIC_DOCS
 
     def create_file_system(revision=None):
       '''Creates a MockFileSystem at |revision| by applying that many |updates|
       to it.
       '''
-      mock_file_system = MockFileSystem(TestFileSystem(test_data))
+      mock_file_system = MockFileSystem(
+          TestFileSystem(test_data, relative_to=EXTENSIONS))
       updates_for_revision = (
           updates if revision is None else updates[:int(revision)])
       for update in updates_for_revision:
         mock_file_system.Update(update)
       return mock_file_system
 
     delegate = _TestDelegate(create_file_system)
     delegate.SetAppVersion('2-0-8')
 
     file_systems = delegate.file_systems
 
     # No updates applied yet.
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('storage.html contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
 
     # Apply updates to storage.html.
     updates.append(storage_html_update('interim contents'))
     updates.append(storage_html_update('new contents'))
 
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('new contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
 
     # Apply several updates to storage.html and app.yaml. The file system
     # should be pinned at the version before app.yaml changed.
     updates.append(storage_html_update('stuck here contents'))
 
     double_update = storage_html_update('newer contents')
     double_update.update(app_yaml_update('2-0-10'))
     updates.append(double_update)
 
     updates.append(storage_html_update('never gonna reach here'))
 
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('stuck here contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
 
     # Further pushes to storage.html will keep it pinned.
     updates.append(storage_html_update('y u not update!'))
 
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('stuck here contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
 
     # Likewise app.yaml.
     updates.append(app_yaml_update('2-1-0'))
 
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('stuck here contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
 
     # And updates to other content won't happen either.
     updates.append(static_txt_update('important content!'))
 
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-0-8'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('stuck here contents',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
     self.assertEqual('static.txt contents',
                      file_systems[-1].ReadSingle(static_txt_path).Get())
 
     # Lastly - when the app version changes, everything should no longer be
     # pinned.
     delegate.SetAppVersion('2-1-0')
     CronServlet(Request.ForTest('trunk'), delegate_for_test=delegate).Get()
     self.assertEqual(AppYamlHelper.GenerateAppYaml('2-1-0'),
-                     file_systems[-1].ReadSingle(app_yaml_path).Get())
+                     file_systems[-1].ReadSingle(APP_YAML).Get())
     self.assertEqual('y u not update!',
                      file_systems[-1].ReadSingle(storage_html_path).Get())
     self.assertEqual('important content!',
                      file_systems[-1].ReadSingle(static_txt_path).Get())
 
 if __name__ == '__main__':
   unittest.main()