1// Copyright 2013 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#include <string> 6 7#include "base/message_loop/message_loop.h" 8#include "base/run_loop.h" 9#include "google_apis/gaia/gaia_constants.h" 10#include "google_apis/gaia/google_service_auth_error.h" 11#include "google_apis/gaia/oauth2_access_token_consumer.h" 12#include "google_apis/gaia/oauth2_access_token_fetcher_impl.h" 13#include "google_apis/gaia/oauth2_token_service.h" 14#include "google_apis/gaia/oauth2_token_service_test_util.h" 15#include "net/http/http_status_code.h" 16#include "net/url_request/test_url_fetcher_factory.h" 17#include "net/url_request/url_fetcher_delegate.h" 18#include "net/url_request/url_request_test_util.h" 19#include "testing/gtest/include/gtest/gtest.h" 20 21// A testing consumer that retries on error. 22class RetryingTestingOAuth2TokenServiceConsumer 23 : public TestingOAuth2TokenServiceConsumer { 24 public: 25 RetryingTestingOAuth2TokenServiceConsumer( 26 OAuth2TokenService* oauth2_service, 27 const std::string& account_id) 28 : oauth2_service_(oauth2_service), 29 account_id_(account_id) {} 30 virtual ~RetryingTestingOAuth2TokenServiceConsumer() {} 31 32 virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request, 33 const GoogleServiceAuthError& error) OVERRIDE { 34 TestingOAuth2TokenServiceConsumer::OnGetTokenFailure(request, error); 35 request_.reset(oauth2_service_->StartRequest( 36 account_id_, OAuth2TokenService::ScopeSet(), this).release()); 37 } 38 39 OAuth2TokenService* oauth2_service_; 40 std::string account_id_; 41 scoped_ptr<OAuth2TokenService::Request> request_; 42}; 43 44class TestOAuth2TokenService : public OAuth2TokenService { 45 public: 46 explicit TestOAuth2TokenService(net::TestURLRequestContextGetter* getter) 47 : request_context_getter_(getter) { 48 } 49 50 void CancelAllRequestsForTest() { CancelAllRequests(); } 51 52 void CancelRequestsForAccountForTest(const std::string& account_id) { 53 CancelRequestsForAccount(account_id); 54 } 55 56 // For testing: set the refresh token to be used. 57 void set_refresh_token(const std::string& account_id, 58 const std::string& refresh_token) { 59 if (refresh_token.empty()) 60 refresh_tokens_.erase(account_id); 61 else 62 refresh_tokens_[account_id] = refresh_token; 63 } 64 65 virtual bool RefreshTokenIsAvailable(const std::string& account_id) const 66 OVERRIDE { 67 std::map<std::string, std::string>::const_iterator it = 68 refresh_tokens_.find(account_id); 69 70 return it != refresh_tokens_.end(); 71 }; 72 73 private: 74 // OAuth2TokenService implementation. 75 virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE { 76 return request_context_getter_.get(); 77 } 78 79 virtual OAuth2AccessTokenFetcher* CreateAccessTokenFetcher( 80 const std::string& account_id, 81 net::URLRequestContextGetter* getter, 82 OAuth2AccessTokenConsumer* consumer) OVERRIDE { 83 std::map<std::string, std::string>::const_iterator it = 84 refresh_tokens_.find(account_id); 85 DCHECK(it != refresh_tokens_.end()); 86 std::string refresh_token(it->second); 87 return new OAuth2AccessTokenFetcherImpl(consumer, getter, refresh_token); 88 }; 89 90 std::map<std::string, std::string> refresh_tokens_; 91 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; 92}; 93 94class OAuth2TokenServiceTest : public testing::Test { 95 public: 96 virtual void SetUp() OVERRIDE { 97 oauth2_service_.reset( 98 new TestOAuth2TokenService(new net::TestURLRequestContextGetter( 99 message_loop_.message_loop_proxy()))); 100 account_id_ = "test_user@gmail.com"; 101 } 102 103 virtual void TearDown() OVERRIDE { 104 // Makes sure that all the clean up tasks are run. 105 base::RunLoop().RunUntilIdle(); 106 } 107 108 protected: 109 base::MessageLoopForIO message_loop_; // net:: stuff needs IO message loop. 110 net::TestURLFetcherFactory factory_; 111 scoped_ptr<TestOAuth2TokenService> oauth2_service_; 112 std::string account_id_; 113 TestingOAuth2TokenServiceConsumer consumer_; 114}; 115 116TEST_F(OAuth2TokenServiceTest, NoOAuth2RefreshToken) { 117 scoped_ptr<OAuth2TokenService::Request> request( 118 oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(), 119 &consumer_)); 120 base::RunLoop().RunUntilIdle(); 121 122 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 123 EXPECT_EQ(1, consumer_.number_of_errors_); 124} 125 126TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) { 127 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 128 scoped_ptr<OAuth2TokenService::Request> request( 129 oauth2_service_->StartRequest(account_id_, 130 OAuth2TokenService::ScopeSet(), 131 &consumer_)); 132 base::RunLoop().RunUntilIdle(); 133 134 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 135 EXPECT_EQ(0, consumer_.number_of_errors_); 136 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 137 ASSERT_TRUE(fetcher); 138 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 139 fetcher->SetResponseString(std::string()); 140 fetcher->delegate()->OnURLFetchComplete(fetcher); 141 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 142 EXPECT_EQ(1, consumer_.number_of_errors_); 143 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 144} 145 146TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) { 147 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 148 scoped_ptr<OAuth2TokenService::Request> request( 149 oauth2_service_->StartRequest(account_id_, 150 OAuth2TokenService::ScopeSet(), 151 &consumer_)); 152 base::RunLoop().RunUntilIdle(); 153 154 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 155 EXPECT_EQ(0, consumer_.number_of_errors_); 156 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 157 ASSERT_TRUE(fetcher); 158 fetcher->set_response_code(net::HTTP_OK); 159 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 160 fetcher->delegate()->OnURLFetchComplete(fetcher); 161 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 162 EXPECT_EQ(0, consumer_.number_of_errors_); 163 EXPECT_EQ("token", consumer_.last_token_); 164} 165 166TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) { 167 OAuth2TokenService::ScopeSet scopes1; 168 scopes1.insert("s1"); 169 scopes1.insert("s2"); 170 OAuth2TokenService::ScopeSet scopes1_same; 171 scopes1_same.insert("s2"); 172 scopes1_same.insert("s1"); 173 OAuth2TokenService::ScopeSet scopes2; 174 scopes2.insert("s3"); 175 176 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 177 178 // First request. 179 scoped_ptr<OAuth2TokenService::Request> request( 180 oauth2_service_->StartRequest(account_id_, scopes1, &consumer_)); 181 base::RunLoop().RunUntilIdle(); 182 183 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 184 EXPECT_EQ(0, consumer_.number_of_errors_); 185 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 186 ASSERT_TRUE(fetcher); 187 fetcher->set_response_code(net::HTTP_OK); 188 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 189 fetcher->delegate()->OnURLFetchComplete(fetcher); 190 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 191 EXPECT_EQ(0, consumer_.number_of_errors_); 192 EXPECT_EQ("token", consumer_.last_token_); 193 194 // Second request to the same set of scopes, should return the same token 195 // without needing a network request. 196 scoped_ptr<OAuth2TokenService::Request> request2( 197 oauth2_service_->StartRequest(account_id_, scopes1_same, &consumer_)); 198 base::RunLoop().RunUntilIdle(); 199 200 // No new network fetcher. 201 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 202 EXPECT_EQ(0, consumer_.number_of_errors_); 203 EXPECT_EQ("token", consumer_.last_token_); 204 205 // Third request to a new set of scopes, should return another token. 206 scoped_ptr<OAuth2TokenService::Request> request3( 207 oauth2_service_->StartRequest(account_id_, scopes2, &consumer_)); 208 base::RunLoop().RunUntilIdle(); 209 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 210 EXPECT_EQ(0, consumer_.number_of_errors_); 211 fetcher = factory_.GetFetcherByID(0); 212 ASSERT_TRUE(fetcher); 213 fetcher->set_response_code(net::HTTP_OK); 214 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 215 fetcher->delegate()->OnURLFetchComplete(fetcher); 216 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 217 EXPECT_EQ(0, consumer_.number_of_errors_); 218 EXPECT_EQ("token2", consumer_.last_token_); 219} 220 221TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) { 222 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 223 224 // First request. 225 scoped_ptr<OAuth2TokenService::Request> request( 226 oauth2_service_->StartRequest(account_id_, 227 OAuth2TokenService::ScopeSet(), 228 &consumer_)); 229 base::RunLoop().RunUntilIdle(); 230 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 231 EXPECT_EQ(0, consumer_.number_of_errors_); 232 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 233 ASSERT_TRUE(fetcher); 234 fetcher->set_response_code(net::HTTP_OK); 235 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 236 fetcher->delegate()->OnURLFetchComplete(fetcher); 237 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 238 EXPECT_EQ(0, consumer_.number_of_errors_); 239 EXPECT_EQ("token", consumer_.last_token_); 240 241 // Second request must try to access the network as the token has expired. 242 scoped_ptr<OAuth2TokenService::Request> request2( 243 oauth2_service_->StartRequest(account_id_, 244 OAuth2TokenService::ScopeSet(), 245 &consumer_)); 246 base::RunLoop().RunUntilIdle(); 247 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 248 EXPECT_EQ(0, consumer_.number_of_errors_); 249 250 // Network failure. 251 fetcher = factory_.GetFetcherByID(0); 252 ASSERT_TRUE(fetcher); 253 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 254 fetcher->SetResponseString(std::string()); 255 fetcher->delegate()->OnURLFetchComplete(fetcher); 256 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 257 EXPECT_EQ(1, consumer_.number_of_errors_); 258} 259 260TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) { 261 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 262 263 // First request. 264 scoped_ptr<OAuth2TokenService::Request> request( 265 oauth2_service_->StartRequest(account_id_, 266 OAuth2TokenService::ScopeSet(), 267 &consumer_)); 268 base::RunLoop().RunUntilIdle(); 269 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 270 EXPECT_EQ(0, consumer_.number_of_errors_); 271 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 272 ASSERT_TRUE(fetcher); 273 fetcher->set_response_code(net::HTTP_OK); 274 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 275 fetcher->delegate()->OnURLFetchComplete(fetcher); 276 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 277 EXPECT_EQ(0, consumer_.number_of_errors_); 278 EXPECT_EQ("token", consumer_.last_token_); 279 280 // Second request must try to access the network as the token has expired. 281 scoped_ptr<OAuth2TokenService::Request> request2( 282 oauth2_service_->StartRequest(account_id_, 283 OAuth2TokenService::ScopeSet(), 284 &consumer_)); 285 base::RunLoop().RunUntilIdle(); 286 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 287 EXPECT_EQ(0, consumer_.number_of_errors_); 288 289 fetcher = factory_.GetFetcherByID(0); 290 ASSERT_TRUE(fetcher); 291 fetcher->set_response_code(net::HTTP_OK); 292 fetcher->SetResponseString(GetValidTokenResponse("another token", 0)); 293 fetcher->delegate()->OnURLFetchComplete(fetcher); 294 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 295 EXPECT_EQ(0, consumer_.number_of_errors_); 296 EXPECT_EQ("another token", consumer_.last_token_); 297} 298 299TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) { 300 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 301 302 scoped_ptr<OAuth2TokenService::Request> request( 303 oauth2_service_->StartRequest(account_id_, 304 OAuth2TokenService::ScopeSet(), 305 &consumer_)); 306 base::RunLoop().RunUntilIdle(); 307 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 308 EXPECT_EQ(0, consumer_.number_of_errors_); 309 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 310 ASSERT_TRUE(fetcher); 311 312 request.reset(); 313 314 fetcher->set_response_code(net::HTTP_OK); 315 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 316 fetcher->delegate()->OnURLFetchComplete(fetcher); 317 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 318 EXPECT_EQ(0, consumer_.number_of_errors_); 319} 320 321TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) { 322 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 323 324 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 325 account_id_, OAuth2TokenService::ScopeSet(), &consumer_)); 326 base::RunLoop().RunUntilIdle(); 327 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 328 ASSERT_TRUE(fetcher); 329 fetcher->set_response_code(net::HTTP_OK); 330 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 331 fetcher->delegate()->OnURLFetchComplete(fetcher); 332 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 333 EXPECT_EQ(0, consumer_.number_of_errors_); 334 EXPECT_EQ("token", consumer_.last_token_); 335 336 request.reset(); 337 338 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 339 EXPECT_EQ(0, consumer_.number_of_errors_); 340 EXPECT_EQ("token", consumer_.last_token_); 341} 342 343TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) { 344 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 345 346 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 347 account_id_, OAuth2TokenService::ScopeSet(), &consumer_)); 348 base::RunLoop().RunUntilIdle(); 349 scoped_ptr<OAuth2TokenService::Request> request2( 350 oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(), 351 &consumer_)); 352 base::RunLoop().RunUntilIdle(); 353 354 request.reset(); 355 356 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 357 ASSERT_TRUE(fetcher); 358 fetcher->set_response_code(net::HTTP_OK); 359 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 360 fetcher->delegate()->OnURLFetchComplete(fetcher); 361 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 362 EXPECT_EQ(0, consumer_.number_of_errors_); 363} 364 365TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) { 366 // We have a valid refresh token; the first request is successful. 367 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 368 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 369 account_id_, OAuth2TokenService::ScopeSet(), &consumer_)); 370 base::RunLoop().RunUntilIdle(); 371 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 372 ASSERT_TRUE(fetcher); 373 fetcher->set_response_code(net::HTTP_OK); 374 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 375 fetcher->delegate()->OnURLFetchComplete(fetcher); 376 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 377 EXPECT_EQ(0, consumer_.number_of_errors_); 378 EXPECT_EQ("token", consumer_.last_token_); 379 380 // The refresh token is no longer available; subsequent requests fail. 381 oauth2_service_->set_refresh_token(account_id_, ""); 382 request = oauth2_service_->StartRequest(account_id_, 383 OAuth2TokenService::ScopeSet(), &consumer_); 384 base::RunLoop().RunUntilIdle(); 385 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 386 EXPECT_EQ(1, consumer_.number_of_errors_); 387} 388 389TEST_F(OAuth2TokenServiceTest, 390 ChangedRefreshTokenDoesNotAffectInFlightRequests) { 391 oauth2_service_->set_refresh_token(account_id_, "first refreshToken"); 392 OAuth2TokenService::ScopeSet scopes; 393 scopes.insert("s1"); 394 scopes.insert("s2"); 395 OAuth2TokenService::ScopeSet scopes1; 396 scopes.insert("s3"); 397 scopes.insert("s4"); 398 399 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 400 account_id_, scopes, &consumer_)); 401 base::RunLoop().RunUntilIdle(); 402 net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0); 403 ASSERT_TRUE(fetcher1); 404 405 // Note |request| is still pending when the refresh token changes. 406 oauth2_service_->set_refresh_token(account_id_, "second refreshToken"); 407 408 // A 2nd request (using the new refresh token) that occurs and completes 409 // while the 1st request is in flight is successful. 410 TestingOAuth2TokenServiceConsumer consumer2; 411 scoped_ptr<OAuth2TokenService::Request> request2( 412 oauth2_service_->StartRequest(account_id_, scopes1, &consumer2)); 413 base::RunLoop().RunUntilIdle(); 414 415 net::TestURLFetcher* fetcher2 = factory_.GetFetcherByID(0); 416 fetcher2->set_response_code(net::HTTP_OK); 417 fetcher2->SetResponseString(GetValidTokenResponse("second token", 3600)); 418 fetcher2->delegate()->OnURLFetchComplete(fetcher2); 419 EXPECT_EQ(1, consumer2.number_of_successful_tokens_); 420 EXPECT_EQ(0, consumer2.number_of_errors_); 421 EXPECT_EQ("second token", consumer2.last_token_); 422 423 fetcher1->set_response_code(net::HTTP_OK); 424 fetcher1->SetResponseString(GetValidTokenResponse("first token", 3600)); 425 fetcher1->delegate()->OnURLFetchComplete(fetcher1); 426 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 427 EXPECT_EQ(0, consumer_.number_of_errors_); 428 EXPECT_EQ("first token", consumer_.last_token_); 429} 430 431TEST_F(OAuth2TokenServiceTest, ServiceShutDownBeforeFetchComplete) { 432 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 433 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 434 account_id_, OAuth2TokenService::ScopeSet(), &consumer_)); 435 base::RunLoop().RunUntilIdle(); 436 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 437 EXPECT_EQ(0, consumer_.number_of_errors_); 438 439 // The destructor should cancel all in-flight fetchers. 440 oauth2_service_.reset(NULL); 441 442 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 443 EXPECT_EQ(1, consumer_.number_of_errors_); 444} 445 446TEST_F(OAuth2TokenServiceTest, RetryingConsumer) { 447 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 448 RetryingTestingOAuth2TokenServiceConsumer consumer(oauth2_service_.get(), 449 account_id_); 450 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 451 account_id_, OAuth2TokenService::ScopeSet(), &consumer)); 452 base::RunLoop().RunUntilIdle(); 453 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 454 EXPECT_EQ(0, consumer.number_of_errors_); 455 456 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 457 ASSERT_TRUE(fetcher); 458 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 459 fetcher->SetResponseString(std::string()); 460 fetcher->delegate()->OnURLFetchComplete(fetcher); 461 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 462 EXPECT_EQ(1, consumer.number_of_errors_); 463 464 fetcher = factory_.GetFetcherByID(0); 465 ASSERT_TRUE(fetcher); 466 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 467 fetcher->SetResponseString(std::string()); 468 fetcher->delegate()->OnURLFetchComplete(fetcher); 469 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 470 EXPECT_EQ(2, consumer.number_of_errors_); 471} 472 473TEST_F(OAuth2TokenServiceTest, InvalidateToken) { 474 OAuth2TokenService::ScopeSet scopes; 475 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 476 477 // First request. 478 scoped_ptr<OAuth2TokenService::Request> request( 479 oauth2_service_->StartRequest(account_id_, scopes, &consumer_)); 480 base::RunLoop().RunUntilIdle(); 481 482 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 483 EXPECT_EQ(0, consumer_.number_of_errors_); 484 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 485 ASSERT_TRUE(fetcher); 486 fetcher->set_response_code(net::HTTP_OK); 487 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 488 fetcher->delegate()->OnURLFetchComplete(fetcher); 489 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 490 EXPECT_EQ(0, consumer_.number_of_errors_); 491 EXPECT_EQ("token", consumer_.last_token_); 492 493 // Second request, should return the same token without needing a network 494 // request. 495 scoped_ptr<OAuth2TokenService::Request> request2( 496 oauth2_service_->StartRequest(account_id_, scopes, &consumer_)); 497 base::RunLoop().RunUntilIdle(); 498 499 // No new network fetcher. 500 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 501 EXPECT_EQ(0, consumer_.number_of_errors_); 502 EXPECT_EQ("token", consumer_.last_token_); 503 504 // Invalidating the token should return a new token on the next request. 505 oauth2_service_->InvalidateToken(account_id_, scopes, consumer_.last_token_); 506 scoped_ptr<OAuth2TokenService::Request> request3( 507 oauth2_service_->StartRequest(account_id_, scopes, &consumer_)); 508 base::RunLoop().RunUntilIdle(); 509 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 510 EXPECT_EQ(0, consumer_.number_of_errors_); 511 fetcher = factory_.GetFetcherByID(0); 512 ASSERT_TRUE(fetcher); 513 fetcher->set_response_code(net::HTTP_OK); 514 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 515 fetcher->delegate()->OnURLFetchComplete(fetcher); 516 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 517 EXPECT_EQ(0, consumer_.number_of_errors_); 518 EXPECT_EQ("token2", consumer_.last_token_); 519} 520 521TEST_F(OAuth2TokenServiceTest, CancelAllRequests) { 522 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 523 scoped_ptr<OAuth2TokenService::Request> request( 524 oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(), 525 &consumer_)); 526 527 oauth2_service_->set_refresh_token("account_id_2", "refreshToken2"); 528 scoped_ptr<OAuth2TokenService::Request> request2( 529 oauth2_service_->StartRequest(account_id_, OAuth2TokenService::ScopeSet(), 530 &consumer_)); 531 532 base::RunLoop().RunUntilIdle(); 533 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 534 EXPECT_EQ(0, consumer_.number_of_errors_); 535 536 oauth2_service_->CancelAllRequestsForTest(); 537 538 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 539 EXPECT_EQ(2, consumer_.number_of_errors_); 540} 541 542TEST_F(OAuth2TokenServiceTest, CancelRequestsForAccount) { 543 OAuth2TokenService::ScopeSet scope_set_1; 544 scope_set_1.insert("scope1"); 545 scope_set_1.insert("scope2"); 546 OAuth2TokenService::ScopeSet scope_set_2(scope_set_1.begin(), 547 scope_set_1.end()); 548 scope_set_2.insert("scope3"); 549 550 oauth2_service_->set_refresh_token(account_id_, "refreshToken"); 551 scoped_ptr<OAuth2TokenService::Request> request1( 552 oauth2_service_->StartRequest(account_id_, scope_set_1, &consumer_)); 553 scoped_ptr<OAuth2TokenService::Request> request2( 554 oauth2_service_->StartRequest(account_id_, scope_set_2, &consumer_)); 555 556 std::string account_id_2("account_id_2"); 557 oauth2_service_->set_refresh_token(account_id_2, "refreshToken2"); 558 scoped_ptr<OAuth2TokenService::Request> request3( 559 oauth2_service_->StartRequest(account_id_2, scope_set_1, &consumer_)); 560 561 base::RunLoop().RunUntilIdle(); 562 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 563 EXPECT_EQ(0, consumer_.number_of_errors_); 564 565 oauth2_service_->CancelRequestsForAccountForTest(account_id_); 566 567 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 568 EXPECT_EQ(2, consumer_.number_of_errors_); 569 570 oauth2_service_->CancelRequestsForAccountForTest(account_id_2); 571 572 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 573 EXPECT_EQ(3, consumer_.number_of_errors_); 574} 575 576TEST_F(OAuth2TokenServiceTest, SameScopesRequestedForDifferentClients) { 577 std::string client_id_1("client1"); 578 std::string client_secret_1("secret1"); 579 std::string client_id_2("client2"); 580 std::string client_secret_2("secret2"); 581 std::set<std::string> scope_set; 582 scope_set.insert("scope1"); 583 scope_set.insert("scope2"); 584 585 std::string refresh_token("refreshToken"); 586 oauth2_service_->set_refresh_token(account_id_, refresh_token); 587 588 scoped_ptr<OAuth2TokenService::Request> request1( 589 oauth2_service_->StartRequestForClient(account_id_, 590 client_id_1, 591 client_secret_1, 592 scope_set, 593 &consumer_)); 594 scoped_ptr<OAuth2TokenService::Request> request2( 595 oauth2_service_->StartRequestForClient(account_id_, 596 client_id_2, 597 client_secret_2, 598 scope_set, 599 &consumer_)); 600 // Start a request that should be duplicate of |request1|. 601 scoped_ptr<OAuth2TokenService::Request> request3( 602 oauth2_service_->StartRequestForClient(account_id_, 603 client_id_1, 604 client_secret_1, 605 scope_set, 606 &consumer_)); 607 base::RunLoop().RunUntilIdle(); 608 609 ASSERT_EQ(2U, 610 oauth2_service_->GetNumPendingRequestsForTesting( 611 client_id_1, 612 account_id_, 613 scope_set)); 614 ASSERT_EQ(1U, 615 oauth2_service_->GetNumPendingRequestsForTesting( 616 client_id_2, 617 account_id_, 618 scope_set)); 619} 620 621TEST_F(OAuth2TokenServiceTest, RequestParametersOrderTest) { 622 OAuth2TokenService::ScopeSet set_0; 623 OAuth2TokenService::ScopeSet set_1; 624 set_1.insert("1"); 625 626 OAuth2TokenService::RequestParameters params[] = { 627 OAuth2TokenService::RequestParameters("0", "0", set_0), 628 OAuth2TokenService::RequestParameters("0", "0", set_1), 629 OAuth2TokenService::RequestParameters("0", "1", set_0), 630 OAuth2TokenService::RequestParameters("0", "1", set_1), 631 OAuth2TokenService::RequestParameters("1", "0", set_0), 632 OAuth2TokenService::RequestParameters("1", "0", set_1), 633 OAuth2TokenService::RequestParameters("1", "1", set_0), 634 OAuth2TokenService::RequestParameters("1", "1", set_1), 635 }; 636 637 for (size_t i = 0; i < arraysize(params); i++) { 638 for (size_t j = 0; j < arraysize(params); j++) { 639 if (i == j) { 640 EXPECT_FALSE(params[i] < params[j]) << " i=" << i << ", j=" << j; 641 EXPECT_FALSE(params[j] < params[i]) << " i=" << i << ", j=" << j; 642 } else if (i < j) { 643 EXPECT_TRUE(params[i] < params[j]) << " i=" << i << ", j=" << j; 644 EXPECT_FALSE(params[j] < params[i]) << " i=" << i << ", j=" << j; 645 } else { 646 EXPECT_TRUE(params[j] < params[i]) << " i=" << i << ", j=" << j; 647 EXPECT_FALSE(params[i] < params[j]) << " i=" << i << ", j=" << j; 648 } 649 } 650 } 651} 652