Adding SSL ETS Tests

net/url_request/url_fetcher_impl_unittest.cc

 // Copyright (c) 2012 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/url_request/url_fetcher_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 15 matching lines @@
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
-#include "net/test/spawned_test_server/spawned_test_server.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.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 {
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 // TODO(akalin): Move all the test data to somewhere under net/.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("net/data/url_fetcher_impl_unittest");
-const char kTestServerFilePrefix[] = "files/";
+const char kTestServerFilePrefix[] = "/";
 
 // Test server path and response body for the default URL used by many of the
 // tests.
-const char kDefaultResponsePath[] = "defaultresponse";
+const char kDefaultResponsePath[] = "/defaultresponse";
 const char kDefaultResponseBody[] =
     "Default response given for path: /defaultresponse";
 
 // Request body for streams created by CreateUploadStream.
 const char kCreateUploadStreamBody[] = "rosebud";
 
 base::FilePath GetUploadFileTestPath() {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   return path.Append(
@@ skipping 305 matching lines @@
     EXPECT_TRUE(delegate->fetcher()->GetStatus().is_success());
     EXPECT_EQ(200, delegate->fetcher()->GetResponseCode());
 
     base::FilePath out_path;
     EXPECT_TRUE(
         delegate->fetcher()->GetResponseAsFilePath(take_ownership, &out_path));
     if (!save_to_temporary_file) {
       EXPECT_EQ(requested_out_path, out_path);
     }
 
+    base::FilePath server_root;
+    PathService::Get(base::DIR_SOURCE_ROOT, &server_root);
+
     EXPECT_TRUE(base::ContentsEqual(
-        test_server_->GetDocumentRoot().AppendASCII(file_to_fetch), out_path));
+        server_root.Append(base::FilePath(kDocRoot)).AppendASCII(file_to_fetch),
+        out_path));
 
     // Delete the delegate and run the message loop to give the fetcher's
     // destructor a chance to delete the file.
     delegate.reset();
     base::RunLoop().RunUntilIdle();
 
     // File should only exist if |take_ownership| was true.
     EXPECT_EQ(take_ownership, base::PathExists(out_path));
 
     // Cleanup.
     if (base::PathExists(out_path))
       base::DeleteFile(out_path, false);
   }
 
   // Returns a URL that hangs on DNS resolution when using a context created by
   // the test fixture.
   const GURL& hanging_url() const { return hanging_url_; }
 
   // testing::Test:
   void SetUp() override {
     SetUpServer();
     ASSERT_TRUE(test_server_->Start());
 
     // URL that will hang when lookups reach the host resolver.
     hanging_url_ = GURL(base::StringPrintf(
-        "http://example.com:%d/%s", test_server_->host_port_pair().port(),
+        "http://example.com:%d%s", test_server_->host_port_pair().port(),
         kDefaultResponsePath));
     ASSERT_TRUE(hanging_url_.is_valid());
 
 #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
   }
 
   // Initializes |test_server_| without starting it.  Allows subclasses to use
   // their own server configuration.
   virtual void SetUpServer() {
-    test_server_.reset(new SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
-                                             SpawnedTestServer::kLocalhost,
-                                             base::FilePath(kDocRoot)));
+    test_server_.reset(new EmbeddedTestServer);
+    test_server_->AddDefaultHandlers(base::FilePath(kDocRoot));
   }
 
   // Network thread for cross-thread tests.  Most threads just use the main
   // thread for network activity.
   scoped_ptr<base::Thread> network_thread_;
 
