| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/test/embedded_test_server/http_server.h" | |
| 6 | |
| 7 #include "base/stringprintf.h" | |
| 8 #include "base/threading/thread.h" | |
| 9 #include "net/http/http_response_headers.h" | |
| 10 #include "net/test/embedded_test_server/http_request.h" | |
| 11 #include "net/test/embedded_test_server/http_response.h" | |
| 12 #include "net/url_request/url_fetcher.h" | |
| 13 #include "net/url_request/url_fetcher_delegate.h" | |
| 14 #include "net/url_request/url_request_test_util.h" | |
| 15 #include "testing/gtest/include/gtest/gtest.h" | |
| 16 | |
| 17 namespace google_apis { | |
| 18 namespace test_server { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // Gets the content from the given URLFetcher. | |
| 23 std::string GetContentFromFetcher(const net::URLFetcher& fetcher) { | |
| 24 std::string result; | |
| 25 const bool success = fetcher.GetResponseAsString(&result); | |
| 26 EXPECT_TRUE(success); | |
| 27 return result; | |
| 28 } | |
| 29 | |
| 30 // Gets the content type from the given URLFetcher. | |
| 31 std::string GetContentTypeFromFetcher(const net::URLFetcher& fetcher) { | |
| 32 const net::HttpResponseHeaders* headers = fetcher.GetResponseHeaders(); | |
| 33 if (headers) { | |
| 34 std::string content_type; | |
| 35 if (headers->GetMimeType(&content_type)) | |
| 36 return content_type; | |
| 37 } | |
| 38 return std::string(); | |
| 39 } | |
| 40 | |
| 41 } // namespace | |
| 42 | |
| 43 class HttpServerTest : public testing::Test, | |
| 44 public net::URLFetcherDelegate { | |
| 45 public: | |
| 46 HttpServerTest() | |
| 47 : num_responses_received_(0), | |
| 48 num_responses_expected_(0), | |
| 49 io_thread_("io_thread") { | |
| 50 } | |
| 51 | |
| 52 virtual void SetUp() OVERRIDE { | |
| 53 base::Thread::Options thread_options; | |
| 54 thread_options.message_loop_type = MessageLoop::TYPE_IO; | |
| 55 ASSERT_TRUE(io_thread_.StartWithOptions(thread_options)); | |
| 56 | |
| 57 request_context_getter_ = new net::TestURLRequestContextGetter( | |
| 58 io_thread_.message_loop_proxy()); | |
| 59 | |
| 60 server_.reset(new HttpServer(io_thread_.message_loop_proxy())); | |
| 61 ASSERT_TRUE(server_->InitializeAndWaitUntilReady()); | |
| 62 } | |
| 63 | |
| 64 virtual void TearDown() OVERRIDE { | |
| 65 ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete()); | |
| 66 } | |
| 67 | |
| 68 // net::URLFetcherDelegate override. | |
| 69 virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE { | |
| 70 ++num_responses_received_; | |
| 71 if (num_responses_received_ == num_responses_expected_) | |
| 72 MessageLoop::current()->Quit(); | |
| 73 } | |
| 74 | |
| 75 // Waits until the specified number of responses are received. | |
| 76 void WaitForResponses(int num_responses) { | |
| 77 num_responses_received_ = 0; | |
| 78 num_responses_expected_ = num_responses; | |
| 79 // Will be terminated in OnURLFetchComplete(). | |
| 80 MessageLoop::current()->Run(); | |
| 81 } | |
| 82 | |
| 83 // Handles |request| sent to |path| and returns the response per |content|, | |
| 84 // |content type|, and |code|. Saves the request URL for verification. | |
| 85 scoped_ptr<HttpResponse> HandleRequest(const std::string& path, | |
| 86 const std::string& content, | |
| 87 const std::string& content_type, | |
| 88 ResponseCode code, | |
| 89 const HttpRequest& request) { | |
| 90 request_relative_url_ = request.relative_url; | |
| 91 | |
| 92 GURL absolute_url = server_->GetURL(request.relative_url); | |
| 93 if (absolute_url.path() == path) { | |
| 94 scoped_ptr<HttpResponse> http_response(new HttpResponse); | |
| 95 http_response->set_code(code); | |
| 96 http_response->set_content(content); | |
| 97 http_response->set_content_type(content_type); | |
| 98 return http_response.Pass(); | |
| 99 } | |
| 100 | |
| 101 return scoped_ptr<HttpResponse>(); | |
| 102 } | |
| 103 | |
| 104 protected: | |
| 105 int num_responses_received_; | |
| 106 int num_responses_expected_; | |
| 107 std::string request_relative_url_; | |
| 108 base::Thread io_thread_; | |
| 109 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; | |
| 110 scoped_ptr<HttpServer> server_; | |
| 111 }; | |
| 112 | |
| 113 TEST_F(HttpServerTest, GetBaseURL) { | |
| 114 EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%d/", server_->port()), | |
| 115 server_->base_url().spec()); | |
| 116 } | |
| 117 | |
| 118 TEST_F(HttpServerTest, GetURL) { | |
| 119 EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%d/path?query=foo", | |
| 120 server_->port()), | |
| 121 server_->GetURL("/path?query=foo").spec()); | |
| 122 } | |
| 123 | |
| 124 TEST_F(HttpServerTest, RegisterRequestHandler) { | |
| 125 server_->RegisterRequestHandler(base::Bind(&HttpServerTest::HandleRequest, | |
| 126 base::Unretained(this), | |
| 127 "/test", | |
| 128 "<b>Worked!</b>", | |
| 129 "text/html", | |
| 130 SUCCESS)); | |
| 131 | |
| 132 scoped_ptr<net::URLFetcher> fetcher( | |
| 133 net::URLFetcher::Create(server_->GetURL("/test?q=foo"), | |
| 134 net::URLFetcher::GET, | |
| 135 this)); | |
| 136 fetcher->SetRequestContext(request_context_getter_.get()); | |
| 137 fetcher->Start(); | |
| 138 WaitForResponses(1); | |
| 139 | |
| 140 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); | |
| 141 EXPECT_EQ(SUCCESS, fetcher->GetResponseCode()); | |
| 142 EXPECT_EQ("<b>Worked!</b>", GetContentFromFetcher(*fetcher)); | |
| 143 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher)); | |
| 144 | |
| 145 EXPECT_EQ("/test?q=foo", request_relative_url_); | |
| 146 } | |
| 147 | |
| 148 TEST_F(HttpServerTest, DefaultNotFoundResponse) { | |
| 149 scoped_ptr<net::URLFetcher> fetcher( | |
| 150 net::URLFetcher::Create(server_->GetURL("/non-existent"), | |
| 151 net::URLFetcher::GET, | |
| 152 this)); | |
| 153 fetcher->SetRequestContext(request_context_getter_.get()); | |
| 154 | |
| 155 fetcher->Start(); | |
| 156 WaitForResponses(1); | |
| 157 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); | |
| 158 EXPECT_EQ(NOT_FOUND, fetcher->GetResponseCode()); | |
| 159 } | |
| 160 | |
| 161 TEST_F(HttpServerTest, ConcurrentFetches) { | |
| 162 server_->RegisterRequestHandler( | |
| 163 base::Bind(&HttpServerTest::HandleRequest, | |
| 164 base::Unretained(this), | |
| 165 "/test1", | |
| 166 "Raspberry chocolate", | |
| 167 "text/html", | |
| 168 SUCCESS)); | |
| 169 server_->RegisterRequestHandler( | |
| 170 base::Bind(&HttpServerTest::HandleRequest, | |
| 171 base::Unretained(this), | |
| 172 "/test2", | |
| 173 "Vanilla chocolate", | |
| 174 "text/html", | |
| 175 SUCCESS)); | |
| 176 server_->RegisterRequestHandler( | |
| 177 base::Bind(&HttpServerTest::HandleRequest, | |
| 178 base::Unretained(this), | |
| 179 "/test3", | |
| 180 "No chocolates", | |
| 181 "text/plain", | |
| 182 NOT_FOUND)); | |
| 183 | |
| 184 scoped_ptr<net::URLFetcher> fetcher1 = scoped_ptr<net::URLFetcher>( | |
| 185 net::URLFetcher::Create(server_->GetURL("/test1"), | |
| 186 net::URLFetcher::GET, | |
| 187 this)); | |
| 188 fetcher1->SetRequestContext(request_context_getter_.get()); | |
| 189 scoped_ptr<net::URLFetcher> fetcher2 = scoped_ptr<net::URLFetcher>( | |
| 190 net::URLFetcher::Create(server_->GetURL("/test2"), | |
| 191 net::URLFetcher::GET, | |
| 192 this)); | |
| 193 fetcher2->SetRequestContext(request_context_getter_.get()); | |
| 194 scoped_ptr<net::URLFetcher> fetcher3 = scoped_ptr<net::URLFetcher>( | |
| 195 net::URLFetcher::Create(server_->GetURL("/test3"), | |
| 196 net::URLFetcher::GET, | |
| 197 this)); | |
| 198 fetcher3->SetRequestContext(request_context_getter_.get()); | |
| 199 | |
| 200 // Fetch the three URLs concurrently. | |
| 201 fetcher1->Start(); | |
| 202 fetcher2->Start(); | |
| 203 fetcher3->Start(); | |
| 204 WaitForResponses(3); | |
| 205 | |
| 206 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
| 207 EXPECT_EQ(SUCCESS, fetcher1->GetResponseCode()); | |
| 208 EXPECT_EQ("Raspberry chocolate", GetContentFromFetcher(*fetcher1)); | |
| 209 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher1)); | |
| 210 | |
| 211 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher2->GetStatus().status()); | |
| 212 EXPECT_EQ(SUCCESS, fetcher2->GetResponseCode()); | |
| 213 EXPECT_EQ("Vanilla chocolate", GetContentFromFetcher(*fetcher2)); | |
| 214 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher2)); | |
| 215 | |
| 216 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher3->GetStatus().status()); | |
| 217 EXPECT_EQ(NOT_FOUND, fetcher3->GetResponseCode()); | |
| 218 EXPECT_EQ("No chocolates", GetContentFromFetcher(*fetcher3)); | |
| 219 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher3)); | |
| 220 } | |
| 221 | |
| 222 } // namespace test_server | |
| 223 } // namespace google_apis | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 15069003:
Rename the embedded test server to EmbeddedTestServer in net::test_server namespace. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src