gaia_oauth_client_unittest.cc revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd
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(ALLOW_THIS_IN_INITIALIZER_LIST(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 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