testserver.py listens on ephemeral ports by default.

net/test/test_server.cc

 // Copyright (c) 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.
 
 #include "net/test/test_server.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 22 matching lines @@
 namespace net {
 
 namespace {
 
 // Number of connection attempts for tests.
 const int kServerConnectionAttempts = 10;
 
 // Connection timeout in milliseconds for tests.
 const int kServerConnectionTimeoutMs = 1000;
 
-const char kTestServerShardFlag[] = "test-server-shard";
-
-int GetHTTPSPortBase(const TestServer::HTTPSOptions& options) {
-  if (options.request_client_certificate)
-    return 9543;
-
-  switch (options.server_certificate) {
-    case TestServer::HTTPSOptions::CERT_OK:
-      return 9443;
-    case TestServer::HTTPSOptions::CERT_MISMATCHED_NAME:
-      return 9643;
-    case TestServer::HTTPSOptions::CERT_EXPIRED:
-      // TODO(phajdan.jr): Some tests rely on this hardcoded value.
-      // Some uses of this are actually in .html/.js files.
-      return 9666;
-    default:
-      NOTREACHED();
-  }
-  return -1;
-}
-
-int GetPortBase(TestServer::Type type,
-                const TestServer::HTTPSOptions& options) {
-  switch (type) {
-    case TestServer::TYPE_FTP:
-      return 3117;
-    case TestServer::TYPE_HTTP:
-      return 1337;
-    case TestServer::TYPE_HTTPS:
-      return GetHTTPSPortBase(options);
-    default:
-      NOTREACHED();
-  }
-  return -1;
-}
-
-int GetPort(TestServer::Type type,
-            const TestServer::HTTPSOptions& options) {
-  int port = GetPortBase(type, options);
-  if (CommandLine::ForCurrentProcess()->HasSwitch(kTestServerShardFlag)) {
-    std::string shard_str(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-                              kTestServerShardFlag));
-    int shard = -1;
-    if (base::StringToInt(shard_str, &shard)) {
-      port += shard;
-    } else {
-      LOG(FATAL) << "Got invalid " << kTestServerShardFlag << " flag value. "
-                 << "An integer is expected.";
-    }
-  }
-  return port;
-}
-
 std::string GetHostname(TestServer::Type type,
                         const TestServer::HTTPSOptions& options) {
   if (type == TestServer::TYPE_HTTPS &&
       options.server_certificate ==
           TestServer::HTTPSOptions::CERT_MISMATCHED_NAME) {
     // Return a different hostname string that resolves to the same hostname.
     return "localhost";
   }
 
   return "127.0.0.1";
@@ skipping 25 matching lines @@
       return FilePath(FILE_PATH_LITERAL("ok_cert.pem"));
     case CERT_EXPIRED:
       return FilePath(FILE_PATH_LITERAL("expired_cert.pem"));
     default:
       NOTREACHED();
   }
   return FilePath();
 }
 
 TestServer::TestServer(Type type, const FilePath& document_root)
-    : type_(type) {
+    : type_(type),
+      started_(false) {
   Init(document_root);
 }
 
 TestServer::TestServer(const HTTPSOptions& https_options,
                        const FilePath& document_root)
-    : https_options_(https_options), type_(TYPE_HTTPS) {
+    : https_options_(https_options),
+      type_(TYPE_HTTPS),
+      started_(false) {
   Init(document_root);
 }
 
 TestServer::~TestServer() {
 #if defined(OS_MACOSX)
   SetMacTestCertificate(NULL);
 #endif
   Stop();
 }
 
 void TestServer::Init(const FilePath& document_root) {
-  host_port_pair_ = HostPortPair(GetHostname(type_, https_options_),
-                                 GetPort(type_, https_options_));
+  // At this point, the port that the testserver will listen on is unknown.
+  // The testserver will listen on an ephemeral port, and write the port
+  // number out over a pipe that this TestServer object will read from. Once
+  // that is complete, the host_port_pair_ will contain the actual port.
+  host_port_pair_ = HostPortPair(GetHostname(type_, https_options_), 0);
   process_handle_ = base::kNullProcessHandle;
 
   FilePath src_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &src_dir);
 
   document_root_ = src_dir.Append(document_root);
 
   certificates_dir_ = src_dir.Append(FILE_PATH_LITERAL("net"))
                        .Append(FILE_PATH_LITERAL("data"))
                        .Append(FILE_PATH_LITERAL("ssl"))
@@ skipping 24 matching lines @@
     return false;
 
   if (!LaunchPython(testserver_path))
     return false;
 
   if (!WaitToStart()) {
     Stop();
     return false;
   }
 
+  started_ = true;
   return true;
 }
 
 bool TestServer::Stop() {
   if (!process_handle_)
     return true;
 
+  started_ = false;
+
   // First check if the process has already terminated.
   bool ret = base::WaitForSingleProcess(process_handle_, 0);
   if (!ret)
     ret = base::KillProcess(process_handle_, 1, true);
 
   if (ret) {
     base::CloseProcessHandle(process_handle_);
     process_handle_ = base::kNullProcessHandle;
   } else {
     VLOG(1) << "Kill failed?";
   }
 
   return ret;
 }
 
+const HostPortPair& TestServer::host_port_pair() const {
+  DCHECK(started_);
+  return host_port_pair_;
+}
+
 std::string TestServer::GetScheme() const {
   switch (type_) {
     case TYPE_FTP:
       return "ftp";
     case TYPE_HTTP:
       return "http";
     case TYPE_HTTPS:
       return "https";
     default:
       NOTREACHED();
@@ skipping 147 matching lines @@
     if (https_options_.bulk_ciphers & HTTPSOptions::BULK_CIPHER_AES256)
       command_line->AppendSwitchASCII(kBulkCipherSwitch, "aes256");
     if (https_options_.bulk_ciphers & HTTPSOptions::BULK_CIPHER_3DES)
       command_line->AppendSwitchASCII(kBulkCipherSwitch, "3des");
   }
 
   return true;
 }
 
 }  // namespace net