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 http_response.set_code(MOVED); |
hashimoto
2012/11/16 05:38:10
Please add a brief description about why you chose
satorux1
2012/11/16 05:56:44
Done.
| |
84 "No chocolates", // Dummy response text. | 106 http_response.set_content("<b>Moved!</b>"); |
hashimoto
2012/11/16 05:38:10
How about making this data a constant?
The same go
satorux1
2012/11/16 05:56:44
It's rather repetitive, but I think just using str
| |
85 "text/plain", // Content type. | 107 http_response.set_content_type("text/html"); |
hashimoto
2012/11/16 05:38:10
ditto.
| |
86 NOT_FOUND); // Response code (404 here). | 108 http_response.AddCustomHeader("Server", "test server"); |
hashimoto
2012/11/16 05:38:10
ditto.
| |
87 ASSERT_NE("", url3.spec()); | 109 server_.RegisterDefaultResponse("/test", http_response); |
hashimoto
2012/11/16 05:38:10
ditto.
| |
88 | 110 |
89 // Set up fetchers. | 111 scoped_ptr<net::URLFetcher> fetcher( |
90 scoped_ptr<net::URLFetcher> fetcher1 = scoped_ptr<net::URLFetcher>( | 112 net::URLFetcher::Create(server_.GetURL("/test"), |
91 net::URLFetcher::Create(url1, | |
92 net::URLFetcher::GET, | 113 net::URLFetcher::GET, |
93 this)); | 114 this)); |
94 fetcher1->SetRequestContext(request_context_getter_.get()); | 115 fetcher->SetRequestContext(request_context_getter_.get()); |
95 scoped_ptr<net::URLFetcher> fetcher2 = scoped_ptr<net::URLFetcher>( | 116 fetcher->Start(); |
96 net::URLFetcher::Create(url2, | 117 WaitForResponses(1); |
118 | |
119 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); | |
120 EXPECT_EQ(301, fetcher->GetResponseCode()); | |
hashimoto
2012/11/16 05:38:10
Why are you using MOVED above and 301 here?
The sa
satorux1
2012/11/16 05:56:44
Done.
| |
121 EXPECT_EQ("<b>Moved!</b>", GetContentFromFetcher(*fetcher)); | |
122 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher)); | |
123 const net::HttpResponseHeaders* headers = fetcher->GetResponseHeaders(); | |
124 ASSERT_TRUE(headers); | |
125 ASSERT_TRUE(headers->HasHeaderValue("Server", "test server")); | |
126 | |
hashimoto
2012/11/16 05:38:10
nit: No need have a blank line here.
satorux1
2012/11/16 05:56:44
Done.
| |
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(200, fetcher->GetResponseCode()); | |
145 EXPECT_EQ("Raspberry chocolate", GetContentFromFetcher(*fetcher)); | |
146 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher)); | |
147 } | |
148 | |
149 TEST_F(HttpServerTest, RegisterFileResponse) { | |
150 server_.RegisterFileResponse( | |
151 "/test", | |
152 test_util::GetTestFilePath("gdata/testfile.txt"), | |
153 "text/plain", | |
154 SUCCESS); | |
155 | |
156 scoped_ptr<net::URLFetcher> fetcher( | |
157 net::URLFetcher::Create(server_.GetURL("/test"), | |
102 net::URLFetcher::GET, | 158 net::URLFetcher::GET, |
103 this)); | 159 this)); |
104 fetcher3->SetRequestContext(request_context_getter_.get()); | 160 fetcher->SetRequestContext(request_context_getter_.get()); |
161 fetcher->Start(); | |
162 WaitForResponses(1); | |
105 | 163 |
106 // Test. | 164 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
107 fetcher1->Start(); | 165 EXPECT_EQ(200, fetcher->GetResponseCode()); |
108 MessageLoop::current()->Run(); | 166 EXPECT_EQ("test file\n", GetContentFromFetcher(*fetcher)); |
109 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | 167 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher)); |
110 EXPECT_EQ(200, fetcher1->GetResponseCode()); | |
111 EXPECT_EQ("Raspberry chocolate", GetFetcherResponseContent(fetcher1.get())); | |
112 | |
113 fetcher2->Start(); | |
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 } | 168 } |
125 | 169 |
126 TEST_F(HttpServerTest, DefaultNotFoundResponse) { | 170 TEST_F(HttpServerTest, DefaultNotFoundResponse) { |
127 ASSERT_NE("", server_->GetBaseURL().spec()); | 171 scoped_ptr<net::URLFetcher> fetcher( |
128 | 172 net::URLFetcher::Create(server_.GetBaseURL(), |
hashimoto
2012/11/16 05:38:10
Instead of GetBaseURL, how about using something l
satorux1
2012/11/16 05:56:44
Done.
| |
129 scoped_ptr<net::URLFetcher> fetcher = scoped_ptr<net::URLFetcher>( | |
130 net::URLFetcher::Create(server_->GetBaseURL(), | |
131 net::URLFetcher::GET, | 173 net::URLFetcher::GET, |
132 this)); | 174 this)); |
133 fetcher->SetRequestContext(request_context_getter_.get()); | 175 fetcher->SetRequestContext(request_context_getter_.get()); |
134 | 176 |
135 fetcher->Start(); | 177 fetcher->Start(); |
136 MessageLoop::current()->Run(); | 178 WaitForResponses(1); |
137 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); | 179 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher->GetStatus().status()); |
138 EXPECT_EQ(404, fetcher->GetResponseCode()); | 180 EXPECT_EQ(404, fetcher->GetResponseCode()); |
139 } | 181 } |
140 | 182 |
141 // TODO(mtomasz): Write a test for a file response. | 183 TEST_F(HttpServerTest, ConcurrentFetches) { |
184 server_.RegisterTextResponse("/test1", | |
185 "Raspberry chocolate", | |
186 "text/html", | |
187 SUCCESS); | |
188 server_.RegisterTextResponse("/test2", | |
189 "Vanilla chocolate", | |
190 "text/html", | |
191 SUCCESS); | |
192 server_.RegisterTextResponse("/test3", | |
193 "No chocolates", | |
194 "text/plain", | |
195 NOT_FOUND); | |
196 | |
197 scoped_ptr<net::URLFetcher> fetcher1 = scoped_ptr<net::URLFetcher>( | |
198 net::URLFetcher::Create(server_.GetURL("/test1"), | |
199 net::URLFetcher::GET, | |
200 this)); | |
201 fetcher1->SetRequestContext(request_context_getter_.get()); | |
202 scoped_ptr<net::URLFetcher> fetcher2 = scoped_ptr<net::URLFetcher>( | |
203 net::URLFetcher::Create(server_.GetURL("/test2"), | |
204 net::URLFetcher::GET, | |
205 this)); | |
206 fetcher2->SetRequestContext(request_context_getter_.get()); | |
207 scoped_ptr<net::URLFetcher> fetcher3 = scoped_ptr<net::URLFetcher>( | |
208 net::URLFetcher::Create(server_.GetURL("/test3"), | |
209 net::URLFetcher::GET, | |
210 this)); | |
211 fetcher3->SetRequestContext(request_context_getter_.get()); | |
212 | |
213 // Fetch the three URLs concurrently. | |
214 fetcher1->Start(); | |
215 fetcher2->Start(); | |
216 fetcher3->Start(); | |
217 WaitForResponses(3); | |
218 | |
219 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
220 EXPECT_EQ(200, fetcher1->GetResponseCode()); | |
221 EXPECT_EQ("Raspberry chocolate", GetContentFromFetcher(*fetcher1)); | |
222 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher1)); | |
223 | |
224 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
hashimoto
2012/11/16 05:38:10
fetcher2?
satorux1
2012/11/16 05:56:44
Good catch! Done.
| |
225 EXPECT_EQ(200, fetcher2->GetResponseCode()); | |
226 EXPECT_EQ("Vanilla chocolate", GetContentFromFetcher(*fetcher2)); | |
227 EXPECT_EQ("text/html", GetContentTypeFromFetcher(*fetcher2)); | |
228 | |
229 EXPECT_EQ(net::URLRequestStatus::SUCCESS, fetcher1->GetStatus().status()); | |
hashimoto
2012/11/16 05:38:10
fetcher3?
satorux1
2012/11/16 05:56:44
Done.
| |
230 EXPECT_EQ(404, fetcher3->GetResponseCode()); | |
231 EXPECT_EQ("No chocolates", GetContentFromFetcher(*fetcher3)); | |
232 EXPECT_EQ("text/plain", GetContentTypeFromFetcher(*fetcher3)); | |
233 } | |
142 | 234 |
143 } // namespace test_server | 235 } // namespace test_server |
144 } // namespace google_apis | 236 } // namespace google_apis |
OLD | NEW |