SSLUITest's work with ephemeral port testserver.

net/tools/testserver/testserver.py

 #!/usr/bin/python2.4
 # Copyright (c) 2006-2010 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.
 
 """This is a simple HTTP server used for testing Chrome.
 
 It supports several test URLs, as specified by the handlers in TestPageHandler.
 It defaults to living on localhost:8888.
 It can use https if you specify the flag --https=CERT where CERT is the path
 to a pem file containing the certificate and private key that should be used.
 """
 
 import base64
 import BaseHTTPServer
 import cgi
 import optparse
 import os
 import re
 import shutil
 import SocketServer
 import sys
 import time
-import urllib2
+import urlparse
 import warnings
 
 # Ignore deprecation warnings, they make our output more cluttered.
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 import pyftpdlib.ftpserver
 import tlslite
 import tlslite.api
 
 try:
@@ skipping 531 matching lines @@
     if not self._ShouldHandleRequest("/download-finish"):
       return False
 
     self.server.waitForDownload = False
     self.send_response(200)
     self.send_header('Content-type', 'text/html')
     self.send_header('Cache-Control', 'max-age=0')
     self.end_headers()
     return True
 
+  def _ReplaceFileData(self, data, query_parameters):
+    """Replaces matching substrings in a file.
+
+    If the 'replace_orig' and 'replace_new' URL query parameters are present,
+    a new string is returned with all occasions of the 'replace_orig' value
+    replaced by the 'replace_new' value.
+
+    If the parameters are not present, |data| is returned.
+    """
+    query_dict = cgi.parse_qs(query_parameters)
+    orig_values = query_dict.get('replace_orig', [])
+    new_values = query_dict.get('replace_new', [])
+    if not orig_values or not new_values:
+      return data
+    orig_value = orig_values[0]
+    new_value = new_values[0]
+    return data.replace(orig_value, new_value)
+
   def FileHandler(self):
     """This handler sends the contents of the requested file.  Wow, it's like
     a real webserver!"""
 
     prefix = self.server.file_root_url
     if not self.path.startswith(prefix):
       return False
 
     # Consume a request body if present.
     if self.command == 'POST' or self.command == 'PUT' :
       self.rfile.read(int(self.headers.getheader('content-length')))
 
-    file = self.path[len(prefix):]
-    if file.find('?') > -1:
-      # Ignore the query parameters entirely.
-      url, querystring = file.split('?')
-    else:
-      url = file
-    entries = url.split('/')
-    path = os.path.join(self.server.data_dir, *entries)
-    if os.path.isdir(path):
-      path = os.path.join(path, 'index.html')
+    _, _, url_path, _, query, _ = urlparse.urlparse(self.path)
+    sub_path = url_path[len(prefix):]
+    entries = sub_path.split('/')
+    file_path = os.path.join(self.server.data_dir, *entries)
+    if os.path.isdir(file_path):
+      file_path = os.path.join(file_path, 'index.html')
 
-    if not os.path.isfile(path):
-      print "File not found " + file + " full path:" + path
+    if not os.path.isfile(file_path):
+      print "File not found " + sub_path + " full path:" + file_path
       self.send_error(404)
       return True
 
-    f = open(path, "rb")
+    f = open(file_path, "rb")
     data = f.read()
     f.close()
 
+    data = self._ReplaceFileData(data, query)
+
     # If file.mock-http-headers exists, it contains the headers we
     # should send.  Read them in and parse them.
-    headers_path = path + '.mock-http-headers'
+    headers_path = file_path + '.mock-http-headers'
     if os.path.isfile(headers_path):
       f = open(headers_path, "r")
 
       # "HTTP/1.1 200 OK"
       response = f.readline()
       status_code = re.findall('HTTP/\d+.\d+ (\d+)', response)[0]
       self.send_response(int(status_code))
 
       for line in f:
         header_values = re.findall('(\S+):\s*(.*)', line)
         if len(header_values) > 0:
           # "name: value"
           name, value = header_values[0]
           self.send_header(name, value)
       f.close()
     else:
       # Could be more generic once we support mime-type sniffing, but for
       # now we need to set it explicitly.
       self.send_response(200)
-      self.send_header('Content-type', self.GetMIMETypeFromName(file))
+      self.send_header('Content-type', self.GetMIMETypeFromName(file_path))
       self.send_header('Content-Length', len(data))
     self.end_headers()
 
     self.wfile.write(data)
 
     return True
 
   def RealFileWithCommonHeaderHandler(self):
     """This handler sends the contents of the requested file without the pseudo
     http head!"""
@@ skipping 617 matching lines @@
                            'option may appear multiple times, indicating '
                            'multiple algorithms should be enabled.');
   option_parser.add_option('', '--file-root-url', default='/files/',
                            help='Specify a root URL for files served.')
   option_parser.add_option('', '--startup-pipe', type='int',
                            dest='startup_pipe',
                            help='File handle of pipe to parent process')
   options, args = option_parser.parse_args()
 
   sys.exit(main(options, args))