SSL in EmbeddedTestServer

net/test/embedded_test_server/embedded_test_server_unittest.cc

Index: net/test/embedded_test_server/embedded_test_server_unittest.cc
diff --git a/net/test/embedded_test_server/embedded_test_server_unittest.cc b/net/test/embedded_test_server/embedded_test_server_unittest.cc
index 91cb16f3f4c91f9810b6aaa270b7a3fc20d6eda6..321ded7098de9b2e5a8ea2230b03571a3b749762 100644
--- a/net/test/embedded_test_server/embedded_test_server_unittest.cc
+++ b/net/test/embedded_test_server/embedded_test_server_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
+#include "crypto/nss_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/log/test_net_log.h"
@@ -18,12 +19,15 @@
 #include "net/test/embedded_test_server/embedded_test_server_connection_listener.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
-#include "net/test/spawned_test_server/base_test_server.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+#include "net/cert_net/nss_ocsp.h"
+#endif
+
 namespace net {
 namespace test_server {
 
@@ -101,8 +105,9 @@ class TestConnectionListener
   DISALLOW_COPY_AND_ASSIGN(TestConnectionListener);
 };
 
-class EmbeddedTestServerTest: public testing::Test,
-                              public URLFetcherDelegate {
+class EmbeddedTestServerTest
+    : public testing::TestWithParam<EmbeddedTestServer::Type>,
+      public URLFetcherDelegate {
  public:
   EmbeddedTestServerTest()
       : num_responses_received_(0),
@@ -111,6 +116,15 @@ class EmbeddedTestServerTest: public testing::Test,
   }
 
   void SetUp() override {
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+    // This is needed so NSS's HTTP client functions are initialized on the
+    // right thread. These tests create SSLClientSockets on a different thread.
+    // TODO(davidben): Initialization should not happen deep in
+    // SSLClientSocket. See https://crbug.com/539520.
+    crypto::EnsureNSSInit();
+    EnsureNSSHttpIOInit();
+#endif
+
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread_.StartWithOptions(thread_options));
@@ -118,12 +132,15 @@ class EmbeddedTestServerTest: public testing::Test,
     request_context_getter_ =
         new TestURLRequestContextGetter(io_thread_.task_runner());
 
-    server_.reset(new EmbeddedTestServer);
+    server_.reset(new EmbeddedTestServer(GetParam()));
     server_->SetConnectionListener(&connection_listener_);
-    ASSERT_TRUE(server_->InitializeAndWaitUntilReady());
+    ASSERT_TRUE(server_->Start());
   }
 
   void TearDown() override {
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+    ShutdownNSSHttpIO();
+#endif
     ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete());
   }
 
@@ -173,24 +190,41 @@ class EmbeddedTestServerTest: public testing::Test,
   scoped_ptr<EmbeddedTestServer> server_;
 };
 
-TEST_F(EmbeddedTestServerTest, GetBaseURL) {
-  EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%u/", server_->port()),
-                               server_->base_url().spec());
+TEST_P(EmbeddedTestServerTest, GetBaseURL) {
+  if (server_->use_ssl()) {
+    EXPECT_EQ(base::StringPrintf("https://127.0.0.1:%u/", server_->port()),
+              server_->base_url().spec());
+  } else {
+    EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%u/", server_->port()),
+              server_->base_url().spec());
+  }
 }
 
-TEST_F(EmbeddedTestServerTest, GetURL) {
-  EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%u/path?query=foo",
-                               server_->port()),
-            server_->GetURL("/path?query=foo").spec());
+TEST_P(EmbeddedTestServerTest, GetURL) {
+  if (server_->use_ssl()) {
+    EXPECT_EQ(base::StringPrintf("https://127.0.0.1:%u/path?query=foo",
+                                 server_->port()),
+              server_->GetURL("/path?query=foo").spec());
+  } else {
+    EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%u/path?query=foo",
+                                 server_->port()),
+              server_->GetURL("/path?query=foo").spec());
+  }
 }
 
