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 "chrome/browser/chromeos/login/mock_url_fetchers.h"
6
7#include <errno.h>
8
9#include "base/bind.h"
10#include "base/message_loop/message_loop.h"
11#include "base/strings/stringprintf.h"
12#include "net/http/http_status_code.h"
13#include "net/url_request/url_fetcher.h"
14#include "net/url_request/url_fetcher_delegate.h"
15#include "net/url_request/url_request_status.h"
16#include "testing/gtest/include/gtest/gtest.h"
17#include "url/gurl.h"
18
19namespace chromeos {
20
21ExpectCanceledFetcher::ExpectCanceledFetcher(
22    bool success,
23    const GURL& url,
24    const std::string& results,
25    net::URLFetcher::RequestType request_type,
26    net::URLFetcherDelegate* d)
27    : net::TestURLFetcher(0, url, d),
28      weak_factory_(this) {
29}
30
31ExpectCanceledFetcher::~ExpectCanceledFetcher() {
32}
33
34void ExpectCanceledFetcher::Start() {
35  base::MessageLoop::current()->PostDelayedTask(
36      FROM_HERE,
37      base::Bind(&ExpectCanceledFetcher::CompleteFetch,
38                 weak_factory_.GetWeakPtr()),
39      base::TimeDelta::FromMilliseconds(100));
40}
41
42void ExpectCanceledFetcher::CompleteFetch() {
43  ADD_FAILURE() << "Fetch completed in ExpectCanceledFetcher!";
44  base::MessageLoop::current()->Quit();  // Allow exiting even if we mess up.
45}
46
47GotCanceledFetcher::GotCanceledFetcher(
48    bool success,
49    const GURL& url,
50    const std::string& results,
51    net::URLFetcher::RequestType request_type,
52    net::URLFetcherDelegate* d)
53    : net::TestURLFetcher(0, url, d) {
54  set_url(url);
55  set_status(net::URLRequestStatus(net::URLRequestStatus::CANCELED, 0));
56  set_response_code(net::HTTP_FORBIDDEN);
57}
58
59GotCanceledFetcher::~GotCanceledFetcher() {}
60
61void GotCanceledFetcher::Start() {
62  delegate()->OnURLFetchComplete(this);
63}
64
65SuccessFetcher::SuccessFetcher(bool success,
66                               const GURL& url,
67                               const std::string& results,
68                               net::URLFetcher::RequestType request_type,
69                               net::URLFetcherDelegate* d)
70    : net::TestURLFetcher(0, url, d) {
71  set_url(url);
72  set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0));
73  set_response_code(net::HTTP_OK);
74}
75
76SuccessFetcher::~SuccessFetcher() {}
77
78void SuccessFetcher::Start() {
79  delegate()->OnURLFetchComplete(this);
80}
81
82FailFetcher::FailFetcher(bool success,
83                         const GURL& url,
84                         const std::string& results,
85                         net::URLFetcher::RequestType request_type,
86                         net::URLFetcherDelegate* d)
87    : net::TestURLFetcher(0, url, d) {
88  set_url(url);
89  set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED, ECONNRESET));
90  set_response_code(net::HTTP_OK);
91}
92
93FailFetcher::~FailFetcher() {}
94
95void FailFetcher::Start() {
96  delegate()->OnURLFetchComplete(this);
97}
98
99// static
100const char CaptchaFetcher::kCaptchaToken[] = "token";
101// static
102const char CaptchaFetcher::kCaptchaUrlBase[] = "http://accounts.google.com/";
103// static
104const char CaptchaFetcher::kCaptchaUrlFragment[] = "fragment";
105// static
106const char CaptchaFetcher::kUnlockUrl[] = "http://what.ever";
107
108
109CaptchaFetcher::CaptchaFetcher(bool success,
110                               const GURL& url,
111                               const std::string& results,
112                               net::URLFetcher::RequestType request_type,
113                               net::URLFetcherDelegate* d)
114    : net::TestURLFetcher(0, url, d) {
115  set_url(url);
116  set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0));
117  set_response_code(net::HTTP_FORBIDDEN);
118  SetResponseString(base::StringPrintf("Error=%s\n"
119                                       "Url=%s\n"
120                                       "CaptchaUrl=%s\n"
121                                       "CaptchaToken=%s\n",
122                                       "CaptchaRequired",
123                                       kUnlockUrl,
124                                       kCaptchaUrlFragment,
125                                       kCaptchaToken));
126}
127
128CaptchaFetcher::~CaptchaFetcher() {}
129
130// static
131std::string CaptchaFetcher::GetCaptchaToken() {
132  return kCaptchaToken;
133}
134
135// static
136std::string CaptchaFetcher::GetCaptchaUrl() {
137  return std::string(kCaptchaUrlBase).append(kCaptchaUrlFragment);
138}
139
140// static
141std::string CaptchaFetcher::GetUnlockUrl() {
142  return kUnlockUrl;
143}
144
145void CaptchaFetcher::Start() {
146  delegate()->OnURLFetchComplete(this);
147}
148
149HostedFetcher::HostedFetcher(bool success,
150                             const GURL& url,
151                             const std::string& results,
152                             net::URLFetcher::RequestType request_type,
153                             net::URLFetcherDelegate* d)
154    : net::TestURLFetcher(0, url, d) {
155  set_url(url);
156  set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0));
157  set_response_code(net::HTTP_OK);
158}
159
160HostedFetcher::~HostedFetcher() {}
161
162void HostedFetcher::Start() {
163  VLOG(1) << upload_data();
164  if (upload_data().find("HOSTED") == std::string::npos) {
165    VLOG(1) << "HostedFetcher failing request";
166    set_response_code(net::HTTP_FORBIDDEN);
167    SetResponseString("Error=BadAuthentication");
168  }
169  delegate()->OnURLFetchComplete(this);
170}
171
172}  // namespace chromeos
173