Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(62)

Side by Side Diff: chrome/browser/google_apis/test_server/http_server_unittest.cc

Issue 11416030: google_apis: Add GetURL() to test_server::HttpServer (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix android Created 8 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
OLDNEW
« no previous file with comments | « chrome/browser/google_apis/test_server/http_server.cc ('k') | chrome/test/data/chromeos/gdata/testfile.txt » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698