-TEST_F(EmbeddedTestServerTest, GetURLWithHostname) {
-  EXPECT_EQ(base::StringPrintf("http://foo.com:%d/path?query=foo",
-                               server_->port()),
-            server_->GetURL("foo.com", "/path?query=foo").spec());
+TEST_P(EmbeddedTestServerTest, GetURLWithHostname) {
+  if (server_->use_ssl()) {
+    EXPECT_EQ(base::StringPrintf("https://foo.com:%d/path?query=foo",
+                                 server_->port()),
+              server_->GetURL("foo.com", "/path?query=foo").spec());
+  } else {
+    EXPECT_EQ(
+        base::StringPrintf("http://foo.com:%d/path?query=foo", server_->port()),
+        server_->GetURL("foo.com", "/path?query=foo").spec());
+  }
 }
 
-TEST_F(EmbeddedTestServerTest, RegisterRequestHandler) {
+TEST_P(EmbeddedTestServerTest, RegisterRequestHandler) {
   server_->RegisterRequestHandler(
       base::Bind(&EmbeddedTestServerTest::HandleRequest,
                  base::Unretained(this),
@@ -213,7 +247,7 @@ TEST_F(EmbeddedTestServerTest, RegisterRequestHandler) {
   EXPECT_EQ("/test?q=foo", request_relative_url_);
 }
 
-TEST_F(EmbeddedTestServerTest, ServeFilesFromDirectory) {
+TEST_P(EmbeddedTestServerTest, ServeFilesFromDirectory) {
   base::FilePath src_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
   server_->ServeFilesFromDirectory(
@@ -228,10 +262,10 @@ TEST_F(EmbeddedTestServerTest, ServeFilesFromDirectory) {
   EXPECT_EQ(URLRequestStatus::SUCCESS, fetcher->GetStatus().status());
   EXPECT_EQ(HTTP_OK, fetcher->GetResponseCode());
   EXPECT_EQ("<p>Hello World!</p>", GetContentFromFetcher(*fetcher));
-  EXPECT_EQ("", GetContentTypeFromFetcher(*fetcher));
+  EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher));
 }
 
-TEST_F(EmbeddedTestServerTest, DefaultNotFoundResponse) {
+TEST_P(EmbeddedTestServerTest, DefaultNotFoundResponse) {
   scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
@@ -242,7 +276,7 @@ TEST_F(EmbeddedTestServerTest, DefaultNotFoundResponse) {
   EXPECT_EQ(HTTP_NOT_FOUND, fetcher->GetResponseCode());
 }
 
-TEST_F(EmbeddedTestServerTest, ConnectionListenerAccept) {
+TEST_P(EmbeddedTestServerTest, ConnectionListenerAccept) {
   TestNetLog net_log;
   net::AddressList address_list;
   EXPECT_TRUE(server_->GetAddressList(&address_list));
@@ -259,7 +293,7 @@ TEST_F(EmbeddedTestServerTest, ConnectionListenerAccept) {
   EXPECT_FALSE(connection_listener_.DidReadFromSocket());
 }
 
-TEST_F(EmbeddedTestServerTest, ConnectionListenerRead) {
+TEST_P(EmbeddedTestServerTest, ConnectionListenerRead) {
   scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
@@ -270,7 +304,7 @@ TEST_F(EmbeddedTestServerTest, ConnectionListenerRead) {
   EXPECT_TRUE(connection_listener_.DidReadFromSocket());
 }
 
-TEST_F(EmbeddedTestServerTest, ConcurrentFetches) {
+TEST_P(EmbeddedTestServerTest, ConcurrentFetches) {
   server_->RegisterRequestHandler(
       base::Bind(&EmbeddedTestServerTest::HandleRequest,
                  base::Unretained(this),
@@ -325,14 +359,37 @@ TEST_F(EmbeddedTestServerTest, ConcurrentFetches) {
   EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher3));
 }
 
+INSTANTIATE_TEST_CASE_P(EmbeddedTestServerTestInstantiation,
+                        EmbeddedTestServerTest,
+                        testing::Values(EmbeddedTestServer::TYPE_HTTP,
+                                        EmbeddedTestServer::TYPE_HTTPS));
+
 // Below test exercises EmbeddedTestServer's ability to cope with the situation
 // where there is no MessageLoop available on the thread at EmbeddedTestServer
 // initialization and/or destruction.
 
-typedef std::tr1::tuple<bool, bool> ThreadingTestParams;
+typedef std::tr1::tuple<bool, bool, EmbeddedTestServer::Type>
+    ThreadingTestParams;
 
 class EmbeddedTestServerThreadingTest
-    : public testing::TestWithParam<ThreadingTestParams> {};
+    : public testing::TestWithParam<ThreadingTestParams> {
+  void SetUp() override {
+// This is needed so NSS's HTTP client functions are initialized on the
+// right thread. These tests create SSLClientSockets on a different thread.
+// TODO(davidben): Initialization should not happen deep in
+// SSLClientSocket. See https://crbug.com/539520.
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+    crypto::EnsureNSSInit();
+    EnsureNSSHttpIOInit();
+#endif
+  }
+
+  void TearDown() override {
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+    ShutdownNSSHttpIO();
+#endif
+  }
+};
 
 class EmbeddedTestServerThreadingTestDelegate
     : public base::PlatformThread::Delegate,
@@ -340,9 +397,11 @@ class EmbeddedTestServerThreadingTestDelegate
  public:
   EmbeddedTestServerThreadingTestDelegate(
       bool message_loop_present_on_initialize,
-      bool message_loop_present_on_shutdown)
+      bool message_loop_present_on_shutdown,
+      EmbeddedTestServer::Type type)
       : message_loop_present_on_initialize_(message_loop_present_on_initialize),
-        message_loop_present_on_shutdown_(message_loop_present_on_shutdown) {}
+        message_loop_present_on_shutdown_(message_loop_present_on_shutdown),
+        type_(type) {}
 
   // base::PlatformThread::Delegate:
   void ThreadMain() override {
@@ -358,10 +417,10 @@ class EmbeddedTestServerThreadingTestDelegate
       loop.reset(new base::MessageLoopForIO);
 
     // Create the test server instance.
-    EmbeddedTestServer server;
+    EmbeddedTestServer server(type_);
     base::FilePath src_dir;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
-    ASSERT_TRUE(server.InitializeAndWaitUntilReady());
+    ASSERT_TRUE(server.Start());
 
     // Make a request and wait for the reply.
     if (!loop)
@@ -390,6 +449,7 @@ class EmbeddedTestServerThreadingTestDelegate
  private:
   bool message_loop_present_on_initialize_;
   bool message_loop_present_on_shutdown_;
+  EmbeddedTestServer::Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbeddedTestServerThreadingTestDelegate);
 };
@@ -400,15 +460,19 @@ TEST_P(EmbeddedTestServerThreadingTest, RunTest) {
   // main test thread.
   base::PlatformThreadHandle thread_handle;
   EmbeddedTestServerThreadingTestDelegate delegate(
-      std::tr1::get<0>(GetParam()),
-      std::tr1::get<1>(GetParam()));
+      std::tr1::get<0>(GetParam()), std::tr1::get<1>(GetParam()),
+      std::tr1::get<2>(GetParam()));
   ASSERT_TRUE(base::PlatformThread::Create(0, &delegate, &thread_handle));
   base::PlatformThread::Join(thread_handle);
 }
 
-INSTANTIATE_TEST_CASE_P(EmbeddedTestServerThreadingTestInstantiation,
-                        EmbeddedTestServerThreadingTest,
-                        testing::Combine(testing::Bool(), testing::Bool()));
+INSTANTIATE_TEST_CASE_P(
+    EmbeddedTestServerThreadingTestInstantiation,
+    EmbeddedTestServerThreadingTest,
+    testing::Combine(testing::Bool(),
+                     testing::Bool(),
+                     testing::Values(EmbeddedTestServer::TYPE_HTTP,
+                                     EmbeddedTestServer::TYPE_HTTPS)));
 
 }  // namespace test_server
 }  // namespace net