| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/memory/scoped_ptr.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/message_loop/message_loop_proxy.h" |
| #include "base/strings/string_util.h" |
| #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" |
| #include "components/signin/core/browser/account_service_flag_fetcher.h" |
| #include "google_apis/gaia/gaia_urls.h" |
| #include "net/url_request/test_url_fetcher_factory.h" |
| #include "net/url_request/url_request_test_util.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| const char kAccountId[] = "user@gmail.com"; |
| const char kDifferentAccountId[] = "some_other_user@gmail.com"; |
| |
| const int kGaiaAuthFetcherURLFetcherID = 0; |
| |
| // TODO(treib): This class should really live in components/signin/ next to the |
| // AccountServiceFlagFetcher, but it uses the FakePO2TS which lives in |
| // chrome/browser/ (because it uses the AndroidPO2TS which depends on stuff from |
| // chrome/browser/). So when the AndroidPO2TS is componentized, then this should |
| // move as well. |
| class AccountServiceFlagFetcherTest : public testing::Test { |
| public: |
| AccountServiceFlagFetcherTest() |
| : request_context_(new net::TestURLRequestContextGetter( |
| base::MessageLoopProxy::current())) { |
| service_flags_.push_back("some_flag"); |
| service_flags_.push_back("another_flag"); |
| service_flags_.push_back("andonemore"); |
| } |
| |
| MOCK_METHOD2(OnFlagsFetched, |
| void(AccountServiceFlagFetcher::ResultCode result, |
| const std::vector<std::string>& flags)); |
| |
| protected: |
| net::TestURLFetcher* GetLoginURLFetcher() { |
| net::TestURLFetcher* fetcher = |
| url_fetcher_factory_.GetFetcherByID(kGaiaAuthFetcherURLFetcherID); |
| EXPECT_TRUE(fetcher); |
| |
| EXPECT_EQ(GaiaUrls::GetInstance()->oauth1_login_url(), |
| fetcher->GetOriginalURL()); |
| |
| return fetcher; |
| } |
| |
| net::TestURLFetcher* GetGetUserInfoURLFetcher() { |
| net::TestURLFetcher* fetcher = |
| url_fetcher_factory_.GetFetcherByID(kGaiaAuthFetcherURLFetcherID); |
| EXPECT_TRUE(fetcher); |
| |
| EXPECT_EQ(GaiaUrls::GetInstance()->get_user_info_url(), |
| fetcher->GetOriginalURL()); |
| |
| return fetcher; |
| } |
| |
| void SendValidLoginResponse() { |
| net::TestURLFetcher* fetcher = GetLoginURLFetcher(); |
| fetcher->set_status( |
| net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0)); |
| fetcher->set_response_code(net::HTTP_OK); |
| fetcher->SetResponseString(std::string("SID=sid\nLSID=lsid\nAuth=auth\n")); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| } |
| |
| void SendFailedLoginResponse() { |
| net::TestURLFetcher* fetcher = GetLoginURLFetcher(); |
| fetcher->set_status( |
| net::URLRequestStatus(net::URLRequestStatus::CANCELED, 0)); |
| fetcher->set_response_code(net::HTTP_OK); |
| fetcher->SetResponseString(std::string()); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| } |
| |
| void SendValidGetUserInfoResponse() { |
| net::TestURLFetcher* fetcher = GetGetUserInfoURLFetcher(); |
| fetcher->set_status( |
| net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0)); |
| fetcher->set_response_code(net::HTTP_OK); |
| fetcher->SetResponseString(BuildGetUserInfoResponse()); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| } |
| |
| void SendInvalidGetUserInfoResponse() { |
| net::TestURLFetcher* fetcher = GetGetUserInfoURLFetcher(); |
| fetcher->set_status( |
| net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0)); |
| fetcher->set_response_code(net::HTTP_OK); |
| fetcher->SetResponseString(std::string("allServicesIsMissing=true")); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| } |
| |
| void SendFailedGetUserInfoResponse() { |
| net::TestURLFetcher* fetcher = GetGetUserInfoURLFetcher(); |
| fetcher->set_status( |
| net::URLRequestStatus(net::URLRequestStatus::CANCELED, 0)); |
| fetcher->set_response_code(net::HTTP_OK); |
| fetcher->SetResponseString(std::string()); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| } |
| |
| std::string BuildGetUserInfoResponse() const { |
| return "allServices=" + JoinString(service_flags_, ','); |
| } |
| |
| base::MessageLoop message_loop_; |
| FakeProfileOAuth2TokenService token_service_; |
| scoped_refptr<net::TestURLRequestContextGetter> request_context_; |
| net::TestURLFetcherFactory url_fetcher_factory_; |
| net::ResponseCookies cookies_; |
| std::vector<std::string> service_flags_; |
| }; |
| |
| TEST_F(AccountServiceFlagFetcherTest, Success) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| // Since a refresh token is already available, we should immediately get a |
| // request for an access token. |
| EXPECT_EQ(1U, token_service_.GetPendingRequests().size()); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| SendValidLoginResponse(); |
| |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::SUCCESS, |
| service_flags_)); |
| SendValidGetUserInfoResponse(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, SuccessAfterWaitingForRefreshToken) { |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| // Since there is no refresh token yet, we should not get a request for an |
| // access token at this point. |
| EXPECT_EQ(0U, token_service_.GetPendingRequests().size()); |
| |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| // Now there is a refresh token and we should have got a request for an |
| // access token. |
| EXPECT_EQ(1U, token_service_.GetPendingRequests().size()); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| SendValidLoginResponse(); |
| |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::SUCCESS, |
| service_flags_)); |
| SendValidGetUserInfoResponse(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, NoRefreshToken) { |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| token_service_.UpdateCredentials(kDifferentAccountId, "refresh_token"); |
| |
| // Credentials for a different user should be ignored, i.e. not result in a |
| // request for an access token. |
| EXPECT_EQ(0U, token_service_.GetPendingRequests().size()); |
| |
| // After all refresh tokens have been loaded, there is still no token for our |
| // user, so we expect a token error. |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::TOKEN_ERROR, |
| std::vector<std::string>())); |
| token_service_.IssueAllRefreshTokensLoaded(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, GetTokenFailure) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| // On failure to get an access token we expect a token error. |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::TOKEN_ERROR, |
| std::vector<std::string>())); |
| token_service_.IssueErrorForAllPendingRequestsForAccount( |
| kAccountId, |
| GoogleServiceAuthError(GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS)); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, ClientLoginFailure) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| // Login failure should result in a service error. |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::SERVICE_ERROR, |
| std::vector<std::string>())); |
| SendFailedLoginResponse(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, GetUserInfoInvalidResponse) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| SendValidLoginResponse(); |
| |
| // Invalid response data from GetUserInfo should result in a service error. |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::SERVICE_ERROR, |
| std::vector<std::string>())); |
| SendInvalidGetUserInfoResponse(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, GetUserInfoFailure) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| SendValidLoginResponse(); |
| |
| // Failed GetUserInfo call should result in a service error. |
| EXPECT_CALL(*this, OnFlagsFetched(AccountServiceFlagFetcher::SERVICE_ERROR, |
| std::vector<std::string>())); |
| SendFailedGetUserInfoResponse(); |
| } |
| |
| TEST_F(AccountServiceFlagFetcherTest, DestroyFetcher) { |
| token_service_.UpdateCredentials(kAccountId, "refresh_token"); |
| |
| // When the fetcher is destroyed before the request completes, OnFlagsFetched |
| // should not be called. |
| EXPECT_CALL(*this, OnFlagsFetched(testing::_, testing::_)).Times(0); |
| |
| AccountServiceFlagFetcher fetcher( |
| kAccountId, |
| &token_service_, |
| request_context_.get(), |
| base::Bind(&AccountServiceFlagFetcherTest::OnFlagsFetched, |
| base::Unretained(this))); |
| |
| token_service_.IssueAllTokensForAccount( |
| kAccountId, |
| "access_token", |
| base::Time::Now() + base::TimeDelta::FromHours(1)); |
| |
| SendValidLoginResponse(); |
| // Do not send a GetUserInfo response, but make sure the request is there. |
| GetGetUserInfoURLFetcher(); |
| } |