| 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/http/http_transaction_unittest.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/message_loop/message_loop.h" | |
| 11 #include "base/strings/stringprintf.h" | |
| 12 #include "base/time/time.h" | |
| 13 #include "net/base/load_flags.h" | |
| 14 #include "net/base/load_timing_info.h" | |
| 15 #include "net/base/net_errors.h" | |
| 16 #include "net/disk_cache/disk_cache.h" | |
| 17 #include "net/http/http_cache.h" | |
| 18 #include "net/http/http_request_info.h" | |
| 19 #include "net/http/http_response_info.h" | |
| 20 #include "net/http/http_transaction.h" | |
| 21 #include "testing/gtest/include/gtest/gtest.h" | |
| 22 | |
| 23 namespace { | |
| 24 typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap; | |
| 25 static MockTransactionMap mock_transactions; | |
| 26 } // namespace | |
| 27 | |
| 28 //----------------------------------------------------------------------------- | |
| 29 // mock transaction data | |
| 30 | |
| 31 const MockTransaction kSimpleGET_Transaction = { | |
| 32 "http://www.google.com/", | |
| 33 "GET", | |
| 34 base::Time(), | |
| 35 "", | |
| 36 net::LOAD_NORMAL, | |
| 37 "HTTP/1.1 200 OK", | |
| 38 "Cache-Control: max-age=10000\n", | |
| 39 base::Time(), | |
| 40 "<html><body>Google Blah Blah</body></html>", | |
| 41 TEST_MODE_NORMAL, | |
| 42 NULL, | |
| 43 0, | |
| 44 net::OK | |
| 45 }; | |
| 46 | |
| 47 const MockTransaction kSimplePOST_Transaction = { | |
| 48 "http://bugdatabase.com/edit", | |
| 49 "POST", | |
| 50 base::Time(), | |
| 51 "", | |
| 52 net::LOAD_NORMAL, | |
| 53 "HTTP/1.1 200 OK", | |
| 54 "", | |
| 55 base::Time(), | |
| 56 "<html><body>Google Blah Blah</body></html>", | |
| 57 TEST_MODE_NORMAL, | |
| 58 NULL, | |
| 59 0, | |
| 60 net::OK | |
| 61 }; | |
| 62 | |
| 63 const MockTransaction kTypicalGET_Transaction = { | |
| 64 "http://www.example.com/~foo/bar.html", | |
| 65 "GET", | |
| 66 base::Time(), | |
| 67 "", | |
| 68 net::LOAD_NORMAL, | |
| 69 "HTTP/1.1 200 OK", | |
| 70 "Date: Wed, 28 Nov 2007 09:40:09 GMT\n" | |
| 71 "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n", | |
| 72 base::Time(), | |
| 73 "<html><body>Google Blah Blah</body></html>", | |
| 74 TEST_MODE_NORMAL, | |
| 75 NULL, | |
| 76 0, | |
| 77 net::OK | |
| 78 }; | |
| 79 | |
| 80 const MockTransaction kETagGET_Transaction = { | |
| 81 "http://www.google.com/foopy", | |
| 82 "GET", | |
| 83 base::Time(), | |
| 84 "", | |
| 85 net::LOAD_NORMAL, | |
| 86 "HTTP/1.1 200 OK", | |
| 87 "Cache-Control: max-age=10000\n" | |
| 88 "Etag: \"foopy\"\n", | |
| 89 base::Time(), | |
| 90 "<html><body>Google Blah Blah</body></html>", | |
| 91 TEST_MODE_NORMAL, | |
| 92 NULL, | |
| 93 0, | |
| 94 net::OK | |
| 95 }; | |
| 96 | |
| 97 const MockTransaction kRangeGET_Transaction = { | |
| 98 "http://www.google.com/", | |
| 99 "GET", | |
| 100 base::Time(), | |
| 101 "Range: 0-100\r\n", | |
| 102 net::LOAD_NORMAL, | |
| 103 "HTTP/1.1 200 OK", | |
| 104 "Cache-Control: max-age=10000\n", | |
| 105 base::Time(), | |
| 106 "<html><body>Google Blah Blah</body></html>", | |
| 107 TEST_MODE_NORMAL, | |
| 108 NULL, | |
| 109 0, | |
| 110 net::OK | |
| 111 }; | |
| 112 | |
| 113 static const MockTransaction* const kBuiltinMockTransactions[] = { | |
| 114 &kSimpleGET_Transaction, | |
| 115 &kSimplePOST_Transaction, | |
| 116 &kTypicalGET_Transaction, | |
| 117 &kETagGET_Transaction, | |
| 118 &kRangeGET_Transaction | |
| 119 }; | |
| 120 | |
| 121 const MockTransaction* FindMockTransaction(const GURL& url) { | |
| 122 // look for overrides: | |
| 123 MockTransactionMap::const_iterator it = mock_transactions.find(url.spec()); | |
| 124 if (it != mock_transactions.end()) | |
| 125 return it->second; | |
| 126 | |
| 127 // look for builtins: | |
| 128 for (size_t i = 0; i < arraysize(kBuiltinMockTransactions); ++i) { | |
| 129 if (url == GURL(kBuiltinMockTransactions[i]->url)) | |
| 130 return kBuiltinMockTransactions[i]; | |
| 131 } | |
| 132 return NULL; | |
| 133 } | |
| 134 | |
| 135 void AddMockTransaction(const MockTransaction* trans) { | |
| 136 mock_transactions[GURL(trans->url).spec()] = trans; | |
| 137 } | |
| 138 | |
| 139 void RemoveMockTransaction(const MockTransaction* trans) { | |
| 140 mock_transactions.erase(GURL(trans->url).spec()); | |
| 141 } | |
| 142 | |
| 143 MockHttpRequest::MockHttpRequest(const MockTransaction& t) { | |
| 144 url = GURL(t.url); | |
| 145 method = t.method; | |
| 146 extra_headers.AddHeadersFromString(t.request_headers); | |
| 147 load_flags = t.load_flags; | |
| 148 } | |
| 149 | |
| 150 //----------------------------------------------------------------------------- | |
| 151 | |
| 152 // static | |
| 153 int TestTransactionConsumer::quit_counter_ = 0; | |
| 154 | |
| 155 TestTransactionConsumer::TestTransactionConsumer( | |
| 156 net::RequestPriority priority, | |
| 157 net::HttpTransactionFactory* factory) | |
| 158 : state_(IDLE), error_(net::OK) { | |
| 159 // Disregard the error code. | |
| 160 factory->CreateTransaction(priority, &trans_); | |
| 161 ++quit_counter_; | |
| 162 } | |
| 163 | |
| 164 TestTransactionConsumer::~TestTransactionConsumer() { | |
| 165 } | |
| 166 | |
| 167 void TestTransactionConsumer::Start(const net::HttpRequestInfo* request, | |
| 168 const net::BoundNetLog& net_log) { | |
| 169 state_ = STARTING; | |
| 170 int result = trans_->Start( | |
| 171 request, base::Bind(&TestTransactionConsumer::OnIOComplete, | |
| 172 base::Unretained(this)), net_log); | |
| 173 if (result != net::ERR_IO_PENDING) | |
| 174 DidStart(result); | |
| 175 } | |
| 176 | |
| 177 void TestTransactionConsumer::DidStart(int result) { | |
| 178 if (result != net::OK) { | |
| 179 DidFinish(result); | |
| 180 } else { | |
| 181 Read(); | |
| 182 } | |
| 183 } | |
| 184 | |
| 185 void TestTransactionConsumer::DidRead(int result) { | |
| 186 if (result <= 0) { | |
| 187 DidFinish(result); | |
| 188 } else { | |
| 189 content_.append(read_buf_->data(), result); | |
| 190 Read(); | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 void TestTransactionConsumer::DidFinish(int result) { | |
| 195 state_ = DONE; | |
| 196 error_ = result; | |
| 197 if (--quit_counter_ == 0) | |
| 198 base::MessageLoop::current()->Quit(); | |
| 199 } | |
| 200 | |
| 201 void TestTransactionConsumer::Read() { | |
| 202 state_ = READING; | |
| 203 read_buf_ = new net::IOBuffer(1024); | |
| 204 int result = trans_->Read(read_buf_.get(), | |
| 205 1024, | |
| 206 base::Bind(&TestTransactionConsumer::OnIOComplete, | |
| 207 base::Unretained(this))); | |
| 208 if (result != net::ERR_IO_PENDING) | |
| 209 DidRead(result); | |
| 210 } | |
| 211 | |
| 212 void TestTransactionConsumer::OnIOComplete(int result) { | |
| 213 switch (state_) { | |
| 214 case STARTING: | |
| 215 DidStart(result); | |
| 216 break; | |
| 217 case READING: | |
| 218 DidRead(result); | |
| 219 break; | |
| 220 default: | |
| 221 NOTREACHED(); | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 MockNetworkTransaction::MockNetworkTransaction( | |
| 226 net::RequestPriority priority, | |
| 227 MockNetworkLayer* factory) | |
| 228 : weak_factory_(this), | |
| 229 request_(NULL), | |
| 230 data_cursor_(0), | |
| 231 priority_(priority), | |
| 232 websocket_handshake_stream_create_helper_(NULL), | |
| 233 transaction_factory_(factory->AsWeakPtr()), | |
| 234 received_bytes_(0), | |
| 235 socket_log_id_(net::NetLog::Source::kInvalidId) { | |
| 236 } | |
| 237 | |
| 238 MockNetworkTransaction::~MockNetworkTransaction() {} | |
| 239 | |
| 240 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request, | |
| 241 const net::CompletionCallback& callback, | |
| 242 const net::BoundNetLog& net_log) { | |
| 243 if (request_) | |
| 244 return net::ERR_FAILED; | |
| 245 | |
| 246 request_ = request; | |
| 247 return StartInternal(request, callback, net_log); | |
| 248 } | |
| 249 | |
| 250 int MockNetworkTransaction::RestartIgnoringLastError( | |
| 251 const net::CompletionCallback& callback) { | |
| 252 return net::ERR_FAILED; | |
| 253 } | |
| 254 | |
| 255 int MockNetworkTransaction::RestartWithCertificate( | |
| 256 net::X509Certificate* client_cert, | |
| 257 const net::CompletionCallback& callback) { | |
| 258 return net::ERR_FAILED; | |
| 259 } | |
| 260 | |
| 261 int MockNetworkTransaction::RestartWithAuth( | |
| 262 const net::AuthCredentials& credentials, | |
| 263 const net::CompletionCallback& callback) { | |
| 264 if (!IsReadyToRestartForAuth()) | |
| 265 return net::ERR_FAILED; | |
| 266 | |
| 267 net::HttpRequestInfo auth_request_info = *request_; | |
| 268 auth_request_info.extra_headers.AddHeaderFromString("Authorization: Bar"); | |
| 269 | |
| 270 // Let the MockTransactionHandler worry about this: the only way for this | |
| 271 // test to succeed is by using an explicit handler for the transaction so | |
| 272 // that server behavior can be simulated. | |
| 273 return StartInternal(&auth_request_info, callback, net::BoundNetLog()); | |
| 274 } | |
| 275 | |
| 276 bool MockNetworkTransaction::IsReadyToRestartForAuth() { | |
| 277 if (!request_) | |
| 278 return false; | |
| 279 | |
| 280 // Only mock auth when the test asks for it. | |
| 281 return request_->extra_headers.HasHeader("X-Require-Mock-Auth"); | |
| 282 } | |
| 283 | |
| 284 int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len, | |
| 285 const net::CompletionCallback& callback) { | |
| 286 int data_len = static_cast<int>(data_.size()); | |
| 287 int num = std::min(buf_len, data_len - data_cursor_); | |
| 288 if (test_mode_ & TEST_MODE_SLOW_READ) | |
| 289 num = std::min(num, 1); | |
| 290 if (num) { | |
| 291 memcpy(buf->data(), data_.data() + data_cursor_, num); | |
| 292 data_cursor_ += num; | |
| 293 } | |
| 294 if (test_mode_ & TEST_MODE_SYNC_NET_READ) | |
| 295 return num; | |
| 296 | |
| 297 CallbackLater(callback, num); | |
| 298 return net::ERR_IO_PENDING; | |
| 299 } | |
| 300 | |
| 301 void MockNetworkTransaction::StopCaching() { | |
| 302 if (transaction_factory_.get()) | |
| 303 transaction_factory_->TransactionStopCaching(); | |
| 304 } | |
| 305 | |
| 306 bool MockNetworkTransaction::GetFullRequestHeaders( | |
| 307 net::HttpRequestHeaders* headers) const { | |
| 308 return false; | |
| 309 } | |
| 310 | |
| 311 int64 MockNetworkTransaction::GetTotalReceivedBytes() const { | |
| 312 return received_bytes_; | |
| 313 } | |
| 314 | |
| 315 void MockNetworkTransaction::DoneReading() { | |
| 316 if (transaction_factory_.get()) | |
| 317 transaction_factory_->TransactionDoneReading(); | |
| 318 } | |
| 319 | |
| 320 const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const { | |
| 321 return &response_; | |
| 322 } | |
| 323 | |
| 324 net::LoadState MockNetworkTransaction::GetLoadState() const { | |
| 325 if (data_cursor_) | |
| 326 return net::LOAD_STATE_READING_RESPONSE; | |
| 327 return net::LOAD_STATE_IDLE; | |
| 328 } | |
| 329 | |
| 330 net::UploadProgress MockNetworkTransaction::GetUploadProgress() const { | |
| 331 return net::UploadProgress(); | |
| 332 } | |
| 333 | |
| 334 void MockNetworkTransaction::SetQuicServerInfo( | |
| 335 net::QuicServerInfo* quic_server_info) {} | |
| 336 | |
| 337 bool MockNetworkTransaction::GetLoadTimingInfo( | |
| 338 net::LoadTimingInfo* load_timing_info) const { | |
| 339 if (socket_log_id_ != net::NetLog::Source::kInvalidId) { | |
| 340 // The minimal set of times for a request that gets a response, assuming it | |
| 341 // gets a new socket. | |
| 342 load_timing_info->socket_reused = false; | |
| 343 load_timing_info->socket_log_id = socket_log_id_; | |
| 344 load_timing_info->connect_timing.connect_start = base::TimeTicks::Now(); | |
| 345 load_timing_info->connect_timing.connect_end = base::TimeTicks::Now(); | |
| 346 load_timing_info->send_start = base::TimeTicks::Now(); | |
| 347 load_timing_info->send_end = base::TimeTicks::Now(); | |
| 348 } else { | |
| 349 // If there's no valid socket ID, just use the generic socket reused values. | |
| 350 // No tests currently depend on this, just should not match the values set | |
| 351 // by a cache hit. | |
| 352 load_timing_info->socket_reused = true; | |
| 353 load_timing_info->send_start = base::TimeTicks::Now(); | |
| 354 load_timing_info->send_end = base::TimeTicks::Now(); | |
| 355 } | |
| 356 return true; | |
| 357 } | |
| 358 | |
| 359 void MockNetworkTransaction::SetPriority(net::RequestPriority priority) { | |
| 360 priority_ = priority; | |
| 361 } | |
| 362 | |
| 363 void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper( | |
| 364 net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) { | |
| 365 websocket_handshake_stream_create_helper_ = create_helper; | |
| 366 } | |
| 367 | |
| 368 int MockNetworkTransaction::StartInternal( | |
| 369 const net::HttpRequestInfo* request, | |
| 370 const net::CompletionCallback& callback, | |
| 371 const net::BoundNetLog& net_log) { | |
| 372 const MockTransaction* t = FindMockTransaction(request->url); | |
| 373 if (!t) | |
| 374 return net::ERR_FAILED; | |
| 375 | |
| 376 test_mode_ = t->test_mode; | |
| 377 | |
| 378 // Return immediately if we're returning an error. | |
| 379 if (net::OK != t->return_code) { | |
| 380 if (test_mode_ & TEST_MODE_SYNC_NET_START) | |
| 381 return t->return_code; | |
| 382 CallbackLater(callback, t->return_code); | |
| 383 return net::ERR_IO_PENDING; | |
| 384 } | |
| 385 | |
| 386 std::string resp_status = t->status; | |
| 387 std::string resp_headers = t->response_headers; | |
| 388 std::string resp_data = t->data; | |
| 389 received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size(); | |
| 390 if (t->handler) | |
| 391 (t->handler)(request, &resp_status, &resp_headers, &resp_data); | |
| 392 | |
| 393 std::string header_data = base::StringPrintf( | |
| 394 "%s\n%s\n", resp_status.c_str(), resp_headers.c_str()); | |
| 395 std::replace(header_data.begin(), header_data.end(), '\n', '\0'); | |
| 396 | |
| 397 response_.request_time = base::Time::Now(); | |
| 398 if (!t->request_time.is_null()) | |
| 399 response_.request_time = t->request_time; | |
| 400 | |
| 401 response_.was_cached = false; | |
| 402 response_.network_accessed = true; | |
| 403 | |
| 404 response_.response_time = base::Time::Now(); | |
| 405 if (!t->response_time.is_null()) | |
| 406 response_.response_time = t->response_time; | |
| 407 | |
| 408 response_.headers = new net::HttpResponseHeaders(header_data); | |
| 409 response_.vary_data.Init(*request, *response_.headers.get()); | |
| 410 response_.ssl_info.cert_status = t->cert_status; | |
| 411 data_ = resp_data; | |
| 412 | |
| 413 if (net_log.net_log()) | |
| 414 socket_log_id_ = net_log.net_log()->NextID(); | |
| 415 | |
| 416 if (test_mode_ & TEST_MODE_SYNC_NET_START) | |
| 417 return net::OK; | |
| 418 | |
| 419 CallbackLater(callback, net::OK); | |
| 420 return net::ERR_IO_PENDING; | |
| 421 } | |
| 422 | |
| 423 void MockNetworkTransaction::SetBeforeNetworkStartCallback( | |
| 424 const BeforeNetworkStartCallback& callback) { | |
| 425 } | |
| 426 | |
| 427 int MockNetworkTransaction::ResumeNetworkStart() { | |
| 428 // Should not get here. | |
| 429 return net::ERR_FAILED; | |
| 430 } | |
| 431 | |
| 432 void MockNetworkTransaction::CallbackLater( | |
| 433 const net::CompletionCallback& callback, int result) { | |
| 434 base::MessageLoop::current()->PostTask( | |
| 435 FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback, | |
| 436 weak_factory_.GetWeakPtr(), callback, result)); | |
| 437 } | |
| 438 | |
| 439 void MockNetworkTransaction::RunCallback( | |
| 440 const net::CompletionCallback& callback, int result) { | |
| 441 callback.Run(result); | |
| 442 } | |
| 443 | |
| 444 MockNetworkLayer::MockNetworkLayer() | |
| 445 : transaction_count_(0), | |
| 446 done_reading_called_(false), | |
| 447 stop_caching_called_(false), | |
| 448 last_create_transaction_priority_(net::DEFAULT_PRIORITY) {} | |
| 449 | |
| 450 MockNetworkLayer::~MockNetworkLayer() {} | |
| 451 | |
| 452 void MockNetworkLayer::TransactionDoneReading() { | |
| 453 done_reading_called_ = true; | |
| 454 } | |
| 455 | |
| 456 void MockNetworkLayer::TransactionStopCaching() { | |
| 457 stop_caching_called_ = true; | |
| 458 } | |
| 459 | |
| 460 int MockNetworkLayer::CreateTransaction( | |
| 461 net::RequestPriority priority, | |
| 462 scoped_ptr<net::HttpTransaction>* trans) { | |
| 463 transaction_count_++; | |
| 464 last_create_transaction_priority_ = priority; | |
| 465 scoped_ptr<MockNetworkTransaction> mock_transaction( | |
| 466 new MockNetworkTransaction(priority, this)); | |
| 467 last_transaction_ = mock_transaction->AsWeakPtr(); | |
| 468 *trans = mock_transaction.Pass(); | |
| 469 return net::OK; | |
| 470 } | |
| 471 | |
| 472 net::HttpCache* MockNetworkLayer::GetCache() { | |
| 473 return NULL; | |
| 474 } | |
| 475 | |
| 476 net::HttpNetworkSession* MockNetworkLayer::GetSession() { | |
| 477 return NULL; | |
| 478 } | |
| 479 | |
| 480 //----------------------------------------------------------------------------- | |
| 481 // helpers | |
| 482 | |
| 483 int ReadTransaction(net::HttpTransaction* trans, std::string* result) { | |
| 484 int rv; | |
| 485 | |
| 486 net::TestCompletionCallback callback; | |
| 487 | |
| 488 std::string content; | |
| 489 do { | |
| 490 scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256)); | |
| 491 rv = trans->Read(buf.get(), 256, callback.callback()); | |
| 492 if (rv == net::ERR_IO_PENDING) | |
| 493 rv = callback.WaitForResult(); | |
| 494 | |
| 495 if (rv > 0) | |
| 496 content.append(buf->data(), rv); | |
| 497 else if (rv < 0) | |
| 498 return rv; | |
| 499 } while (rv > 0); | |
| 500 | |
| 501 result->swap(content); | |
| 502 return net::OK; | |
| 503 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 280763003:
Rename http_transaction_unittest to http_transaction_test_util. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master