[GCM] Fetching OAuth2 tokens periodically in account tracker

chrome/browser/services/gcm/gcm_account_tracker_unittest.cc

 // 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 "chrome/browser/services/gcm/gcm_account_tracker.h"
 
 #include <map>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "google_apis/gaia/fake_identity_provider.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
@@ skipping 46 matching lines @@
  public:
   CustomFakeGCMDriver();
   ~CustomFakeGCMDriver() override;
 
   // GCMDriver overrides:
   void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
   void AddConnectionObserver(GCMConnectionObserver* observer) override;
   void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
   bool IsConnected() const override { return connected_; }
+  base::Time GetLastTokenFetchTime() override;
+  void SetLastTokenFetchTime(const base::Time& time) override;
 
   // Test results and helpers.
   void SetConnected(bool connected);
   void ResetResults();
   bool update_accounts_called() const { return update_accounts_called_; }
   const std::vector<GCMClient::AccountTokenInfo>& accounts() const {
     return accounts_;
   }
   const GCMConnectionObserver* last_connection_observer() const {
     return last_connection_observer_;
   }
   const GCMConnectionObserver* last_removed_connection_observer() const {
     return removed_connection_observer_;
   }
 
  private:
   bool connected_;
   std::vector<GCMClient::AccountTokenInfo> accounts_;
   bool update_accounts_called_;
   GCMConnectionObserver* last_connection_observer_;
   GCMConnectionObserver* removed_connection_observer_;
   net::IPEndPoint ip_endpoint_;
+  base::Time last_token_fetch_time_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
 };
 
 CustomFakeGCMDriver::CustomFakeGCMDriver()
     : connected_(true),
       update_accounts_called_(false),
       last_connection_observer_(NULL),
       removed_connection_observer_(NULL) {
 }
@@ skipping 23 matching lines @@
     last_connection_observer_->OnConnected(ip_endpoint_);
 }
 
 void CustomFakeGCMDriver::ResetResults() {
   accounts_.clear();
   update_accounts_called_ = false;
   last_connection_observer_ = NULL;
   removed_connection_observer_ = NULL;
 }
 
+
+base::Time CustomFakeGCMDriver::GetLastTokenFetchTime() {
+  return last_token_fetch_time_;
+}
+
+void CustomFakeGCMDriver::SetLastTokenFetchTime(const base::Time& time) {
+  last_token_fetch_time_ = time;
+}
+
 }  // namespace
 
 class GCMAccountTrackerTest : public testing::Test {
  public:
   GCMAccountTrackerTest();
   ~GCMAccountTrackerTest() override;
 
   // Helpers to pass fake events to the tracker. Tests should have either a pair
   // of Start/FinishAccountSignIn or SignInAccount per account. Don't mix.
   // Call to SignOutAccount is not mandatory.
   void StartAccountSignIn(const std::string& account_key);
   void FinishAccountSignIn(const std::string& account_key);
   void SignInAccount(const std::string& account_key);
   void SignOutAccount(const std::string& account_key);
 
   // Helpers for dealing with OAuth2 access token requests.
   void IssueAccessToken(const std::string& account_key);
   void IssueExpiredAccessToken(const std::string& account_key);
   void IssueError(const std::string& account_key);
 
   // Accessors to account tracker and gcm driver.
   GCMAccountTracker* tracker() { return tracker_.get(); }
   CustomFakeGCMDriver* driver() { return &driver_; }
 
+  // Accessors to private methods of account tracker.
+  bool IsFetchingRequired() const;
+  bool IsTokenReportingRequired() const;
+  base::TimeDelta GetTimeToNextTokenFetching() const;
+
  private:
   CustomFakeGCMDriver driver_;
 
   base::MessageLoop message_loop_;
   net::TestURLFetcherFactory test_fetcher_factory_;
   scoped_ptr<FakeOAuth2TokenService> fake_token_service_;
   scoped_ptr<FakeIdentityProvider> fake_identity_provider_;
   scoped_ptr<GCMAccountTracker> tracker_;
 };
 
