Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(347)

Side by Side Diff: google_apis/gaia/oauth2_token_service_unittest.cc

Issue 22581003: Handling of multiple concurrent requests from different clients in OAuth2TokenService (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fixes for bustes tests Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « google_apis/gaia/oauth2_token_service.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <string> 5 #include <string>
6 6
7 #include "base/message_loop/message_loop.h" 7 #include "base/message_loop/message_loop.h"
8 #include "base/run_loop.h" 8 #include "base/run_loop.h"
9 #include "google_apis/gaia/gaia_constants.h" 9 #include "google_apis/gaia/gaia_constants.h"
10 #include "google_apis/gaia/google_service_auth_error.h" 10 #include "google_apis/gaia/google_service_auth_error.h"
11 #include "google_apis/gaia/oauth2_access_token_consumer.h" 11 #include "google_apis/gaia/oauth2_access_token_consumer.h"
12 #include "google_apis/gaia/oauth2_access_token_fetcher.h"
12 #include "google_apis/gaia/oauth2_token_service.h" 13 #include "google_apis/gaia/oauth2_token_service.h"
13 #include "google_apis/gaia/oauth2_token_service_test_util.h" 14 #include "google_apis/gaia/oauth2_token_service_test_util.h"
14 #include "net/http/http_status_code.h" 15 #include "net/http/http_status_code.h"
15 #include "net/url_request/test_url_fetcher_factory.h" 16 #include "net/url_request/test_url_fetcher_factory.h"
16 #include "net/url_request/url_fetcher_delegate.h" 17 #include "net/url_request/url_fetcher_delegate.h"
17 #include "net/url_request/url_request_test_util.h" 18 #include "net/url_request/url_request_test_util.h"
18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "testing/gtest/include/gtest/gtest.h"
19 20
20 // A testing consumer that retries on error. 21 // A testing consumer that retries on error.
21 class RetryingTestingOAuth2TokenServiceConsumer 22 class RetryingTestingOAuth2TokenServiceConsumer
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
98 99
99 TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) { 100 TEST_F(OAuth2TokenServiceTest, FailureShouldNotRetry) {
100 oauth2_service_->set_refresh_token("refreshToken"); 101 oauth2_service_->set_refresh_token("refreshToken");
101 scoped_ptr<OAuth2TokenService::Request> request( 102 scoped_ptr<OAuth2TokenService::Request> request(
102 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 103 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
103 base::RunLoop().RunUntilIdle(); 104 base::RunLoop().RunUntilIdle();
104 105
105 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 106 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
106 EXPECT_EQ(0, consumer_.number_of_errors_); 107 EXPECT_EQ(0, consumer_.number_of_errors_);
107 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 108 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
108 EXPECT_TRUE(fetcher); 109 ASSERT_TRUE(fetcher);
109 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 110 fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
110 fetcher->SetResponseString(std::string()); 111 fetcher->SetResponseString(std::string());
111 fetcher->delegate()->OnURLFetchComplete(fetcher); 112 fetcher->delegate()->OnURLFetchComplete(fetcher);
112 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 113 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
113 EXPECT_EQ(1, consumer_.number_of_errors_); 114 EXPECT_EQ(1, consumer_.number_of_errors_);
114 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0)); 115 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0));
115 } 116 }
116 117
117 TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) { 118 TEST_F(OAuth2TokenServiceTest, SuccessWithoutCaching) {
118 oauth2_service_->set_refresh_token("refreshToken"); 119 oauth2_service_->set_refresh_token("refreshToken");
119 scoped_ptr<OAuth2TokenService::Request> request( 120 scoped_ptr<OAuth2TokenService::Request> request(
120 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 121 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
121 base::RunLoop().RunUntilIdle(); 122 base::RunLoop().RunUntilIdle();
122 123
123 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 124 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
124 EXPECT_EQ(0, consumer_.number_of_errors_); 125 EXPECT_EQ(0, consumer_.number_of_errors_);
125 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 126 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
126 EXPECT_TRUE(fetcher); 127 ASSERT_TRUE(fetcher);
127 fetcher->set_response_code(net::HTTP_OK); 128 fetcher->set_response_code(net::HTTP_OK);
128 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 129 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
129 fetcher->delegate()->OnURLFetchComplete(fetcher); 130 fetcher->delegate()->OnURLFetchComplete(fetcher);
130 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 131 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
131 EXPECT_EQ(0, consumer_.number_of_errors_); 132 EXPECT_EQ(0, consumer_.number_of_errors_);
132 EXPECT_EQ("token", consumer_.last_token_); 133 EXPECT_EQ("token", consumer_.last_token_);
133 } 134 }
134 135
135 TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) { 136 TEST_F(OAuth2TokenServiceTest, SuccessWithCaching) {
136 std::set<std::string> scopes1; 137 std::set<std::string> scopes1;
137 scopes1.insert("s1"); 138 scopes1.insert("s1");
138 scopes1.insert("s2"); 139 scopes1.insert("s2");
139 std::set<std::string> scopes1_same; 140 std::set<std::string> scopes1_same;
140 scopes1_same.insert("s2"); 141 scopes1_same.insert("s2");
141 scopes1_same.insert("s1"); 142 scopes1_same.insert("s1");
142 std::set<std::string> scopes2; 143 std::set<std::string> scopes2;
143 scopes2.insert("s3"); 144 scopes2.insert("s3");
144 145
145 oauth2_service_->set_refresh_token("refreshToken"); 146 oauth2_service_->set_refresh_token("refreshToken");
146 147
147 // First request. 148 // First request.
148 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 149 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
149 scopes1, &consumer_)); 150 scopes1, &consumer_));
150 base::RunLoop().RunUntilIdle(); 151 base::RunLoop().RunUntilIdle();
151 152
152 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 153 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
153 EXPECT_EQ(0, consumer_.number_of_errors_); 154 EXPECT_EQ(0, consumer_.number_of_errors_);
154 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 155 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
155 EXPECT_TRUE(fetcher); 156 ASSERT_TRUE(fetcher);
156 fetcher->set_response_code(net::HTTP_OK); 157 fetcher->set_response_code(net::HTTP_OK);
157 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 158 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
158 fetcher->delegate()->OnURLFetchComplete(fetcher); 159 fetcher->delegate()->OnURLFetchComplete(fetcher);
159 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 160 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
160 EXPECT_EQ(0, consumer_.number_of_errors_); 161 EXPECT_EQ(0, consumer_.number_of_errors_);
161 EXPECT_EQ("token", consumer_.last_token_); 162 EXPECT_EQ("token", consumer_.last_token_);
162 163
163 // Second request to the same set of scopes, should return the same token 164 // Second request to the same set of scopes, should return the same token
164 // without needing a network request. 165 // without needing a network request.
165 scoped_ptr<OAuth2TokenService::Request> request2( 166 scoped_ptr<OAuth2TokenService::Request> request2(
166 oauth2_service_->StartRequest(scopes1_same, &consumer_)); 167 oauth2_service_->StartRequest(scopes1_same, &consumer_));
167 base::RunLoop().RunUntilIdle(); 168 base::RunLoop().RunUntilIdle();
168 169
169 // No new network fetcher. 170 // No new network fetcher.
170 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0));
171 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 171 EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
172 EXPECT_EQ(0, consumer_.number_of_errors_); 172 EXPECT_EQ(0, consumer_.number_of_errors_);
173 EXPECT_EQ("token", consumer_.last_token_); 173 EXPECT_EQ("token", consumer_.last_token_);
174 174
175 // Third request to a new set of scopes, should return another token. 175 // Third request to a new set of scopes, should return another token.
176 scoped_ptr<OAuth2TokenService::Request> request3( 176 scoped_ptr<OAuth2TokenService::Request> request3(
177 oauth2_service_->StartRequest(scopes2, &consumer_)); 177 oauth2_service_->StartRequest(scopes2, &consumer_));
178 base::RunLoop().RunUntilIdle(); 178 base::RunLoop().RunUntilIdle();
179 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 179 EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
180 EXPECT_EQ(0, consumer_.number_of_errors_); 180 EXPECT_EQ(0, consumer_.number_of_errors_);
181 fetcher = factory_.GetFetcherByID(0); 181 fetcher = factory_.GetFetcherByID(0);
182 EXPECT_TRUE(fetcher); 182 ASSERT_TRUE(fetcher);
183 fetcher->set_response_code(net::HTTP_OK); 183 fetcher->set_response_code(net::HTTP_OK);
184 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 184 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600));
185 fetcher->delegate()->OnURLFetchComplete(fetcher); 185 fetcher->delegate()->OnURLFetchComplete(fetcher);
186 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 186 EXPECT_EQ(3, consumer_.number_of_successful_tokens_);
187 EXPECT_EQ(0, consumer_.number_of_errors_); 187 EXPECT_EQ(0, consumer_.number_of_errors_);
188 EXPECT_EQ("token2", consumer_.last_token_); 188 EXPECT_EQ("token2", consumer_.last_token_);
189 } 189 }
190 190
191 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) { 191 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndFailure) {
192 oauth2_service_->set_refresh_token("refreshToken"); 192 oauth2_service_->set_refresh_token("refreshToken");
193 193
194 // First request. 194 // First request.
195 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 195 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
196 std::set<std::string>(), &consumer_)); 196 std::set<std::string>(), &consumer_));
197 base::RunLoop().RunUntilIdle(); 197 base::RunLoop().RunUntilIdle();
198 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 198 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
199 EXPECT_EQ(0, consumer_.number_of_errors_); 199 EXPECT_EQ(0, consumer_.number_of_errors_);
200 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 200 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
201 EXPECT_TRUE(fetcher); 201 ASSERT_TRUE(fetcher);
202 fetcher->set_response_code(net::HTTP_OK); 202 fetcher->set_response_code(net::HTTP_OK);
203 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 203 fetcher->SetResponseString(GetValidTokenResponse("token", 0));
204 fetcher->delegate()->OnURLFetchComplete(fetcher); 204 fetcher->delegate()->OnURLFetchComplete(fetcher);
205 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 205 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
206 EXPECT_EQ(0, consumer_.number_of_errors_); 206 EXPECT_EQ(0, consumer_.number_of_errors_);
207 EXPECT_EQ("token", consumer_.last_token_); 207 EXPECT_EQ("token", consumer_.last_token_);
208 208
209 // Second request must try to access the network as the token has expired. 209 // Second request must try to access the network as the token has expired.
210 scoped_ptr<OAuth2TokenService::Request> request2( 210 scoped_ptr<OAuth2TokenService::Request> request2(
211 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 211 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
212 base::RunLoop().RunUntilIdle(); 212 base::RunLoop().RunUntilIdle();
213 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 213 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
214 EXPECT_EQ(0, consumer_.number_of_errors_); 214 EXPECT_EQ(0, consumer_.number_of_errors_);
215 215
216 // Network failure. 216 // Network failure.
217 fetcher = factory_.GetFetcherByID(0); 217 fetcher = factory_.GetFetcherByID(0);
218 EXPECT_TRUE(fetcher); 218 ASSERT_TRUE(fetcher);
219 fetcher->set_response_code(net::HTTP_UNAUTHORIZED); 219 fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
220 fetcher->SetResponseString(std::string()); 220 fetcher->SetResponseString(std::string());
221 fetcher->delegate()->OnURLFetchComplete(fetcher); 221 fetcher->delegate()->OnURLFetchComplete(fetcher);
222 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 222 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
223 EXPECT_EQ(1, consumer_.number_of_errors_); 223 EXPECT_EQ(1, consumer_.number_of_errors_);
224 } 224 }
225 225
226 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) { 226 TEST_F(OAuth2TokenServiceTest, SuccessAndExpirationAndSuccess) {
227 oauth2_service_->set_refresh_token("refreshToken"); 227 oauth2_service_->set_refresh_token("refreshToken");
228 228
229 // First request. 229 // First request.
230 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 230 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
231 std::set<std::string>(), &consumer_)); 231 std::set<std::string>(), &consumer_));
232 base::RunLoop().RunUntilIdle(); 232 base::RunLoop().RunUntilIdle();
233 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 233 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
234 EXPECT_EQ(0, consumer_.number_of_errors_); 234 EXPECT_EQ(0, consumer_.number_of_errors_);
235 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 235 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
236 EXPECT_TRUE(fetcher); 236 ASSERT_TRUE(fetcher);
237 fetcher->set_response_code(net::HTTP_OK); 237 fetcher->set_response_code(net::HTTP_OK);
238 fetcher->SetResponseString(GetValidTokenResponse("token", 0)); 238 fetcher->SetResponseString(GetValidTokenResponse("token", 0));
239 fetcher->delegate()->OnURLFetchComplete(fetcher); 239 fetcher->delegate()->OnURLFetchComplete(fetcher);
240 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 240 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
241 EXPECT_EQ(0, consumer_.number_of_errors_); 241 EXPECT_EQ(0, consumer_.number_of_errors_);
242 EXPECT_EQ("token", consumer_.last_token_); 242 EXPECT_EQ("token", consumer_.last_token_);
243 243
244 // Second request must try to access the network as the token has expired. 244 // Second request must try to access the network as the token has expired.
245 scoped_ptr<OAuth2TokenService::Request> request2( 245 scoped_ptr<OAuth2TokenService::Request> request2(
246 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 246 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
247 base::RunLoop().RunUntilIdle(); 247 base::RunLoop().RunUntilIdle();
248 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 248 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
249 EXPECT_EQ(0, consumer_.number_of_errors_); 249 EXPECT_EQ(0, consumer_.number_of_errors_);
250 250
251 fetcher = factory_.GetFetcherByID(0); 251 fetcher = factory_.GetFetcherByID(0);
252 EXPECT_TRUE(fetcher); 252 ASSERT_TRUE(fetcher);
253 fetcher->set_response_code(net::HTTP_OK); 253 fetcher->set_response_code(net::HTTP_OK);
254 fetcher->SetResponseString(GetValidTokenResponse("another token", 0)); 254 fetcher->SetResponseString(GetValidTokenResponse("another token", 0));
255 fetcher->delegate()->OnURLFetchComplete(fetcher); 255 fetcher->delegate()->OnURLFetchComplete(fetcher);
256 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 256 EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
257 EXPECT_EQ(0, consumer_.number_of_errors_); 257 EXPECT_EQ(0, consumer_.number_of_errors_);
258 EXPECT_EQ("another token", consumer_.last_token_); 258 EXPECT_EQ("another token", consumer_.last_token_);
259 } 259 }
260 260
261 TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) { 261 TEST_F(OAuth2TokenServiceTest, RequestDeletedBeforeCompletion) {
262 oauth2_service_->set_refresh_token("refreshToken"); 262 oauth2_service_->set_refresh_token("refreshToken");
263 263
264 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 264 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
265 std::set<std::string>(), &consumer_)); 265 std::set<std::string>(), &consumer_));
266 base::RunLoop().RunUntilIdle(); 266 base::RunLoop().RunUntilIdle();
267 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 267 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
268 EXPECT_EQ(0, consumer_.number_of_errors_); 268 EXPECT_EQ(0, consumer_.number_of_errors_);
269 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 269 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
270 EXPECT_TRUE(fetcher); 270 ASSERT_TRUE(fetcher);
271 271
272 request.reset(); 272 request.reset();
273 273
274 fetcher->set_response_code(net::HTTP_OK); 274 fetcher->set_response_code(net::HTTP_OK);
275 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 275 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
276 fetcher->delegate()->OnURLFetchComplete(fetcher); 276 fetcher->delegate()->OnURLFetchComplete(fetcher);
277 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 277 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
278 EXPECT_EQ(0, consumer_.number_of_errors_); 278 EXPECT_EQ(0, consumer_.number_of_errors_);
279 } 279 }
280 280
281 TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) { 281 TEST_F(OAuth2TokenServiceTest, RequestDeletedAfterCompletion) {
282 oauth2_service_->set_refresh_token("refreshToken"); 282 oauth2_service_->set_refresh_token("refreshToken");
283 283
284 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 284 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
285 std::set<std::string>(), &consumer_)); 285 std::set<std::string>(), &consumer_));
286 base::RunLoop().RunUntilIdle(); 286 base::RunLoop().RunUntilIdle();
287 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 287 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
288 ASSERT_TRUE(fetcher);
288 fetcher->set_response_code(net::HTTP_OK); 289 fetcher->set_response_code(net::HTTP_OK);
289 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 290 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
290 fetcher->delegate()->OnURLFetchComplete(fetcher); 291 fetcher->delegate()->OnURLFetchComplete(fetcher);
291 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 292 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
292 EXPECT_EQ(0, consumer_.number_of_errors_); 293 EXPECT_EQ(0, consumer_.number_of_errors_);
293 EXPECT_EQ("token", consumer_.last_token_); 294 EXPECT_EQ("token", consumer_.last_token_);
294 295
295 request.reset(); 296 request.reset();
296 297
297 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 298 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
298 EXPECT_EQ(0, consumer_.number_of_errors_); 299 EXPECT_EQ(0, consumer_.number_of_errors_);
299 EXPECT_EQ("token", consumer_.last_token_); 300 EXPECT_EQ("token", consumer_.last_token_);
300 } 301 }
301 302
302 TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) { 303 TEST_F(OAuth2TokenServiceTest, MultipleRequestsForTheSameScopesWithOneDeleted) {
303 oauth2_service_->set_refresh_token("refreshToken"); 304 oauth2_service_->set_refresh_token("refreshToken");
304 305
305 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 306 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
306 std::set<std::string>(), &consumer_)); 307 std::set<std::string>(), &consumer_));
307 base::RunLoop().RunUntilIdle(); 308 base::RunLoop().RunUntilIdle();
308 scoped_ptr<OAuth2TokenService::Request> request2( 309 scoped_ptr<OAuth2TokenService::Request> request2(
309 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_)); 310 oauth2_service_->StartRequest(std::set<std::string>(), &consumer_));
310 base::RunLoop().RunUntilIdle(); 311 base::RunLoop().RunUntilIdle();
311 312
312 request.reset(); 313 request.reset();
313 314
314 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 315 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
316 ASSERT_TRUE(fetcher);
315 fetcher->set_response_code(net::HTTP_OK); 317 fetcher->set_response_code(net::HTTP_OK);
316 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 318 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
317 fetcher->delegate()->OnURLFetchComplete(fetcher); 319 fetcher->delegate()->OnURLFetchComplete(fetcher);
318 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 320 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
319 EXPECT_EQ(0, consumer_.number_of_errors_); 321 EXPECT_EQ(0, consumer_.number_of_errors_);
320 } 322 }
321 323
322 TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) { 324 TEST_F(OAuth2TokenServiceTest, ClearedRefreshTokenFailsSubsequentRequests) {
323 // We have a valid refresh token; the first request is successful. 325 // We have a valid refresh token; the first request is successful.
324 oauth2_service_->set_refresh_token("refreshToken"); 326 oauth2_service_->set_refresh_token("refreshToken");
325 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 327 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
326 std::set<std::string>(), &consumer_)); 328 std::set<std::string>(), &consumer_));
327 base::RunLoop().RunUntilIdle(); 329 base::RunLoop().RunUntilIdle();
328 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 330 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
331 ASSERT_TRUE(fetcher);
329 fetcher->set_response_code(net::HTTP_OK); 332 fetcher->set_response_code(net::HTTP_OK);
330 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 333 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
331 fetcher->delegate()->OnURLFetchComplete(fetcher); 334 fetcher->delegate()->OnURLFetchComplete(fetcher);
332 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 335 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
333 EXPECT_EQ(0, consumer_.number_of_errors_); 336 EXPECT_EQ(0, consumer_.number_of_errors_);
334 EXPECT_EQ("token", consumer_.last_token_); 337 EXPECT_EQ("token", consumer_.last_token_);
335 338
336 // The refresh token is no longer available; subsequent requests fail. 339 // The refresh token is no longer available; subsequent requests fail.
337 oauth2_service_->set_refresh_token(""); 340 oauth2_service_->set_refresh_token("");
338 request = oauth2_service_->StartRequest(std::set<std::string>(), &consumer_); 341 request = oauth2_service_->StartRequest(std::set<std::string>(), &consumer_);
339 base::RunLoop().RunUntilIdle(); 342 base::RunLoop().RunUntilIdle();
340 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0));
341 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 343 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
342 EXPECT_EQ(1, consumer_.number_of_errors_); 344 EXPECT_EQ(1, consumer_.number_of_errors_);
343 } 345 }
344 346
345 TEST_F(OAuth2TokenServiceTest, 347 TEST_F(OAuth2TokenServiceTest,
346 ChangedRefreshTokenDoesNotAffectInFlightRequests) { 348 ChangedRefreshTokenDoesNotAffectInFlightRequests) {
347 oauth2_service_->set_refresh_token("first refreshToken"); 349 oauth2_service_->set_refresh_token("first refreshToken");
348 std::set<std::string> scopes; 350 std::set<std::string> scopes;
349 scopes.insert("s1"); 351 scopes.insert("s1");
350 scopes.insert("s2"); 352 scopes.insert("s2");
351 353
352 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest( 354 scoped_ptr<OAuth2TokenService::Request> request(oauth2_service_->StartRequest(
353 scopes, &consumer_)); 355 scopes, &consumer_));
354 base::RunLoop().RunUntilIdle(); 356 base::RunLoop().RunUntilIdle();
355 net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0); 357 net::TestURLFetcher* fetcher1 = factory_.GetFetcherByID(0);
358 ASSERT_TRUE(fetcher1);
356 359
357 // Note |request| is still pending when the refresh token changes. 360 // Note |request| is still pending when the refresh token changes.
358 oauth2_service_->set_refresh_token("second refreshToken"); 361 oauth2_service_->set_refresh_token("second refreshToken");
359 362
360 // A 2nd request (using the new refresh token) that occurs and completes 363 // A 2nd request (using the new refresh token) that occurs and completes
361 // while the 1st request is in flight is successful. 364 // while the 1st request is in flight is successful.
362 TestingOAuth2TokenServiceConsumer consumer2; 365 TestingOAuth2TokenServiceConsumer consumer2;
363 scoped_ptr<OAuth2TokenService::Request> request2( 366 scoped_ptr<OAuth2TokenService::Request> request2(
364 oauth2_service_->StartRequest(scopes, &consumer2)); 367 oauth2_service_->StartRequest(scopes, &consumer2));
365 base::RunLoop().RunUntilIdle(); 368 base::RunLoop().RunUntilIdle();
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
426 oauth2_service_->set_refresh_token("refreshToken"); 429 oauth2_service_->set_refresh_token("refreshToken");
427 430
428 // First request. 431 // First request.
429 scoped_ptr<OAuth2TokenService::Request> request( 432 scoped_ptr<OAuth2TokenService::Request> request(
430 oauth2_service_->StartRequest(scopes, &consumer_)); 433 oauth2_service_->StartRequest(scopes, &consumer_));
431 base::RunLoop().RunUntilIdle(); 434 base::RunLoop().RunUntilIdle();
432 435
433 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 436 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
434 EXPECT_EQ(0, consumer_.number_of_errors_); 437 EXPECT_EQ(0, consumer_.number_of_errors_);
435 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); 438 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
436 EXPECT_TRUE(fetcher); 439 ASSERT_TRUE(fetcher);
437 fetcher->set_response_code(net::HTTP_OK); 440 fetcher->set_response_code(net::HTTP_OK);
438 fetcher->SetResponseString(GetValidTokenResponse("token", 3600)); 441 fetcher->SetResponseString(GetValidTokenResponse("token", 3600));
439 fetcher->delegate()->OnURLFetchComplete(fetcher); 442 fetcher->delegate()->OnURLFetchComplete(fetcher);
440 EXPECT_EQ(1, consumer_.number_of_successful_tokens_); 443 EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
441 EXPECT_EQ(0, consumer_.number_of_errors_); 444 EXPECT_EQ(0, consumer_.number_of_errors_);
442 EXPECT_EQ("token", consumer_.last_token_); 445 EXPECT_EQ("token", consumer_.last_token_);
443 446
444 // Second request, should return the same token without needing a network 447 // Second request, should return the same token without needing a network
445 // request. 448 // request.
446 scoped_ptr<OAuth2TokenService::Request> request2( 449 scoped_ptr<OAuth2TokenService::Request> request2(
447 oauth2_service_->StartRequest(scopes, &consumer_)); 450 oauth2_service_->StartRequest(scopes, &consumer_));
448 base::RunLoop().RunUntilIdle(); 451 base::RunLoop().RunUntilIdle();
449 452
450 // No new network fetcher. 453 // No new network fetcher.
451 EXPECT_EQ(fetcher, factory_.GetFetcherByID(0));
452 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 454 EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
453 EXPECT_EQ(0, consumer_.number_of_errors_); 455 EXPECT_EQ(0, consumer_.number_of_errors_);
454 EXPECT_EQ("token", consumer_.last_token_); 456 EXPECT_EQ("token", consumer_.last_token_);
455 457
456 // Invalidating the token should return a new token on the next request. 458 // Invalidating the token should return a new token on the next request.
457 oauth2_service_->InvalidateToken(scopes, consumer_.last_token_); 459 oauth2_service_->InvalidateToken(scopes, consumer_.last_token_);
458 scoped_ptr<OAuth2TokenService::Request> request3( 460 scoped_ptr<OAuth2TokenService::Request> request3(
459 oauth2_service_->StartRequest(scopes, &consumer_)); 461 oauth2_service_->StartRequest(scopes, &consumer_));
460 base::RunLoop().RunUntilIdle(); 462 base::RunLoop().RunUntilIdle();
461 EXPECT_EQ(2, consumer_.number_of_successful_tokens_); 463 EXPECT_EQ(2, consumer_.number_of_successful_tokens_);
462 EXPECT_EQ(0, consumer_.number_of_errors_); 464 EXPECT_EQ(0, consumer_.number_of_errors_);
463 fetcher = factory_.GetFetcherByID(0); 465 fetcher = factory_.GetFetcherByID(0);
464 EXPECT_TRUE(fetcher); 466 ASSERT_TRUE(fetcher);
465 fetcher->set_response_code(net::HTTP_OK); 467 fetcher->set_response_code(net::HTTP_OK);
466 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600)); 468 fetcher->SetResponseString(GetValidTokenResponse("token2", 3600));
467 fetcher->delegate()->OnURLFetchComplete(fetcher); 469 fetcher->delegate()->OnURLFetchComplete(fetcher);
468 EXPECT_EQ(3, consumer_.number_of_successful_tokens_); 470 EXPECT_EQ(3, consumer_.number_of_successful_tokens_);
469 EXPECT_EQ(0, consumer_.number_of_errors_); 471 EXPECT_EQ(0, consumer_.number_of_errors_);
470 EXPECT_EQ("token2", consumer_.last_token_); 472 EXPECT_EQ("token2", consumer_.last_token_);
471 } 473 }
472 474
473 TEST_F(OAuth2TokenServiceTest, CancelAllRequests) { 475 TEST_F(OAuth2TokenServiceTest, CancelAllRequests) {
474 oauth2_service_->set_refresh_token("refreshToken"); 476 oauth2_service_->set_refresh_token("refreshToken");
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
513 oauth2_service_->CancelRequestsForTokenForTest("refreshToken"); 515 oauth2_service_->CancelRequestsForTokenForTest("refreshToken");
514 516
515 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 517 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
516 EXPECT_EQ(2, consumer_.number_of_errors_); 518 EXPECT_EQ(2, consumer_.number_of_errors_);
517 519
518 oauth2_service_->CancelRequestsForTokenForTest("refreshToken2"); 520 oauth2_service_->CancelRequestsForTokenForTest("refreshToken2");
519 521
520 EXPECT_EQ(0, consumer_.number_of_successful_tokens_); 522 EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
521 EXPECT_EQ(3, consumer_.number_of_errors_); 523 EXPECT_EQ(3, consumer_.number_of_errors_);
522 } 524 }
525
526 TEST_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
568 TEST_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
596 TEST_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 }
OLDNEW
« no previous file with comments | « google_apis/gaia/oauth2_token_service.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698