Docserver: Make the .html extension unnecessary for content pages, for example,

chrome/common/extensions/docs/server2/integration_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.
 
 # Run build_server so that files needed by tests are copied to the local
 # third_party directory.
 import build_server
 build_server.main()
 
 import json
 import optparse
 import os
 import posixpath
 import sys
 import time
 import unittest
 
 from branch_utility import BranchUtility
 from chroot_file_system import ChrootFileSystem
 from extensions_paths import CONTENT_PROVIDERS, EXTENSIONS, PUBLIC_TEMPLATES
 from fake_fetchers import ConfigureFakeFetchers
-from third_party.json_schema_compiler import json_parse
+from special_paths import SITE_VERIFICATION_FILE
 from handler import Handler
 from link_error_detector import LinkErrorDetector, StringifyBrokenLinks
 from local_file_system import LocalFileSystem
 from local_renderer import LocalRenderer
 from path_util import AssertIsValid
 from servlet import Request
+from third_party.json_schema_compiler import json_parse
 from test_util import (
     ChromiumPath, DisableLogging, EnableLogging, ReadFile, Server2Path)
 
 
 # Arguments set up if __main__ specifies them.
 _EXPLICIT_TEST_FILES = None
 _REBASE = False
 _VERBOSE = False
 
 
@@ skipping 19 matching lines @@
     public_files = {}
     for root, dirs, files in os.walk(path, topdown=True):
       relative_root = root[len(path):].lstrip(os.path.sep)
       dirs[:] = _FilterHidden(dirs)
       for filename in _FilterHidden(files):
         with open(os.path.join(root, filename), 'r') as f:
           request_path = posixpath.join(prefix, relative_root, filename)
           public_files[request_path] = f.read()
     return public_files
 
-  # Public file locations are defined in content_providers.json, sort of.  Epic
+  # Public file locations are defined in content_providers.json, sort of. Epic
   # hack to pull them out; list all the files from the directories that
   # Chromium content providers ask for.
   public_files = {}
   content_providers = json_parse.Parse(ReadFile(CONTENT_PROVIDERS))
   for content_provider in content_providers.itervalues():
     if 'chromium' in content_provider:
       public_files.update(walk(content_provider['chromium']['dir'],
                                prefix=content_provider['serveFrom']))
   return public_files
 
@@ skipping 72 matching lines @@
     public_files = _GetPublicFiles()
 
     print('Rendering %s public files...' % len(public_files.keys()))
     start_time = time.time()
     try:
       for path, content in public_files.iteritems():
         AssertIsValid(path)
         if path.endswith('redirects.json'):
           continue
 
+        # The non-example html and md files are served without their file
+        # extensions.
+        path_without_ext, ext = posixpath.splitext(path)
+        if (ext in ('.html', '.md') and
+            '/examples/' not in path and
+            path != SITE_VERIFICATION_FILE):
+          path = path_without_ext
+
         def check_result(response):
           self.assertEqual(200, response.status,
               'Got %s when rendering %s' % (response.status, path))
+
           # This is reaaaaally rough since usually these will be tiny templates
           # that render large files. At least it'll catch zero-length responses.
           self.assertTrue(len(response.content) >= len(content),
               'Rendered content length was %s vs template content length %s '
               'when rendering %s' % (len(response.content), len(content), path))
 
         check_result(Handler(Request.ForTest(path)).Get())
 
         if path.startswith(('apps/', 'extensions/')):
-          # Make sure that leaving out the .html will temporarily redirect to
-          # the path with the .html for APIs and articles.
+          # Make sure that adding the .html will temporarily redirect to
+          # the path without the .html for APIs and articles.
           if '/examples/' not in path:
-            base, _ = posixpath.splitext(path)
+            redirect_response = Handler(Request.ForTest(path + '.html')).Get()
             self.assertEqual(
-                ('/' + path, False),
-                Handler(Request.ForTest(base)).Get().GetRedirect(),
-                '%s did not (temporarily) redirect to %s.html' % (path, path))
+                ('/' + path, False), redirect_response.GetRedirect(),
+                '%s.html did not (temporarily) redirect to %s (status %s)' %
+                    (path, path, redirect_response.status))
 
           # Make sure including a channel will permanently redirect to the same
           # path without a channel.
           for channel in BranchUtility.GetAllChannelNames():
-            redirect_result = Handler(
+            redirect_response = Handler(
                 Request.ForTest(posixpath.join(channel, path))).Get()
             self.assertEqual(
                 ('/' + path, True),
-                redirect_result.GetRedirect(),
-                '%s did not redirect to strip channel %s' % (path, channel))
+                redirect_response.GetRedirect(),
+                '%s/%s did not (permanently) redirect to %s (status %s)' %
+                    (channel, path, path, redirect_response.status))
 
         # Samples are internationalized, test some locales.
-        if path.endswith('/samples.html'):
+        if path.endswith('/samples'):
           for lang in ('en-US', 'es', 'ar'):
             check_result(Handler(Request.ForTest(
                 path,
                 headers={'Accept-Language': '%s;q=0.8' % lang})).Get())
     finally:
       print('Took %s seconds' % (time.time() - start_time))
 
     #if _REBASE:
     #  print('Rebasing broken links with %s newly broken and %s fixed links.' %
     #        (len(newly_broken_links), len(fixed_links)))
@@ skipping 33 matching lines @@
         self.assertEqual(200, response.status)
         self.assertTrue(response.content != '')
       finally:
         print('Took %s seconds' % (time.time() - start_time))
 
     # TODO(jshumway): Check page for broken links (currently prohibited by the
     # time it takes to render the pages).
 
   @DisableLogging('warning')
   def testFileNotFound(self):
-    response = Handler(Request.ForTest('/extensions/notfound.html')).Get()
+    response = Handler(Request.ForTest('/extensions/notfound')).Get()
     self.assertEqual(404, response.status)
 
+  def testSiteVerificationFile(self):
+    response = Handler(Request.ForTest('/' + SITE_VERIFICATION_FILE)).Get()
+    self.assertEqual(200, response.status)
+
 if __name__ == '__main__':
   parser = optparse.OptionParser()
   parser.add_option('-a', '--all', action='store_true', default=False,
                     help='Render all pages, not just the one specified')
   parser.add_option('-r', '--rebase', action='store_true', default=False,
                     help='Rewrites the known_broken_links.json file with '
                          'the current set of broken links')
   parser.add_option('-v', '--verbose', action='store_true', default=False,
                     help='Show verbose output like currently broken links')
   (opts, args) = parser.parse_args()
   if not opts.all:
     _EXPLICIT_TEST_FILES = args
   _REBASE = opts.rebase
   _VERBOSE = opts.verbose
   # Kill sys.argv because we have our own flags.
   sys.argv = [sys.argv[0]]
   unittest.main()