oauth2_token_service_unittest.cc revision 58537e28ecd584eab876aee8be7156509866d23a 
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.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      : oauth2_service_(oauth2_service) {}
28  virtual ~RetryingTestingOAuth2TokenServiceConsumer() {}
29
30  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
31                                 const GoogleServiceAuthError& error) OVERRIDE {
32    TestingOAuth2TokenServiceConsumer::OnGetTokenFailure(request, error);
33    request_.reset(oauth2_service_->StartRequest(
34        std::set<std::string>(), this).release());
35  }
36
37  OAuth2TokenService* oauth2_service_;
38  scoped_ptr<OAuth2TokenService::Request> request_;
39};
40
41class TestOAuth2TokenService : public OAuth2TokenService {
42 public:
43  explicit TestOAuth2TokenService(net::TestURLRequestContextGetter* getter)
44      : request_context_getter_(getter) {
45  }
46
47  void CancelAllRequestsForTest() { CancelAllRequests(); }
48
49  void CancelRequestsForTokenForTest(const std::string& refresh_token) {
50    CancelRequestsForToken(refresh_token);
51  }
52
53  // For testing: set the refresh token to be used.
54  void set_refresh_token(const std::string& refresh_token) {
55    refresh_token_ = refresh_token;
56  }
57
58 protected:
59  virtual std::string GetRefreshToken() OVERRIDE { return refresh_token_; }
60
61 private:
62  // OAuth2TokenService implementation.
63  virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE {
64    return request_context_getter_.get();
65  }
66
67  std::string refresh_token_;
68  scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
69};
70
71class OAuth2TokenServiceTest : public testing::Test {
72 public:
73  virtual void SetUp() OVERRIDE {
74    oauth2_service_.reset(
75        new TestOAuth2TokenService(new net::TestURLRequestContextGetter(
76            message_loop_.message_loop_proxy())));
77  }
78
79  virtual void TearDown() OVERRIDE {
80    // Makes sure that all the clean up tasks are run.
81    base::RunLoop().RunUntilIdle();
82  }
83
84 protected:
85  base::MessageLoopForIO message_loop_;  // net:: stuff needs IO message loop.
86  net::TestURLFetcherFactory factory_;
87  scoped_ptr<TestOAuth2TokenService> oauth2_service_;
88  TestingOAuth2TokenServiceConsumer consumer_;
89};
90
91TEST_F(OAuth2TokenServiceTest, NoOAuth2RefreshToken) {
92  scoped_ptr<OAuth2TokenService::Request> request(
93      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
94  base::RunLoop().RunUntilIdle();
95
96  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
97  EXPECT_EQ(1, consumer_.number_of_errors_);
98}
99
100TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) {
101  oauth2_service_->set_refresh_token("refreshToken");
102  scoped_ptr<OAuth2TokenService::Request> request(
103      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
104  base::RunLoop().RunUntilIdle();
105
106  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
107  EXPECT_EQ(0, consumer_.number_of_errors_);
108  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
109  ASSERT_TRUE(fetcher);
110  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
111  fetcher->SetResponseString(std::string());
112  fetcher->delegate()->OnURLFetchComplete(fetcher);
113  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
114  EXPECT_EQ(1, consumer_.number_of_errors_);
115  EXPECT_EQ(fetcher, factory_.GetFetcherByID(0));
116}
117
118TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) {
119  oauth2_service_->set_refresh_token("refreshToken");
120  scoped_ptr<OAuth2TokenService::Request> request(
121      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
122  base::RunLoop().RunUntilIdle();
123
124  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
125  EXPECT_EQ(0, consumer_.number_of_errors_);
126  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
127  ASSERT_TRUE(fetcher);
128  fetcher->set_response_code(net::HTTP_OK);
129  fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
130  fetcher->delegate()->OnURLFetchComplete(fetcher);
131  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
132  EXPECT_EQ(0, consumer_.number_of_errors_);
133  EXPECT_EQ("token", consumer_.last_token_);
134}
135
136TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
137  std::set<std::string> scopes1;
138  scopes1.insert("s1");
139  scopes1.insert("s2");
140  std::set<std::string> scopes1_same;
141  scopes1_same.insert("s2");
142  scopes1_same.insert("s1");
143  std::set<std::string> scopes2;
144  scopes2.insert("s3");
145
146  oauth2_service_->set_refresh_token("refreshToken");
147
148  // First request.
149  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
150      scopes1, &consumer_));
151  base::RunLoop().RunUntilIdle();
152
153  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
154  EXPECT_EQ(0, consumer_.number_of_errors_);
155  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
156  ASSERT_TRUE(fetcher);
157  fetcher->set_response_code(net::HTTP_OK);
158  fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
159  fetcher->delegate()->OnURLFetchComplete(fetcher);
160  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
161  EXPECT_EQ(0, consumer_.number_of_errors_);
162  EXPECT_EQ("token", consumer_.last_token_);
163
164  // Second request to the same set of scopes, should return the same token
165  // without needing a network request.
166  scoped_ptr<OAuth2TokenService::Request> request2(
167      oauth2_service_->StartRequest(scopes1_same, &consumer_));
168  base::RunLoop().RunUntilIdle();
169
170  // No new network fetcher.
171  EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
172  EXPECT_EQ(0, consumer_.number_of_errors_);
173  EXPECT_EQ("token", consumer_.last_token_);
174
175  // Third request to a new set of scopes, should return another token.
176  scoped_ptr<OAuth2TokenService::Request> request3(
177      oauth2_service_->StartRequest(scopes2, &consumer_));
178  base::RunLoop().RunUntilIdle();
179  EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
180  EXPECT_EQ(0, consumer_.number_of_errors_);
181  fetcher = factory_.GetFetcherByID(0);
182  ASSERT_TRUE(fetcher);
183  fetcher->set_response_code(net::HTTP_OK);
184  fetcher->SetResponseString(GetValidTokenResponse("token2", 3600));
185  fetcher->delegate()->OnURLFetchComplete(fetcher);
186  EXPECT_EQ(3, consumer_.number_of_successful_tokens_);
187  EXPECT_EQ(0, consumer_.number_of_errors_);
188  EXPECT_EQ("token2", consumer_.last_token_);
189}
190
191TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) {
192  oauth2_service_->set_refresh_token("refreshToken");
193
194  // First request.
195  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
196      std::set<std::string>(), &consumer_));
197  base::RunLoop().RunUntilIdle();
198  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
199  EXPECT_EQ(0, consumer_.number_of_errors_);
200  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
201  ASSERT_TRUE(fetcher);
202  fetcher->set_response_code(net::HTTP_OK);
203  fetcher->SetResponseString(GetValidTokenResponse("token", 0));
204  fetcher->delegate()->OnURLFetchComplete(fetcher);
205  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
206  EXPECT_EQ(0, consumer_.number_of_errors_);
207  EXPECT_EQ("token", consumer_.last_token_);
208
209  // Second request must try to access the network as the token has expired.
210  scoped_ptr<OAuth2TokenService::Request> request2(
211      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
212  base::RunLoop().RunUntilIdle();
213  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
214  EXPECT_EQ(0, consumer_.number_of_errors_);
215
216  // Network failure.
217  fetcher = factory_.GetFetcherByID(0);
218  ASSERT_TRUE(fetcher);
219  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
220  fetcher->SetResponseString(std::string());
221  fetcher->delegate()->OnURLFetchComplete(fetcher);
222  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
223  EXPECT_EQ(1, consumer_.number_of_errors_);
224}
225
226TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) {
227  oauth2_service_->set_refresh_token("refreshToken");
228
229  // First request.
230  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
231      std::set<std::string>(), &consumer_));
232  base::RunLoop().RunUntilIdle();
233  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
234  EXPECT_EQ(0, consumer_.number_of_errors_);
235  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
236  ASSERT_TRUE(fetcher);
237  fetcher->set_response_code(net::HTTP_OK);
238  fetcher->SetResponseString(GetValidTokenResponse("token", 0));
239  fetcher->delegate()->OnURLFetchComplete(fetcher);
240  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
241  EXPECT_EQ(0, consumer_.number_of_errors_);
242  EXPECT_EQ("token", consumer_.last_token_);
243
244  // Second request must try to access the network as the token has expired.
245  scoped_ptr<OAuth2TokenService::Request> request2(
246      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
247  base::RunLoop().RunUntilIdle();
248  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
249  EXPECT_EQ(0, consumer_.number_of_errors_);
250
251  fetcher = factory_.GetFetcherByID(0);
252  ASSERT_TRUE(fetcher);
253  fetcher->set_response_code(net::HTTP_OK);
254  fetcher->SetResponseString(GetValidTokenResponse("another token", 0));
255  fetcher->delegate()->OnURLFetchComplete(fetcher);
256  EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
257  EXPECT_EQ(0, consumer_.number_of_errors_);
258  EXPECT_EQ("another token", consumer_.last_token_);
259}
260
261TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) {
262  oauth2_service_->set_refresh_token("refreshToken");
263
264  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
265      std::set<std::string>(), &consumer_));
266  base::RunLoop().RunUntilIdle();
267  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
268  EXPECT_EQ(0, consumer_.number_of_errors_);
269  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
270  ASSERT_TRUE(fetcher);
271
272  request.reset();
273
274  fetcher->set_response_code(net::HTTP_OK);
275  fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
276  fetcher->delegate()->OnURLFetchComplete(fetcher);
277  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
278  EXPECT_EQ(0, consumer_.number_of_errors_);
279}
280
281TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) {
282  oauth2_service_->set_refresh_token("refreshToken");
283
284  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
285      std::set<std::string>(), &consumer_));
286  base::RunLoop().RunUntilIdle();
287  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
288  ASSERT_TRUE(fetcher);
289  fetcher->set_response_code(net::HTTP_OK);
290  fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
291  fetcher->delegate()->OnURLFetchComplete(fetcher);
292  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
293  EXPECT_EQ(0, consumer_.number_of_errors_);
294  EXPECT_EQ("token", consumer_.last_token_);
295
296  request.reset();
297
298  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
299  EXPECT_EQ(0, consumer_.number_of_errors_);
300  EXPECT_EQ("token", consumer_.last_token_);
301}
302
303TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) {
304  oauth2_service_->set_refresh_token("refreshToken");
305
306  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
307      std::set<std::string>(), &consumer_));
308  base::RunLoop().RunUntilIdle();
309  scoped_ptr<OAuth2TokenService::Request> request2(
310      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
311  base::RunLoop().RunUntilIdle();
312
313  request.reset();
314
315  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
316  ASSERT_TRUE(fetcher);
317  fetcher->set_response_code(net::HTTP_OK);
318  fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
319  fetcher->delegate()->OnURLFetchComplete(fetcher);
320  EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
321  EXPECT_EQ(0, consumer_.number_of_errors_);
322}
323
324TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) {
325  // We have a valid refresh token; the first request is successful.
326  oauth2_service_->set_refresh_token("refreshToken");
327  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
328      std::set<std::string>(), &consumer_));
329  base::RunLoop().RunUntilIdle();
330  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
331  ASSERT_TRUE(fetcher);
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(1, consumer_.number_of_successful_tokens_);
344  EXPECT_EQ(1, consumer_.number_of_errors_);
345}
346
347TEST_F(OAuth2TokenServiceTest,
348       ChangedRefreshTokenDoesNotAffectInFlightRequests) {
349  oauth2_service_->set_refresh_token("first refreshToken");
350  std::set<std::string> scopes;
351  scopes.insert("s1");
352  scopes.insert("s2");
353
354  scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
355      scopes, &consumer_));
356  base::RunLoop().RunUntilIdle();
357  net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0);
358  ASSERT_TRUE(fetcher1);
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  ASSERT_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(2, consumer_.number_of_successful_tokens_);
455  EXPECT_EQ(0, consumer_.number_of_errors_);
456  EXPECT_EQ("token", consumer_.last_token_);
457
458  // Invalidating the token should return a new token on the next request.
459  oauth2_service_->InvalidateToken(scopes, consumer_.last_token_);
460  scoped_ptr<OAuth2TokenService::Request> request3(
461      oauth2_service_->StartRequest(scopes, &consumer_));
462  base::RunLoop().RunUntilIdle();
463  EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
464  EXPECT_EQ(0, consumer_.number_of_errors_);
465  fetcher = factory_.GetFetcherByID(0);
466  ASSERT_TRUE(fetcher);
467  fetcher->set_response_code(net::HTTP_OK);
468  fetcher->SetResponseString(GetValidTokenResponse("token2", 3600));
469  fetcher->delegate()->OnURLFetchComplete(fetcher);
470  EXPECT_EQ(3, consumer_.number_of_successful_tokens_);
471  EXPECT_EQ(0, consumer_.number_of_errors_);
472  EXPECT_EQ("token2", consumer_.last_token_);
473}
474
475TEST_F(OAuth2TokenServiceTest, CancelAllRequests) {
476  oauth2_service_->set_refresh_token("refreshToken");
477  scoped_ptr<OAuth2TokenService::Request> request(
478      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
479
480  oauth2_service_->set_refresh_token("refreshToken2");
481  scoped_ptr<OAuth2TokenService::Request> request2(
482      oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
483
484  base::RunLoop().RunUntilIdle();
485  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
486  EXPECT_EQ(0, consumer_.number_of_errors_);
487
488  oauth2_service_->CancelAllRequestsForTest();
489
490  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
491  EXPECT_EQ(2, consumer_.number_of_errors_);
492}
493
494TEST_F(OAuth2TokenServiceTest, CancelRequestsForToken) {
495  std::set<std::string> scope_set_1;
496  scope_set_1.insert("scope1");
497  scope_set_1.insert("scope2");
498  std::set<std::string> scope_set_2(scope_set_1.begin(), scope_set_1.end());
499  scope_set_2.insert("scope3");
500
501  oauth2_service_->set_refresh_token("refreshToken");
502  scoped_ptr<OAuth2TokenService::Request> request1(
503      oauth2_service_->StartRequest(scope_set_1, &consumer_));
504  scoped_ptr<OAuth2TokenService::Request> request2(
505      oauth2_service_->StartRequest(scope_set_2, &consumer_));
506
507  oauth2_service_->set_refresh_token("refreshToken2");
508  scoped_ptr<OAuth2TokenService::Request> request3(
509      oauth2_service_->StartRequest(scope_set_1, &consumer_));
510
511  base::RunLoop().RunUntilIdle();
512  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
513  EXPECT_EQ(0, consumer_.number_of_errors_);
514
515  oauth2_service_->CancelRequestsForTokenForTest("refreshToken");
516
517  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
518  EXPECT_EQ(2, consumer_.number_of_errors_);
519
520  oauth2_service_->CancelRequestsForTokenForTest("refreshToken2");
521
522  EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
523  EXPECT_EQ(3, consumer_.number_of_errors_);
524}
525
526TEST_F(OAuth2TokenServiceTest, SameScopesRequestedForDifferentClients) {
527  std::string client_id_1("client1");
528  std::string client_secret_1("secret1");
529  std::string client_id_2("client2");
530  std::string client_secret_2("secret2");
531  std::set<std::string> scope_set;
532  scope_set.insert("scope1");
533  scope_set.insert("scope2");
534
535  std::string refresh_token("refreshToken");
536  oauth2_service_->set_refresh_token(refresh_token);
537
538  scoped_ptr<OAuth2TokenService::Request> request1(
539      oauth2_service_->StartRequestForClient(client_id_1,
540                                             client_secret_1,
541                                             scope_set,
542                                             &consumer_));
543  scoped_ptr<OAuth2TokenService::Request> request2(
544      oauth2_service_->StartRequestForClient(client_id_2,
545                                             client_secret_2,
546                                             scope_set,
547                                             &consumer_));
548  // Start a request that should be duplicate of |request1|.
549  scoped_ptr<OAuth2TokenService::Request> request3(
550      oauth2_service_->StartRequestForClient(client_id_1,
551                                             client_secret_1,
552                                             scope_set,
553                                             &consumer_));
554  base::RunLoop().RunUntilIdle();
555
556  ASSERT_EQ(2U,
557            oauth2_service_->GetNumPendingRequestsForTesting(
558                client_id_1,
559                refresh_token,
560                scope_set));
561   ASSERT_EQ(1U,
562             oauth2_service_->GetNumPendingRequestsForTesting(
563                client_id_2,
564                refresh_token,
565                scope_set));
566}
567
568TEST_F(OAuth2TokenServiceTest, ClientScopeSetOrderTest) {
569  OAuth2TokenService::ScopeSet set_0;
570  OAuth2TokenService::ScopeSet set_1;
571  set_1.insert("1");
572
573  OAuth2TokenService::ClientScopeSet sets[] = {
574      OAuth2TokenService::ClientScopeSet("0", set_0),
575      OAuth2TokenService::ClientScopeSet("0", set_1),
576      OAuth2TokenService::ClientScopeSet("1", set_0),
577      OAuth2TokenService::ClientScopeSet("1", set_1),
578  };
579
580  for (size_t i = 0; i < arraysize(sets); i++) {
581    for (size_t j = 0; j < arraysize(sets); j++) {
582      if (i == j) {
583        EXPECT_FALSE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
584        EXPECT_FALSE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
585      } else if (i < j) {
586        EXPECT_TRUE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
587        EXPECT_FALSE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
588      } else {
589        EXPECT_TRUE(sets[j] < sets[i]) << " i=" << i << ", j=" << j;
590        EXPECT_FALSE(sets[i] < sets[j]) << " i=" << i << ", j=" << j;
591      }
592    }
593  }
594}
595
596TEST_F(OAuth2TokenServiceTest, FetchParametersOrderTest) {
597  OAuth2TokenService::ScopeSet set_0;
598  OAuth2TokenService::ScopeSet set_1;
599  set_1.insert("1");
600
601  OAuth2TokenService::FetchParameters params[] = {
602      OAuth2TokenService::FetchParameters("0", "0", set_0),
603      OAuth2TokenService::FetchParameters("0", "0", set_1),
604      OAuth2TokenService::FetchParameters("0", "1", set_0),
605      OAuth2TokenService::FetchParameters("0", "1", set_1),
606      OAuth2TokenService::FetchParameters("1", "0", set_0),
607      OAuth2TokenService::FetchParameters("1", "0", set_1),
608      OAuth2TokenService::FetchParameters("1", "1", set_0),
609      OAuth2TokenService::FetchParameters("1", "1", set_1),
610  };
611
612  for (size_t i = 0; i < arraysize(params); i++) {
613    for (size_t j = 0; j < arraysize(params); j++) {
614      if (i == j) {
615        EXPECT_FALSE(params[i] < params[j]) << " i=" << i << ", j=" << j;
616        EXPECT_FALSE(params[j] < params[i]) << " i=" << i << ", j=" << j;
617      } else if (i < j) {
618        EXPECT_TRUE(params[i] < params[j]) << " i=" << i << ", j=" << j;
619        EXPECT_FALSE(params[j] < params[i]) << " i=" << i << ", j=" << j;
620      } else {
621        EXPECT_TRUE(params[j] < params[i]) << " i=" << i << ", j=" << j;
622        EXPECT_FALSE(params[i] < params[j]) << " i=" << i << ", j=" << j;
623      }
624    }
625  }
626}
627