@@ skipping 52 matching lines @@
   fake_token_service_->IssueAllTokensForAccount(
       account_key, MakeAccessToken(account_key), base::Time::Now());
 }
 
 void GCMAccountTrackerTest::IssueError(const std::string& account_key) {
   fake_token_service_->IssueErrorForAllPendingRequestsForAccount(
       account_key,
       GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
 }
 
+bool GCMAccountTrackerTest::IsFetchingRequired() const {
+  return tracker_->IsTokenFetchingRequired();
+}
+
+bool GCMAccountTrackerTest::IsTokenReportingRequired() const {
+  return tracker_->IsTokenReportingRequired();
+}
+
+base::TimeDelta GCMAccountTrackerTest::GetTimeToNextTokenFetching() const {
+  return tracker_->GetTimeToNextTokenFetching();
+}
+
 TEST_F(GCMAccountTrackerTest, NoAccounts) {
   EXPECT_FALSE(driver()->update_accounts_called());
   tracker()->Start();
   // Callback should not be called if there where no accounts provided.
   EXPECT_FALSE(driver()->update_accounts_called());
   EXPECT_TRUE(driver()->accounts().empty());
 }
 
 // Verifies that callback is called after a token is issued for a single account
 // with a specific scope. In this scenario, the underlying account tracker is
@@ skipping 146 matching lines @@
   StartAccountSignIn(kAccountId1);
   tracker()->Start();
   FinishAccountSignIn(kAccountId1);
 
   EXPECT_EQ(0UL, tracker()->get_pending_token_request_count());
   driver()->SetConnected(true);
 
   EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
 }
 
-TEST_F(GCMAccountTrackerTest, IvalidateExpiredTokens) {
+TEST_F(GCMAccountTrackerTest, InvalidateExpiredTokens) {
   StartAccountSignIn(kAccountId1);
   StartAccountSignIn(kAccountId2);
   tracker()->Start();
   FinishAccountSignIn(kAccountId1);
   FinishAccountSignIn(kAccountId2);
 
   EXPECT_EQ(2UL, tracker()->get_pending_token_request_count());
 
   IssueExpiredAccessToken(kAccountId1);
   IssueAccessToken(kAccountId2);
   // Because the first token is expired, we expect the sanitize to kick in and
   // clean it up before the SetAccessToken is called. This also means a new
   // token request will be issued
   EXPECT_FALSE(driver()->update_accounts_called());
   EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
 }
 
+// Testing for whether there are still more tokens to be fetched. Typically the
+// need for token fetching triggers immediate request, unless there is no
+// connection, that is why connection is set on and off in this test.
+TEST_F(GCMAccountTrackerTest, IsTokenFetchingRequired) {
+  tracker()->Start();
+  driver()->SetConnected(false);
+  EXPECT_FALSE(IsFetchingRequired());
+  StartAccountSignIn(kAccountId1);
+  FinishAccountSignIn(kAccountId1);
+  EXPECT_TRUE(IsFetchingRequired());
+
+  driver()->SetConnected(true);
+  EXPECT_FALSE(IsFetchingRequired());  // Indicates that fetching has started.
+  IssueAccessToken(kAccountId1);
+  EXPECT_FALSE(IsFetchingRequired());
+
+  driver()->SetConnected(false);
+  StartAccountSignIn(kAccountId2);
+  FinishAccountSignIn(kAccountId2);
+  EXPECT_TRUE(IsFetchingRequired());
+
+  IssueExpiredAccessToken(kAccountId2);
+  // Make sure that if the token was expired it is still needed.
+  EXPECT_TRUE(IsFetchingRequired());
+}
+
+// Tests what is the expected time to the next token fetching.
+TEST_F(GCMAccountTrackerTest, GetTimeToNextTokenFetching) {
+  tracker()->Start();
+  // At this point the last token fetch time is never.
+  EXPECT_EQ(base::TimeDelta(), GetTimeToNextTokenFetching());
+
+  driver()->SetLastTokenFetchTime(base::Time::Now());
+  EXPECT_TRUE(GetTimeToNextTokenFetching() <=
+                  base::TimeDelta::FromSeconds(12 * 60 * 60));
+}
+
+// Tests conditions when token reporting is required.
+TEST_F(GCMAccountTrackerTest, IsTokenReportingRequired) {
+  tracker()->Start();
+  // Required because it is overdue.
+  EXPECT_TRUE(IsTokenReportingRequired());
+
+  // Not required because it just happened.
+  driver()->SetLastTokenFetchTime(base::Time::Now());
+  EXPECT_FALSE(IsTokenReportingRequired());
+
+  SignInAccount(kAccountId1);
+  IssueAccessToken(kAccountId1);
+  driver()->ResetResults();
+  // Reporting was triggered, which means testing for required will give false,
+  // but we have the update call.
+  SignOutAccount(kAccountId1);
+  EXPECT_TRUE(driver()->update_accounts_called());
+  EXPECT_FALSE(IsTokenReportingRequired());
+}
+
 // TODO(fgorski): Add test for adding account after removal >> make sure it does
 // not mark removal.
 
 }  // namespace gcm