-  scoped_ptr<SpawnedTestServer> test_server_;
+  scoped_ptr<EmbeddedTestServer> test_server_;
   GURL hanging_url_;
 
   size_t num_upload_streams_created_;
 };
 
 namespace {
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest() {}
 
   // URLFetcherTest:
   void SetUpServer() override {
-    SpawnedTestServer::SSLOptions ssl_options(
-        SpawnedTestServer::SSLOptions::CERT_EXPIRED);
-    test_server_.reset(new SpawnedTestServer(
-        SpawnedTestServer::TYPE_HTTPS, ssl_options, base::FilePath(kDocRoot)));
+    test_server_.reset(
+        new EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+    test_server_->SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
+    test_server_->ServeFilesFromSourceDirectory("net/data/ssl");
   }
 };
 
 // Create the fetcher on the main thread.  Since network IO will happen on the
 // main thread, this will test URLFetcher's ability to do everything on one
 // thread.
 TEST_F(URLFetcherTest, SameThreadTest) {
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL(kDefaultResponsePath),
                          URLFetcher::GET, CreateSameThreadContextGetter());
@@ skipping 180 matching lines @@
 
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(kDefaultResponseBody, data);
 }
 
 TEST_F(URLFetcherTest, PostString) {
   const char kUploadData[] = "bobsyeruncle";
 
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadData("application/x-www-form-urlencoded",
                                     kUploadData);
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(kUploadData, data);
 }
 
 TEST_F(URLFetcherTest, PostEmptyString) {
   const char kUploadData[] = "";
 
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadData("application/x-www-form-urlencoded",
                                     kUploadData);
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(kUploadData, data);
 }
 
 TEST_F(URLFetcherTest, PostEntireFile) {
   base::FilePath upload_path = GetUploadFileTestPath();
 
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadFilePath("application/x-www-form-urlencoded",
                                         upload_path, 0, kuint64max,
                                         base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
 
   std::string expected;
   ASSERT_TRUE(base::ReadFileToString(upload_path, &expected));
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(expected, data);
 }
 
 TEST_F(URLFetcherTest, PostFileRange) {
   const size_t kRangeStart = 30;
   const size_t kRangeLength = 100;
   base::FilePath upload_path = GetUploadFileTestPath();
 
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadFilePath("application/x-www-form-urlencoded",
                                         upload_path, kRangeStart, kRangeLength,
                                         base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
 
   std::string expected;
   ASSERT_TRUE(base::ReadFileToString(upload_path, &expected));
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(expected.substr(kRangeStart, kRangeLength), data);
 }
 
 TEST_F(URLFetcherTest, PostWithUploadStreamFactory) {
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadStreamFactory(
       "text/plain",
       base::Bind(&URLFetcherTest::CreateUploadStream, base::Unretained(this)));
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(kCreateUploadStreamBody, data);
   EXPECT_EQ(1u, num_upload_streams_created());
 }
 
 TEST_F(URLFetcherTest, PostWithUploadStreamFactoryAndRetries) {
   WaitingURLFetcherDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo?status=500"),
+  delegate.CreateFetcher(test_server_->GetURL("/echo?status=500"),
                          URLFetcher::POST, CreateSameThreadContextGetter());
   delegate.fetcher()->SetAutomaticallyRetryOn5xx(true);
   delegate.fetcher()->SetMaxRetriesOn5xx(1);
   delegate.fetcher()->SetUploadStreamFactory(
       "text/plain",
       base::Bind(&URLFetcherTest::CreateUploadStream, base::Unretained(this)));
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(500, delegate.fetcher()->GetResponseCode());
@@ skipping 41 matching lines @@
   const std::string chunk_;
 
   int64 num_chunks_appended_;
   int64 last_seen_progress_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckUploadProgressDelegate);
 };
 
 TEST_F(URLFetcherTest, UploadProgress) {
   CheckUploadProgressDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   // Use a chunked upload so that the upload can be paused after uploading data.
   // Since upload progress uses a timer, the delegate may not receive any
   // notification otherwise.
   delegate.fetcher()->SetChunkedUpload("application/x-www-form-urlencoded");
 
   delegate.fetcher()->Start();
   // Append the first chunk.  Others will be appended automatically in response
   // to OnURLFetchUploadProgress events.
   delegate.MaybeAppendChunk();
@@ skipping 33 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CheckDownloadProgressDelegate);
 };
 
 TEST_F(URLFetcherTest, DownloadProgress) {
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   const char kFileToFetch[] = "animate1.gif";
 
   std::string file_contents;
+
+  base::FilePath server_root;
+  PathService::Get(base::DIR_SOURCE_ROOT, &server_root);
+
   ASSERT_TRUE(base::ReadFileToString(
-      test_server_->GetDocumentRoot().AppendASCII(kFileToFetch),
+      server_root.Append(base::FilePath(kDocRoot)).AppendASCII(kFileToFetch),
       &file_contents));
 
   CheckDownloadProgressDelegate delegate(file_contents.size());
   delegate.CreateFetcher(
       test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
@@ skipping 14 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CancelOnUploadProgressDelegate);
 };
 
 // Check that a fetch can be safely cancelled/deleted during an upload progress
 // callback.
 TEST_F(URLFetcherTest, CancelInUploadProgressCallback) {
   CancelOnUploadProgressDelegate delegate;
-  delegate.CreateFetcher(test_server_->GetURL("echo"), URLFetcher::POST,
+  delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetChunkedUpload("application/x-www-form-urlencoded");
   delegate.fetcher()->Start();
   // Use a chunked upload so that the upload can be paused after uploading data.
   // Since uploads progress uses a timer, may not receive any notification,
   // otherwise.
   std::string upload_data(1 << 16, 'a');
   delegate.fetcher()->AppendChunkToUpload(upload_data, false);
   delegate.WaitForComplete();
 
@@ skipping 34 matching lines @@
   // Make sure there are no pending events that cause problems when run.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(delegate.did_complete());
   EXPECT_FALSE(delegate.fetcher());
 }
 
 TEST_F(URLFetcherTest, Headers) {
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(
-      test_server_->GetURL("set-header?cache-control: private"),
+      test_server_->GetURL("/set-header?cache-control: private"),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string header;
   ASSERT_TRUE(delegate.fetcher()->GetResponseHeaders()->GetNormalizedHeader(
       "cache-control", &header));
   EXPECT_EQ("private", header);
 }
@@ skipping 10 matching lines @@
             delegate.fetcher()->GetSocketAddress().port());
   EXPECT_EQ(test_server_->host_port_pair().host(),
             delegate.fetcher()->GetSocketAddress().host());
 }
 
 TEST_F(URLFetcherTest, StopOnRedirect) {
   const char kRedirectTarget[] = "http://redirect.target.com";
 
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(
-      test_server_->GetURL(std::string("server-redirect?") + kRedirectTarget),
+      test_server_->GetURL(std::string("/server-redirect?") + kRedirectTarget),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.fetcher()->SetStopOnRedirect(true);
   delegate.StartFetcherAndWait();
 
   EXPECT_EQ(GURL(kRedirectTarget), delegate.fetcher()->GetURL());
   EXPECT_EQ(URLRequestStatus::CANCELED,
             delegate.fetcher()->GetStatus().status());
   EXPECT_EQ(ERR_ABORTED, delegate.fetcher()->GetStatus().error());
   EXPECT_EQ(301, delegate.fetcher()->GetResponseCode());
 }
@@ skipping 23 matching lines @@
     EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   }
 
   // 20 requests were sent. Due to throttling, they should have collectively
   // taken over 1 second.
   EXPECT_GE(Time::Now() - start_time, base::TimeDelta::FromSeconds(1));
 }
 
 TEST_F(URLFetcherTest, ThrottleOn5xxRetries) {
   base::Time start_time = Time::Now();
-  GURL url(test_server_->GetURL("files/server-unavailable.html"));
+  GURL url(test_server_->GetURL("/server-unavailable.html"));
 
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
   context_getter->AddThrottlerEntry(
       url, std::string() /* url_id */, 200 /* sliding_window_period_ms */,
@@ skipping 16 matching lines @@
 
   // The request should have been retried 11 times (12 times including the first
   // attempt).  Due to throttling, they should have collectively taken over 1
   // second.
   EXPECT_GE(Time::Now() - start_time, base::TimeDelta::FromSeconds(1));
 }
 
 // Tests overload protection, when responses passed through.
 TEST_F(URLFetcherTest, ProtectTestPassedThrough) {
   base::Time start_time = Time::Now();
-  GURL url(test_server_->GetURL("files/server-unavailable.html"));
+  GURL url(test_server_->GetURL("/server-unavailable.html"));
 
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 150000 milliseconds.
   // Maximum retries allowed is set to 11.
   // Total time if *not* for not doing automatic backoff would be 150s.
   // In reality it should be "as soon as server responds".
@@ skipping 148 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ReuseFetcherDelegate);
 };
 
 TEST_F(URLFetcherTest, ReuseFetcherForSameURL) {
   // TODO(mmenke):  It's really weird that this is supported, particularly
   // some fields can be modified between requests, but some (Like upload body)
   // cannot be. Can we get rid of support for this?
   scoped_refptr<URLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
   ReuseFetcherDelegate delegate(context_getter);
-  delegate.CreateFetcher(test_server_->GetURL("echoheader?test"),
+  delegate.CreateFetcher(test_server_->GetURL("/echoheader?test"),
                          URLFetcher::GET, context_getter);
   delegate.fetcher()->SetExtraRequestHeaders("test: request1");
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ("request2", data);
 }
@@ skipping 162 matching lines @@
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_TRUE(delegate.fetcher()->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net