Signin/OAuth: Create an AccessTokenFetcher helper class

components/suggestions/suggestions_service_impl_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 "components/suggestions/suggestions_service_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
+#include "components/signin/core/browser/fake_signin_manager.h"
+#include "components/signin/core/browser/test_signin_client.h"
 #include "components/suggestions/blacklist_store.h"
 #include "components/suggestions/image_manager.h"
 #include "components/suggestions/proto/suggestions.pb.h"
 #include "components/suggestions/suggestions_store.h"
 #include "components/sync/driver/fake_sync_service.h"
 #include "components/sync/driver/sync_service.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "net/base/escape.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image.h"
 
+using sync_preferences::TestingPrefServiceSyncable;
+using testing::_;
+using testing::AnyNumber;
 using testing::DoAll;
-using ::testing::AnyNumber;
-using ::testing::Eq;
-using ::testing::Return;
+using testing::Eq;
+using testing::NiceMock;
+using testing::Return;
 using testing::SetArgPointee;
-using ::testing::NiceMock;
-using ::testing::StrictMock;
-using ::testing::_;
+using testing::StrictMock;
 
 namespace {
 
-// SuggestionsService::AccessTokenFetcher provides an empty account ID if its
-// SigninManager is null.
-const char kAccountId[] = "";
+const char kAccountId[] = "account";
 const char kTestTitle[] = "a title";
 const char kTestUrl[] = "http://go.com";
 const char kTestFaviconUrl[] =
     "https://s2.googleusercontent.com/s2/favicons?domain_url="
     "http://go.com&alt=s&sz=32";
 const char kBlacklistedUrl[] = "http://blacklist.com";
 const char kBlacklistedUrlAlt[] = "http://blacklist-atl.com";
 const int64_t kTestDefaultExpiry = 1402200000000000;
 const int64_t kTestSetExpiry = 1404792000000000;
 
@@ skipping 130 matching lines @@
   int suggestions_empty_data_count_;
   bool blacklisting_failed_;
   bool undo_blacklisting_failed_;
 
  protected:
   SuggestionsServiceTest()
       : suggestions_data_callback_count_(0),
         suggestions_empty_data_count_(0),
         blacklisting_failed_(false),
         undo_blacklisting_failed_(false),
+        signin_client_(&pref_service_),
+        signin_manager_(&signin_client_, &account_tracker_),
         factory_(nullptr, base::Bind(&CreateURLFetcher)),
         mock_sync_service_(nullptr),
         mock_thumbnail_manager_(nullptr),
         mock_blacklist_store_(nullptr),
         test_suggestions_store_(nullptr) {
+    SigninManagerBase::RegisterProfilePrefs(pref_service_.registry());
+    SigninManagerBase::RegisterPrefs(pref_service_.registry());
+
+    signin_manager_.SignIn(kAccountId);
     token_service_.UpdateCredentials(kAccountId, "refresh_token");
     token_service_.set_auto_post_fetch_response_on_message_loop(true);
   }
 
   ~SuggestionsServiceTest() override {}
 
   void SetUp() override {
     request_context_ =
         new net::TestURLRequestContextGetter(io_message_loop_.task_runner());
   }
 
   std::unique_ptr<SuggestionsServiceImpl> CreateSuggestionsServiceWithMocks() {
     mock_sync_service_.reset(new MockSyncService);
-    ON_CALL(*mock_sync_service_, CanSyncStart()).WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, IsSyncActive()).WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, ConfigurationDone())
-        .WillByDefault(Return(true));
-    ON_CALL(*mock_sync_service_, GetActiveDataTypes())
-        .WillByDefault(
+    EXPECT_CALL(*mock_sync_service_, CanSyncStart())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_, IsSyncActive())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_, ConfigurationDone())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_, GetActiveDataTypes())
+        .Times(AnyNumber())
+        .WillRepeatedly(
             Return(syncer::ModelTypeSet(syncer::HISTORY_DELETE_DIRECTIVES)));
 
     // These objects are owned by the returned SuggestionsService, but we keep
     // the pointer around for testing.
     test_suggestions_store_ = new TestSuggestionsStore();
     mock_thumbnail_manager_ = new StrictMock<MockImageManager>();
     mock_blacklist_store_ = new StrictMock<MockBlacklistStore>();
     return base::MakeUnique<SuggestionsServiceImpl>(
-        nullptr /* signin_manager */, &token_service_, mock_sync_service_.get(),
+        &signin_manager_, &token_service_, mock_sync_service_.get(),
         request_context_.get(), base::WrapUnique(test_suggestions_store_),
         base::WrapUnique(mock_thumbnail_manager_),
         base::WrapUnique(mock_blacklist_store_));
   }
 
   void Blacklist(SuggestionsService* suggestions_service, GURL url) {
     blacklisting_failed_ = !suggestions_service->BlacklistURL(url);
   }
 
   void UndoBlacklist(SuggestionsService* suggestions_service, GURL url) {
@@ skipping 47 matching lines @@
     EXPECT_TRUE(undo_blacklisting_failed_);
   }
 
   bool HasPendingSuggestionsRequest(
       SuggestionsServiceImpl* suggestions_service) {
     return !!suggestions_service->pending_request_.get();
   }
 
  protected:
   base::MessageLoopForIO io_message_loop_;
+  TestingPrefServiceSyncable pref_service_;
+  AccountTrackerService account_tracker_;
+  TestSigninClient signin_client_;
+  FakeSigninManagerBase signin_manager_;
   net::FakeURLFetcherFactory factory_;
   FakeProfileOAuth2TokenService token_service_;
   std::unique_ptr<MockSyncService> mock_sync_service_;
   // Only used if the SuggestionsService is built with mocks. Not owned.
   MockImageManager* mock_thumbnail_manager_;
   MockBlacklistStore* mock_blacklist_store_;
   TestSuggestionsStore* test_suggestions_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 
  private:
@@ skipping 82 matching lines @@
   suggestions_service->FetchSuggestionsData();
 
   // Let any network request run.
   base::RunLoop().RunUntilIdle();
 
   // Ensure that CheckCallback didn't run again.
   EXPECT_EQ(1, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoAccessToken) {
-  token_service_.RevokeCredentials(kAccountId);
+  token_service_.set_auto_post_fetch_response_on_message_loop(false);
 
   std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   suggestions_service->FetchSuggestionsData();
 
+  token_service_.IssueErrorForAllPendingRequests(GoogleServiceAuthError(
+      GoogleServiceAuthError::State::INVALID_GAIA_CREDENTIALS));
+
   // No network request should be sent.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(HasPendingSuggestionsRequest(suggestions_service.get()));
   EXPECT_EQ(0, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingError) {
   std::unique_ptr<SuggestionsServiceImpl> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
@@ skipping 311 matching lines @@
   EXPECT_CALL(*mock_thumbnail_manager_, GetImageForURL(test_url, _));
   suggestions_service->GetPageThumbnail(test_url, dummy_callback);
 
   EXPECT_CALL(*mock_thumbnail_manager_, AddImageURL(test_url, thumbnail_url));
   EXPECT_CALL(*mock_thumbnail_manager_, GetImageForURL(test_url, _));
   suggestions_service->GetPageThumbnailWithURL(test_url, thumbnail_url,
                                                dummy_callback);
 }
 
 }  // namespace suggestions