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