gaia_oauth_client_unittest.cc revision a3f7b4e666c476898878fa745f637129375cd889 
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// A complete set of unit tests for GaiaOAuthClient.
6
7#include <string>
8#include <vector>
9
10#include "base/strings/string_number_conversions.h"
11#include "base/values.h"
12#include "google_apis/gaia/gaia_oauth_client.h"
13#include "net/base/net_errors.h"
14#include "net/http/http_status_code.h"
15#include "net/url_request/test_url_fetcher_factory.h"
16#include "net/url_request/url_fetcher_delegate.h"
17#include "net/url_request/url_request_status.h"
18#include "net/url_request/url_request_test_util.h"
19#include "testing/gmock/include/gmock/gmock.h"
20#include "testing/gtest/include/gtest/gtest.h"
21#include "url/gurl.h"
22
23using ::testing::_;
24using ::testing::Eq;
25using ::testing::HasSubstr;
26using ::testing::Pointee;
27using ::testing::SaveArg;
28
29namespace {
30
31// Responds as though OAuth returned from the server.
32class MockOAuthFetcher : public net::TestURLFetcher {
33 public:
34  MockOAuthFetcher(int response_code,
35                   int max_failure_count,
36                   bool complete_immediately,
37                   const GURL& url,
38                   const std::string& results,
39                   net::URLFetcher::RequestType request_type,
40                   net::URLFetcherDelegate* d)
41      : net::TestURLFetcher(0, url, d),
42        max_failure_count_(max_failure_count),
43        current_failure_count_(0),
44        complete_immediately_(complete_immediately) {
45    set_url(url);
46    set_response_code(response_code);
47    SetResponseString(results);
48  }
49
50  virtual ~MockOAuthFetcher() { }
51
52  virtual void Start() OVERRIDE {
53    if ((GetResponseCode() != net::HTTP_OK) && (max_failure_count_ != -1) &&
54        (current_failure_count_ == max_failure_count_)) {
55      set_response_code(net::HTTP_OK);
56    }
57
58    net::URLRequestStatus::Status code = net::URLRequestStatus::SUCCESS;
59    if (GetResponseCode() != net::HTTP_OK) {
60      code = net::URLRequestStatus::FAILED;
61      current_failure_count_++;
62    }
63    set_status(net::URLRequestStatus(code, 0));
64
65    if (complete_immediately_)
66      delegate()->OnURLFetchComplete(this);
67  }
68
69  void Finish() {
70    ASSERT_FALSE(complete_immediately_);
71    delegate()->OnURLFetchComplete(this);
72  }
73
74 private:
75  int max_failure_count_;
76  int current_failure_count_;
77  bool complete_immediately_;
78  DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcher);
79};
80
81class MockOAuthFetcherFactory : public net::URLFetcherFactory,
82                                public net::ScopedURLFetcherFactory {
83 public:
84  MockOAuthFetcherFactory()
85      : net::ScopedURLFetcherFactory(this),
86        response_code_(net::HTTP_OK),
87        complete_immediately_(true) {
88  }
89  virtual ~MockOAuthFetcherFactory() {}
90  virtual net::URLFetcher* CreateURLFetcher(
91      int id,
92      const GURL& url,
93      net::URLFetcher::RequestType request_type,
94      net::URLFetcherDelegate* d) OVERRIDE {
95    url_fetcher_ = new MockOAuthFetcher(
96        response_code_,
97        max_failure_count_,
98        complete_immediately_,
99        url,
100        results_,
101        request_type,
102        d);
103    return url_fetcher_;
104  }
105  void set_response_code(int response_code) {
106    response_code_ = response_code;
107  }
108  void set_max_failure_count(int count) {
109    max_failure_count_ = count;
110  }
111  void set_results(const std::string& results) {
112    results_ = results;
113  }
114  MockOAuthFetcher* get_url_fetcher() {
115    return url_fetcher_;
116  }
117  void set_complete_immediately(bool complete_immediately) {
118    complete_immediately_ = complete_immediately;
119  }
120 private:
121  MockOAuthFetcher* url_fetcher_;
122  int response_code_;
123  bool complete_immediately_;
124  int max_failure_count_;
125  std::string results_;
126  DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcherFactory);
127};
128
129const std::string kTestAccessToken = "1/fFAGRNJru1FTz70BzhT3Zg";
130const std::string kTestRefreshToken =
131    "1/6BMfW9j53gdGImsixUH6kU5RsR4zwI9lUVX-tqf8JXQ";
132const std::string kTestUserEmail = "a_user@gmail.com";
133const int kTestExpiresIn = 3920;
134
135const std::string kDummyGetTokensResult =
136  "{\"access_token\":\"" + kTestAccessToken + "\","
137  "\"expires_in\":" + base::IntToString(kTestExpiresIn) + ","
138  "\"refresh_token\":\"" + kTestRefreshToken + "\"}";
139
140const std::string kDummyRefreshTokenResult =
141  "{\"access_token\":\"" + kTestAccessToken + "\","
142  "\"expires_in\":" + base::IntToString(kTestExpiresIn) + "}";
143
144const std::string kDummyUserInfoResult =
145  "{\"email\":\"" + kTestUserEmail + "\"}";
146
147const std::string kDummyTokenInfoResult =
148  "{\"issued_to\": \"1234567890.apps.googleusercontent.com\","
149  "\"audience\": \"1234567890.apps.googleusercontent.com\","
150  "\"scope\": \"https://googleapis.com/oauth2/v2/tokeninfo\","
151  "\"expires_in\":" + base::IntToString(kTestExpiresIn) + "}";
152}
153
154namespace gaia {
155
156class GaiaOAuthClientTest : public testing::Test {
157 protected:
158  virtual void SetUp() OVERRIDE {
159    client_info_.client_id = "test_client_id";
160    client_info_.client_secret = "test_client_secret";
161    client_info_.redirect_uri = "test_redirect_uri";
162  };
163
164 protected:
165  net::TestURLRequestContextGetter* GetRequestContext() {
166    if (!request_context_getter_) {
167      request_context_getter_ = new net::TestURLRequestContextGetter(
168          message_loop_.message_loop_proxy());
169    }
170    return request_context_getter_;
171  }
172
173  base::MessageLoop message_loop_;
174  scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
175  OAuthClientInfo client_info_;
176};
177
178class MockGaiaOAuthClientDelegate : public gaia::GaiaOAuthClient::Delegate {
179 public:
180  MockGaiaOAuthClientDelegate() {}
181  ~MockGaiaOAuthClientDelegate() {}
182
183  MOCK_METHOD3(OnGetTokensResponse, void(const std::string& refresh_token,
184                                         const std::string& access_token,
185                                         int expires_in_seconds));
186  MOCK_METHOD2(OnRefreshTokenResponse, void(const std::string& access_token,
187                                            int expires_in_seconds));
188  MOCK_METHOD1(OnGetUserEmailResponse, void(const std::string& user_email));
189  MOCK_METHOD0(OnOAuthError, void());
190  MOCK_METHOD1(OnNetworkError, void(int response_code));
191
192  // gMock doesn't like methods that take or return scoped_ptr.  A
193  // work-around is to create a mock method that takes a raw ptr, and
194  // override the problematic method to call through to it.
195  // https://groups.google.com/a/chromium.org/d/msg/chromium-dev/01sDxsJ1OYw/I_S0xCBRF2oJ
196  MOCK_METHOD1(OnGetTokenInfoResponsePtr,
197               void(const DictionaryValue* token_info));
198  virtual void OnGetTokenInfoResponse(scoped_ptr<DictionaryValue> token_info)
199      OVERRIDE {
200    token_info_.reset(token_info.release());
201    OnGetTokenInfoResponsePtr(token_info_.get());
202  }
203
204 private:
205  scoped_ptr<DictionaryValue> token_info_;
206  DISALLOW_COPY_AND_ASSIGN(MockGaiaOAuthClientDelegate);
207};
208
209TEST_F(GaiaOAuthClientTest, NetworkFailure) {
210  int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
211
212  MockGaiaOAuthClientDelegate delegate;
213  EXPECT_CALL(delegate, OnNetworkError(response_code))
214      .Times(1);
215
216  MockOAuthFetcherFactory factory;
217  factory.set_response_code(response_code);
218  factory.set_max_failure_count(4);
219
220  GaiaOAuthClient auth(GetRequestContext());
221  auth.GetTokensFromAuthCode(client_info_, "auth_code", 2, &delegate);
222}
223
224TEST_F(GaiaOAuthClientTest, NetworkFailureRecover) {
225  int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
226
227  MockGaiaOAuthClientDelegate delegate;
228  EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
229      kTestExpiresIn)).Times(1);
230
231  MockOAuthFetcherFactory factory;
232  factory.set_response_code(response_code);
233  factory.set_max_failure_count(4);
234  factory.set_results(kDummyGetTokensResult);
235
236  GaiaOAuthClient auth(GetRequestContext());
237  auth.GetTokensFromAuthCode(client_info_, "auth_code", -1, &delegate);
238}
239
240TEST_F(GaiaOAuthClientTest, OAuthFailure) {
241  int response_code = net::HTTP_BAD_REQUEST;
242
243  MockGaiaOAuthClientDelegate delegate;
244  EXPECT_CALL(delegate, OnOAuthError()).Times(1);
245
246  MockOAuthFetcherFactory factory;
247  factory.set_response_code(response_code);
248  factory.set_max_failure_count(-1);
249  factory.set_results(kDummyGetTokensResult);
250
251  GaiaOAuthClient auth(GetRequestContext());
252  auth.GetTokensFromAuthCode(client_info_, "auth_code", -1, &delegate);
253}
254
255
256TEST_F(GaiaOAuthClientTest, GetTokensSuccess) {
257  MockGaiaOAuthClientDelegate delegate;
258  EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
259      kTestExpiresIn)).Times(1);
260
261  MockOAuthFetcherFactory factory;
262  factory.set_results(kDummyGetTokensResult);
263
264  GaiaOAuthClient auth(GetRequestContext());
265  auth.GetTokensFromAuthCode(client_info_, "auth_code", -1, &delegate);
266}
267
268TEST_F(GaiaOAuthClientTest, RefreshTokenSuccess) {
269  MockGaiaOAuthClientDelegate delegate;
270  EXPECT_CALL(delegate, OnRefreshTokenResponse(kTestAccessToken,
271      kTestExpiresIn)).Times(1);
272
273  MockOAuthFetcherFactory factory;
274  factory.set_results(kDummyRefreshTokenResult);
275  factory.set_complete_immediately(false);
276
277  GaiaOAuthClient auth(GetRequestContext());
278  auth.RefreshToken(client_info_, "refresh_token", std::vector<std::string>(),
279                    -1, &delegate);
280  EXPECT_THAT(factory.get_url_fetcher()->upload_data(),
281              Not(HasSubstr("scope")));
282  factory.get_url_fetcher()->Finish();
283}
284
285TEST_F(GaiaOAuthClientTest, RefreshTokenDownscopingSuccess) {
286  MockGaiaOAuthClientDelegate delegate;
287  EXPECT_CALL(delegate, OnRefreshTokenResponse(kTestAccessToken,
288      kTestExpiresIn)).Times(1);
289
290  MockOAuthFetcherFactory factory;
291  factory.set_results(kDummyRefreshTokenResult);
292  factory.set_complete_immediately(false);
293
294  GaiaOAuthClient auth(GetRequestContext());
295  auth.RefreshToken(client_info_, "refresh_token",
296                    std::vector<std::string>(1, "scope4test"), -1, &delegate);
297  EXPECT_THAT(factory.get_url_fetcher()->upload_data(),
298              HasSubstr("&scope=scope4test"));
299  factory.get_url_fetcher()->Finish();
300}
301
302
303TEST_F(GaiaOAuthClientTest, GetUserEmail) {
304  MockGaiaOAuthClientDelegate delegate;
305  EXPECT_CALL(delegate, OnGetUserEmailResponse(kTestUserEmail)).Times(1);
306
307  MockOAuthFetcherFactory factory;
308  factory.set_results(kDummyUserInfoResult);
309
310  GaiaOAuthClient auth(GetRequestContext());
311  auth.GetUserEmail("access_token", 1, &delegate);
312}
313
314TEST_F(GaiaOAuthClientTest, GetTokenInfo) {
315  const DictionaryValue* captured_result;
316
317  MockGaiaOAuthClientDelegate delegate;
318  EXPECT_CALL(delegate, OnGetTokenInfoResponsePtr(_))
319      .WillOnce(SaveArg<0>(&captured_result));
320
321  MockOAuthFetcherFactory factory;
322  factory.set_results(kDummyTokenInfoResult);
323
324  GaiaOAuthClient auth(GetRequestContext());
325  auth.GetTokenInfo("access_token", 1, &delegate);
326
327  std::string issued_to;
328  ASSERT_TRUE(captured_result->GetString("issued_to",  &issued_to));
329  ASSERT_EQ("1234567890.apps.googleusercontent.com", issued_to);
330}
331
332}  // namespace gaia
333