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