📰 Persist category dismissals

components/ntp_snippets/content_suggestions_service_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/content_suggestions_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/category_status.h"
 #include "components/ntp_snippets/content_suggestion.h"
 #include "components/ntp_snippets/content_suggestions_provider.h"
+#include "components/prefs/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image.h"
 
 using testing::ElementsAre;
 using testing::Eq;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Property;
@@ skipping 28 matching lines @@
     return CategoryInfo(base::ASCIIToUTF16("Section title"),
                         ContentSuggestionsCardLayout::FULL_CARD, true, true);
   }
 
   void FireSuggestionsChanged(
       Category category,
       std::vector<ContentSuggestion> suggestions) {
     observer()->OnNewSuggestions(this, category, std::move(suggestions));
   }
 
+  void FireSuggestionBatchChanged(
+      ContentSuggestionsService::SuggestionBatch suggestion_batch) {
+    observer()->OnNewSuggestionBatch(this, std::move(suggestion_batch));
+  }
+
   void FireCategoryStatusChanged(Category category, CategoryStatus new_status) {
     statuses_[category.id()] = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   }
 
   void FireCategoryStatusChangedWithCurrentStatus(Category category) {
     observer()->OnCategoryStatusChanged(this, category,
                                         statuses_[category.id()]);
   }
 
@@ skipping 34 matching lines @@
   MOCK_METHOD0(ContentSuggestionsServiceShutdown, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockServiceObserver);
 };
 
 }  // namespace
 
 class ContentSuggestionsServiceTest : public testing::Test {
  public:
-  ContentSuggestionsServiceTest() {}
+  ContentSuggestionsServiceTest()
+      : pref_service_(new TestingPrefServiceSimple()) {}
 
   void SetUp() override {
+    RegisterPrefs();
     CreateContentSuggestionsService(ContentSuggestionsService::State::ENABLED);
   }
 
   void TearDown() override {
     service_->Shutdown();
     service_.reset();
   }
 
   // Verifies that exactly the suggestions with the given |numbers| are
   // returned by the service for the given |category|.
@@ skipping 46 matching lines @@
     std::unique_ptr<MockProvider> provider = base::MakeUnique<MockProvider>(
         service(), category_factory(), provided_categories);
     MockProvider* result = provider.get();
     service()->RegisterProvider(std::move(provider));
     return result;
   }
 
   MOCK_METHOD1(OnImageFetched, void(const gfx::Image&));
 
  protected:
+  void RegisterPrefs() {
+    ContentSuggestionsService::RegisterProfilePrefs(pref_service_->registry());
+    UserClassifier::RegisterProfilePrefs(pref_service_->registry());
+  }
+
   void CreateContentSuggestionsService(
       ContentSuggestionsService::State enabled) {
     ASSERT_FALSE(service_);
-    service_.reset(new ContentSuggestionsService(enabled,
-                                                 nullptr /* history_service */,
-                                                 nullptr /* pref_service */));
+    service_.reset(new ContentSuggestionsService(
+        enabled, nullptr /* history_service */, pref_service_.get()));
   }
 
   ContentSuggestionsService* service() { return service_.get(); }
 
   // Returns a suggestion instance for testing.
   ContentSuggestion CreateSuggestion(Category category, int number) {
     return ContentSuggestion(
         category, base::IntToString(number),
         GURL("http://testsuggestion/" + base::IntToString(number)));
   }
 
   std::vector<ContentSuggestion> CreateSuggestions(
       Category category,
       const std::vector<int>& numbers) {
     std::vector<ContentSuggestion> result;
     for (int number : numbers) {
       result.push_back(CreateSuggestion(category, number));
     }
     return result;
   }
 
  private:
   std::unique_ptr<ContentSuggestionsService> service_;
+  std::unique_ptr<TestingPrefServiceSimple> pref_service_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSuggestionsServiceTest);
 };
 
 class ContentSuggestionsServiceDisabledTest
     : public ContentSuggestionsServiceTest {
  public:
   void SetUp() override {
+    RegisterPrefs();
     CreateContentSuggestionsService(ContentSuggestionsService::State::DISABLED);
   }
 };
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRegisterProviders) {
   EXPECT_THAT(service()->state(),
               Eq(ContentSuggestionsService::State::ENABLED));
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::DOWNLOADS);
@@ skipping 354 matching lines @@
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardClearHistory) {
   Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider = RegisterProvider(category);
   base::Time begin = base::Time::FromTimeT(123),
              end = base::Time::FromTimeT(456);
   EXPECT_CALL(*provider, ClearHistory(begin, end, _));
   base::Callback<bool(const GURL& url)> filter;
   service()->ClearHistory(begin, end, filter);
 }
 
