| OLD | NEW |
|---|
| (Empty) |
| 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 "base/bind.h" | |
| 6 #include "base/memory/scoped_ptr.h" | |
| 7 #include "base/strings/stringprintf.h" | |
| 8 #include "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h" | |
| 9 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" | |
| 10 #include "chrome/test/base/testing_profile.h" | |
| 11 #include "content/public/test/test_browser_thread_bundle.h" | |
| 12 #include "google_apis/gaia/gaia_constants.h" | |
| 13 #include "google_apis/gaia/gaia_oauth_client.h" | |
| 14 #include "google_apis/gaia/gaia_urls.h" | |
| 15 #include "google_apis/gaia/google_service_auth_error.h" | |
| 16 #include "google_apis/gaia/oauth2_token_service.h" | |
| 17 #include "net/base/net_errors.h" | |
| 18 #include "net/base/url_util.h" | |
| 19 #include "net/http/http_request_headers.h" | |
| 20 #include "net/http/http_status_code.h" | |
| 21 #include "net/url_request/test_url_fetcher_factory.h" | |
| 22 #include "net/url_request/url_fetcher_delegate.h" | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 | |
| 25 namespace { | |
| 26 | |
| 27 const char kAccountId[] = "account_id"; | |
| 28 const char kDeviceName[] = "Compy"; | |
| 29 const char kManagedUserId[] = "abcdef"; | |
| 30 | |
| 31 const char kAccessToken[] = "accesstoken"; | |
| 32 const char kAuthorizationCode[] = "authorizationcode"; | |
| 33 const char kManagedUserToken[] = "managedusertoken"; | |
| 34 const char kOAuth2RefreshToken[] = "refreshtoken"; | |
| 35 | |
| 36 const char kIssueTokenResponseFormat[] = | |
| 37 "{" | |
| 38 " \"code\": \"%s\"" | |
| 39 "}"; | |
| 40 | |
| 41 const char kGetRefreshTokenResponseFormat[] = | |
| 42 "{" | |
| 43 " \"access_token\": \"<ignored>\"," | |
| 44 " \"expires_in\": 12345," | |
| 45 " \"refresh_token\": \"%s\"" | |
| 46 "}"; | |
| 47 | |
| 48 // Utility methods -------------------------------------------------- | |
| 49 | |
| 50 // Slightly hacky way to extract a value from a URL-encoded POST request body. | |
| 51 bool GetValueForKey(const std::string& encoded_string, | |
| 52 const std::string& key, | |
| 53 std::string* value) { | |
| 54 GURL url("http://example.com/?" + encoded_string); | |
| 55 return net::GetValueForKeyInQuery(url, key, value); | |
| 56 } | |
| 57 | |
| 58 void SendResponse(net::TestURLFetcher* url_fetcher, | |
| 59 const std::string& response) { | |
| 60 url_fetcher->set_status( | |
| 61 net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0)); | |
| 62 url_fetcher->set_response_code(net::HTTP_OK); | |
| 63 url_fetcher->SetResponseString(response); | |
| 64 url_fetcher->delegate()->OnURLFetchComplete(url_fetcher); | |
| 65 } | |
| 66 | |
| 67 void SetNetworkError(net::TestURLFetcher* url_fetcher, int error) { | |
| 68 url_fetcher->set_status( | |
| 69 net::URLRequestStatus(net::URLRequestStatus::FAILED, error)); | |
| 70 url_fetcher->delegate()->OnURLFetchComplete(url_fetcher); | |
| 71 } | |
| 72 | |
| 73 void SetHttpError(net::TestURLFetcher* url_fetcher, int error) { | |
| 74 url_fetcher->set_status(net::URLRequestStatus()); | |
| 75 url_fetcher->set_response_code(error); | |
| 76 url_fetcher->delegate()->OnURLFetchComplete(url_fetcher); | |
| 77 } | |
| 78 | |
| 79 void VerifyTokenRequest( | |
| 80 std::vector<FakeProfileOAuth2TokenService::PendingRequest> requests) { | |
| 81 ASSERT_EQ(1u, requests.size()); | |
| 82 EXPECT_EQ(1u, requests[0].scopes.size()); | |
| 83 EXPECT_EQ(1u, requests[0].scopes.count(GaiaConstants::kOAuth1LoginScope)); | |
| 84 } | |
| 85 | |
| 86 } // namespace | |
| 87 | |
| 88 class ManagedUserRefreshTokenFetcherTest : public testing::Test { | |
| 89 public: | |
| 90 ManagedUserRefreshTokenFetcherTest(); | |
| 91 virtual ~ManagedUserRefreshTokenFetcherTest() {} | |
| 92 | |
| 93 protected: | |
| 94 void StartFetching(); | |
| 95 | |
| 96 net::TestURLFetcher* GetIssueTokenRequest(); | |
| 97 net::TestURLFetcher* GetRefreshTokenRequest(); | |
| 98 | |
| 99 void MakeOAuth2TokenServiceRequestSucceed(); | |
| 100 void MakeOAuth2TokenServiceRequestFail(GoogleServiceAuthError::State error); | |
| 101 void MakeIssueTokenRequestSucceed(); | |
| 102 void MakeRefreshTokenFetchSucceed(); | |
| 103 | |
| 104 void Reset(); | |
| 105 | |
| 106 const GoogleServiceAuthError& error() const { return error_; } | |
| 107 const std::string& token() const { return token_; } | |
| 108 | |
| 109 private: | |
| 110 void OnTokenFetched(const GoogleServiceAuthError& error, | |
| 111 const std::string& token); | |
| 112 | |
| 113 content::TestBrowserThreadBundle thread_bundle_; | |
| 114 TestingProfile profile_; | |
| 115 FakeProfileOAuth2TokenService oauth2_token_service_; | |
| 116 net::TestURLFetcherFactory url_fetcher_factory_; | |
| 117 scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher_; | |
| 118 | |
| 119 GoogleServiceAuthError error_; | |
| 120 std::string token_; | |
| 121 base::WeakPtrFactory<ManagedUserRefreshTokenFetcherTest> weak_ptr_factory_; | |
| 122 }; | |
| 123 | |
| 124 ManagedUserRefreshTokenFetcherTest::ManagedUserRefreshTokenFetcherTest() | |
| 125 : token_fetcher_( | |
| 126 ManagedUserRefreshTokenFetcher::Create(&oauth2_token_service_, | |
| 127 kAccountId, | |
| 128 profile_.GetRequestContext())), | |
| 129 error_(GoogleServiceAuthError::NONE), | |
| 130 weak_ptr_factory_(this) {} | |
| 131 | |
| 132 void ManagedUserRefreshTokenFetcherTest::StartFetching() { | |
| 133 oauth2_token_service_.IssueRefreshToken(kOAuth2RefreshToken); | |
| 134 token_fetcher_->Start(kManagedUserId, kDeviceName, | |
| 135 base::Bind( | |
| 136 &ManagedUserRefreshTokenFetcherTest::OnTokenFetched, | |
| 137 weak_ptr_factory_.GetWeakPtr())); | |
| 138 } | |
| 139 | |
| 140 net::TestURLFetcher* | |
| 141 ManagedUserRefreshTokenFetcherTest::GetIssueTokenRequest() { | |
| 142 net::TestURLFetcher* url_fetcher = url_fetcher_factory_.GetFetcherByID(1); | |
| 143 if (!url_fetcher) | |
| 144 return NULL; | |
| 145 | |
| 146 EXPECT_EQ(GaiaUrls::GetInstance()->oauth2_issue_token_url(), | |
| 147 url_fetcher->GetOriginalURL()); | |
| 148 std::string access_token; | |
| 149 net::HttpRequestHeaders headers; | |
| 150 url_fetcher->GetExtraRequestHeaders(&headers); | |
| 151 EXPECT_TRUE(headers.GetHeader("Authorization", &access_token)); | |
| 152 EXPECT_EQ(std::string("Bearer ") + kAccessToken, access_token); | |
| 153 const std::string upload_data = url_fetcher->upload_data(); | |
| 154 std::string managed_user_id; | |
| 155 EXPECT_TRUE(GetValueForKey(upload_data, "profile_id", &managed_user_id)); | |
| 156 EXPECT_EQ(kManagedUserId, managed_user_id); | |
| 157 std::string device_name; | |
| 158 EXPECT_TRUE(GetValueForKey(upload_data, "device_name", &device_name)); | |
| 159 EXPECT_EQ(kDeviceName, device_name); | |
| 160 return url_fetcher; | |
| 161 } | |
| 162 | |
| 163 net::TestURLFetcher* | |
| 164 ManagedUserRefreshTokenFetcherTest::GetRefreshTokenRequest() { | |
| 165 net::TestURLFetcher* url_fetcher = url_fetcher_factory_.GetFetcherByID( | |
| 166 gaia::GaiaOAuthClient::kUrlFetcherId); | |
| 167 if (!url_fetcher) | |
| 168 return NULL; | |
| 169 | |
| 170 EXPECT_EQ(GaiaUrls::GetInstance()->oauth2_token_url(), | |
| 171 url_fetcher->GetOriginalURL()); | |
| 172 std::string auth_code; | |
| 173 EXPECT_TRUE(GetValueForKey(url_fetcher->upload_data(), "code", &auth_code)); | |
| 174 EXPECT_EQ(kAuthorizationCode, auth_code); | |
| 175 return url_fetcher; | |
| 176 } | |
| 177 | |
| 178 void | |
| 179 ManagedUserRefreshTokenFetcherTest::MakeOAuth2TokenServiceRequestSucceed() { | |
| 180 std::vector<FakeProfileOAuth2TokenService::PendingRequest> requests = | |
| 181 oauth2_token_service_.GetPendingRequests(); | |
| 182 VerifyTokenRequest(requests); | |
| 183 base::Time expiration_date = base::Time::Now() + | |
| 184 base::TimeDelta::FromHours(1); | |
| 185 oauth2_token_service_.IssueTokenForScope(requests[0].scopes, | |
| 186 kAccessToken, | |
| 187 expiration_date); | |
| 188 } | |
| 189 | |
| 190 void | |
| 191 ManagedUserRefreshTokenFetcherTest::MakeOAuth2TokenServiceRequestFail( | |
| 192 GoogleServiceAuthError::State error) { | |
| 193 std::vector<FakeProfileOAuth2TokenService::PendingRequest> requests = | |
| 194 oauth2_token_service_.GetPendingRequests(); | |
| 195 VerifyTokenRequest(requests); | |
| 196 oauth2_token_service_.IssueErrorForScope(requests[0].scopes, | |
| 197 GoogleServiceAuthError(error)); | |
| 198 } | |
| 199 | |
| 200 void ManagedUserRefreshTokenFetcherTest::MakeIssueTokenRequestSucceed() { | |
| 201 SendResponse(GetIssueTokenRequest(), | |
| 202 base::StringPrintf(kIssueTokenResponseFormat, | |
| 203 kAuthorizationCode)); | |
| 204 } | |
| 205 | |
| 206 void ManagedUserRefreshTokenFetcherTest::MakeRefreshTokenFetchSucceed() { | |
| 207 SendResponse(GetRefreshTokenRequest(), | |
| 208 base::StringPrintf(kGetRefreshTokenResponseFormat, | |
| 209 kManagedUserToken)); | |
| 210 } | |
| 211 | |
| 212 void ManagedUserRefreshTokenFetcherTest::Reset() { | |
| 213 token_fetcher_.reset(); | |
| 214 } | |
| 215 | |
| 216 void ManagedUserRefreshTokenFetcherTest::OnTokenFetched( | |
| 217 const GoogleServiceAuthError& error, | |
| 218 const std::string& token) { | |
| 219 error_ = error; | |
| 220 token_ = token; | |
| 221 } | |
| 222 | |
| 223 // Tests -------------------------------------------------------- | |
| 224 | |
| 225 TEST_F(ManagedUserRefreshTokenFetcherTest, Success) { | |
| 226 StartFetching(); | |
| 227 MakeOAuth2TokenServiceRequestSucceed(); | |
| 228 MakeIssueTokenRequestSucceed(); | |
| 229 MakeRefreshTokenFetchSucceed(); | |
| 230 | |
| 231 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 232 EXPECT_EQ(kManagedUserToken, token()); | |
| 233 } | |
| 234 | |
| 235 TEST_F(ManagedUserRefreshTokenFetcherTest, ExpiredAccessToken) { | |
| 236 StartFetching(); | |
| 237 MakeOAuth2TokenServiceRequestSucceed(); | |
| 238 SetHttpError(GetIssueTokenRequest(), net::HTTP_UNAUTHORIZED); | |
| 239 MakeOAuth2TokenServiceRequestSucceed(); | |
| 240 MakeIssueTokenRequestSucceed(); | |
| 241 MakeRefreshTokenFetchSucceed(); | |
| 242 | |
| 243 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 244 EXPECT_EQ(kManagedUserToken, token()); | |
| 245 } | |
| 246 | |
| 247 TEST_F(ManagedUserRefreshTokenFetcherTest, ExpiredAccessTokenRetry) { | |
| 248 // If we get a 401 error for the second time, we should give up instead of | |
| 249 // retrying again. | |
| 250 StartFetching(); | |
| 251 MakeOAuth2TokenServiceRequestSucceed(); | |
| 252 SetHttpError(GetIssueTokenRequest(), net::HTTP_UNAUTHORIZED); | |
| 253 MakeOAuth2TokenServiceRequestSucceed(); | |
| 254 SetHttpError(GetIssueTokenRequest(), net::HTTP_UNAUTHORIZED); | |
| 255 | |
| 256 EXPECT_EQ(GoogleServiceAuthError::CONNECTION_FAILED, error().state()); | |
| 257 EXPECT_EQ(net::ERR_FAILED, error().network_error()); | |
| 258 EXPECT_EQ(std::string(), token()); | |
| 259 } | |
| 260 | |
| 261 TEST_F(ManagedUserRefreshTokenFetcherTest, MalformedIssueTokenResponse) { | |
| 262 StartFetching(); | |
| 263 MakeOAuth2TokenServiceRequestSucceed(); | |
| 264 SendResponse(GetIssueTokenRequest(), "choke"); | |
| 265 | |
| 266 EXPECT_EQ(GoogleServiceAuthError::CONNECTION_FAILED, error().state()); | |
| 267 EXPECT_EQ(net::ERR_INVALID_RESPONSE, error().network_error()); | |
| 268 EXPECT_EQ(std::string(), token()); | |
| 269 } | |
| 270 | |
| 271 TEST_F(ManagedUserRefreshTokenFetcherTest, FetchAccessTokenFailure) { | |
| 272 StartFetching(); | |
| 273 MakeOAuth2TokenServiceRequestFail( | |
| 274 GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS); | |
| 275 | |
| 276 EXPECT_EQ(GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS, error().state()); | |
| 277 EXPECT_EQ(std::string(), token()); | |
| 278 } | |
| 279 | |
| 280 TEST_F(ManagedUserRefreshTokenFetcherTest, IssueTokenNetworkError) { | |
| 281 StartFetching(); | |
| 282 MakeOAuth2TokenServiceRequestSucceed(); | |
| 283 SetNetworkError(GetIssueTokenRequest(), net::ERR_SSL_PROTOCOL_ERROR); | |
| 284 | |
| 285 EXPECT_EQ(GoogleServiceAuthError::CONNECTION_FAILED, error().state()); | |
| 286 EXPECT_EQ(net::ERR_SSL_PROTOCOL_ERROR, error().network_error()); | |
| 287 EXPECT_EQ(std::string(), token()); | |
| 288 } | |
| 289 | |
| 290 TEST_F(ManagedUserRefreshTokenFetcherTest, FetchRefreshTokenNetworkError) { | |
| 291 StartFetching(); | |
| 292 MakeOAuth2TokenServiceRequestSucceed(); | |
| 293 MakeIssueTokenRequestSucceed(); | |
| 294 SetNetworkError(GetRefreshTokenRequest(), net::ERR_CONNECTION_REFUSED); | |
| 295 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 296 SetNetworkError(GetRefreshTokenRequest(), net::ERR_CONNECTION_REFUSED); | |
| 297 | |
| 298 EXPECT_EQ(GoogleServiceAuthError::CONNECTION_FAILED, error().state()); | |
| 299 EXPECT_EQ(net::ERR_FAILED, error().network_error()); | |
| 300 EXPECT_EQ(std::string(), token()); | |
| 301 } | |
| 302 | |
| 303 TEST_F(ManagedUserRefreshTokenFetcherTest, | |
| 304 FetchRefreshTokenTransientNetworkError) { | |
| 305 StartFetching(); | |
| 306 MakeOAuth2TokenServiceRequestSucceed(); | |
| 307 MakeIssueTokenRequestSucceed(); | |
| 308 SetNetworkError(GetRefreshTokenRequest(), net::ERR_CONNECTION_REFUSED); | |
| 309 | |
| 310 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 311 MakeRefreshTokenFetchSucceed(); | |
| 312 | |
| 313 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 314 EXPECT_EQ(kManagedUserToken, token()); | |
| 315 } | |
| 316 | |
| 317 TEST_F(ManagedUserRefreshTokenFetcherTest, FetchRefreshTokenBadRequest) { | |
| 318 StartFetching(); | |
| 319 MakeOAuth2TokenServiceRequestSucceed(); | |
| 320 MakeIssueTokenRequestSucceed(); | |
| 321 SetHttpError(GetRefreshTokenRequest(), net::HTTP_BAD_REQUEST); | |
| 322 | |
| 323 EXPECT_EQ(GoogleServiceAuthError::CONNECTION_FAILED, error().state()); | |
| 324 EXPECT_EQ(net::ERR_FAILED, error().network_error()); | |
| 325 EXPECT_EQ(std::string(), token()); | |
| 326 } | |
| 327 | |
| 328 TEST_F(ManagedUserRefreshTokenFetcherTest, CancelWhileFetchingAccessToken) { | |
| 329 StartFetching(); | |
| 330 Reset(); | |
| 331 | |
| 332 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 333 EXPECT_EQ(std::string(), token()); | |
| 334 } | |
| 335 | |
| 336 TEST_F(ManagedUserRefreshTokenFetcherTest, CancelWhileCallingIssueToken) { | |
| 337 StartFetching(); | |
| 338 MakeOAuth2TokenServiceRequestSucceed(); | |
| 339 Reset(); | |
| 340 | |
| 341 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 342 EXPECT_EQ(std::string(), token()); | |
| 343 } | |
| 344 | |
| 345 TEST_F(ManagedUserRefreshTokenFetcherTest, CancelWhileFetchingRefreshToken) { | |
| 346 StartFetching(); | |
| 347 MakeOAuth2TokenServiceRequestSucceed(); | |
| 348 MakeIssueTokenRequestSucceed(); | |
| 349 Reset(); | |
| 350 | |
| 351 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 352 EXPECT_EQ(std::string(), token()); | |
| 353 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 335833003:
Rename "managed (mode|user)" to "supervised user" (part 2) (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src