Refactor OfflinePageSuggestionsProviderTest

components/ntp_snippets/offline_pages/offline_page_suggestions_provider_unittest.cc

 // Copyright 2016 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/ntp_snippets/offline_pages/offline_page_suggestions_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
 OfflinePageItem CreateDummyRecentTab(int id, base::Time time) {
   OfflinePageItem item = CreateDummyRecentTab(id);
   item.last_access_time = time;
   return item;
 }
 
 OfflinePageItem CreateDummyDownload(int id) {
   return CreateDummyItem(offline_pages::kAsyncNamespace, id);
 }
 
+void CaptureDismissedSuggestions(
+    std::vector<ContentSuggestion>* captured_suggestions,
+    std::vector<ContentSuggestion> dismissed_suggestions) {
+  std::move(dismissed_suggestions.begin(), dismissed_suggestions.end(),
+            std::back_inserter(*captured_suggestions));
+}
+
 }  // namespace
 
-class MockOfflinePageModel : public StubOfflinePageModel {
+class FakeOfflinePageModel : public StubOfflinePageModel {
  public:
-  MockOfflinePageModel() {}
+  FakeOfflinePageModel() {}
 
   void GetAllPages(const MultipleOfflinePageItemCallback& callback) override {
     callback.Run(items_);
   }
 
-  std::vector<OfflinePageItem>* items() { return &items_; }
+  const std::vector<OfflinePageItem>& items() { return items_; }
+  std::vector<OfflinePageItem>* mutable_items() { return &items_; }
 
  private:
   std::vector<OfflinePageItem> items_;
 };
 
 class OfflinePageSuggestionsProviderTest : public testing::Test {
  public:
   OfflinePageSuggestionsProviderTest()
       : pref_service_(new TestingPrefServiceSimple()) {
     OfflinePageSuggestionsProvider::RegisterProfilePrefs(
@@ skipping 20 matching lines @@
   }
 
   Category recent_tabs_category() {
     return category_factory_.FromKnownCategory(KnownCategories::RECENT_TABS);
   }
 
   Category downloads_category() {
     return category_factory_.FromKnownCategory(KnownCategories::DOWNLOADS);
   }
 
-  void AddItem(OfflinePageItem item) { model()->items()->push_back(item); }
-
   std::string GetDummySuggestionId(Category category, int id) {
     return provider_->MakeUniqueID(category, base::IntToString(id));
   }
 
   ContentSuggestion CreateDummySuggestion(Category category, int id) {
     std::string strid = base::IntToString(id);
     ContentSuggestion result(
         GetDummySuggestionId(category, id),
         GURL("file:///some/folder/test" + strid + ".mhtml"));
     result.set_title(base::UTF8ToUTF16("http://dummy.com/" + strid));
     return result;
   }
 
   void FireOfflinePageModelChanged() {
     provider_->OfflinePageModelChanged(model());
   }
 
   void FireOfflinePageDeleted(const OfflinePageItem& item) {
     provider_->OfflinePageDeleted(item.offline_id, item.client_id);
   }
 
   std::set<std::string> ReadDismissedIDsFromPrefs(Category category) {
     return provider_->ReadDismissedIDsFromPrefs(category);
   }
 
-  // Workaround to realize a DismissedSuggestionsCallback. Because gMock can't
-  // handle non-movable parameters, a helper method is needed to forward the
-  // call to the actual MOCK_METHOD.
-  void DismissedSuggestionsHelper(
-      std::vector<ContentSuggestion> dismissed_suggestions) {
-    ReceivedDismissedSuggestions(dismissed_suggestions);
-  }
-  MOCK_METHOD1(
-      ReceivedDismissedSuggestions,
-      void(const std::vector<ContentSuggestion>& dismissed_suggestions));
-
   ContentSuggestionsProvider* provider() { return provider_.get(); }
-  MockOfflinePageModel* model() { return &model_; }
+  FakeOfflinePageModel* model() { return &model_; }
   MockContentSuggestionsProviderObserver* observer() { return &observer_; }
   TestingPrefServiceSimple* pref_service() { return pref_service_.get(); }
 
  private:
-  MockOfflinePageModel model_;
+  FakeOfflinePageModel model_;
   MockContentSuggestionsProviderObserver observer_;
   CategoryFactory category_factory_;
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
   // Last so that the dependencies are deleted after the provider.
   std::unique_ptr<OfflinePageSuggestionsProvider> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageSuggestionsProviderTest);
 };
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldSplitAndConvertToSuggestions) {
-  AddItem(CreateDummyRecentTab(1));
-  AddItem(CreateDummyRecentTab(2));
-  AddItem(CreateDummyRecentTab(3));
-  AddItem(CreateDummyDownload(101));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3));
+  model()->mutable_items()->push_back(CreateDummyDownload(101));
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, recent_tabs_category(),
                        UnorderedElementsAre(
                            Property(&ContentSuggestion::url,
                                     GURL("file:///some/folder/test1.mhtml")),
                            Property(&ContentSuggestion::url,
                                     GURL("file:///some/folder/test2.mhtml")),
                            Property(&ContentSuggestion::url,
                                     GURL("file:///some/folder/test3.mhtml")))));
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(
                   _, downloads_category(),
                   UnorderedElementsAre(AllOf(
                       Property(&ContentSuggestion::url,
                                GURL("file:///some/folder/test101.mhtml")),
                       Property(&ContentSuggestion::title,
                                base::UTF8ToUTF16("http://dummy.com/101"))))));
 
   FireOfflinePageModelChanged();
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldIgnoreDisabledCategories) {
-  AddItem(CreateDummyRecentTab(1));
-  AddItem(CreateDummyRecentTab(2));
-  AddItem(CreateDummyRecentTab(3));
-  AddItem(CreateDummyDownload(101));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3));
+  model()->mutable_items()->push_back(CreateDummyDownload(101));
 
   // Disable recent tabs, enable downloads.
   EXPECT_CALL(*observer(), OnNewSuggestions(_, recent_tabs_category(), _))
       .Times(0);
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(Property(
                            &ContentSuggestion::url,
                            GURL("file:///some/folder/test101.mhtml")))));
