privet_confirm_api_flow_unittest.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
1// Copyright 2013 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 "base/bind.h"
6#include "base/message_loop/message_loop.h"
7#include "chrome/browser/local_discovery/privet_confirm_api_flow.h"
8#include "content/public/test/test_browser_thread.h"
9#include "google_apis/gaia/fake_oauth2_token_service.h"
10#include "google_apis/gaia/google_service_auth_error.h"
11#include "net/base/host_port_pair.h"
12#include "net/base/net_errors.h"
13#include "net/http/http_request_headers.h"
14#include "net/url_request/test_url_fetcher_factory.h"
15#include "net/url_request/url_request_test_util.h"
16#include "testing/gmock/include/gmock/gmock.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19using testing::NiceMock;
20
21namespace local_discovery {
22
23namespace {
24
25const char kSampleConfirmResponse[] = "{"
26    "   \"success\": true"
27    "}";
28
29const char kFailedConfirmResponse[] = "{"
30    "   \"success\": false"
31    "}";
32
33const char kFailedConfirmResponseBadJson[] = "["
34    "   \"success\""
35    "]";
36
37const char kGCDConfirmResponse[] =
38    "{"
39    "   \"kind\": \"clouddevices#registrationTicket\""
40    "}";
41
42const char kAccountId[] = "account_id";
43
44class MockableConfirmCallback {
45 public:
46  MOCK_METHOD1(ConfirmCallback, void(GCDBaseApiFlow::Status));
47
48  PrivetConfirmApiCallFlow::ResponseCallback callback() {
49    return base::Bind(&MockableConfirmCallback::ConfirmCallback,
50                      base::Unretained(this));
51  }
52};
53
54class PrivetConfirmApiFlowTest : public testing::Test {
55 public:
56  PrivetConfirmApiFlowTest()
57      : ui_thread_(content::BrowserThread::UI,
58                   &loop_),
59        request_context_(new net::TestURLRequestContextGetter(
60            base::MessageLoopProxy::current())),
61        account_id_(kAccountId) {
62    token_service_.set_request_context(request_context_.get());
63    token_service_.AddAccount(account_id_);
64    ui_thread_.Stop();  // HACK: Fake being on the UI thread
65  }
66
67  virtual ~PrivetConfirmApiFlowTest() {
68  }
69
70 protected:
71  base::MessageLoopForUI loop_;
72  content::TestBrowserThread ui_thread_;
73  scoped_refptr<net::TestURLRequestContextGetter> request_context_;
74  net::TestURLFetcherFactory fetcher_factory_;
75  FakeOAuth2TokenService token_service_;
76  MockableConfirmCallback callback_;
77  std::string account_id_;
78};
79
80TEST_F(PrivetConfirmApiFlowTest, SuccessOAuth2) {
81  PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
82                                        &token_service_,
83                                        account_id_,
84                                        true,
85                                        "SomeToken",
86                                        callback_.callback());
87  GCDBaseApiFlow* cloudprint_flow = confirm_flow.GetBaseApiFlowForTests();
88
89  confirm_flow.Start();
90
91  cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
92  net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
93
94  EXPECT_EQ(GURL("https://www.google.com/cloudprint/confirm?token=SomeToken"),
95            fetcher->GetOriginalURL());
96
97  net::HttpRequestHeaders headers;
98  fetcher->GetExtraRequestHeaders(&headers);
99  std::string oauth_header;
100  std::string proxy;
101  EXPECT_TRUE(headers.GetHeader("Authorization", &oauth_header));
102  EXPECT_EQ("Bearer SomeToken", oauth_header);
103  EXPECT_TRUE(headers.GetHeader("X-Cloudprint-Proxy", &proxy));
104  EXPECT_EQ("Chrome", proxy);
105
106  fetcher->SetResponseString(kSampleConfirmResponse);
107  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
108                                            net::OK));
109  fetcher->set_response_code(200);
110
111  EXPECT_CALL(callback_, ConfirmCallback(GCDBaseApiFlow::SUCCESS));
112
113  fetcher->delegate()->OnURLFetchComplete(fetcher);
114}
115
116TEST_F(PrivetConfirmApiFlowTest, BadToken) {
117  PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
118                                        &token_service_,
119                                        account_id_,
120                                        true,
121                                        "SomeCloudprintToken",
122                                        callback_.callback());
123
124  confirm_flow.Start();
125
126  GCDBaseApiFlow* cloudprint_flow = confirm_flow.GetBaseApiFlowForTests();
127
128  EXPECT_CALL(callback_, ConfirmCallback(GCDBaseApiFlow::ERROR_TOKEN));
129  cloudprint_flow->OnGetTokenFailure(NULL, GoogleServiceAuthError(
130      GoogleServiceAuthError::USER_NOT_SIGNED_UP));
131}
132
133TEST_F(PrivetConfirmApiFlowTest, ServerFailure) {
134  PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
135                                        &token_service_,
136                                        account_id_,
137                                        true,
138                                        "SomeToken",
139                                        callback_.callback());
140
141  confirm_flow.Start();
142
143  GCDBaseApiFlow* cloudprint_flow = confirm_flow.GetBaseApiFlowForTests();
144
145  cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
146  net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
147
148  EXPECT_EQ(GURL("https://www.google.com/cloudprint/confirm?token=SomeToken"),
149            fetcher->GetOriginalURL());
150
151  fetcher->SetResponseString(kFailedConfirmResponse);
152  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
153                                            net::OK));
154  fetcher->set_response_code(200);
155
156  EXPECT_CALL(callback_, ConfirmCallback(GCDBaseApiFlow::ERROR_FROM_SERVER));
157
158  fetcher->delegate()->OnURLFetchComplete(fetcher);
159}
160
161TEST_F(PrivetConfirmApiFlowTest, BadJson) {
162  PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
163                                        &token_service_,
164                                        account_id_,
165                                        true,
166                                        "SomeToken",
167                                        callback_.callback());
168
169  confirm_flow.Start();
170
171  GCDBaseApiFlow* cloudprint_flow = confirm_flow.GetBaseApiFlowForTests();
172
173  cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
174  net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
175
176  EXPECT_EQ(GURL("https://www.google.com/cloudprint/confirm?token=SomeToken"),
177            fetcher->GetOriginalURL());
178
179  fetcher->SetResponseString(kFailedConfirmResponseBadJson);
180  fetcher->set_status(net::URLRequestStatus(
181      net::URLRequestStatus::SUCCESS,
182      net::OK));
183  fetcher->set_response_code(200);
184
185  EXPECT_CALL(callback_,
186              ConfirmCallback(GCDBaseApiFlow::ERROR_MALFORMED_RESPONSE));
187
188  fetcher->delegate()->OnURLFetchComplete(fetcher);
189}
190
191TEST_F(PrivetConfirmApiFlowTest, SuccessGCD) {
192  PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
193                                        &token_service_,
194                                        account_id_,
195                                        false,
196                                        "SomeGcdToken",
197                                        callback_.callback());
198  GCDBaseApiFlow* gcd_flow = confirm_flow.GetBaseApiFlowForTests();
199
200  confirm_flow.Start();
201
202  gcd_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
203  net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
204
205  EXPECT_EQ(GURL("https://www.googleapis.com/clouddevices/v1/"
206                 "registrationTickets/SomeGcdToken"),
207            fetcher->GetOriginalURL());
208
209  EXPECT_EQ("{ \"userEmail\": \"me\" }", fetcher->upload_data());
210
211  net::HttpRequestHeaders headers;
212  fetcher->GetExtraRequestHeaders(&headers);
213  std::string oauth_header;
214  std::string proxy;
215  EXPECT_TRUE(headers.GetHeader("Authorization", &oauth_header));
216  EXPECT_EQ("Bearer SomeToken", oauth_header);
217  EXPECT_FALSE(headers.GetHeader("X-Cloudprint-Proxy", &proxy));
218
219  fetcher->SetResponseString(kGCDConfirmResponse);
220  fetcher->set_status(
221      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
222  fetcher->set_response_code(200);
223
224  EXPECT_CALL(callback_, ConfirmCallback(GCDBaseApiFlow::SUCCESS));
225
226  fetcher->delegate()->OnURLFetchComplete(fetcher);
227}
228
229}  // namespace
230
231}  // namespace local_discovery
232