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