1// Copyright 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#include <string> 6 7#include "base/run_loop.h" 8#include "base/strings/stringprintf.h" 9#include "chrome/browser/chrome_notification_types.h" 10#include "chrome/browser/signin/oauth2_token_service.h" 11#include "chrome/browser/signin/oauth2_token_service_test_util.h" 12#include "chrome/browser/signin/token_service_factory.h" 13#include "chrome/browser/signin/token_service_unittest.h" 14#include "chrome/test/base/testing_browser_process.h" 15#include "content/public/browser/browser_thread.h" 16#include "google_apis/gaia/gaia_constants.h" 17#include "google_apis/gaia/google_service_auth_error.h" 18#include "google_apis/gaia/oauth2_access_token_consumer.h" 19#include "net/http/http_status_code.h" 20#include "net/url_request/test_url_fetcher_factory.h" 21#include "net/url_request/url_request_status.h" 22#include "net/url_request/url_request_test_util.h" 23#include "testing/gtest/include/gtest/gtest.h" 24 25using content::BrowserThread; 26 27// A testing consumer that retries on error. 28class RetryingTestingOAuth2TokenServiceConsumer 29 : public TestingOAuth2TokenServiceConsumer { 30 public: 31 RetryingTestingOAuth2TokenServiceConsumer( 32 OAuth2TokenService* oauth2_service) 33 : oauth2_service_(oauth2_service) {} 34 virtual ~RetryingTestingOAuth2TokenServiceConsumer() {} 35 36 virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request, 37 const GoogleServiceAuthError& error) OVERRIDE { 38 TestingOAuth2TokenServiceConsumer::OnGetTokenFailure(request, error); 39 request_.reset(oauth2_service_->StartRequest( 40 std::set<std::string>(), this).release()); 41 } 42 43 OAuth2TokenService* oauth2_service_; 44 scoped_ptr<OAuth2TokenService::Request> request_; 45}; 46 47class TestOAuth2TokenService : public OAuth2TokenService { 48 public: 49 explicit TestOAuth2TokenService(net::TestURLRequestContextGetter* getter) 50 : request_context_getter_(getter) { 51 } 52 53 void CancelAllRequestsForTest() { CancelAllRequests(); } 54 55 void CancelRequestsForTokenForTest(const std::string& refresh_token) { 56 CancelRequestsForToken(refresh_token); 57 } 58 59 // For testing: set the refresh token to be used. 60 void set_refresh_token(const std::string& refresh_token) { 61 refresh_token_ = refresh_token; 62 } 63 64 protected: 65 virtual std::string GetRefreshToken() OVERRIDE { return refresh_token_; } 66 67 private: 68 // OAuth2TokenService implementation. 69 virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE { 70 return request_context_getter_.get(); 71 } 72 73 std::string refresh_token_; 74 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; 75}; 76 77class OAuth2TokenServiceTest : public TokenServiceTestHarness { 78 public: 79 virtual void SetUp() OVERRIDE { 80 TokenServiceTestHarness::SetUp(); 81 oauth2_service_.reset( 82 new TestOAuth2TokenService(new net::TestURLRequestContextGetter( 83 BrowserThread::GetMessageLoopProxyForThread( 84 BrowserThread::IO)))); 85 } 86 87 protected: 88 net::TestURLFetcherFactory factory_; 89 scoped_ptr<TestOAuth2TokenService> oauth2_service_; 90 TestingOAuth2TokenServiceConsumer consumer_; 91}; 92 93TEST_F(OAuth2TokenServiceTest, NoOAuth2RefreshToken) { 94 scoped_ptr<OAuth2TokenService::Request> request( 95 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 96 base::RunLoop().RunUntilIdle(); 97 98 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 99 EXPECT_EQ(1, consumer_.number_of_errors_); 100} 101 102TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) { 103 oauth2_service_->set_refresh_token("refreshToken"); 104 scoped_ptr<OAuth2TokenService::Request> request( 105 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 106 base::RunLoop().RunUntilIdle(); 107 108 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 109 EXPECT_EQ(0, consumer_.number_of_errors_); 110 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 111 EXPECT_TRUE(fetcher); 112 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 113 fetcher->SetResponseString(std::string()); 114 fetcher->delegate()->OnURLFetchComplete(fetcher); 115 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 116 EXPECT_EQ(1, consumer_.number_of_errors_); 117 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 118} 119 120TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) { 121 oauth2_service_->set_refresh_token("refreshToken"); 122 scoped_ptr<OAuth2TokenService::Request> request( 123 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 124 base::RunLoop().RunUntilIdle(); 125 126 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 127 EXPECT_EQ(0, consumer_.number_of_errors_); 128 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 129 EXPECT_TRUE(fetcher); 130 fetcher->set_response_code(net::HTTP_OK); 131 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 132 fetcher->delegate()->OnURLFetchComplete(fetcher); 133 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 134 EXPECT_EQ(0, consumer_.number_of_errors_); 135 EXPECT_EQ("token", consumer_.last_token_); 136} 137 138TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) { 139 std::set<std::string> scopes1; 140 scopes1.insert("s1"); 141 scopes1.insert("s2"); 142 std::set<std::string> scopes1_same; 143 scopes1_same.insert("s2"); 144 scopes1_same.insert("s1"); 145 std::set<std::string> scopes2; 146 scopes2.insert("s3"); 147 148 oauth2_service_->set_refresh_token("refreshToken"); 149 150 // First request. 151 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 152 scopes1, &consumer_)); 153 base::RunLoop().RunUntilIdle(); 154 155 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 156 EXPECT_EQ(0, consumer_.number_of_errors_); 157 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 158 EXPECT_TRUE(fetcher); 159 fetcher->set_response_code(net::HTTP_OK); 160 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 161 fetcher->delegate()->OnURLFetchComplete(fetcher); 162 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 163 EXPECT_EQ(0, consumer_.number_of_errors_); 164 EXPECT_EQ("token", consumer_.last_token_); 165 166 // Second request to the same set of scopes, should return the same token 167 // without needing a network request. 168 scoped_ptr<OAuth2TokenService::Request> request2( 169 oauth2_service_->StartRequest(scopes1_same, &consumer_)); 170 base::RunLoop().RunUntilIdle(); 171 172 // No new network fetcher. 173 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 174 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 175 EXPECT_EQ(0, consumer_.number_of_errors_); 176 EXPECT_EQ("token", consumer_.last_token_); 177 178 // Third request to a new set of scopes, should return another token. 179 scoped_ptr<OAuth2TokenService::Request> request3( 180 oauth2_service_->StartRequest(scopes2, &consumer_)); 181 base::RunLoop().RunUntilIdle(); 182 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 183 EXPECT_EQ(0, consumer_.number_of_errors_); 184 fetcher = factory_.GetFetcherByID(0); 185 EXPECT_TRUE(fetcher); 186 fetcher->set_response_code(net::HTTP_OK); 187 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 188 fetcher->delegate()->OnURLFetchComplete(fetcher); 189 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 190 EXPECT_EQ(0, consumer_.number_of_errors_); 191 EXPECT_EQ("token2", consumer_.last_token_); 192} 193 194TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) { 195 oauth2_service_->set_refresh_token("refreshToken"); 196 197 // First request. 198 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 199 std::set<std::string>(), &consumer_)); 200 base::RunLoop().RunUntilIdle(); 201 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 202 EXPECT_EQ(0, consumer_.number_of_errors_); 203 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 204 EXPECT_TRUE(fetcher); 205 fetcher->set_response_code(net::HTTP_OK); 206 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 207 fetcher->delegate()->OnURLFetchComplete(fetcher); 208 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 209 EXPECT_EQ(0, consumer_.number_of_errors_); 210 EXPECT_EQ("token", consumer_.last_token_); 211 212 // Second request must try to access the network as the token has expired. 213 scoped_ptr<OAuth2TokenService::Request> request2( 214 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 215 base::RunLoop().RunUntilIdle(); 216 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 217 EXPECT_EQ(0, consumer_.number_of_errors_); 218 219 // Network failure. 220 fetcher = factory_.GetFetcherByID(0); 221 EXPECT_TRUE(fetcher); 222 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 223 fetcher->SetResponseString(std::string()); 224 fetcher->delegate()->OnURLFetchComplete(fetcher); 225 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 226 EXPECT_EQ(1, consumer_.number_of_errors_); 227} 228 229TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) { 230 oauth2_service_->set_refresh_token("refreshToken"); 231 232 // First request. 233 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 234 std::set<std::string>(), &consumer_)); 235 base::RunLoop().RunUntilIdle(); 236 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 237 EXPECT_EQ(0, consumer_.number_of_errors_); 238 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 239 EXPECT_TRUE(fetcher); 240 fetcher->set_response_code(net::HTTP_OK); 241 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 242 fetcher->delegate()->OnURLFetchComplete(fetcher); 243 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 244 EXPECT_EQ(0, consumer_.number_of_errors_); 245 EXPECT_EQ("token", consumer_.last_token_); 246 247 // Second request must try to access the network as the token has expired. 248 scoped_ptr<OAuth2TokenService::Request> request2( 249 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 250 base::RunLoop().RunUntilIdle(); 251 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 252 EXPECT_EQ(0, consumer_.number_of_errors_); 253 254 fetcher = factory_.GetFetcherByID(0); 255 EXPECT_TRUE(fetcher); 256 fetcher->set_response_code(net::HTTP_OK); 257 fetcher->SetResponseString(GetValidTokenResponse("another token", 0)); 258 fetcher->delegate()->OnURLFetchComplete(fetcher); 259 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 260 EXPECT_EQ(0, consumer_.number_of_errors_); 261 EXPECT_EQ("another token", consumer_.last_token_); 262} 263 264TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) { 265 oauth2_service_->set_refresh_token("refreshToken"); 266 267 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 268 std::set<std::string>(), &consumer_)); 269 base::RunLoop().RunUntilIdle(); 270 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 271 EXPECT_EQ(0, consumer_.number_of_errors_); 272 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 273 EXPECT_TRUE(fetcher); 274 275 request.reset(); 276 277 fetcher->set_response_code(net::HTTP_OK); 278 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 279 fetcher->delegate()->OnURLFetchComplete(fetcher); 280 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 281 EXPECT_EQ(0, consumer_.number_of_errors_); 282} 283 284TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) { 285 oauth2_service_->set_refresh_token("refreshToken"); 286 287 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 288 std::set<std::string>(), &consumer_)); 289 base::RunLoop().RunUntilIdle(); 290 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 291 fetcher->set_response_code(net::HTTP_OK); 292 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 293 fetcher->delegate()->OnURLFetchComplete(fetcher); 294 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 295 EXPECT_EQ(0, consumer_.number_of_errors_); 296 EXPECT_EQ("token", consumer_.last_token_); 297 298 request.reset(); 299 300 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 301 EXPECT_EQ(0, consumer_.number_of_errors_); 302 EXPECT_EQ("token", consumer_.last_token_); 303} 304 305TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) { 306 oauth2_service_->set_refresh_token("refreshToken"); 307 308 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 309 std::set<std::string>(), &consumer_)); 310 base::RunLoop().RunUntilIdle(); 311 scoped_ptr<OAuth2TokenService::Request> request2( 312 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 313 base::RunLoop().RunUntilIdle(); 314 315 request.reset(); 316 317 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 318 fetcher->set_response_code(net::HTTP_OK); 319 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 320 fetcher->delegate()->OnURLFetchComplete(fetcher); 321 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 322 EXPECT_EQ(0, consumer_.number_of_errors_); 323} 324 325TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) { 326 // We have a valid refresh token; the first request is successful. 327 oauth2_service_->set_refresh_token("refreshToken"); 328 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 329 std::set<std::string>(), &consumer_)); 330 base::RunLoop().RunUntilIdle(); 331 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 332 fetcher->set_response_code(net::HTTP_OK); 333 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 334 fetcher->delegate()->OnURLFetchComplete(fetcher); 335 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 336 EXPECT_EQ(0, consumer_.number_of_errors_); 337 EXPECT_EQ("token", consumer_.last_token_); 338 339 // The refresh token is no longer available; subsequent requests fail. 340 oauth2_service_->set_refresh_token(""); 341 request = oauth2_service_->StartRequest(std::set<std::string>(), &consumer_); 342 base::RunLoop().RunUntilIdle(); 343 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 344 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 345 EXPECT_EQ(1, consumer_.number_of_errors_); 346} 347 348TEST_F(OAuth2TokenServiceTest, 349 ChangedRefreshTokenDoesNotAffectInFlightRequests) { 350 oauth2_service_->set_refresh_token("first refreshToken"); 351 std::set<std::string> scopes; 352 scopes.insert("s1"); 353 scopes.insert("s2"); 354 355 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 356 scopes, &consumer_)); 357 base::RunLoop().RunUntilIdle(); 358 net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0); 359 360 // Note |request| is still pending when the refresh token changes. 361 oauth2_service_->set_refresh_token("second refreshToken"); 362 363 // A 2nd request (using the new refresh token) that occurs and completes 364 // while the 1st request is in flight is successful. 365 TestingOAuth2TokenServiceConsumer consumer2; 366 scoped_ptr<OAuth2TokenService::Request> request2( 367 oauth2_service_->StartRequest(scopes, &consumer2)); 368 base::RunLoop().RunUntilIdle(); 369 370 net::TestURLFetcher* fetcher2 = factory_.GetFetcherByID(0); 371 fetcher2->set_response_code(net::HTTP_OK); 372 fetcher2->SetResponseString(GetValidTokenResponse("second token", 3600)); 373 fetcher2->delegate()->OnURLFetchComplete(fetcher2); 374 EXPECT_EQ(1, consumer2.number_of_successful_tokens_); 375 EXPECT_EQ(0, consumer2.number_of_errors_); 376 EXPECT_EQ("second token", consumer2.last_token_); 377 378 fetcher1->set_response_code(net::HTTP_OK); 379 fetcher1->SetResponseString(GetValidTokenResponse("first token", 3600)); 380 fetcher1->delegate()->OnURLFetchComplete(fetcher1); 381 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 382 EXPECT_EQ(0, consumer_.number_of_errors_); 383 EXPECT_EQ("first token", consumer_.last_token_); 384} 385 386TEST_F(OAuth2TokenServiceTest, ServiceShutDownBeforeFetchComplete) { 387 oauth2_service_->set_refresh_token("refreshToken"); 388 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 389 std::set<std::string>(), &consumer_)); 390 base::RunLoop().RunUntilIdle(); 391 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 392 EXPECT_EQ(0, consumer_.number_of_errors_); 393 394 // The destructor should cancel all in-flight fetchers. 395 oauth2_service_.reset(NULL); 396 397 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 398 EXPECT_EQ(1, consumer_.number_of_errors_); 399} 400 401TEST_F(OAuth2TokenServiceTest, RetryingConsumer) { 402 oauth2_service_->set_refresh_token("refreshToken"); 403 RetryingTestingOAuth2TokenServiceConsumer consumer(oauth2_service_.get()); 404 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 405 std::set<std::string>(), &consumer)); 406 base::RunLoop().RunUntilIdle(); 407 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 408 EXPECT_EQ(0, consumer.number_of_errors_); 409 410 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 411 ASSERT_TRUE(fetcher); 412 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 413 fetcher->SetResponseString(std::string()); 414 fetcher->delegate()->OnURLFetchComplete(fetcher); 415 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 416 EXPECT_EQ(1, consumer.number_of_errors_); 417 418 fetcher = factory_.GetFetcherByID(0); 419 ASSERT_TRUE(fetcher); 420 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 421 fetcher->SetResponseString(std::string()); 422 fetcher->delegate()->OnURLFetchComplete(fetcher); 423 EXPECT_EQ(0, consumer.number_of_successful_tokens_); 424 EXPECT_EQ(2, consumer.number_of_errors_); 425} 426 427TEST_F(OAuth2TokenServiceTest, InvalidateToken) { 428 std::set<std::string> scopes; 429 oauth2_service_->set_refresh_token("refreshToken"); 430 431 // First request. 432 scoped_ptr<OAuth2TokenService::Request> request( 433 oauth2_service_->StartRequest(scopes, &consumer_)); 434 base::RunLoop().RunUntilIdle(); 435 436 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 437 EXPECT_EQ(0, consumer_.number_of_errors_); 438 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 439 EXPECT_TRUE(fetcher); 440 fetcher->set_response_code(net::HTTP_OK); 441 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 442 fetcher->delegate()->OnURLFetchComplete(fetcher); 443 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 444 EXPECT_EQ(0, consumer_.number_of_errors_); 445 EXPECT_EQ("token", consumer_.last_token_); 446 447 // Second request, should return the same token without needing a network 448 // request. 449 scoped_ptr<OAuth2TokenService::Request> request2( 450 oauth2_service_->StartRequest(scopes, &consumer_)); 451 base::RunLoop().RunUntilIdle(); 452 453 // No new network fetcher. 454 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 455 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 456 EXPECT_EQ(0, consumer_.number_of_errors_); 457 EXPECT_EQ("token", consumer_.last_token_); 458 459 // Invalidating the token should return a new token on the next request. 460 oauth2_service_->InvalidateToken(scopes, consumer_.last_token_); 461 scoped_ptr<OAuth2TokenService::Request> request3( 462 oauth2_service_->StartRequest(scopes, &consumer_)); 463 base::RunLoop().RunUntilIdle(); 464 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 465 EXPECT_EQ(0, consumer_.number_of_errors_); 466 fetcher = factory_.GetFetcherByID(0); 467 EXPECT_TRUE(fetcher); 468 fetcher->set_response_code(net::HTTP_OK); 469 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 470 fetcher->delegate()->OnURLFetchComplete(fetcher); 471 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 472 EXPECT_EQ(0, consumer_.number_of_errors_); 473 EXPECT_EQ("token2", consumer_.last_token_); 474} 475 476TEST_F(OAuth2TokenServiceTest, CancelAllRequests) { 477 oauth2_service_->set_refresh_token("refreshToken"); 478 scoped_ptr<OAuth2TokenService::Request> request( 479 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 480 481 oauth2_service_->set_refresh_token("refreshToken2"); 482 scoped_ptr<OAuth2TokenService::Request> request2( 483 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 484 485 base::RunLoop().RunUntilIdle(); 486 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 487 EXPECT_EQ(0, consumer_.number_of_errors_); 488 489 oauth2_service_->CancelAllRequestsForTest(); 490 491 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 492 EXPECT_EQ(2, consumer_.number_of_errors_); 493} 494 495TEST_F(OAuth2TokenServiceTest, CancelRequestsForToken) { 496 std::set<std::string> scope_set_1; 497 scope_set_1.insert("scope1"); 498 scope_set_1.insert("scope2"); 499 std::set<std::string> scope_set_2(scope_set_1.begin(), scope_set_1.end()); 500 scope_set_2.insert("scope3"); 501 502 oauth2_service_->set_refresh_token("refreshToken"); 503 scoped_ptr<OAuth2TokenService::Request> request1( 504 oauth2_service_->StartRequest(scope_set_1, &consumer_)); 505 scoped_ptr<OAuth2TokenService::Request> request2( 506 oauth2_service_->StartRequest(scope_set_2, &consumer_)); 507 508 oauth2_service_->set_refresh_token("refreshToken2"); 509 scoped_ptr<OAuth2TokenService::Request> request3( 510 oauth2_service_->StartRequest(scope_set_1, &consumer_)); 511 512 base::RunLoop().RunUntilIdle(); 513 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 514 EXPECT_EQ(0, consumer_.number_of_errors_); 515 516 oauth2_service_->CancelRequestsForTokenForTest("refreshToken"); 517 518 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 519 EXPECT_EQ(2, consumer_.number_of_errors_); 520 521 oauth2_service_->CancelRequestsForTokenForTest("refreshToken2"); 522 523 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 524 EXPECT_EQ(3, consumer_.number_of_errors_); 525} 526