OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/google_apis/test_server/http_server.h" | 5 #include "chrome/browser/google_apis/test_server/http_server.h" |
6 | 6 |
| 7 #include "base/stringprintf.h" |
7 #include "base/threading/thread.h" | 8 #include "base/threading/thread.h" |
| 9 #include "chrome/browser/google_apis/test_util.h" |
8 #include "content/public/browser/browser_thread.h" | 10 #include "content/public/browser/browser_thread.h" |
9 #include "content/public/test/test_browser_thread.h" | 11 #include "content/public/test/test_browser_thread.h" |
| 12 #include "net/http/http_response_headers.h" |
10 #include "net/url_request/url_fetcher.h" | 13 #include "net/url_request/url_fetcher.h" |
11 #include "net/url_request/url_fetcher_delegate.h" | 14 #include "net/url_request/url_fetcher_delegate.h" |
12 #include "net/url_request/url_request_test_util.h" | 15 #include "net/url_request/url_request_test_util.h" |
13 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
14 | 17 |
15 namespace google_apis { | 18 namespace google_apis { |
16 namespace test_server { | 19 namespace test_server { |
17 | 20 |
18 namespace { | 21 namespace { |
19 | 22 |
20 // Helper function to receive content of a response returned after invoking | 23 // Gets the content from the given URLFetcher. |
21 // |fetcher|. | 24 std::string GetContentFromFetcher(const net::URLFetcher& fetcher) { |
22 std::string GetFetcherResponseContent(const net::URLFetcher* fetcher) { | |
23 std::string result; | 25 std::string result; |
24 const bool success = fetcher->GetResponseAsString(&result); | 26 const bool success = fetcher.GetResponseAsString(&result); |
25 EXPECT_TRUE(success); | 27 EXPECT_TRUE(success); |
26 return result; | 28 return result; |
27 } | 29 } |
28 | 30 |
| 31 // Gets the content type from the given URLFetcher. |
| 32 std::string GetContentTypeFromFetcher(const net::URLFetcher& fetcher) { |
| 33 const net::HttpResponseHeaders* headers = fetcher.GetResponseHeaders(); |
| 34 if (headers) { |
| 35 std::string content_type; |
| 36 if (headers->GetMimeType(&content_type)) |
| 37 return content_type; |
| 38 } |
| 39 return ""; |
| 40 } |
| 41 |
29 } // namespace | 42 } // namespace |
30 | 43 |
31 class HttpServerTest : public testing::Test, | 44 class HttpServerTest : public testing::Test, |
32 public net::URLFetcherDelegate { | 45 public net::URLFetcherDelegate { |
33 public: | 46 public: |
34 HttpServerTest() | 47 HttpServerTest() |
35 : ui_thread_(content::BrowserThread::UI, &message_loop_), | 48 : num_responses_received_(0), |
36 io_thread_(content::BrowserThread::IO) { | 49 num_responses_expected_(0), |
| 50 ui_thread_(content::BrowserThread::UI, &message_loop_), |
| 51 io_thread_(content::BrowserThread::IO) { |
37 } | 52 } |
38 | 53 |
39 virtual void SetUp() OVERRIDE { | 54 virtual void SetUp() OVERRIDE { |
40 io_thread_.StartIOThread(); | 55 io_thread_.StartIOThread(); |
41 | 56 |
42 request_context_getter_ = new net::TestURLRequestContextGetter( | 57 request_context_getter_ = new net::TestURLRequestContextGetter( |
43 content::BrowserThread::GetMessageLoopProxyForThread( | 58 content::BrowserThread::GetMessageLoopProxyForThread( |
44 content::BrowserThread::IO)); | 59 content::BrowserThread::IO)); |
45 | 60 |
46 server_.reset(new HttpServer()); | 61 ASSERT_TRUE(server_.InitializeAndWaitUntilReady()); |
47 ASSERT_TRUE(server_->InitializeAndWaitUntilReady()); | |
48 } | 62 } |
49 | 63 |
50 virtual void TearDown() OVERRIDE { | 64 virtual void TearDown() OVERRIDE { |
51 server_->ShutdownAndWaitUntilComplete(); | 65 server_.ShutdownAndWaitUntilComplete(); |
52 } | 66 } |
53 | 67 |
54 // net::URLFetcherDelegate override. | 68 // net::URLFetcherDelegate override. |
55 virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE { | 69 virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE { |
56 MessageLoop::current()->Quit(); | 70 ++num_responses_received_; |
| 71 if (num_responses_received_ == num_responses_expected_) |
| 72 message_loop_.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 message_loop_.Run(); // Will be terminated in OnURLFetchComplete(). |
57 } | 80 } |
58 | 81 |
59 protected: | 82 protected: |
| 83 int num_responses_received_; |
| 84 int num_responses_expected_; |
60 MessageLoopForUI message_loop_; | 85 MessageLoopForUI message_loop_; |
61 content::TestBrowserThread ui_thread_; | 86 content::TestBrowserThread ui_thread_; |
62 content::TestBrowserThread io_thread_; | 87 content::TestBrowserThread io_thread_; |
63 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; | 88 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; |
64 scoped_ptr<HttpServer> server_; | 89 HttpServer server_; |
65 }; | 90 }; |
66 | 91 |
67 TEST_F(HttpServerTest, TextRequest) { | 92 TEST_F(HttpServerTest, GetBaseURL) { |
68 // The simplest text response with an auto generated url. | 93 EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%d/", server_.port()), |
69 GURL url1 = server_->RegisterTextResponse("test1", | 94 server_.GetBaseURL().spec()); |
70 "Raspberry chocolate", | 95 } |
71 "text/html", | |
72 SUCCESS); | |
73 ASSERT_NE("", url1.spec()); | |
74 | 96 |
75 GURL url2 = server_->RegisterTextResponse("test2", | 97 TEST_F(HttpServerTest, GetURL) { |
76 "Vanilla chocolate", | 98 EXPECT_EQ(base::StringPrintf("http://127.0.0.1:%d/path?query=foo", |
77 "text/html", | 99 server_.port()), |
78 SUCCESS); | 100 server_.GetURL("/path?query=foo").spec()); |
79 ASSERT_NE("", url2.spec()); | 101 } |
80 | 102 |
81 // Response with a specified url and response code. | 103 TEST_F(HttpServerTest, RegisterDefaultResponse) { |
82 GURL url3 = server_->RegisterTextResponse( | 104 HttpResponse http_response; |
83 "chocolate/bar.html", // URL | 105 // MOVED is chosen here, as it's rather an unusual code. |
84 "No chocolates", // Dummy response text. | 106 http_response.set_code(MOVED); |
85 "text/plain", // Content type. | 107 http_response.set_content("<b>Moved!</b>"); |
86 NOT_FOUND); // Response code (404 here). | 108 http_response.set_content_type("text/html"); |
87 ASSERT_NE("", url3.spec()); | 109 http_response.AddCustomHeader("Server", "test server"); |
| 110 server_.RegisterDefaultResponse("/test", http_response); |
88 | 111 |
89 // Set up fetchers. | 112 scoped_ptr<net::URLFetcher> fetcher( |
90 scoped_ptr<net::URLFetcher> fetcher1 = scoped_ptr<net::URLFetcher>( | 113 net::URLFetcher::Create(server_.GetURL("/test"), |
91 net::URLFetcher::Create(url1, | |
92 net::URLFetcher::GET, | 114 net::URLFetcher::GET, |
93 this)); | 115 this)); |
94 fetcher1->SetRequestContext(request_context_getter_.get()); | 116 fetcher->SetRequestContext(request_context_getter_.get()); |
95 scoped_ptr<net::URLFetcher> fetcher2 = scoped_ptr<net::URLFetcher>( | 117 fetcher->Start(); |
96 net::URLFetcher::Create(url2, | 118 WaitForResponses(1); |
| 119 |
| 120 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
| 121 EXPECT_EQ(MOVED, fetcher->GetResponseCode()); |
| 122 EXPECT_EQ("<b>Moved!</b>", GetContentFromFetcher(*fetcher)); |
| 123 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher)); |
| 124 const net::HttpResponseHeaders* headers = fetcher->GetResponseHeaders(); |
| 125 ASSERT_TRUE(headers); |
| 126 ASSERT_TRUE(headers->HasHeaderValue("Server", "test server")); |
| 127 } |
| 128 |
| 129 TEST_F(HttpServerTest, RegisterTextResponse) { |
| 130 server_.RegisterTextResponse("/test", |
| 131 "Raspberry chocolate", |
| 132 "text/plain", |
| 133 SUCCESS); |
| 134 |
| 135 scoped_ptr<net::URLFetcher> fetcher( |
| 136 net::URLFetcher::Create(server_.GetURL("/test"), |
97 net::URLFetcher::GET, | 137 net::URLFetcher::GET, |
98 this)); | 138 this)); |
99 fetcher2->SetRequestContext(request_context_getter_.get()); | 139 fetcher->SetRequestContext(request_context_getter_.get()); |
100 scoped_ptr<net::URLFetcher> fetcher3 = scoped_ptr<net::URLFetcher>( | 140 fetcher->Start(); |
101 net::URLFetcher::Create(url3, | 141 WaitForResponses(1); |
| 142 |
| 143 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
| 144 EXPECT_EQ(SUCCESS, fetcher->GetResponseCode()); |
| 145 EXPECT_EQ("Raspberry chocolate", GetContentFromFetcher(*fetcher)); |
| 146 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher)); |
| 147 } |
| 148 |
| 149 // Test files cannot be opened on Android. |
| 150 #if !defined(OS_ANDROID) |
| 151 |
| 152 TEST_F(HttpServerTest, RegisterFileResponse) { |
| 153 server_.RegisterFileResponse( |
| 154 "/test", |
| 155 test_util::GetTestFilePath("gdata/testfile.txt"), |
| 156 "text/plain", |
| 157 SUCCESS); |
| 158 |
| 159 scoped_ptr<net::URLFetcher> fetcher( |
| 160 net::URLFetcher::Create(server_.GetURL("/test"), |
102 net::URLFetcher::GET, | 161 net::URLFetcher::GET, |
103 this)); | 162 this)); |
104 fetcher3->SetRequestContext(request_context_getter_.get()); | 163 fetcher->SetRequestContext(request_context_getter_.get()); |
| 164 fetcher->Start(); |
| 165 WaitForResponses(1); |
105 | 166 |
106 // Test. | 167 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
107 fetcher1->Start(); | 168 EXPECT_EQ(SUCCESS, fetcher->GetResponseCode()); |
108 MessageLoop::current()->Run(); | 169 // Trim the trailing whitespace as it can be CRLF on Windows... |
109 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | 170 const std::string content = GetContentFromFetcher(*fetcher); |
110 EXPECT_EQ(200, fetcher1->GetResponseCode()); | 171 std::string trimmed; |
111 EXPECT_EQ("Raspberry chocolate", GetFetcherResponseContent(fetcher1.get())); | 172 TrimWhitespaceASCII(content, TRIM_TRAILING, &trimmed); |
112 | 173 EXPECT_EQ("test file", trimmed); |
113 fetcher2->Start(); | 174 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher)); |
114 MessageLoop::current()->Run(); | |
115 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
116 EXPECT_EQ(200, fetcher2->GetResponseCode()); | |
117 EXPECT_EQ("Vanilla chocolate", GetFetcherResponseContent(fetcher2.get())); | |
118 | |
119 fetcher3->Start(); | |
120 MessageLoop::current()->Run(); | |
121 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
122 EXPECT_EQ(404, fetcher3->GetResponseCode()); | |
123 EXPECT_EQ("No chocolates", GetFetcherResponseContent(fetcher3.get())); | |
124 } | 175 } |
125 | 176 |
| 177 #endif // !defined(OS_ANDROID) |
| 178 |
126 TEST_F(HttpServerTest, DefaultNotFoundResponse) { | 179 TEST_F(HttpServerTest, DefaultNotFoundResponse) { |
127 ASSERT_NE("", server_->GetBaseURL().spec()); | 180 scoped_ptr<net::URLFetcher> fetcher( |
128 | 181 net::URLFetcher::Create(server_.GetURL("/non-existent"), |
129 scoped_ptr<net::URLFetcher> fetcher = scoped_ptr<net::URLFetcher>( | |
130 net::URLFetcher::Create(server_->GetBaseURL(), | |
131 net::URLFetcher::GET, | 182 net::URLFetcher::GET, |
132 this)); | 183 this)); |
133 fetcher->SetRequestContext(request_context_getter_.get()); | 184 fetcher->SetRequestContext(request_context_getter_.get()); |
134 | 185 |
135 fetcher->Start(); | 186 fetcher->Start(); |
136 MessageLoop::current()->Run(); | 187 WaitForResponses(1); |
137 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); | 188 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
138 EXPECT_EQ(404, fetcher->GetResponseCode()); | 189 EXPECT_EQ(NOT_FOUND, fetcher->GetResponseCode()); |
139 } | 190 } |
140 | 191 |
141 // TODO(mtomasz): Write a test for a file response. | 192 TEST_F(HttpServerTest, ConcurrentFetches) { |
| 193 server_.RegisterTextResponse("/test1", |
| 194 "Raspberry chocolate", |
| 195 "text/html", |
| 196 SUCCESS); |
| 197 server_.RegisterTextResponse("/test2", |
| 198 "Vanilla chocolate", |
| 199 "text/html", |
| 200 SUCCESS); |
| 201 server_.RegisterTextResponse("/test3", |
| 202 "No chocolates", |
| 203 "text/plain", |
| 204 NOT_FOUND); |
| 205 |
| 206 scoped_ptr<net::URLFetcher> fetcher1 = scoped_ptr<net::URLFetcher>( |
| 207 net::URLFetcher::Create(server_.GetURL("/test1"), |
| 208 net::URLFetcher::GET, |
| 209 this)); |
| 210 fetcher1->SetRequestContext(request_context_getter_.get()); |
| 211 scoped_ptr<net::URLFetcher> fetcher2 = scoped_ptr<net::URLFetcher>( |
| 212 net::URLFetcher::Create(server_.GetURL("/test2"), |
| 213 net::URLFetcher::GET, |
| 214 this)); |
| 215 fetcher2->SetRequestContext(request_context_getter_.get()); |
| 216 scoped_ptr<net::URLFetcher> fetcher3 = scoped_ptr<net::URLFetcher>( |
| 217 net::URLFetcher::Create(server_.GetURL("/test3"), |
| 218 net::URLFetcher::GET, |
| 219 this)); |
| 220 fetcher3->SetRequestContext(request_context_getter_.get()); |
| 221 |
| 222 // Fetch the three URLs concurrently. |
| 223 fetcher1->Start(); |
| 224 fetcher2->Start(); |
| 225 fetcher3->Start(); |
| 226 WaitForResponses(3); |
| 227 |
| 228 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); |
| 229 EXPECT_EQ(SUCCESS, fetcher1->GetResponseCode()); |
| 230 EXPECT_EQ("Raspberry chocolate", GetContentFromFetcher(*fetcher1)); |
| 231 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher1)); |
| 232 |
| 233 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher2->GetStatus().status()); |
| 234 EXPECT_EQ(SUCCESS, fetcher2->GetResponseCode()); |
| 235 EXPECT_EQ("Vanilla chocolate", GetContentFromFetcher(*fetcher2)); |
| 236 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher2)); |
| 237 |
| 238 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher3->GetStatus().status()); |
| 239 EXPECT_EQ(NOT_FOUND,fetcher3->GetResponseCode()); |
| 240 EXPECT_EQ("No chocolates", GetContentFromFetcher(*fetcher3)); |
| 241 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher3)); |
| 242 } |
142 | 243 |
143 } // namespace test_server | 244 } // namespace test_server |
144 } // namespace google_apis | 245 } // namespace google_apis |
OLD | NEW |