+TEST_F(ContentSuggestionsServiceTest, ShouldClearCategoryDismissal) {
+  // Create and register provider
+  Category category1 = service()->category_factory()->FromIDValue(1);
+  Category category10042 = service()->category_factory()->FromIDValue(10042);
+  Category category10043 = service()->category_factory()->FromIDValue(10043);
+
+  // Setup and verify initial state
+  MockProvider* provider =
+      RegisterProvider({category1, category10042, category10043});
+  provider->FireCategoryStatusChangedWithCurrentStatus(category1);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category10042);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category10043);
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::AVAILABLE));
+
+  // Dismiss all the categories. None should be provided now.
+  service()->DismissCategory(category1);
+  service()->DismissCategory(category10042);
+  service()->DismissCategory(category10043);
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::NOT_PROVIDED));
+
+  // Receiving a notification without suggestions should not change anything.
+  provider->FireSuggestionsChanged(category1, std::vector<ContentSuggestion>());
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::NOT_PROVIDED));
+
+  // A notification with suggestions should make the category available.
+  provider->FireSuggestionsChanged(category1,
+                                   CreateSuggestions(category1, {1, 2}));
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::NOT_PROVIDED));
+
+  // A batch notification with suggestions should make the category available.
+  ContentSuggestionsService::SuggestionBatch suggestion_batch;
+  suggestion_batch[category10042] = CreateSuggestions(category10042, {3, 4});
+  suggestion_batch[category10043] = std::vector<ContentSuggestion>();
+  provider->FireSuggestionBatchChanged(std::move(suggestion_batch));
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::NOT_PROVIDED));
+
+  // A batch notification with a missing category should clear its dismissal.
+  suggestion_batch = ContentSuggestionsService::SuggestionBatch();
+  suggestion_batch[category10042] = CreateSuggestions(category10042, {5, 6});
+  provider->FireSuggestionBatchChanged(std::move(suggestion_batch));
+
+  ASSERT_THAT(service()->GetCategoryStatus(category1),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10042),
+              Eq(CategoryStatus::AVAILABLE));
+  ASSERT_THAT(service()->GetCategoryStatus(category10043),
+              Eq(CategoryStatus::AVAILABLE));
+}
+
+TEST_F(ContentSuggestionsServiceTest, ShouldNotReturnDismissedCategories) {
+  Category category = FromKnownCategory(KnownCategories::ARTICLES);
+
+  // Create and register provider
+  MockProvider* provider = RegisterProvider(category);
+  provider->FireCategoryStatusChangedWithCurrentStatus(category);
+  ASSERT_THAT(providers().count(category), Eq(1ul));
+  EXPECT_THAT(providers().at(category), Eq(provider));
+  ASSERT_THAT(service()->GetCategories(), ElementsAre(category));
+
+  // Create and register observer
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  EXPECT_THAT(service()->GetCategoryStatus(category),
+              Eq(CategoryStatus::AVAILABLE));
+  EXPECT_TRUE(service()->GetCategoryInfo(category));
+
+  service()->DismissCategory(category);
+  EXPECT_THAT(service()->GetCategories(), ElementsAre(category));
+  EXPECT_THAT(service()->GetCategoryStatus(category),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  EXPECT_FALSE(service()->GetCategoryInfo(category));
+  EXPECT_TRUE(service()->GetSuggestionsForCategory(category).empty());
+
+  // OnCategoryStatusChanged
+  EXPECT_CALL(observer, OnCategoryStatusChanged(category, _)).Times(0);
+  provider->FireCategoryStatusChanged(category, CategoryStatus::SIGNED_OUT);
+  provider->FireCategoryStatusChanged(category, CategoryStatus::AVAILABLE);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // OnNewSuggestions (with suggestions)
+  EXPECT_CALL(observer, OnNewSuggestions(category));
+  provider->FireSuggestionsChanged(category,
+                                   CreateSuggestions(category, {1, 2}));
+  ExpectThatSuggestionsAre(category, {1, 2});
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_THAT(service()->GetCategoryStatus(category),
+              Eq(CategoryStatus::AVAILABLE));
+  EXPECT_TRUE(service()->GetCategoryInfo(category));
+  EXPECT_FALSE(service()->GetSuggestionsForCategory(category).empty());
+
+  EXPECT_CALL(observer,
+              OnCategoryStatusChanged(category, CategoryStatus::SIGNED_OUT));
+  provider->FireCategoryStatusChanged(category, CategoryStatus::SIGNED_OUT);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  service()->RemoveObserver(&observer);
+}
+
 }  // namespace ntp_snippets