gaia_auth_fetcher_unittest.cc revision 9ab5563a3196760eb381d102cbb2bc0f7abc6a50
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 GaiaAuthFetcher. 6// Originally ported from GoogleAuthenticator tests. 7 8#include <string> 9 10#include "base/json/json_reader.h" 11#include "base/message_loop/message_loop.h" 12#include "base/strings/stringprintf.h" 13#include "base/values.h" 14#include "google_apis/gaia/gaia_auth_consumer.h" 15#include "google_apis/gaia/gaia_auth_fetcher.h" 16#include "google_apis/gaia/gaia_urls.h" 17#include "google_apis/gaia/google_service_auth_error.h" 18#include "google_apis/gaia/mock_url_fetcher_factory.h" 19#include "google_apis/google_api_keys.h" 20#include "net/base/load_flags.h" 21#include "net/base/net_errors.h" 22#include "net/http/http_status_code.h" 23#include "net/url_request/test_url_fetcher_factory.h" 24#include "net/url_request/url_fetcher_delegate.h" 25#include "net/url_request/url_request_status.h" 26#include "net/url_request/url_request_test_util.h" 27#include "testing/gmock/include/gmock/gmock.h" 28#include "testing/gtest/include/gtest/gtest.h" 29#include "url/gurl.h" 30 31using ::testing::_; 32using ::testing::Invoke; 33 34namespace { 35static const char kGetAuthCodeValidCookie[] = 36 "oauth_code=test-code; Path=/test; Secure; HttpOnly"; 37static const char kGetAuthCodeCookieNoSecure[] = 38 "oauth_code=test-code; Path=/test; HttpOnly"; 39static const char kGetAuthCodeCookieNoHttpOnly[] = 40 "oauth_code=test-code; Path=/test; Secure"; 41static const char kGetAuthCodeCookieNoOAuthCode[] = 42 "Path=/test; Secure; HttpOnly"; 43static const char kGetTokenPairValidResponse[] = 44 "{" 45 " \"refresh_token\": \"rt1\"," 46 " \"access_token\": \"at1\"," 47 " \"expires_in\": 3600," 48 " \"token_type\": \"Bearer\"" 49 "}"; 50static const char kClientOAuthValidResponse[] = 51 "{" 52 " \"oauth2\": {" 53 " \"refresh_token\": \"rt1\"," 54 " \"access_token\": \"at1\"," 55 " \"expires_in\": 3600," 56 " \"token_type\": \"Bearer\"" 57 " }" 58 "}"; 59 60} // namespace 61 62MockFetcher::MockFetcher(bool success, 63 const GURL& url, 64 const std::string& results, 65 net::URLFetcher::RequestType request_type, 66 net::URLFetcherDelegate* d) 67 : TestURLFetcher(0, url, d) { 68 set_url(url); 69 net::URLRequestStatus::Status code; 70 71 if (success) { 72 set_response_code(net::HTTP_OK); 73 code = net::URLRequestStatus::SUCCESS; 74 } else { 75 set_response_code(net::HTTP_FORBIDDEN); 76 code = net::URLRequestStatus::FAILED; 77 } 78 79 set_status(net::URLRequestStatus(code, 0)); 80 SetResponseString(results); 81} 82 83MockFetcher::MockFetcher(const GURL& url, 84 const net::URLRequestStatus& status, 85 int response_code, 86 const net::ResponseCookies& cookies, 87 const std::string& results, 88 net::URLFetcher::RequestType request_type, 89 net::URLFetcherDelegate* d) 90 : TestURLFetcher(0, url, d) { 91 set_url(url); 92 set_status(status); 93 set_response_code(response_code); 94 set_cookies(cookies); 95 SetResponseString(results); 96} 97 98MockFetcher::~MockFetcher() {} 99 100void MockFetcher::Start() { 101 delegate()->OnURLFetchComplete(this); 102} 103 104class GaiaAuthFetcherTest : public testing::Test { 105 public: 106 GaiaAuthFetcherTest() 107 : client_login_source_(GaiaUrls::GetInstance()->client_login_url()), 108 issue_auth_token_source_( 109 GaiaUrls::GetInstance()->issue_auth_token_url()), 110 client_login_to_oauth2_source_( 111 GaiaUrls::GetInstance()->client_login_to_oauth2_url()), 112 oauth2_token_source_(GaiaUrls::GetInstance()->oauth2_token_url()), 113 token_auth_source_(GaiaUrls::GetInstance()->token_auth_url()), 114 merge_session_source_(GaiaUrls::GetInstance()->merge_session_url()), 115 uberauth_token_source_(base::StringPrintf( 116 "%s?source=&issueuberauth=1", 117 GaiaUrls::GetInstance()->oauth1_login_url().c_str())), 118 oauth_login_gurl_(GaiaUrls::GetInstance()->oauth1_login_url()) {} 119 120 void RunParsingTest(const std::string& data, 121 const std::string& sid, 122 const std::string& lsid, 123 const std::string& token) { 124 std::string out_sid; 125 std::string out_lsid; 126 std::string out_token; 127 128 GaiaAuthFetcher::ParseClientLoginResponse(data, 129 &out_sid, 130 &out_lsid, 131 &out_token); 132 EXPECT_EQ(lsid, out_lsid); 133 EXPECT_EQ(sid, out_sid); 134 EXPECT_EQ(token, out_token); 135 } 136 137 void RunErrorParsingTest(const std::string& data, 138 const std::string& error, 139 const std::string& error_url, 140 const std::string& captcha_url, 141 const std::string& captcha_token) { 142 std::string out_error; 143 std::string out_error_url; 144 std::string out_captcha_url; 145 std::string out_captcha_token; 146 147 GaiaAuthFetcher::ParseClientLoginFailure(data, 148 &out_error, 149 &out_error_url, 150 &out_captcha_url, 151 &out_captcha_token); 152 EXPECT_EQ(error, out_error); 153 EXPECT_EQ(error_url, out_error_url); 154 EXPECT_EQ(captcha_url, out_captcha_url); 155 EXPECT_EQ(captcha_token, out_captcha_token); 156 } 157 158 net::ResponseCookies cookies_; 159 GURL client_login_source_; 160 GURL issue_auth_token_source_; 161 GURL client_login_to_oauth2_source_; 162 GURL oauth2_token_source_; 163 GURL token_auth_source_; 164 GURL merge_session_source_; 165 GURL uberauth_token_source_; 166 GURL oauth_login_gurl_; 167 168 protected: 169 net::TestURLRequestContextGetter* GetRequestContext() { 170 if (!request_context_getter_) { 171 request_context_getter_ = new net::TestURLRequestContextGetter( 172 message_loop_.message_loop_proxy()); 173 } 174 return request_context_getter_; 175 } 176 177 base::MessageLoop message_loop_; 178 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; 179}; 180 181class MockGaiaConsumer : public GaiaAuthConsumer { 182 public: 183 MockGaiaConsumer() {} 184 ~MockGaiaConsumer() {} 185 186 MOCK_METHOD1(OnClientLoginSuccess, void(const ClientLoginResult& result)); 187 MOCK_METHOD2(OnIssueAuthTokenSuccess, void(const std::string& service, 188 const std::string& token)); 189 MOCK_METHOD1(OnClientOAuthSuccess, 190 void(const GaiaAuthConsumer::ClientOAuthResult& result)); 191 MOCK_METHOD1(OnMergeSessionSuccess, void(const std::string& data)); 192 MOCK_METHOD1(OnUberAuthTokenSuccess, void(const std::string& data)); 193 MOCK_METHOD1(OnClientLoginFailure, 194 void(const GoogleServiceAuthError& error)); 195 MOCK_METHOD2(OnIssueAuthTokenFailure, void(const std::string& service, 196 const GoogleServiceAuthError& error)); 197 MOCK_METHOD1(OnClientOAuthFailure, 198 void(const GoogleServiceAuthError& error)); 199 MOCK_METHOD1(OnMergeSessionFailure, void( 200 const GoogleServiceAuthError& error)); 201 MOCK_METHOD1(OnUberAuthTokenFailure, void( 202 const GoogleServiceAuthError& error)); 203}; 204 205#if defined(OS_WIN) 206#define MAYBE_ErrorComparator DISABLED_ErrorComparator 207#else 208#define MAYBE_ErrorComparator ErrorComparator 209#endif 210 211TEST_F(GaiaAuthFetcherTest, MAYBE_ErrorComparator) { 212 GoogleServiceAuthError expected_error = 213 GoogleServiceAuthError::FromConnectionError(-101); 214 215 GoogleServiceAuthError matching_error = 216 GoogleServiceAuthError::FromConnectionError(-101); 217 218 EXPECT_TRUE(expected_error == matching_error); 219 220 expected_error = GoogleServiceAuthError::FromConnectionError(6); 221 222 EXPECT_FALSE(expected_error == matching_error); 223 224 expected_error = GoogleServiceAuthError(GoogleServiceAuthError::NONE); 225 226 EXPECT_FALSE(expected_error == matching_error); 227 228 matching_error = GoogleServiceAuthError(GoogleServiceAuthError::NONE); 229 230 EXPECT_TRUE(expected_error == matching_error); 231} 232 233TEST_F(GaiaAuthFetcherTest, LoginNetFailure) { 234 int error_no = net::ERR_CONNECTION_RESET; 235 net::URLRequestStatus status(net::URLRequestStatus::FAILED, error_no); 236 237 GoogleServiceAuthError expected_error = 238 GoogleServiceAuthError::FromConnectionError(error_no); 239 240 MockGaiaConsumer consumer; 241 EXPECT_CALL(consumer, OnClientLoginFailure(expected_error)) 242 .Times(1); 243 244 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 245 246 MockFetcher mock_fetcher( 247 client_login_source_, status, 0, net::ResponseCookies(), std::string(), 248 net::URLFetcher::GET, &auth); 249 auth.OnURLFetchComplete(&mock_fetcher); 250} 251 252TEST_F(GaiaAuthFetcherTest, TokenNetFailure) { 253 int error_no = net::ERR_CONNECTION_RESET; 254 net::URLRequestStatus status(net::URLRequestStatus::FAILED, error_no); 255 256 GoogleServiceAuthError expected_error = 257 GoogleServiceAuthError::FromConnectionError(error_no); 258 259 MockGaiaConsumer consumer; 260 EXPECT_CALL(consumer, OnIssueAuthTokenFailure(_, expected_error)) 261 .Times(1); 262 263 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 264 265 MockFetcher mock_fetcher( 266 issue_auth_token_source_, status, 0, cookies_, std::string(), 267 net::URLFetcher::GET, &auth); 268 auth.OnURLFetchComplete(&mock_fetcher); 269} 270 271 272TEST_F(GaiaAuthFetcherTest, LoginDenied) { 273 std::string data("Error=BadAuthentication"); 274 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 275 276 GoogleServiceAuthError expected_error( 277 GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS); 278 279 MockGaiaConsumer consumer; 280 EXPECT_CALL(consumer, OnClientLoginFailure(expected_error)) 281 .Times(1); 282 283 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 284 285 MockFetcher mock_fetcher( 286 client_login_source_, status, net::HTTP_FORBIDDEN, cookies_, data, 287 net::URLFetcher::GET, &auth); 288 auth.OnURLFetchComplete(&mock_fetcher); 289} 290 291TEST_F(GaiaAuthFetcherTest, ParseRequest) { 292 RunParsingTest("SID=sid\nLSID=lsid\nAuth=auth\n", "sid", "lsid", "auth"); 293 RunParsingTest("LSID=lsid\nSID=sid\nAuth=auth\n", "sid", "lsid", "auth"); 294 RunParsingTest("SID=sid\nLSID=lsid\nAuth=auth", "sid", "lsid", "auth"); 295 RunParsingTest("SID=sid\nAuth=auth\n", "sid", std::string(), "auth"); 296 RunParsingTest("LSID=lsid\nAuth=auth\n", std::string(), "lsid", "auth"); 297 RunParsingTest("\nAuth=auth\n", std::string(), std::string(), "auth"); 298 RunParsingTest("SID=sid", "sid", std::string(), std::string()); 299} 300 301TEST_F(GaiaAuthFetcherTest, ParseErrorRequest) { 302 RunErrorParsingTest("Url=U\n" 303 "Error=E\n" 304 "CaptchaToken=T\n" 305 "CaptchaUrl=C\n", "E", "U", "C", "T"); 306 RunErrorParsingTest("CaptchaToken=T\n" 307 "Error=E\n" 308 "Url=U\n" 309 "CaptchaUrl=C\n", "E", "U", "C", "T"); 310 RunErrorParsingTest("\n\n\nCaptchaToken=T\n" 311 "\nError=E\n" 312 "\nUrl=U\n" 313 "CaptchaUrl=C\n", "E", "U", "C", "T"); 314} 315 316 317TEST_F(GaiaAuthFetcherTest, OnlineLogin) { 318 std::string data("SID=sid\nLSID=lsid\nAuth=auth\n"); 319 320 GaiaAuthConsumer::ClientLoginResult result; 321 result.lsid = "lsid"; 322 result.sid = "sid"; 323 result.token = "auth"; 324 result.data = data; 325 326 MockGaiaConsumer consumer; 327 EXPECT_CALL(consumer, OnClientLoginSuccess(result)) 328 .Times(1); 329 330 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 331 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 332 MockFetcher mock_fetcher( 333 client_login_source_, status, net::HTTP_OK, cookies_, data, 334 net::URLFetcher::GET, &auth); 335 auth.OnURLFetchComplete(&mock_fetcher); 336} 337 338TEST_F(GaiaAuthFetcherTest, WorkingIssueAuthToken) { 339 MockGaiaConsumer consumer; 340 EXPECT_CALL(consumer, OnIssueAuthTokenSuccess(_, "token")) 341 .Times(1); 342 343 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 344 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 345 MockFetcher mock_fetcher( 346 issue_auth_token_source_, status, net::HTTP_OK, cookies_, "token", 347 net::URLFetcher::GET, &auth); 348 auth.OnURLFetchComplete(&mock_fetcher); 349} 350 351TEST_F(GaiaAuthFetcherTest, CheckTwoFactorResponse) { 352 std::string response = 353 base::StringPrintf("Error=BadAuthentication\n%s\n", 354 GaiaAuthFetcher::kSecondFactor); 355 EXPECT_TRUE(GaiaAuthFetcher::IsSecondFactorSuccess(response)); 356} 357 358TEST_F(GaiaAuthFetcherTest, CheckNormalErrorCode) { 359 std::string response = "Error=BadAuthentication\n"; 360 EXPECT_FALSE(GaiaAuthFetcher::IsSecondFactorSuccess(response)); 361} 362 363TEST_F(GaiaAuthFetcherTest, TwoFactorLogin) { 364 std::string response = base::StringPrintf("Error=BadAuthentication\n%s\n", 365 GaiaAuthFetcher::kSecondFactor); 366 367 GoogleServiceAuthError error = 368 GoogleServiceAuthError(GoogleServiceAuthError::TWO_FACTOR); 369 370 MockGaiaConsumer consumer; 371 EXPECT_CALL(consumer, OnClientLoginFailure(error)) 372 .Times(1); 373 374 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 375 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 376 MockFetcher mock_fetcher( 377 client_login_source_, status, net::HTTP_FORBIDDEN, cookies_, response, 378 net::URLFetcher::GET, &auth); 379 auth.OnURLFetchComplete(&mock_fetcher); 380} 381 382TEST_F(GaiaAuthFetcherTest, CaptchaParse) { 383 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 384 std::string data = "Url=http://www.google.com/login/captcha\n" 385 "Error=CaptchaRequired\n" 386 "CaptchaToken=CCTOKEN\n" 387 "CaptchaUrl=Captcha?ctoken=CCTOKEN\n"; 388 GoogleServiceAuthError error = 389 GaiaAuthFetcher::GenerateAuthError(data, status); 390 391 std::string token = "CCTOKEN"; 392 GURL image_url("http://accounts.google.com/Captcha?ctoken=CCTOKEN"); 393 GURL unlock_url("http://www.google.com/login/captcha"); 394 395 EXPECT_EQ(error.state(), GoogleServiceAuthError::CAPTCHA_REQUIRED); 396 EXPECT_EQ(error.captcha().token, token); 397 EXPECT_EQ(error.captcha().image_url, image_url); 398 EXPECT_EQ(error.captcha().unlock_url, unlock_url); 399} 400 401TEST_F(GaiaAuthFetcherTest, AccountDeletedError) { 402 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 403 std::string data = "Error=AccountDeleted\n"; 404 GoogleServiceAuthError error = 405 GaiaAuthFetcher::GenerateAuthError(data, status); 406 EXPECT_EQ(error.state(), GoogleServiceAuthError::ACCOUNT_DELETED); 407} 408 409TEST_F(GaiaAuthFetcherTest, AccountDisabledError) { 410 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 411 std::string data = "Error=AccountDisabled\n"; 412 GoogleServiceAuthError error = 413 GaiaAuthFetcher::GenerateAuthError(data, status); 414 EXPECT_EQ(error.state(), GoogleServiceAuthError::ACCOUNT_DISABLED); 415} 416 417TEST_F(GaiaAuthFetcherTest,BadAuthenticationError) { 418 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 419 std::string data = "Error=BadAuthentication\n"; 420 GoogleServiceAuthError error = 421 GaiaAuthFetcher::GenerateAuthError(data, status); 422 EXPECT_EQ(error.state(), GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS); 423} 424 425TEST_F(GaiaAuthFetcherTest,IncomprehensibleError) { 426 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 427 std::string data = "Error=Gobbledygook\n"; 428 GoogleServiceAuthError error = 429 GaiaAuthFetcher::GenerateAuthError(data, status); 430 EXPECT_EQ(error.state(), GoogleServiceAuthError::SERVICE_UNAVAILABLE); 431} 432 433TEST_F(GaiaAuthFetcherTest,ServiceUnavailableError) { 434 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 435 std::string data = "Error=ServiceUnavailable\n"; 436 GoogleServiceAuthError error = 437 GaiaAuthFetcher::GenerateOAuthLoginError(data, status); 438 EXPECT_EQ(error.state(), GoogleServiceAuthError::SERVICE_UNAVAILABLE); 439} 440 441TEST_F(GaiaAuthFetcherTest, OAuthAccountDeletedError) { 442 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 443 std::string data = "Error=adel\n"; 444 GoogleServiceAuthError error = 445 GaiaAuthFetcher::GenerateOAuthLoginError(data, status); 446 EXPECT_EQ(error.state(), GoogleServiceAuthError::ACCOUNT_DELETED); 447} 448 449TEST_F(GaiaAuthFetcherTest, OAuthAccountDisabledError) { 450 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 451 std::string data = "Error=adis\n"; 452 GoogleServiceAuthError error = 453 GaiaAuthFetcher::GenerateOAuthLoginError(data, status); 454 EXPECT_EQ(error.state(), GoogleServiceAuthError::ACCOUNT_DISABLED); 455} 456 457TEST_F(GaiaAuthFetcherTest, OAuthBadAuthenticationError) { 458 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 459 std::string data = "Error=badauth\n"; 460 GoogleServiceAuthError error = 461 GaiaAuthFetcher::GenerateOAuthLoginError(data, status); 462 EXPECT_EQ(error.state(), GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS); 463} 464 465TEST_F(GaiaAuthFetcherTest, OAuthServiceUnavailableError) { 466 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 467 std::string data = "Error=ire\n"; 468 GoogleServiceAuthError error = 469 GaiaAuthFetcher::GenerateOAuthLoginError(data, status); 470 EXPECT_EQ(error.state(), GoogleServiceAuthError::SERVICE_UNAVAILABLE); 471} 472 473TEST_F(GaiaAuthFetcherTest, FullLogin) { 474 MockGaiaConsumer consumer; 475 EXPECT_CALL(consumer, OnClientLoginSuccess(_)) 476 .Times(1); 477 478 MockURLFetcherFactory<MockFetcher> factory; 479 480 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 481 auth.StartClientLogin("username", 482 "password", 483 "service", 484 std::string(), 485 std::string(), 486 GaiaAuthFetcher::HostedAccountsAllowed); 487} 488 489TEST_F(GaiaAuthFetcherTest, FullLoginFailure) { 490 MockGaiaConsumer consumer; 491 EXPECT_CALL(consumer, OnClientLoginFailure(_)) 492 .Times(1); 493 494 MockURLFetcherFactory<MockFetcher> factory; 495 factory.set_success(false); 496 497 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 498 auth.StartClientLogin("username", 499 "password", 500 "service", 501 std::string(), 502 std::string(), 503 GaiaAuthFetcher::HostedAccountsAllowed); 504} 505 506TEST_F(GaiaAuthFetcherTest, ClientFetchPending) { 507 MockGaiaConsumer consumer; 508 EXPECT_CALL(consumer, OnClientLoginSuccess(_)) 509 .Times(1); 510 511 net::TestURLFetcherFactory factory; 512 513 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 514 auth.StartClientLogin("username", 515 "password", 516 "service", 517 std::string(), 518 std::string(), 519 GaiaAuthFetcher::HostedAccountsAllowed); 520 521 EXPECT_TRUE(auth.HasPendingFetch()); 522 MockFetcher mock_fetcher( 523 client_login_source_, 524 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 525 net::HTTP_OK, cookies_, "SID=sid\nLSID=lsid\nAuth=auth\n", 526 net::URLFetcher::GET, &auth); 527 auth.OnURLFetchComplete(&mock_fetcher); 528 EXPECT_FALSE(auth.HasPendingFetch()); 529} 530 531TEST_F(GaiaAuthFetcherTest, FullTokenSuccess) { 532 MockGaiaConsumer consumer; 533 EXPECT_CALL(consumer, OnIssueAuthTokenSuccess("service", "token")) 534 .Times(1); 535 536 net::TestURLFetcherFactory factory; 537 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 538 auth.StartIssueAuthToken("sid", "lsid", "service"); 539 540 EXPECT_TRUE(auth.HasPendingFetch()); 541 MockFetcher mock_fetcher( 542 issue_auth_token_source_, 543 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 544 net::HTTP_OK, cookies_, "token", 545 net::URLFetcher::GET, &auth); 546 auth.OnURLFetchComplete(&mock_fetcher); 547 EXPECT_FALSE(auth.HasPendingFetch()); 548} 549 550TEST_F(GaiaAuthFetcherTest, FullTokenFailure) { 551 MockGaiaConsumer consumer; 552 EXPECT_CALL(consumer, OnIssueAuthTokenFailure("service", _)) 553 .Times(1); 554 555 net::TestURLFetcherFactory factory; 556 557 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 558 auth.StartIssueAuthToken("sid", "lsid", "service"); 559 560 EXPECT_TRUE(auth.HasPendingFetch()); 561 MockFetcher mock_fetcher( 562 issue_auth_token_source_, 563 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 564 net::HTTP_FORBIDDEN, 565 cookies_, 566 std::string(), 567 net::URLFetcher::GET, 568 &auth); 569 auth.OnURLFetchComplete(&mock_fetcher); 570 EXPECT_FALSE(auth.HasPendingFetch()); 571} 572 573TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenSuccess) { 574 MockGaiaConsumer consumer; 575 EXPECT_CALL(consumer, OnClientOAuthSuccess( 576 GaiaAuthConsumer::ClientOAuthResult("rt1", "at1", 3600))).Times(1); 577 578 net::TestURLFetcherFactory factory; 579 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 580 auth.StartLsoForOAuthLoginTokenExchange("lso_token"); 581 net::TestURLFetcher* fetcher = factory.GetFetcherByID(0); 582 EXPECT_TRUE(NULL != fetcher); 583 EXPECT_EQ(net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES, 584 fetcher->GetLoadFlags()); 585 586 net::ResponseCookies cookies; 587 cookies.push_back(kGetAuthCodeValidCookie); 588 EXPECT_TRUE(auth.HasPendingFetch()); 589 MockFetcher mock_fetcher1( 590 client_login_to_oauth2_source_, 591 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 592 net::HTTP_OK, 593 cookies, 594 std::string(), 595 net::URLFetcher::POST, 596 &auth); 597 auth.OnURLFetchComplete(&mock_fetcher1); 598 EXPECT_TRUE(auth.HasPendingFetch()); 599 MockFetcher mock_fetcher2( 600 oauth2_token_source_, 601 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 602 net::HTTP_OK, cookies_, kGetTokenPairValidResponse, 603 net::URLFetcher::POST, &auth); 604 auth.OnURLFetchComplete(&mock_fetcher2); 605 EXPECT_FALSE(auth.HasPendingFetch()); 606} 607 608TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenWithCookies) { 609 MockGaiaConsumer consumer; 610 net::TestURLFetcherFactory factory; 611 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 612 auth.StartCookieForOAuthLoginTokenExchange("0"); 613 net::TestURLFetcher* fetcher = factory.GetFetcherByID(0); 614 EXPECT_TRUE(NULL != fetcher); 615 EXPECT_EQ(net::LOAD_NORMAL, fetcher->GetLoadFlags()); 616} 617 618TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenClientLoginToOAuth2Failure) { 619 MockGaiaConsumer consumer; 620 EXPECT_CALL(consumer, OnClientOAuthFailure(_)) 621 .Times(1); 622 623 net::TestURLFetcherFactory factory; 624 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 625 auth.StartLsoForOAuthLoginTokenExchange("lso_token"); 626 627 net::ResponseCookies cookies; 628 EXPECT_TRUE(auth.HasPendingFetch()); 629 MockFetcher mock_fetcher( 630 client_login_to_oauth2_source_, 631 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 632 net::HTTP_FORBIDDEN, 633 cookies, 634 std::string(), 635 net::URLFetcher::POST, 636 &auth); 637 auth.OnURLFetchComplete(&mock_fetcher); 638 EXPECT_FALSE(auth.HasPendingFetch()); 639} 640 641TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenOAuth2TokenPairFailure) { 642 MockGaiaConsumer consumer; 643 EXPECT_CALL(consumer, OnClientOAuthFailure(_)) 644 .Times(1); 645 646 net::TestURLFetcherFactory factory; 647 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 648 auth.StartLsoForOAuthLoginTokenExchange("lso_token"); 649 650 net::ResponseCookies cookies; 651 cookies.push_back(kGetAuthCodeValidCookie); 652 EXPECT_TRUE(auth.HasPendingFetch()); 653 MockFetcher mock_fetcher1( 654 client_login_to_oauth2_source_, 655 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 656 net::HTTP_OK, 657 cookies, 658 std::string(), 659 net::URLFetcher::POST, 660 &auth); 661 auth.OnURLFetchComplete(&mock_fetcher1); 662 EXPECT_TRUE(auth.HasPendingFetch()); 663 MockFetcher mock_fetcher2( 664 oauth2_token_source_, 665 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 666 net::HTTP_FORBIDDEN, 667 cookies_, 668 std::string(), 669 net::URLFetcher::POST, 670 &auth); 671 auth.OnURLFetchComplete(&mock_fetcher2); 672 EXPECT_FALSE(auth.HasPendingFetch()); 673} 674 675TEST_F(GaiaAuthFetcherTest, MergeSessionSuccess) { 676 MockGaiaConsumer consumer; 677 EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>")) 678 .Times(1); 679 680 net::TestURLFetcherFactory factory; 681 682 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 683 auth.StartMergeSession("myubertoken"); 684 685 EXPECT_TRUE(auth.HasPendingFetch()); 686 MockFetcher mock_fetcher( 687 merge_session_source_, 688 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 689 net::HTTP_OK, cookies_, "<html></html>", net::URLFetcher::GET, 690 &auth); 691 auth.OnURLFetchComplete(&mock_fetcher); 692 EXPECT_FALSE(auth.HasPendingFetch()); 693} 694 695TEST_F(GaiaAuthFetcherTest, MergeSessionSuccessRedirect) { 696 MockGaiaConsumer consumer; 697 EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>")) 698 .Times(1); 699 700 net::TestURLFetcherFactory factory; 701 702 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 703 auth.StartMergeSession("myubertoken"); 704 705 // Make sure the fetcher created has the expected flags. Set its url() 706 // properties to reflect a redirect. 707 net::TestURLFetcher* test_fetcher = factory.GetFetcherByID(0); 708 EXPECT_TRUE(test_fetcher != NULL); 709 EXPECT_TRUE(test_fetcher->GetLoadFlags() == net::LOAD_NORMAL); 710 EXPECT_TRUE(auth.HasPendingFetch()); 711 712 GURL final_url("http://www.google.com/CheckCookie"); 713 test_fetcher->set_url(final_url); 714 test_fetcher->set_status( 715 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0)); 716 test_fetcher->set_response_code(net::HTTP_OK); 717 test_fetcher->set_cookies(cookies_); 718 test_fetcher->SetResponseString("<html></html>"); 719 720 auth.OnURLFetchComplete(test_fetcher); 721 EXPECT_FALSE(auth.HasPendingFetch()); 722} 723 724TEST_F(GaiaAuthFetcherTest, UberAuthTokenSuccess) { 725 MockGaiaConsumer consumer; 726 EXPECT_CALL(consumer, OnUberAuthTokenSuccess("uberToken")) 727 .Times(1); 728 729 net::TestURLFetcherFactory factory; 730 731 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 732 auth.StartTokenFetchForUberAuthExchange("myAccessToken"); 733 734 EXPECT_TRUE(auth.HasPendingFetch()); 735 MockFetcher mock_fetcher( 736 uberauth_token_source_, 737 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0), 738 net::HTTP_OK, cookies_, "uberToken", net::URLFetcher::POST, 739 &auth); 740 auth.OnURLFetchComplete(&mock_fetcher); 741 EXPECT_FALSE(auth.HasPendingFetch()); 742} 743 744TEST_F(GaiaAuthFetcherTest, ParseClientLoginToOAuth2Response) { 745 { // No cookies. 746 std::string auth_code; 747 net::ResponseCookies cookies; 748 EXPECT_FALSE(GaiaAuthFetcher::ParseClientLoginToOAuth2Response( 749 cookies, &auth_code)); 750 EXPECT_EQ("", auth_code); 751 } 752 { // Few cookies, nothing appropriate. 753 std::string auth_code; 754 net::ResponseCookies cookies; 755 cookies.push_back(kGetAuthCodeCookieNoSecure); 756 cookies.push_back(kGetAuthCodeCookieNoHttpOnly); 757 cookies.push_back(kGetAuthCodeCookieNoOAuthCode); 758 EXPECT_FALSE(GaiaAuthFetcher::ParseClientLoginToOAuth2Response( 759 cookies, &auth_code)); 760 EXPECT_EQ("", auth_code); 761 } 762 { // Few cookies, one of them is valid. 763 std::string auth_code; 764 net::ResponseCookies cookies; 765 cookies.push_back(kGetAuthCodeCookieNoSecure); 766 cookies.push_back(kGetAuthCodeCookieNoHttpOnly); 767 cookies.push_back(kGetAuthCodeCookieNoOAuthCode); 768 cookies.push_back(kGetAuthCodeValidCookie); 769 EXPECT_TRUE(GaiaAuthFetcher::ParseClientLoginToOAuth2Response( 770 cookies, &auth_code)); 771 EXPECT_EQ("test-code", auth_code); 772 } 773 { // Single valid cookie (like in real responses). 774 std::string auth_code; 775 net::ResponseCookies cookies; 776 cookies.push_back(kGetAuthCodeValidCookie); 777 EXPECT_TRUE(GaiaAuthFetcher::ParseClientLoginToOAuth2Response( 778 cookies, &auth_code)); 779 EXPECT_EQ("test-code", auth_code); 780 } 781} 782 783TEST_F(GaiaAuthFetcherTest, StartOAuthLogin) { 784 // OAuthLogin returns the same as the ClientLogin endpoint, minus CAPTCHA 785 // responses. 786 std::string data("SID=sid\nLSID=lsid\nAuth=auth\n"); 787 788 GaiaAuthConsumer::ClientLoginResult result; 789 result.lsid = "lsid"; 790 result.sid = "sid"; 791 result.token = "auth"; 792 result.data = data; 793 794 MockGaiaConsumer consumer; 795 EXPECT_CALL(consumer, OnClientLoginSuccess(result)) 796 .Times(1); 797 798 GaiaAuthFetcher auth(&consumer, std::string(), GetRequestContext()); 799 net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0); 800 MockFetcher mock_fetcher( 801 oauth_login_gurl_, status, net::HTTP_OK, cookies_, data, 802 net::URLFetcher::GET, &auth); 803 auth.OnURLFetchComplete(&mock_fetcher); 804} 805