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..dcbc266a9ae03f2c37d30a7cb676504b8532ef04 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,17 @@
 #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/test/embedded_test_server/request_helpers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request.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 +107,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 +118,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 can't be deferred to 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,13 +134,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());
   }
 
   void TearDown() override {
     ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete());
+#if defined(USE_NSS_CERTS) || defined(OS_IOS)
+    ShutdownNSSHttpIO();
+#endif
   }
 
   // URLFetcherDelegate override.
@@ -173,24 +191,44 @@ 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) {
+  ASSERT_TRUE(server_->Start());
+  if (server_->is_using_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) {
+  ASSERT_TRUE(server_->Start());
+  if (server_->is_using_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) {
+  ASSERT_TRUE(server_->Start());
+  if (server_->is_using_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),
@@ -198,6 +236,7 @@ TEST_F(EmbeddedTestServerTest, RegisterRequestHandler) {
                  "<b>Worked!</b>",
                  "text/html",
                  HTTP_OK));
+  ASSERT_TRUE(server_->Start());
 
   scoped_ptr<URLFetcher> fetcher =
       URLFetcher::Create(server_->GetURL("/test?q=foo"), URLFetcher::GET, this);
@@ -213,11 +252,12 @@ 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(
       src_dir.AppendASCII("net").AppendASCII("data"));
+  ASSERT_TRUE(server_->Start());
 
   scoped_ptr<URLFetcher> fetcher =
       URLFetcher::Create(server_->GetURL("/test.html"), URLFetcher::GET, this);
@@ -228,10 +268,12 @@ 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) {
+  ASSERT_TRUE(server_->Start());
+
   scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
@@ -242,7 +284,9 @@ TEST_F(EmbeddedTestServerTest, DefaultNotFoundResponse) {
   EXPECT_EQ(HTTP_NOT_FOUND, fetcher->GetResponseCode());
 }
 
-TEST_F(EmbeddedTestServerTest, ConnectionListenerAccept) {
+TEST_P(EmbeddedTestServerTest, ConnectionListenerAccept) {
+  ASSERT_TRUE(server_->Start());
+
   TestNetLog net_log;
   net::AddressList address_list;
   EXPECT_TRUE(server_->GetAddressList(&address_list));
@@ -259,7 +303,9 @@ TEST_F(EmbeddedTestServerTest, ConnectionListenerAccept) {
   EXPECT_FALSE(connection_listener_.DidReadFromSocket());
 }
 
-TEST_F(EmbeddedTestServerTest, ConnectionListenerRead) {
+TEST_P(EmbeddedTestServerTest, ConnectionListenerRead) {
+  ASSERT_TRUE(server_->Start());
+
   scoped_ptr<URLFetcher> fetcher = URLFetcher::Create(
       server_->GetURL("/non-existent"), URLFetcher::GET, this);
   fetcher->SetRequestContext(request_context_getter_.get());
@@ -270,7 +316,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),
@@ -292,6 +338,7 @@ TEST_F(EmbeddedTestServerTest, ConcurrentFetches) {
                  "No chocolates",
                  "text/plain",
                  HTTP_NOT_FOUND));
+  ASSERT_TRUE(server_->Start());
 
   scoped_ptr<URLFetcher> fetcher1 =
       URLFetcher::Create(server_->GetURL("/test1"), URLFetcher::GET, this);
@@ -325,14 +372,90 @@ TEST_F(EmbeddedTestServerTest, ConcurrentFetches) {
   EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher3));
 }
 
+class CancelRequestDelegate : public TestDelegate {
+ public:
+  CancelRequestDelegate() {}
+
+  void OnResponseStarted(URLRequest* request) override {
+    TestDelegate::OnResponseStarted(request);
+    request->Cancel();
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::RunLoop().QuitClosure(),
+        base::TimeDelta::FromSeconds(1));
+  }
+};
+
+class InfiniteResponse : public BasicHttpResponse {
+ public:
+  InfiniteResponse() : weak_ptr_factory_(this){};
+

[mmenke, 2015/10/21 20:21:36]

private:

[svaldez, 2015/10/21 21:22:29]

Done.

+  void SendInfinite(const SendBytesCallback& send) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(send, "echo",
+                   base::Bind(&InfiniteResponse::SendInfinite,
+                              weak_ptr_factory_.GetWeakPtr(), send)));
+  }
+
+  void SendResponse(const SendBytesCallback& send,
+                    const SendCompleteCallback& done) override {
+    send.Run(ToResponseString(),
+             base::Bind(&InfiniteResponse::SendInfinite,
+                        weak_ptr_factory_.GetWeakPtr(), send));
+  }
+
+  base::WeakPtrFactory<InfiniteResponse> weak_ptr_factory_;

[mmenke, 2015/10/21 20:21:36]

DISALLOW_COPY_AND_ASSIGN

[mmenke, 2015/10/21 20:21:37]

include weak_ptr.

[svaldez, 2015/10/21 21:22:28]

Done.

[svaldez, 2015/10/21 21:22:28]

Done.

+};
+
+scoped_ptr<HttpResponse> HandleInfiniteRequest(const HttpRequest& request) {

[mmenke, 2015/10/21 20:21:37]

Just use HandlePrefixedRequest instead?

[svaldez, 2015/10/21 21:22:28]

Done.

+  if (ShouldHandle(request, "/infinite"))
+    return make_scoped_ptr(new InfiniteResponse);
+  return nullptr;
+}
+
+TEST_P(EmbeddedTestServerTest, CancelDuringRead) {

[mmenke, 2015/10/21 20:21:36]

Cancel -> Close, Read -> Write?  (From the server's standpoint, the socket is
closed in the middle of a write)

[mmenke, 2015/10/21 20:21:37]

Think this test is worth a comment.  Something along the lines of "Tests the
case the connection is closed while the server is sending a response.  May
non-deterministically end up at one of three paths (Discover the close event
synchronously, asynchronously, or server shutting down before it is
discovered)."  Unfortunate that we can't be more deterministic here, but I don't
see a great way to do that.

[svaldez, 2015/10/21 21:22:28]

Done.

[svaldez, 2015/10/21 21:22:28]

Done.

+  CancelRequestDelegate cancel_delegate;
+  TestURLRequestContext context;
+  server_->RegisterRequestHandler(base::Bind(&HandleInfiniteRequest));
+  ASSERT_TRUE(server_->Start());
+
+  scoped_ptr<URLRequest> request = context.CreateRequest(
+      server_->GetURL("/"), DEFAULT_PRIORITY, &cancel_delegate);

[mmenke, 2015/10/21 20:21:36]

/infinite

[svaldez, 2015/10/21 21:22:28]

Done.

+  request->Start();
+  base::RunLoop().RunUntilIdle();

[mmenke, 2015/10/21 20:21:36]

This doesn't run long enough.

Use a TestDelegate and call set_cancel_in_response_started(test) on it.  Then
use base::RunLoop().Run();

Can also check the response code the request received, out of paranoia.

[svaldez, 2015/10/21 21:22:28]

Not sure I understand. We still need to have some artificial delay using
PostDelayedTask, since otherwise the ETS might shutdown right away?

[mmenke, 2015/10/21 21:36:38]

You aren't even waiting for the response to be received - Depending on the
platform, we may not even be establishing a connection, since you're just
calling RunUntilIdle.

+}
+
+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 {
+#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 can't be deferred to SSLClientSocket. See
+    // https://crbug.com/539520.
+    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 +463,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 +483,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 +515,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 +526,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