test_url_fetcher_factory.cc revision 868fa2fe829687343ffae624259930155e16dbd8
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/test_url_fetcher_factory.h" 6 7#include <string> 8 9#include "base/bind.h" 10#include "base/compiler_specific.h" 11#include "base/memory/weak_ptr.h" 12#include "base/message_loop.h" 13#include "net/base/host_port_pair.h" 14#include "net/http/http_response_headers.h" 15#include "net/url_request/url_fetcher_delegate.h" 16#include "net/url_request/url_fetcher_impl.h" 17#include "net/url_request/url_request_status.h" 18 19namespace net { 20 21ScopedURLFetcherFactory::ScopedURLFetcherFactory( 22 URLFetcherFactory* factory) { 23 DCHECK(!URLFetcherImpl::factory()); 24 URLFetcherImpl::set_factory(factory); 25} 26 27ScopedURLFetcherFactory::~ScopedURLFetcherFactory() { 28 DCHECK(URLFetcherImpl::factory()); 29 URLFetcherImpl::set_factory(NULL); 30} 31 32TestURLFetcher::TestURLFetcher(int id, 33 const GURL& url, 34 URLFetcherDelegate* d) 35 : owner_(NULL), 36 id_(id), 37 original_url_(url), 38 delegate_(d), 39 delegate_for_tests_(NULL), 40 did_receive_last_chunk_(false), 41 fake_load_flags_(0), 42 fake_response_code_(-1), 43 fake_response_destination_(STRING), 44 fake_was_fetched_via_proxy_(false), 45 fake_max_retries_(0) { 46} 47 48TestURLFetcher::~TestURLFetcher() { 49 if (delegate_for_tests_) 50 delegate_for_tests_->OnRequestEnd(id_); 51 if (owner_) 52 owner_->RemoveFetcherFromMap(id_); 53} 54 55void TestURLFetcher::SetUploadData(const std::string& upload_content_type, 56 const std::string& upload_content) { 57 upload_data_ = upload_content; 58} 59 60void TestURLFetcher::SetUploadFilePath( 61 const std::string& upload_content_type, 62 const base::FilePath& file_path, 63 uint64 range_offset, 64 uint64 range_length, 65 scoped_refptr<base::TaskRunner> file_task_runner) { 66 upload_file_path_ = file_path; 67} 68 69void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) { 70} 71 72void TestURLFetcher::AppendChunkToUpload(const std::string& data, 73 bool is_last_chunk) { 74 DCHECK(!did_receive_last_chunk_); 75 did_receive_last_chunk_ = is_last_chunk; 76 chunks_.push_back(data); 77 if (delegate_for_tests_) 78 delegate_for_tests_->OnChunkUpload(id_); 79} 80 81void TestURLFetcher::SetLoadFlags(int load_flags) { 82 fake_load_flags_= load_flags; 83} 84 85int TestURLFetcher::GetLoadFlags() const { 86 return fake_load_flags_; 87} 88 89void TestURLFetcher::SetReferrer(const std::string& referrer) { 90} 91 92void TestURLFetcher::SetExtraRequestHeaders( 93 const std::string& extra_request_headers) { 94 fake_extra_request_headers_.Clear(); 95 fake_extra_request_headers_.AddHeadersFromString(extra_request_headers); 96} 97 98void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) { 99 fake_extra_request_headers_.AddHeaderFromString(header_line); 100} 101 102void TestURLFetcher::GetExtraRequestHeaders( 103 HttpRequestHeaders* headers) const { 104 *headers = fake_extra_request_headers_; 105} 106 107void TestURLFetcher::SetRequestContext( 108 URLRequestContextGetter* request_context_getter) { 109} 110 111void TestURLFetcher::SetFirstPartyForCookies( 112 const GURL& first_party_for_cookies) { 113} 114 115void TestURLFetcher::SetURLRequestUserData( 116 const void* key, 117 const CreateDataCallback& create_data_callback) { 118} 119 120void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) { 121} 122 123void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) { 124} 125 126void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) { 127 fake_max_retries_ = max_retries; 128} 129 130int TestURLFetcher::GetMaxRetriesOn5xx() const { 131 return fake_max_retries_; 132} 133 134base::TimeDelta TestURLFetcher::GetBackoffDelay() const { 135 return fake_backoff_delay_; 136} 137 138void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) { 139} 140 141void TestURLFetcher::SaveResponseToFileAtPath( 142 const base::FilePath& file_path, 143 scoped_refptr<base::TaskRunner> file_task_runner) { 144} 145 146void TestURLFetcher::SaveResponseToTemporaryFile( 147 scoped_refptr<base::TaskRunner> file_task_runner) { 148} 149 150HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const { 151 return fake_response_headers_.get(); 152} 153 154HostPortPair TestURLFetcher::GetSocketAddress() const { 155 NOTIMPLEMENTED(); 156 return HostPortPair(); 157} 158 159bool TestURLFetcher::WasFetchedViaProxy() const { 160 return fake_was_fetched_via_proxy_; 161} 162 163void TestURLFetcher::Start() { 164 // Overriden to do nothing. It is assumed the caller will notify the delegate. 165 if (delegate_for_tests_) 166 delegate_for_tests_->OnRequestStart(id_); 167} 168 169const GURL& TestURLFetcher::GetOriginalURL() const { 170 return original_url_; 171} 172 173const GURL& TestURLFetcher::GetURL() const { 174 return fake_url_; 175} 176 177const URLRequestStatus& TestURLFetcher::GetStatus() const { 178 return fake_status_; 179} 180 181int TestURLFetcher::GetResponseCode() const { 182 return fake_response_code_; 183} 184 185const ResponseCookies& TestURLFetcher::GetCookies() const { 186 return fake_cookies_; 187} 188 189bool TestURLFetcher::FileErrorOccurred(int* out_error_code) const { 190 NOTIMPLEMENTED(); 191 return false; 192} 193 194void TestURLFetcher::ReceivedContentWasMalformed() { 195} 196 197bool TestURLFetcher::GetResponseAsString( 198 std::string* out_response_string) const { 199 if (fake_response_destination_ != STRING) 200 return false; 201 202 *out_response_string = fake_response_string_; 203 return true; 204} 205 206bool TestURLFetcher::GetResponseAsFilePath( 207 bool take_ownership, base::FilePath* out_response_path) const { 208 if (fake_response_destination_ != TEMP_FILE) 209 return false; 210 211 *out_response_path = fake_response_file_path_; 212 return true; 213} 214 215void TestURLFetcher::set_status(const URLRequestStatus& status) { 216 fake_status_ = status; 217} 218 219void TestURLFetcher::set_was_fetched_via_proxy(bool flag) { 220 fake_was_fetched_via_proxy_ = flag; 221} 222 223void TestURLFetcher::set_response_headers( 224 scoped_refptr<HttpResponseHeaders> headers) { 225 fake_response_headers_ = headers; 226} 227 228void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) { 229 fake_backoff_delay_ = backoff_delay; 230} 231 232void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) { 233 delegate_for_tests_ = delegate_for_tests; 234} 235 236void TestURLFetcher::SetResponseString(const std::string& response) { 237 fake_response_destination_ = STRING; 238 fake_response_string_ = response; 239} 240 241void TestURLFetcher::SetResponseFilePath(const base::FilePath& path) { 242 fake_response_destination_ = TEMP_FILE; 243 fake_response_file_path_ = path; 244} 245 246TestURLFetcherFactory::TestURLFetcherFactory() 247 : ScopedURLFetcherFactory(this), 248 delegate_for_tests_(NULL), 249 remove_fetcher_on_delete_(false) { 250} 251 252TestURLFetcherFactory::~TestURLFetcherFactory() {} 253 254URLFetcher* TestURLFetcherFactory::CreateURLFetcher( 255 int id, 256 const GURL& url, 257 URLFetcher::RequestType request_type, 258 URLFetcherDelegate* d) { 259 TestURLFetcher* fetcher = new TestURLFetcher(id, url, d); 260 if (remove_fetcher_on_delete_) 261 fetcher->set_owner(this); 262 fetcher->SetDelegateForTests(delegate_for_tests_); 263 fetchers_[id] = fetcher; 264 return fetcher; 265} 266 267TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const { 268 Fetchers::const_iterator i = fetchers_.find(id); 269 return i == fetchers_.end() ? NULL : i->second; 270} 271 272void TestURLFetcherFactory::RemoveFetcherFromMap(int id) { 273 Fetchers::iterator i = fetchers_.find(id); 274 DCHECK(i != fetchers_.end()); 275 fetchers_.erase(i); 276} 277 278void TestURLFetcherFactory::SetDelegateForTests( 279 TestURLFetcherDelegateForTests* delegate_for_tests) { 280 delegate_for_tests_ = delegate_for_tests; 281} 282 283FakeURLFetcher::FakeURLFetcher(const GURL& url, 284 URLFetcherDelegate* d, 285 const std::string& response_data, 286 bool success) 287 : TestURLFetcher(0, url, d), 288 weak_factory_(this) { 289 set_status(URLRequestStatus( 290 success ? URLRequestStatus::SUCCESS : URLRequestStatus::FAILED, 291 0)); 292 set_response_code(success ? 200 : 500); 293 SetResponseString(response_data); 294} 295 296FakeURLFetcher::~FakeURLFetcher() {} 297 298void FakeURLFetcher::Start() { 299 base::MessageLoop::current()->PostTask( 300 FROM_HERE, 301 base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr())); 302} 303 304void FakeURLFetcher::RunDelegate() { 305 delegate()->OnURLFetchComplete(this); 306} 307 308const GURL& FakeURLFetcher::GetURL() const { 309 return TestURLFetcher::GetOriginalURL(); 310} 311 312FakeURLFetcherFactory::FakeURLFetcherFactory( 313 URLFetcherFactory* default_factory) 314 : ScopedURLFetcherFactory(this), 315 creator_(base::Bind(&DefaultFakeURLFetcherCreator)), 316 default_factory_(default_factory) { 317} 318 319FakeURLFetcherFactory::FakeURLFetcherFactory( 320 URLFetcherFactory* default_factory, 321 const FakeURLFetcherCreator& creator) 322 : ScopedURLFetcherFactory(this), 323 creator_(creator), 324 default_factory_(default_factory) { 325} 326 327scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator( 328 const GURL& url, 329 URLFetcherDelegate* delegate, 330 const std::string& response, 331 bool success) { 332 return scoped_ptr<FakeURLFetcher>(new FakeURLFetcher(url, delegate, 333 response, success)); 334} 335 336FakeURLFetcherFactory::~FakeURLFetcherFactory() {} 337 338URLFetcher* FakeURLFetcherFactory::CreateURLFetcher( 339 int id, 340 const GURL& url, 341 URLFetcher::RequestType request_type, 342 URLFetcherDelegate* d) { 343 FakeResponseMap::const_iterator it = fake_responses_.find(url); 344 if (it == fake_responses_.end()) { 345 if (default_factory_ == NULL) { 346 // If we don't have a baked response for that URL we return NULL. 347 DLOG(ERROR) << "No baked response for URL: " << url.spec(); 348 return NULL; 349 } else { 350 return default_factory_->CreateURLFetcher(id, url, request_type, d); 351 } 352 } 353 354 scoped_ptr<FakeURLFetcher> fake_fetcher = 355 creator_.Run(url, d, it->second.first, it->second.second); 356 // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr 357 return fake_fetcher.release(); 358} 359 360void FakeURLFetcherFactory::SetFakeResponse(const std::string& url, 361 const std::string& response_data, 362 bool success) { 363 // Overwrite existing URL if it already exists. 364 fake_responses_[GURL(url)] = std::make_pair(response_data, success); 365} 366 367void FakeURLFetcherFactory::ClearFakeResponses() { 368 fake_responses_.clear(); 369} 370 371URLFetcherImplFactory::URLFetcherImplFactory() {} 372 373URLFetcherImplFactory::~URLFetcherImplFactory() {} 374 375URLFetcher* URLFetcherImplFactory::CreateURLFetcher( 376 int id, 377 const GURL& url, 378 URLFetcher::RequestType request_type, 379 URLFetcherDelegate* d) { 380 return new URLFetcherImpl(url, request_type, d); 381} 382 383} // namespace net 384