test_url_fetcher_factory.cc revision d0247b1b59f9c528cb6df88b4f2b9afaf80d181e 
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/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::SetFakeResponseForURL(
361    const GURL& url,
362    const std::string& response_data,
363    bool success) {
364  // Overwrite existing URL if it already exists.
365  fake_responses_[url] = std::make_pair(response_data, success);
366}
367
368void FakeURLFetcherFactory::SetFakeResponse(const std::string& url,
369                                            const std::string& response_data,
370                                            bool success) {
371  SetFakeResponseForURL(GURL(url), response_data, success);
372}
373
374void FakeURLFetcherFactory::ClearFakeResponses() {
375  fake_responses_.clear();
376}
377
378URLFetcherImplFactory::URLFetcherImplFactory() {}
379
380URLFetcherImplFactory::~URLFetcherImplFactory() {}
381
382URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
383    int id,
384    const GURL& url,
385    URLFetcher::RequestType request_type,
386    URLFetcherDelegate* d) {
387  return new URLFetcherImpl(url, request_type, d);
388}
389
390}  // namespace net
391