@@ skipping 14 matching lines @@
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _))
       .Times(0);
   RecreateProvider(true, false, true);
   Mock::VerifyAndClearExpectations(observer());
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldSortByMostRecentlyVisited) {
   base::Time now = base::Time::Now();
   base::Time yesterday = now - base::TimeDelta::FromDays(1);
   base::Time tomorrow = now + base::TimeDelta::FromDays(1);
-  AddItem(CreateDummyRecentTab(1, now));
-  AddItem(CreateDummyRecentTab(2, yesterday));
-  AddItem(CreateDummyRecentTab(3, tomorrow));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1, now));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2, yesterday));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3, tomorrow));
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(
           _, recent_tabs_category(),
           ElementsAre(Property(&ContentSuggestion::url,
                                GURL("file:///some/folder/test3.mhtml")),
                       Property(&ContentSuggestion::url,
                                GURL("file:///some/folder/test1.mhtml")),
                       Property(&ContentSuggestion::url,
                                GURL("file:///some/folder/test2.mhtml")))));
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
   FireOfflinePageModelChanged();
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldDeliverCorrectCategoryInfo) {
   EXPECT_FALSE(
       provider()->GetCategoryInfo(recent_tabs_category()).has_more_button());
   EXPECT_TRUE(
       provider()->GetCategoryInfo(downloads_category()).has_more_button());
   RecreateProvider(true, true, false);
   EXPECT_FALSE(
       provider()->GetCategoryInfo(recent_tabs_category()).has_more_button());
   EXPECT_FALSE(
       provider()->GetCategoryInfo(downloads_category()).has_more_button());
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldDismiss) {
-  AddItem(CreateDummyRecentTab(1));
-  AddItem(CreateDummyRecentTab(2));
-  AddItem(CreateDummyRecentTab(3));
-  AddItem(CreateDummyRecentTab(4));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(4));
   FireOfflinePageModelChanged();
 
   // Dismiss 2 and 3.
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(0);
   provider()->DismissSuggestion(
       GetDummySuggestionId(recent_tabs_category(), 2));
   provider()->DismissSuggestion(
       GetDummySuggestionId(recent_tabs_category(), 3));
   Mock::VerifyAndClearExpectations(observer());
 
   // They should disappear from the reported suggestions.
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, recent_tabs_category(),
                        UnorderedElementsAre(
                            Property(&ContentSuggestion::url,
                                     GURL("file:///some/folder/test1.mhtml")),
                            Property(&ContentSuggestion::url,
                                     GURL("file:///some/folder/test4.mhtml")))));
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), IsEmpty()));
   FireOfflinePageModelChanged();
   Mock::VerifyAndClearExpectations(observer());
 
   // And appear in the dismissed suggestions for the right category.
-  EXPECT_CALL(*this, ReceivedDismissedSuggestions(UnorderedElementsAre(
-                         Property(&ContentSuggestion::url,
-                                  GURL("file:///some/folder/test2.mhtml")),
-                         Property(&ContentSuggestion::url,
-                                  GURL("file:///some/folder/test3.mhtml")))));
+  std::vector<ContentSuggestion> dismissed_suggestions;
   provider()->GetDismissedSuggestionsForDebugging(
       recent_tabs_category(),
-      base::Bind(
-          &OfflinePageSuggestionsProviderTest::DismissedSuggestionsHelper,
-          base::Unretained(this)));
-  Mock::VerifyAndClearExpectations(this);
+      base::Bind(&CaptureDismissedSuggestions, &dismissed_suggestions));
+  EXPECT_THAT(
+      dismissed_suggestions,
+      UnorderedElementsAre(Property(&ContentSuggestion::url,
+                                    GURL("file:///some/folder/test2.mhtml")),
+                           Property(&ContentSuggestion::url,
+                                    GURL("file:///some/folder/test3.mhtml"))));
 
   // The other category should have no dismissed suggestions.
