gaia_oauth_client_unittest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
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
9#include "base/message_loop.h"
10#include "base/string_number_conversions.h"
11#include "base/string_util.h"
12#include "chrome/test/base/testing_profile.h"
13#include "google_apis/gaia/gaia_oauth_client.h"
14#include "googleurl/src/gurl.h"
15#include "net/base/net_errors.h"
16#include "net/http/http_status_code.h"
17#include "net/url_request/test_url_fetcher_factory.h"
18#include "net/url_request/url_fetcher_delegate.h"
19#include "net/url_request/url_request_status.h"
20#include "testing/gmock/include/gmock/gmock.h"
21#include "testing/gtest/include/gtest/gtest.h"
22
23using ::testing::_;
24
25namespace {
26// Responds as though OAuth returned from the server.
27class MockOAuthFetcher : public net::TestURLFetcher {
28 public:
29  MockOAuthFetcher(int response_code,
30                   int max_failure_count,
31                   const GURL& url,
32                   const std::string& results,
33                   net::URLFetcher::RequestType request_type,
34                   net::URLFetcherDelegate* d)
35      : net::TestURLFetcher(0, url, d),
36        max_failure_count_(max_failure_count),
37        current_failure_count_(0) {
38    set_url(url);
39    set_response_code(response_code);
40    SetResponseString(results);
41  }
42
43  virtual ~MockOAuthFetcher() { }
44
45  virtual void Start() OVERRIDE {
46    if ((GetResponseCode() != net::HTTP_OK) && (max_failure_count_ != -1) &&
47        (current_failure_count_ == max_failure_count_)) {
48      set_response_code(net::HTTP_OK);
49    }
50
51    net::URLRequestStatus::Status code = net::URLRequestStatus::SUCCESS;
52    if (GetResponseCode() != net::HTTP_OK) {
53      code = net::URLRequestStatus::FAILED;
54      current_failure_count_++;
55    }
56    set_status(net::URLRequestStatus(code, 0));
57
58    delegate()->OnURLFetchComplete(this);
59  }
60
61 private:
62  int max_failure_count_;
63  int current_failure_count_;
64  DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcher);
65};
66
67class MockOAuthFetcherFactory : public net::URLFetcherFactory,
68                                public net::ScopedURLFetcherFactory {
69 public:
70  MockOAuthFetcherFactory()
71      : net::ScopedURLFetcherFactory(this),
72        response_code_(net::HTTP_OK) {
73  }
74  virtual ~MockOAuthFetcherFactory() {}
75  virtual net::URLFetcher* CreateURLFetcher(
76      int id,
77      const GURL& url,
78      net::URLFetcher::RequestType request_type,
79      net::URLFetcherDelegate* d) OVERRIDE {
80    return new MockOAuthFetcher(
81        response_code_,
82        max_failure_count_,
83        url,
84        results_,
85        request_type,
86        d);
87  }
88  void set_response_code(int response_code) {
89    response_code_ = response_code;
90  }
91  void set_max_failure_count(int count) {
92    max_failure_count_ = count;
93  }
94  void set_results(const std::string& results) {
95    results_ = results;
96  }
97 private:
98  int response_code_;
99  int max_failure_count_;
100  std::string results_;
101  DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcherFactory);
102};
103
104const std::string kTestAccessToken = "1/fFAGRNJru1FTz70BzhT3Zg";
105const std::string kTestRefreshToken =
106    "1/6BMfW9j53gdGImsixUH6kU5RsR4zwI9lUVX-tqf8JXQ";
107const std::string kTestUserEmail = "a_user@gmail.com";
108const int kTestExpiresIn = 3920;
109
110const std::string kDummyGetTokensResult =
111  "{\"access_token\":\"" + kTestAccessToken + "\","
112  "\"expires_in\":" + base::IntToString(kTestExpiresIn) + ","
113  "\"refresh_token\":\"" + kTestRefreshToken + "\"}";
114
115const std::string kDummyRefreshTokenResult =
116  "{\"access_token\":\"" + kTestAccessToken + "\","
117  "\"expires_in\":" + base::IntToString(kTestExpiresIn) + "}";
118
119const std::string kDummyUserInfoResult =
120  "{\"email\":\"" + kTestUserEmail + "\"}";
121}
122
123namespace gaia {
124
125class GaiaOAuthClientTest : public testing::Test {
126 public:
127  GaiaOAuthClientTest() {}
128
129  TestingProfile profile_;
130 protected:
131  base::MessageLoop message_loop_;
132};
133
134class MockGaiaOAuthClientDelegate : public gaia::GaiaOAuthClient::Delegate {
135 public:
136  MockGaiaOAuthClientDelegate() {}
137  ~MockGaiaOAuthClientDelegate() {}
138
139  MOCK_METHOD3(OnGetTokensResponse, void(const std::string& refresh_token,
140                                         const std::string& access_token,
141                                         int expires_in_seconds));
142  MOCK_METHOD2(OnRefreshTokenResponse, void(const std::string& access_token,
143                                            int expires_in_seconds));
144  MOCK_METHOD1(OnGetUserInfoResponse, void(const std::string& user_email));
145  MOCK_METHOD0(OnOAuthError, void());
146  MOCK_METHOD1(OnNetworkError, void(int response_code));
147};
148
149TEST_F(GaiaOAuthClientTest, NetworkFailure) {
150  int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
151
152  MockGaiaOAuthClientDelegate delegate;
153  EXPECT_CALL(delegate, OnNetworkError(response_code))
154      .Times(1);
155
156  TestingProfile profile;
157
158  MockOAuthFetcherFactory factory;
159  factory.set_response_code(response_code);
160  factory.set_max_failure_count(4);
161
162  OAuthClientInfo client_info;
163  client_info.client_id = "test_client_id";
164  client_info.client_secret = "test_client_secret";
165  client_info.redirect_uri = "test_redirect_uri";
166  GaiaOAuthClient auth(kGaiaOAuth2Url,
167                       profile_.GetRequestContext());
168  auth.GetTokensFromAuthCode(client_info, "auth_code", 2, &delegate);
169}
170
171TEST_F(GaiaOAuthClientTest, NetworkFailureRecover) {
172  int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
173
174  MockGaiaOAuthClientDelegate delegate;
175  EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
176      kTestExpiresIn)).Times(1);
177
178  TestingProfile profile;
179
180  MockOAuthFetcherFactory factory;
181  factory.set_response_code(response_code);
182  factory.set_max_failure_count(4);
183  factory.set_results(kDummyGetTokensResult);
184
185  OAuthClientInfo client_info;
186  client_info.client_id = "test_client_id";
187  client_info.client_secret = "test_client_secret";
188  client_info.redirect_uri = "test_redirect_uri";
189  GaiaOAuthClient auth(kGaiaOAuth2Url,
190                       profile_.GetRequestContext());
191  auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
192}
193
194TEST_F(GaiaOAuthClientTest, OAuthFailure) {
195  int response_code = net::HTTP_BAD_REQUEST;
196
197  MockGaiaOAuthClientDelegate delegate;
198  EXPECT_CALL(delegate, OnOAuthError()).Times(1);
199
200  TestingProfile profile;
201
202  MockOAuthFetcherFactory factory;
203  factory.set_response_code(response_code);
204  factory.set_max_failure_count(-1);
205  factory.set_results(kDummyGetTokensResult);
206
207  OAuthClientInfo client_info;
208  client_info.client_id = "test_client_id";
209  client_info.client_secret = "test_client_secret";
210  client_info.redirect_uri = "test_redirect_uri";
211  GaiaOAuthClient auth(kGaiaOAuth2Url,
212                       profile_.GetRequestContext());
213  auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
214}
215
216
217TEST_F(GaiaOAuthClientTest, GetTokensSuccess) {
218  MockGaiaOAuthClientDelegate delegate;
219  EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
220      kTestExpiresIn)).Times(1);
221
222  TestingProfile profile;
223
224  MockOAuthFetcherFactory factory;
225  factory.set_results(kDummyGetTokensResult);
226
227  OAuthClientInfo client_info;
228  client_info.client_id = "test_client_id";
229  client_info.client_secret = "test_client_secret";
230  client_info.redirect_uri = "test_redirect_uri";
231  GaiaOAuthClient auth(kGaiaOAuth2Url,
232                       profile_.GetRequestContext());
233  auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
234}
235
236TEST_F(GaiaOAuthClientTest, RefreshTokenSuccess) {
237  MockGaiaOAuthClientDelegate delegate;
238  EXPECT_CALL(delegate, OnRefreshTokenResponse(kTestAccessToken,
239      kTestExpiresIn)).Times(1);
240
241  TestingProfile profile;
242
243  MockOAuthFetcherFactory factory;
244  factory.set_results(kDummyRefreshTokenResult);
245
246  OAuthClientInfo client_info;
247  client_info.client_id = "test_client_id";
248  client_info.client_secret = "test_client_secret";
249  client_info.redirect_uri = "test_redirect_uri";
250  GaiaOAuthClient auth(kGaiaOAuth2Url,
251                       profile_.GetRequestContext());
252  auth.RefreshToken(client_info, "refresh_token", -1, &delegate);
253}
254
255TEST_F(GaiaOAuthClientTest, GetUserInfo) {
256  MockGaiaOAuthClientDelegate delegate;
257  EXPECT_CALL(delegate, OnGetUserInfoResponse(kTestUserEmail)).Times(1);
258
259  TestingProfile profile;
260
261  MockOAuthFetcherFactory factory;
262  factory.set_results(kDummyUserInfoResult);
263
264  OAuthClientInfo client_info;
265  client_info.client_id = "test_client_id";
266  client_info.client_secret = "test_client_secret";
267  client_info.redirect_uri = "test_redirect_uri";
268  GaiaOAuthClient auth(kGaiaOAuth2Url,
269                       profile_.GetRequestContext());
270  auth.GetUserInfo("access_token", 1, &delegate);
271}
272
273}  // namespace gaia
274