net/url_request/test_url_fetcher_factory.cc

   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/file_util.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/base/io_buffer.h"
  17 #include "net/base/net_errors.h"
  18 #include "net/http/http_response_headers.h"
  19 #include "net/url_request/url_fetcher_delegate.h"
  20 #include "net/url_request/url_fetcher_impl.h"
  21 #include "net/url_request/url_fetcher_response_writer.h"
  22 #include "net/url_request/url_request_status.h"
  23
  24 namespace net {
  25
  26 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
  27     URLFetcherFactory* factory) {
  28   DCHECK(!URLFetcherImpl::factory());
  29   URLFetcherImpl::set_factory(factory);
  30 }
  31
  32 ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
  33   DCHECK(URLFetcherImpl::factory());
  34   URLFetcherImpl::set_factory(NULL);
  35 }
  36
  37 TestURLFetcher::TestURLFetcher(int id,
  38                                const GURL& url,
  39                                URLFetcherDelegate* d)
  40     : owner_(NULL),
  41       id_(id),
  42       original_url_(url),
  43       delegate_(d),
  44       delegate_for_tests_(NULL),
  45       did_receive_last_chunk_(false),
  46       fake_load_flags_(0),
  47       fake_response_code_(-1),
  48       fake_response_destination_(STRING),
  49       fake_was_fetched_via_proxy_(false),
  50       fake_max_retries_(0) {
  51 }
  52
  53 TestURLFetcher::~TestURLFetcher() {
  54   if (delegate_for_tests_)
  55     delegate_for_tests_->OnRequestEnd(id_);
  56   if (owner_)
  57     owner_->RemoveFetcherFromMap(id_);
  58 }
  59
  60 void TestURLFetcher::SetUploadData(const std::string& upload_content_type,
  61                                    const std::string& upload_content) {
  62   upload_data_ = upload_content;
  63 }
  64
  65 void TestURLFetcher::SetUploadFilePath(
  66     const std::string& upload_content_type,
  67     const base::FilePath& file_path,
  68     uint64 range_offset,
  69     uint64 range_length,
  70     scoped_refptr<base::TaskRunner> file_task_runner) {
  71   upload_file_path_ = file_path;
  72 }
  73
  74 void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) {
  75 }
  76
  77 void TestURLFetcher::AppendChunkToUpload(const std::string& data,
  78                                          bool is_last_chunk) {
  79   DCHECK(!did_receive_last_chunk_);
  80   did_receive_last_chunk_ = is_last_chunk;
  81   chunks_.push_back(data);
  82   if (delegate_for_tests_)
  83     delegate_for_tests_->OnChunkUpload(id_);
  84 }
  85
  86 void TestURLFetcher::SetLoadFlags(int load_flags) {
  87   fake_load_flags_= load_flags;
  88 }
  89
  90 int TestURLFetcher::GetLoadFlags() const {
  91   return fake_load_flags_;
  92 }
  93
  94 void TestURLFetcher::SetReferrer(const std::string& referrer) {
  95 }
  96
  97 void TestURLFetcher::SetReferrerPolicy(
  98     URLRequest::ReferrerPolicy referrer_policy) {
  99 }
 100
 101 void TestURLFetcher::SetExtraRequestHeaders(
 102     const std::string& extra_request_headers) {
 103   fake_extra_request_headers_.Clear();
 104   fake_extra_request_headers_.AddHeadersFromString(extra_request_headers);
 105 }
 106
 107 void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) {
 108   fake_extra_request_headers_.AddHeaderFromString(header_line);
 109 }
 110
 111 void TestURLFetcher::SetRequestContext(
 112     URLRequestContextGetter* request_context_getter) {
 113 }
 114
 115 void TestURLFetcher::SetFirstPartyForCookies(
 116     const GURL& first_party_for_cookies) {
 117 }
 118
 119 void TestURLFetcher::SetURLRequestUserData(
 120     const void* key,
 121     const CreateDataCallback& create_data_callback) {
 122 }
 123
 124 void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) {
 125 }
 126
 127 void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) {
 128 }
 129
 130 void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) {
 131   fake_max_retries_ = max_retries;
 132 }
 133
 134 int TestURLFetcher::GetMaxRetriesOn5xx() const {
 135   return fake_max_retries_;
 136 }
 137
 138 base::TimeDelta TestURLFetcher::GetBackoffDelay() const {
 139   return fake_backoff_delay_;
 140 }
 141
 142 void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
 143 }
 144
 145 void TestURLFetcher::SaveResponseToFileAtPath(
 146     const base::FilePath& file_path,
 147     scoped_refptr<base::SequencedTaskRunner> file_task_runner) {
 148   SetResponseFilePath(file_path);
 149   // Asynchronous IO is not supported, so file_task_runner is ignored.
 150   base::ThreadRestrictions::ScopedAllowIO allow_io;
 151   const size_t written_bytes = base::WriteFile(
 152       file_path, fake_response_string_.c_str(), fake_response_string_.size());
 153   DCHECK_EQ(written_bytes, fake_response_string_.size());
 154 }
 155
 156 void TestURLFetcher::SaveResponseToTemporaryFile(
 157     scoped_refptr<base::SequencedTaskRunner> file_task_runner) {
 158 }
 159
 160 void TestURLFetcher::SaveResponseWithWriter(
 161     scoped_ptr<URLFetcherResponseWriter> response_writer) {
 162   // In class URLFetcherCore this method is called by all three:
 163   // GetResponseAsString() / SaveResponseToFileAtPath() /
 164   // SaveResponseToTemporaryFile(). But here (in TestURLFetcher), this method
 165   // is never used by any of these three methods. So, file writing is expected
 166   // to be done in SaveResponseToFileAtPath(), and this method supports only
 167   // URLFetcherStringWriter (for testing of this method only).
 168   if (fake_response_destination_ == STRING) {
 169     response_writer_ = response_writer.Pass();
 170     int response = response_writer_->Initialize(CompletionCallback());
 171     // The TestURLFetcher doesn't handle asynchronous writes.
 172     DCHECK_EQ(OK, response);
 173
 174     scoped_refptr<IOBuffer> buffer(new StringIOBuffer(fake_response_string_));
 175     response = response_writer_->Write(buffer.get(),
 176                                        fake_response_string_.size(),
 177                                        CompletionCallback());
 178     DCHECK_EQ(static_cast<int>(fake_response_string_.size()), response);
 179     response = response_writer_->Finish(CompletionCallback());
 180     DCHECK_EQ(OK, response);
 181   } else if (fake_response_destination_ == TEMP_FILE) {
 182     // SaveResponseToFileAtPath() should be called instead of this method to
 183     // save file. Asynchronous file writing using URLFetcherFileWriter is not
 184     // supported.
 185     NOTIMPLEMENTED();
 186   } else {
 187     NOTREACHED();
 188   }
 189 }
 190
 191 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
 192   return fake_response_headers_.get();
 193 }
 194
 195 HostPortPair TestURLFetcher::GetSocketAddress() const {
 196   NOTIMPLEMENTED();
 197   return HostPortPair();
 198 }
 199
 200 bool TestURLFetcher::WasFetchedViaProxy() const {
 201   return fake_was_fetched_via_proxy_;
 202 }
 203
 204 void TestURLFetcher::Start() {
 205   // Overriden to do nothing. It is assumed the caller will notify the delegate.
 206   if (delegate_for_tests_)
 207     delegate_for_tests_->OnRequestStart(id_);
 208 }
 209
 210 const GURL& TestURLFetcher::GetOriginalURL() const {
 211   return original_url_;
 212 }
 213
 214 const GURL& TestURLFetcher::GetURL() const {
 215   return fake_url_;
 216 }
 217
 218 const URLRequestStatus& TestURLFetcher::GetStatus() const {
 219   return fake_status_;
 220 }
 221
 222 int TestURLFetcher::GetResponseCode() const {
 223   return fake_response_code_;
 224 }
 225
 226 const ResponseCookies& TestURLFetcher::GetCookies() const {
 227   return fake_cookies_;
 228 }
 229
 230 void TestURLFetcher::ReceivedContentWasMalformed() {
 231 }
 232
 233 bool TestURLFetcher::GetResponseAsString(
 234     std::string* out_response_string) const {
 235   if (fake_response_destination_ != STRING)
 236     return false;
 237
 238   *out_response_string = fake_response_string_;
 239   return true;
 240 }
 241
 242 bool TestURLFetcher::GetResponseAsFilePath(
 243     bool take_ownership, base::FilePath* out_response_path) const {
 244   if (fake_response_destination_ != TEMP_FILE)
 245     return false;
 246
 247   *out_response_path = fake_response_file_path_;
 248   return true;
 249 }
 250
 251 void TestURLFetcher::GetExtraRequestHeaders(
 252     HttpRequestHeaders* headers) const {
 253   *headers = fake_extra_request_headers_;
 254 }
 255
 256 void TestURLFetcher::set_status(const URLRequestStatus& status) {
 257   fake_status_ = status;
 258 }
 259
 260 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
 261   fake_was_fetched_via_proxy_ = flag;
 262 }
 263
 264 void TestURLFetcher::set_response_headers(
 265     scoped_refptr<HttpResponseHeaders> headers) {
 266   fake_response_headers_ = headers;
 267 }
 268
 269 void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
 270   fake_backoff_delay_ = backoff_delay;
 271 }
 272
 273 void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) {
 274   delegate_for_tests_ = delegate_for_tests;
 275 }
 276
 277 void TestURLFetcher::SetResponseString(const std::string& response) {
 278   fake_response_destination_ = STRING;
 279   fake_response_string_ = response;
 280 }
 281
 282 void TestURLFetcher::SetResponseFilePath(const base::FilePath& path) {
 283   fake_response_destination_ = TEMP_FILE;
 284   fake_response_file_path_ = path;
 285 }
 286
 287 TestURLFetcherFactory::TestURLFetcherFactory()
 288     : ScopedURLFetcherFactory(this),
 289       delegate_for_tests_(NULL),
 290       remove_fetcher_on_delete_(false) {
 291 }
 292
 293 TestURLFetcherFactory::~TestURLFetcherFactory() {}
 294
 295 URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
 296     int id,
 297     const GURL& url,
 298     URLFetcher::RequestType request_type,
 299     URLFetcherDelegate* d) {
 300   TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
 301   if (remove_fetcher_on_delete_)
 302     fetcher->set_owner(this);
 303   fetcher->SetDelegateForTests(delegate_for_tests_);
 304   fetchers_[id] = fetcher;
 305   return fetcher;
 306 }
 307
 308 TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
 309   Fetchers::const_iterator i = fetchers_.find(id);
 310   return i == fetchers_.end() ? NULL : i->second;
 311 }
 312
 313 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
 314   Fetchers::iterator i = fetchers_.find(id);
 315   DCHECK(i != fetchers_.end());
 316   fetchers_.erase(i);
 317 }
 318
 319 void TestURLFetcherFactory::SetDelegateForTests(
 320     TestURLFetcherDelegateForTests* delegate_for_tests) {
 321   delegate_for_tests_ = delegate_for_tests;
 322 }
 323
 324 FakeURLFetcher::FakeURLFetcher(const GURL& url,
 325                                URLFetcherDelegate* d,
 326                                const std::string& response_data,
 327                                HttpStatusCode response_code,
 328                                URLRequestStatus::Status status)
 329     : TestURLFetcher(0, url, d),
 330       weak_factory_(this) {
 331   Error error = OK;
 332   switch(status) {
 333     case URLRequestStatus::SUCCESS:
 334       // |error| is initialized to OK.
 335       break;
 336     case URLRequestStatus::IO_PENDING:
 337       error = ERR_IO_PENDING;
 338       break;
 339     case URLRequestStatus::CANCELED:
 340       error = ERR_ABORTED;
 341       break;
 342     case URLRequestStatus::FAILED:
 343       error = ERR_FAILED;
 344       break;
 345   }
 346   set_status(URLRequestStatus(status, error));
 347   set_response_code(response_code);
 348   SetResponseString(response_data);
 349 }
 350
 351 FakeURLFetcher::~FakeURLFetcher() {}
 352
 353 void FakeURLFetcher::Start() {
 354   base::MessageLoop::current()->PostTask(
 355       FROM_HERE,
 356       base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
 357 }
 358
 359 void FakeURLFetcher::RunDelegate() {
 360   delegate()->OnURLFetchComplete(this);
 361 }
 362
 363 const GURL& FakeURLFetcher::GetURL() const {
 364   return TestURLFetcher::GetOriginalURL();
 365 }
 366
 367 FakeURLFetcherFactory::FakeURLFetcherFactory(
 368     URLFetcherFactory* default_factory)
 369     : ScopedURLFetcherFactory(this),
 370       creator_(base::Bind(&DefaultFakeURLFetcherCreator)),
 371       default_factory_(default_factory) {
 372 }
 373
 374 FakeURLFetcherFactory::FakeURLFetcherFactory(
 375     URLFetcherFactory* default_factory,
 376     const FakeURLFetcherCreator& creator)
 377     : ScopedURLFetcherFactory(this),
 378       creator_(creator),
 379       default_factory_(default_factory) {
 380 }
 381
 382 scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator(
 383       const GURL& url,
 384       URLFetcherDelegate* delegate,
 385       const std::string& response_data,
 386       HttpStatusCode response_code,
 387       URLRequestStatus::Status status) {
 388   return scoped_ptr<FakeURLFetcher>(
 389       new FakeURLFetcher(url, delegate, response_data, response_code, status));
 390 }
 391
 392 FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
 393
 394 URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
 395     int id,
 396     const GURL& url,
 397     URLFetcher::RequestType request_type,
 398     URLFetcherDelegate* d) {
 399   FakeResponseMap::const_iterator it = fake_responses_.find(url);
 400   if (it == fake_responses_.end()) {
 401     if (default_factory_ == NULL) {
 402       // If we don't have a baked response for that URL we return NULL.
 403       DLOG(ERROR) << "No baked response for URL: " << url.spec();
 404       return NULL;
 405     } else {
 406       return default_factory_->CreateURLFetcher(id, url, request_type, d);
 407     }
 408   }
 409
 410   scoped_ptr<FakeURLFetcher> fake_fetcher =
 411       creator_.Run(url, d, it->second.response_data,
 412                    it->second.response_code, it->second.status);
 413   // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr
 414   return fake_fetcher.release();
 415 }
 416
 417 void FakeURLFetcherFactory::SetFakeResponse(
 418     const GURL& url,
 419     const std::string& response_data,
 420     HttpStatusCode response_code,
 421     URLRequestStatus::Status status) {
 422   // Overwrite existing URL if it already exists.
 423   FakeURLResponse response;
 424   response.response_data = response_data;
 425   response.response_code = response_code;
 426   response.status = status;
 427   fake_responses_[url] = response;
 428 }
 429
 430 void FakeURLFetcherFactory::ClearFakeResponses() {
 431   fake_responses_.clear();
 432 }
 433
 434 URLFetcherImplFactory::URLFetcherImplFactory() {}
 435
 436 URLFetcherImplFactory::~URLFetcherImplFactory() {}
 437
 438 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
 439     int id,
 440     const GURL& url,
 441     URLFetcher::RequestType request_type,
 442     URLFetcherDelegate* d) {
 443   return new URLFetcherImpl(url, request_type, d);
 444 }
 445
 446 }  // namespace net