-  EXPECT_CALL(*this, ReceivedDismissedSuggestions(IsEmpty()));
+  dismissed_suggestions.clear();
   provider()->GetDismissedSuggestionsForDebugging(
       downloads_category(),
-      base::Bind(
-          &OfflinePageSuggestionsProviderTest::DismissedSuggestionsHelper,
-          base::Unretained(this)));
-  Mock::VerifyAndClearExpectations(this);
+      base::Bind(&CaptureDismissedSuggestions, &dismissed_suggestions));
+  EXPECT_THAT(dismissed_suggestions, IsEmpty());
 
   // Clear dismissed suggestions.
   provider()->ClearDismissedSuggestionsForDebugging(recent_tabs_category());
 
   // They should be gone from the dismissed suggestions.
-  EXPECT_CALL(*this, ReceivedDismissedSuggestions(IsEmpty()));
+  dismissed_suggestions.clear();
   provider()->GetDismissedSuggestionsForDebugging(
       recent_tabs_category(),
-      base::Bind(
-          &OfflinePageSuggestionsProviderTest::DismissedSuggestionsHelper,
-          base::Unretained(this)));
-  Mock::VerifyAndClearExpectations(this);
+      base::Bind(&CaptureDismissedSuggestions, &dismissed_suggestions));
+  EXPECT_THAT(dismissed_suggestions, IsEmpty());
 
   // And appear in the reported suggestions for the category again.
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, recent_tabs_category(), SizeIs(4)));
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), IsEmpty()));
   FireOfflinePageModelChanged();
   Mock::VerifyAndClearExpectations(observer());
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest,
        ShouldInvalidateWhenOfflinePageDeleted) {
-  AddItem(CreateDummyRecentTab(1));
-  AddItem(CreateDummyRecentTab(2));
-  AddItem(CreateDummyRecentTab(3));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3));
   FireOfflinePageModelChanged();
 
   // Invalidation of suggestion 2 should be forwarded.
   EXPECT_CALL(
       *observer(),
       OnSuggestionInvalidated(_, recent_tabs_category(),
                               GetDummySuggestionId(recent_tabs_category(), 2)));
-  FireOfflinePageDeleted(model()->items()->at(1));
+  FireOfflinePageDeleted(model()->items().at(1));
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldClearDismissedOnInvalidate) {
-  AddItem(CreateDummyRecentTab(1));
-  AddItem(CreateDummyRecentTab(2));
-  AddItem(CreateDummyRecentTab(3));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(1));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(2));
+  model()->mutable_items()->push_back(CreateDummyRecentTab(3));
   FireOfflinePageModelChanged();
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), IsEmpty());
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), IsEmpty());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(recent_tabs_category(), 2));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), SizeIs(1));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), IsEmpty());
 
-  FireOfflinePageDeleted(model()->items()->at(1));
+  FireOfflinePageDeleted(model()->items().at(1));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), IsEmpty());
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), IsEmpty());
 }
 
 TEST_F(OfflinePageSuggestionsProviderTest, ShouldClearDismissedOnFetch) {
-  AddItem(CreateDummyDownload(1));
-  AddItem(CreateDummyDownload(2));
-  AddItem(CreateDummyDownload(3));
+  model()->mutable_items()->push_back(CreateDummyDownload(1));
+  model()->mutable_items()->push_back(CreateDummyDownload(2));
+  model()->mutable_items()->push_back(CreateDummyDownload(3));
   FireOfflinePageModelChanged();
 
   provider()->DismissSuggestion(GetDummySuggestionId(downloads_category(), 2));
   provider()->DismissSuggestion(GetDummySuggestionId(downloads_category(), 3));
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), IsEmpty());
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), SizeIs(2));
 
-  model()->items()->clear();
-  AddItem(CreateDummyDownload(2));
+  model()->mutable_items()->clear();
+  model()->mutable_items()->push_back(CreateDummyDownload(2));
   FireOfflinePageModelChanged();
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), IsEmpty());
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), SizeIs(1));
 
-  model()->items()->clear();
+  model()->mutable_items()->clear();
   FireOfflinePageModelChanged();
   EXPECT_THAT(ReadDismissedIDsFromPrefs(recent_tabs_category()), IsEmpty());
   EXPECT_THAT(ReadDismissedIDsFromPrefs(downloads_category()), IsEmpty());
 }
 
 }  // namespace ntp_snippets