OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 } |
OLD | NEW |