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/url_request/url_request_test_util.h" 6 7#include "base/compiler_specific.h" 8#include "base/logging.h" 9#include "base/message_loop/message_loop.h" 10#include "base/threading/thread.h" 11#include "base/threading/worker_pool.h" 12#include "net/base/host_port_pair.h" 13#include "net/cert/cert_verifier.h" 14#include "net/dns/mock_host_resolver.h" 15#include "net/http/http_network_session.h" 16#include "net/http/http_server_properties_impl.h" 17#include "net/http/transport_security_state.h" 18#include "net/ssl/default_server_bound_cert_store.h" 19#include "net/ssl/server_bound_cert_service.h" 20#include "net/url_request/static_http_user_agent_settings.h" 21#include "net/url_request/url_request_job_factory_impl.h" 22#include "testing/gtest/include/gtest/gtest.h" 23 24namespace net { 25 26namespace { 27 28// These constants put the NetworkDelegate events of TestNetworkDelegate 29// into an order. They are used in conjunction with 30// |TestNetworkDelegate::next_states_| to check that we do not send 31// events in the wrong order. 32const int kStageBeforeURLRequest = 1 << 0; 33const int kStageBeforeSendHeaders = 1 << 1; 34const int kStageSendHeaders = 1 << 2; 35const int kStageHeadersReceived = 1 << 3; 36const int kStageAuthRequired = 1 << 4; 37const int kStageBeforeRedirect = 1 << 5; 38const int kStageResponseStarted = 1 << 6; 39const int kStageCompletedSuccess = 1 << 7; 40const int kStageCompletedError = 1 << 8; 41const int kStageURLRequestDestroyed = 1 << 9; 42const int kStageDestruction = 1 << 10; 43 44} // namespace 45 46TestURLRequestContext::TestURLRequestContext() 47 : initialized_(false), 48 client_socket_factory_(NULL), 49 context_storage_(this) { 50 Init(); 51} 52 53TestURLRequestContext::TestURLRequestContext(bool delay_initialization) 54 : initialized_(false), 55 client_socket_factory_(NULL), 56 context_storage_(this) { 57 if (!delay_initialization) 58 Init(); 59} 60 61TestURLRequestContext::~TestURLRequestContext() { 62 DCHECK(initialized_); 63} 64 65void TestURLRequestContext::Init() { 66 DCHECK(!initialized_); 67 initialized_ = true; 68 69 if (!host_resolver()) 70 context_storage_.set_host_resolver( 71 scoped_ptr<HostResolver>(new MockCachingHostResolver())); 72 if (!proxy_service()) 73 context_storage_.set_proxy_service(ProxyService::CreateDirect()); 74 if (!cert_verifier()) 75 context_storage_.set_cert_verifier(CertVerifier::CreateDefault()); 76 if (!transport_security_state()) 77 context_storage_.set_transport_security_state(new TransportSecurityState); 78 if (!ssl_config_service()) 79 context_storage_.set_ssl_config_service(new SSLConfigServiceDefaults); 80 if (!http_auth_handler_factory()) { 81 context_storage_.set_http_auth_handler_factory( 82 HttpAuthHandlerFactory::CreateDefault(host_resolver())); 83 } 84 if (!http_server_properties()) { 85 context_storage_.set_http_server_properties( 86 scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); 87 } 88 if (!transport_security_state()) { 89 context_storage_.set_transport_security_state( 90 new TransportSecurityState()); 91 } 92 if (http_transaction_factory()) { 93 // Make sure we haven't been passed an object we're not going to use. 94 EXPECT_FALSE(client_socket_factory_); 95 } else { 96 HttpNetworkSession::Params params; 97 params.client_socket_factory = client_socket_factory(); 98 params.host_resolver = host_resolver(); 99 params.cert_verifier = cert_verifier(); 100 params.transport_security_state = transport_security_state(); 101 params.proxy_service = proxy_service(); 102 params.ssl_config_service = ssl_config_service(); 103 params.http_auth_handler_factory = http_auth_handler_factory(); 104 params.network_delegate = network_delegate(); 105 params.http_server_properties = http_server_properties(); 106 params.net_log = net_log(); 107 context_storage_.set_http_transaction_factory(new HttpCache( 108 new HttpNetworkSession(params), 109 HttpCache::DefaultBackend::InMemory(0))); 110 } 111 // In-memory cookie store. 112 if (!cookie_store()) 113 context_storage_.set_cookie_store(new CookieMonster(NULL, NULL)); 114 // In-memory origin bound cert service. 115 if (!server_bound_cert_service()) { 116 context_storage_.set_server_bound_cert_service( 117 new ServerBoundCertService( 118 new DefaultServerBoundCertStore(NULL), 119 base::WorkerPool::GetTaskRunner(true))); 120 } 121 if (!http_user_agent_settings()) { 122 context_storage_.set_http_user_agent_settings( 123 new StaticHttpUserAgentSettings("en-us,fr", std::string())); 124 } 125 if (!job_factory()) 126 context_storage_.set_job_factory(new URLRequestJobFactoryImpl); 127} 128 129TestURLRequest::TestURLRequest(const GURL& url, 130 RequestPriority priority, 131 Delegate* delegate, 132 TestURLRequestContext* context) 133 : URLRequest(url, priority, delegate, context) {} 134 135TestURLRequest::~TestURLRequest() { 136} 137 138TestURLRequestContextGetter::TestURLRequestContextGetter( 139 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner) 140 : network_task_runner_(network_task_runner) { 141 DCHECK(network_task_runner_.get()); 142} 143 144TestURLRequestContextGetter::TestURLRequestContextGetter( 145 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner, 146 scoped_ptr<TestURLRequestContext> context) 147 : network_task_runner_(network_task_runner), context_(context.Pass()) { 148 DCHECK(network_task_runner_.get()); 149} 150 151TestURLRequestContextGetter::~TestURLRequestContextGetter() {} 152 153TestURLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() { 154 if (!context_.get()) 155 context_.reset(new TestURLRequestContext); 156 return context_.get(); 157} 158 159scoped_refptr<base::SingleThreadTaskRunner> 160TestURLRequestContextGetter::GetNetworkTaskRunner() const { 161 return network_task_runner_; 162} 163 164TestDelegate::TestDelegate() 165 : cancel_in_rr_(false), 166 cancel_in_rs_(false), 167 cancel_in_rd_(false), 168 cancel_in_rd_pending_(false), 169 quit_on_complete_(true), 170 quit_on_redirect_(false), 171 allow_certificate_errors_(false), 172 response_started_count_(0), 173 received_bytes_count_(0), 174 received_redirect_count_(0), 175 received_data_before_response_(false), 176 request_failed_(false), 177 have_certificate_errors_(false), 178 certificate_errors_are_fatal_(false), 179 auth_required_(false), 180 have_full_request_headers_(false), 181 buf_(new IOBuffer(kBufferSize)) { 182} 183 184TestDelegate::~TestDelegate() {} 185 186void TestDelegate::ClearFullRequestHeaders() { 187 full_request_headers_.Clear(); 188 have_full_request_headers_ = false; 189} 190 191void TestDelegate::OnReceivedRedirect(URLRequest* request, 192 const GURL& new_url, 193 bool* defer_redirect) { 194 EXPECT_TRUE(request->is_redirecting()); 195 196 have_full_request_headers_ = 197 request->GetFullRequestHeaders(&full_request_headers_); 198 199 received_redirect_count_++; 200 if (quit_on_redirect_) { 201 *defer_redirect = true; 202 base::MessageLoop::current()->PostTask(FROM_HERE, 203 base::MessageLoop::QuitClosure()); 204 } else if (cancel_in_rr_) { 205 request->Cancel(); 206 } 207} 208 209void TestDelegate::OnAuthRequired(URLRequest* request, 210 AuthChallengeInfo* auth_info) { 211 auth_required_ = true; 212 if (!credentials_.Empty()) { 213 request->SetAuth(credentials_); 214 } else { 215 request->CancelAuth(); 216 } 217} 218 219void TestDelegate::OnSSLCertificateError(URLRequest* request, 220 const SSLInfo& ssl_info, 221 bool fatal) { 222 // The caller can control whether it needs all SSL requests to go through, 223 // independent of any possible errors, or whether it wants SSL errors to 224 // cancel the request. 225 have_certificate_errors_ = true; 226 certificate_errors_are_fatal_ = fatal; 227 if (allow_certificate_errors_) 228 request->ContinueDespiteLastError(); 229 else 230 request->Cancel(); 231} 232 233void TestDelegate::OnResponseStarted(URLRequest* request) { 234 // It doesn't make sense for the request to have IO pending at this point. 235 DCHECK(!request->status().is_io_pending()); 236 EXPECT_FALSE(request->is_redirecting()); 237 238 have_full_request_headers_ = 239 request->GetFullRequestHeaders(&full_request_headers_); 240 241 response_started_count_++; 242 if (cancel_in_rs_) { 243 request->Cancel(); 244 OnResponseCompleted(request); 245 } else if (!request->status().is_success()) { 246 DCHECK(request->status().status() == URLRequestStatus::FAILED || 247 request->status().status() == URLRequestStatus::CANCELED); 248 request_failed_ = true; 249 OnResponseCompleted(request); 250 } else { 251 // Initiate the first read. 252 int bytes_read = 0; 253 if (request->Read(buf_.get(), kBufferSize, &bytes_read)) 254 OnReadCompleted(request, bytes_read); 255 else if (!request->status().is_io_pending()) 256 OnResponseCompleted(request); 257 } 258} 259 260void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) { 261 // It doesn't make sense for the request to have IO pending at this point. 262 DCHECK(!request->status().is_io_pending()); 263 264 if (response_started_count_ == 0) 265 received_data_before_response_ = true; 266 267 if (cancel_in_rd_) 268 request->Cancel(); 269 270 if (bytes_read >= 0) { 271 // There is data to read. 272 received_bytes_count_ += bytes_read; 273 274 // consume the data 275 data_received_.append(buf_->data(), bytes_read); 276 } 277 278 // If it was not end of stream, request to read more. 279 if (request->status().is_success() && bytes_read > 0) { 280 bytes_read = 0; 281 while (request->Read(buf_.get(), kBufferSize, &bytes_read)) { 282 if (bytes_read > 0) { 283 data_received_.append(buf_->data(), bytes_read); 284 received_bytes_count_ += bytes_read; 285 } else { 286 break; 287 } 288 } 289 } 290 if (!request->status().is_io_pending()) 291 OnResponseCompleted(request); 292 else if (cancel_in_rd_pending_) 293 request->Cancel(); 294} 295 296void TestDelegate::OnResponseCompleted(URLRequest* request) { 297 if (quit_on_complete_) 298 base::MessageLoop::current()->PostTask(FROM_HERE, 299 base::MessageLoop::QuitClosure()); 300} 301 302TestNetworkDelegate::TestNetworkDelegate() 303 : last_error_(0), 304 error_count_(0), 305 created_requests_(0), 306 destroyed_requests_(0), 307 completed_requests_(0), 308 canceled_requests_(0), 309 cookie_options_bit_mask_(0), 310 blocked_get_cookies_count_(0), 311 blocked_set_cookie_count_(0), 312 set_cookie_count_(0), 313 has_load_timing_info_before_redirect_(false), 314 has_load_timing_info_before_auth_(false), 315 can_access_files_(true), 316 can_throttle_requests_(true) { 317} 318 319TestNetworkDelegate::~TestNetworkDelegate() { 320 for (std::map<int, int>::iterator i = next_states_.begin(); 321 i != next_states_.end(); ++i) { 322 event_order_[i->first] += "~TestNetworkDelegate\n"; 323 EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first]; 324 } 325} 326 327bool TestNetworkDelegate::GetLoadTimingInfoBeforeRedirect( 328 LoadTimingInfo* load_timing_info_before_redirect) const { 329 *load_timing_info_before_redirect = load_timing_info_before_redirect_; 330 return has_load_timing_info_before_redirect_; 331} 332 333bool TestNetworkDelegate::GetLoadTimingInfoBeforeAuth( 334 LoadTimingInfo* load_timing_info_before_auth) const { 335 *load_timing_info_before_auth = load_timing_info_before_auth_; 336 return has_load_timing_info_before_auth_; 337} 338 339void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) { 340 if (next_states_.find(request_id) == next_states_.end()) { 341 // TODO(davidben): Although the URLRequest documentation does not allow 342 // calling Cancel() before Start(), the ResourceLoader does so. URLRequest's 343 // destructor also calls Cancel. Either officially support this or fix the 344 // ResourceLoader code. 345 next_states_[request_id] = kStageBeforeURLRequest | kStageCompletedError; 346 event_order_[request_id] = ""; 347 } 348} 349 350int TestNetworkDelegate::OnBeforeURLRequest( 351 URLRequest* request, 352 const CompletionCallback& callback, 353 GURL* new_url ) { 354 int req_id = request->identifier(); 355 InitRequestStatesIfNew(req_id); 356 event_order_[req_id] += "OnBeforeURLRequest\n"; 357 EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest) << 358 event_order_[req_id]; 359 next_states_[req_id] = 360 kStageBeforeSendHeaders | 361 kStageResponseStarted | // data: URLs do not trigger sending headers 362 kStageBeforeRedirect | // a delegate can trigger a redirection 363 kStageCompletedError | // request canceled by delegate 364 kStageAuthRequired; // Auth can come next for FTP requests 365 created_requests_++; 366 return OK; 367} 368 369int TestNetworkDelegate::OnBeforeSendHeaders( 370 URLRequest* request, 371 const CompletionCallback& callback, 372 HttpRequestHeaders* headers) { 373 int req_id = request->identifier(); 374 InitRequestStatesIfNew(req_id); 375 event_order_[req_id] += "OnBeforeSendHeaders\n"; 376 EXPECT_TRUE(next_states_[req_id] & kStageBeforeSendHeaders) << 377 event_order_[req_id]; 378 next_states_[req_id] = 379 kStageSendHeaders | 380 kStageCompletedError; // request canceled by delegate 381 382 return OK; 383} 384 385void TestNetworkDelegate::OnSendHeaders( 386 URLRequest* request, 387 const HttpRequestHeaders& headers) { 388 int req_id = request->identifier(); 389 InitRequestStatesIfNew(req_id); 390 event_order_[req_id] += "OnSendHeaders\n"; 391 EXPECT_TRUE(next_states_[req_id] & kStageSendHeaders) << 392 event_order_[req_id]; 393 next_states_[req_id] = 394 kStageHeadersReceived | 395 kStageCompletedError; 396} 397 398int TestNetworkDelegate::OnHeadersReceived( 399 URLRequest* request, 400 const CompletionCallback& callback, 401 const HttpResponseHeaders* original_response_headers, 402 scoped_refptr<HttpResponseHeaders>* override_response_headers) { 403 int req_id = request->identifier(); 404 event_order_[req_id] += "OnHeadersReceived\n"; 405 InitRequestStatesIfNew(req_id); 406 EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived) << 407 event_order_[req_id]; 408 next_states_[req_id] = 409 kStageBeforeRedirect | 410 kStageResponseStarted | 411 kStageAuthRequired | 412 kStageCompletedError; // e.g. proxy resolution problem 413 414 // Basic authentication sends a second request from the URLRequestHttpJob 415 // layer before the URLRequest reports that a response has started. 416 next_states_[req_id] |= kStageBeforeSendHeaders; 417 418 return OK; 419} 420 421void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request, 422 const GURL& new_location) { 423 load_timing_info_before_redirect_ = LoadTimingInfo(); 424 request->GetLoadTimingInfo(&load_timing_info_before_redirect_); 425 has_load_timing_info_before_redirect_ = true; 426 EXPECT_FALSE(load_timing_info_before_redirect_.request_start_time.is_null()); 427 EXPECT_FALSE(load_timing_info_before_redirect_.request_start.is_null()); 428 429 int req_id = request->identifier(); 430 InitRequestStatesIfNew(req_id); 431 event_order_[req_id] += "OnBeforeRedirect\n"; 432 EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect) << 433 event_order_[req_id]; 434 next_states_[req_id] = 435 kStageBeforeURLRequest | // HTTP redirects trigger this. 436 kStageBeforeSendHeaders | // Redirects from the network delegate do not 437 // trigger onBeforeURLRequest. 438 kStageCompletedError; 439 440 // A redirect can lead to a file or a data URL. In this case, we do not send 441 // headers. 442 next_states_[req_id] |= kStageResponseStarted; 443} 444 445void TestNetworkDelegate::OnResponseStarted(URLRequest* request) { 446 LoadTimingInfo load_timing_info; 447 request->GetLoadTimingInfo(&load_timing_info); 448 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 449 EXPECT_FALSE(load_timing_info.request_start.is_null()); 450 451 int req_id = request->identifier(); 452 InitRequestStatesIfNew(req_id); 453 event_order_[req_id] += "OnResponseStarted\n"; 454 EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted) << 455 event_order_[req_id]; 456 next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError; 457 if (request->status().status() == URLRequestStatus::FAILED) { 458 error_count_++; 459 last_error_ = request->status().error(); 460 } 461} 462 463void TestNetworkDelegate::OnRawBytesRead(const URLRequest& request, 464 int bytes_read) { 465} 466 467void TestNetworkDelegate::OnCompleted(URLRequest* request, bool started) { 468 int req_id = request->identifier(); 469 InitRequestStatesIfNew(req_id); 470 event_order_[req_id] += "OnCompleted\n"; 471 // Expect "Success -> (next_states_ & kStageCompletedSuccess)" 472 // is logically identical to 473 // Expect "!(Success) || (next_states_ & kStageCompletedSuccess)" 474 EXPECT_TRUE(!request->status().is_success() || 475 (next_states_[req_id] & kStageCompletedSuccess)) << 476 event_order_[req_id]; 477 EXPECT_TRUE(request->status().is_success() || 478 (next_states_[req_id] & kStageCompletedError)) << 479 event_order_[req_id]; 480 next_states_[req_id] = kStageURLRequestDestroyed; 481 completed_requests_++; 482 if (request->status().status() == URLRequestStatus::FAILED) { 483 error_count_++; 484 last_error_ = request->status().error(); 485 } else if (request->status().status() == URLRequestStatus::CANCELED) { 486 canceled_requests_++; 487 } else { 488 DCHECK_EQ(URLRequestStatus::SUCCESS, request->status().status()); 489 } 490} 491 492void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) { 493 int req_id = request->identifier(); 494 InitRequestStatesIfNew(req_id); 495 event_order_[req_id] += "OnURLRequestDestroyed\n"; 496 EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) << 497 event_order_[req_id]; 498 next_states_[req_id] = kStageDestruction; 499 destroyed_requests_++; 500} 501 502void TestNetworkDelegate::OnPACScriptError(int line_number, 503 const base::string16& error) { 504} 505 506NetworkDelegate::AuthRequiredResponse TestNetworkDelegate::OnAuthRequired( 507 URLRequest* request, 508 const AuthChallengeInfo& auth_info, 509 const AuthCallback& callback, 510 AuthCredentials* credentials) { 511 load_timing_info_before_auth_ = LoadTimingInfo(); 512 request->GetLoadTimingInfo(&load_timing_info_before_auth_); 513 has_load_timing_info_before_auth_ = true; 514 EXPECT_FALSE(load_timing_info_before_auth_.request_start_time.is_null()); 515 EXPECT_FALSE(load_timing_info_before_auth_.request_start.is_null()); 516 517 int req_id = request->identifier(); 518 InitRequestStatesIfNew(req_id); 519 event_order_[req_id] += "OnAuthRequired\n"; 520 EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired) << 521 event_order_[req_id]; 522 next_states_[req_id] = kStageBeforeSendHeaders | 523 kStageAuthRequired | // For example, proxy auth followed by server auth. 524 kStageHeadersReceived | // Request canceled by delegate simulates empty 525 // response. 526 kStageResponseStarted | // data: URLs do not trigger sending headers 527 kStageBeforeRedirect | // a delegate can trigger a redirection 528 kStageCompletedError; // request cancelled before callback 529 return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION; 530} 531 532bool TestNetworkDelegate::OnCanGetCookies(const URLRequest& request, 533 const CookieList& cookie_list) { 534 bool allow = true; 535 if (cookie_options_bit_mask_ & NO_GET_COOKIES) 536 allow = false; 537 538 if (!allow) { 539 blocked_get_cookies_count_++; 540 } 541 542 return allow; 543} 544 545bool TestNetworkDelegate::OnCanSetCookie(const URLRequest& request, 546 const std::string& cookie_line, 547 CookieOptions* options) { 548 bool allow = true; 549 if (cookie_options_bit_mask_ & NO_SET_COOKIE) 550 allow = false; 551 552 if (!allow) { 553 blocked_set_cookie_count_++; 554 } else { 555 set_cookie_count_++; 556 } 557 558 return allow; 559} 560 561bool TestNetworkDelegate::OnCanAccessFile(const URLRequest& request, 562 const base::FilePath& path) const { 563 return can_access_files_; 564} 565 566bool TestNetworkDelegate::OnCanThrottleRequest( 567 const URLRequest& request) const { 568 return can_throttle_requests_; 569} 570 571int TestNetworkDelegate::OnBeforeSocketStreamConnect( 572 SocketStream* socket, 573 const CompletionCallback& callback) { 574 return OK; 575} 576 577void TestNetworkDelegate::OnRequestWaitStateChange( 578 const URLRequest& request, 579 RequestWaitState state) { 580} 581 582// static 583std::string ScopedCustomUrlRequestTestHttpHost::value_("127.0.0.1"); 584 585ScopedCustomUrlRequestTestHttpHost::ScopedCustomUrlRequestTestHttpHost( 586 const std::string& new_value) 587 : old_value_(value_), 588 new_value_(new_value) { 589 value_ = new_value_; 590} 591 592ScopedCustomUrlRequestTestHttpHost::~ScopedCustomUrlRequestTestHttpHost() { 593 DCHECK_EQ(value_, new_value_); 594 value_ = old_value_; 595} 596 597// static 598const std::string& ScopedCustomUrlRequestTestHttpHost::value() { 599 return value_; 600} 601 602TestJobInterceptor::TestJobInterceptor() : main_intercept_job_(NULL) { 603} 604 605URLRequestJob* TestJobInterceptor::MaybeCreateJob( 606 URLRequest* request, 607 NetworkDelegate* network_delegate) const { 608 URLRequestJob* job = main_intercept_job_; 609 main_intercept_job_ = NULL; 610 return job; 611} 612 613void TestJobInterceptor::set_main_intercept_job(URLRequestJob* job) { 614 main_intercept_job_ = job; 615} 616 617} // namespace net 618