Add ContentSuggestionsService tests.

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 <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 
 namespace {
 
 // Returns a suggestion instance for testing.
 ContentSuggestion CreateSuggestion(int number) {
   return ContentSuggestion(
       base::IntToString(number),
       GURL("http://testsuggestion/" + base::IntToString(number)));
 }
 
-std::vector<ContentSuggestion> CreateSuggestions(std::vector<int> numbers) {
+std::vector<ContentSuggestion> CreateSuggestions(
+    const std::vector<int>& numbers) {
   std::vector<ContentSuggestion> result;
   for (int number : numbers) {
     result.emplace_back(CreateSuggestion(number));
   }
   return result;
 }
 
 class MockProvider : public ContentSuggestionsProvider {
  public:
   MockProvider(Observer* observer,
                CategoryFactory* category_factory,
-               std::vector<Category> provided_categories)
-      : ContentSuggestionsProvider(observer, category_factory),
-        provided_categories_(provided_categories) {
+               const std::vector<Category>& provided_categories)
+      : ContentSuggestionsProvider(observer, category_factory) {
+    SetProvidedCategories(provided_categories);
+  }
+
+  void SetProvidedCategories(const std::vector<Category>& provided_categories) {
+    statuses_.clear();
+    provided_categories_ = provided_categories;
     for (Category category : provided_categories) {
       statuses_[category.id()] = CategoryStatus::AVAILABLE;
     }
   }
 
   std::vector<Category> GetProvidedCategories() override {
     return provided_categories_;
   }
 
   CategoryStatus GetCategoryStatus(Category category) {
     return statuses_[category.id()];
   }
 
   CategoryInfo GetCategoryInfo(Category category) {
     return CategoryInfo(base::ASCIIToUTF16("Section title"),
                         ContentSuggestionsCardLayout::FULL_CARD, true);
   }
 
-  void FireSuggestionsChanged(Category category, std::vector<int> numbers) {
+  void FireSuggestionsChanged(Category category,
+                              const std::vector<int>& numbers) {
     observer()->OnNewSuggestions(this, category, CreateSuggestions(numbers));
   }
 
   void FireCategoryStatusChanged(Category category, CategoryStatus new_status) {
     statuses_[category.id()] = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   }
 
   void FireSuggestionInvalidated(Category category,
                                  const std::string& suggestion_id) {
@@ skipping 70 matching lines @@
   providers() {
     return service()->providers_by_category_;
   }
 
   CategoryFactory* category_factory() { return service()->category_factory(); }
 
   Category FromKnownCategory(KnownCategories known_category) {
     return service()->category_factory()->FromKnownCategory(known_category);
   }
 
-  MockProvider* MakeProvider(Category provided_category) {
-    return MakeProvider(std::vector<Category>({provided_category}));
+  MockProvider* RegisterProvider(Category provided_category) {
+    return RegisterProvider(std::vector<Category>({provided_category}));
   }
 
-  MockProvider* MakeProvider(std::vector<Category> provided_categories) {
+  MockProvider* RegisterProvider(
+      const std::vector<Category>& provided_categories) {
     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_METHOD2(OnImageFetched,
                void(const std::string& suggestion_id, const gfx::Image&));
 
@@ skipping 26 matching lines @@
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
   ASSERT_THAT(providers(), IsEmpty());
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::NOT_PROVIDED));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
-  MockProvider* provider1 = MakeProvider(articles_category);
+  MockProvider* provider1 = RegisterProvider(articles_category);
   EXPECT_THAT(providers().count(offline_pages_category), Eq(0ul));
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   EXPECT_THAT(providers().size(), Eq(1ul));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::NOT_PROVIDED));
 
-  MockProvider* provider2 = MakeProvider(offline_pages_category);
+  MockProvider* provider2 = RegisterProvider(offline_pages_category);
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   EXPECT_THAT(providers().at(offline_pages_category), Eq(provider2));
   EXPECT_THAT(providers().size(), Eq(2ul));
   EXPECT_THAT(service()->GetCategories(),
               ElementsAre(offline_pages_category, articles_category));
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::AVAILABLE));
 }
@@ skipping 11 matching lines @@
               Eq(CategoryStatus::ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
   EXPECT_THAT(service()->GetSuggestionsForCategory(articles_category),
               IsEmpty());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectFetchSuggestionImage) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
-  MockProvider* provider1 = MakeProvider(articles_category);
-  MockProvider* provider2 = MakeProvider(offline_pages_category);
+  MockProvider* provider1 = RegisterProvider(articles_category);
+  MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider1->FireSuggestionsChanged(articles_category, {1});
   std::string suggestion_id = CreateSuggestion(1).id();
 
   EXPECT_CALL(*provider1, FetchSuggestionImage(suggestion_id, _));
   EXPECT_CALL(*provider2, FetchSuggestionImage(_, _)).Times(0);
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
 }
@@ skipping 11 matching lines @@
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
   run_loop.Run();
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectDismissSuggestion) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
-  MockProvider* provider1 = MakeProvider(articles_category);
-  MockProvider* provider2 = MakeProvider(offline_pages_category);
+  MockProvider* provider1 = RegisterProvider(articles_category);
+  MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider2->FireSuggestionsChanged(offline_pages_category, {11});
   std::string suggestion_id = CreateSuggestion(11).id();
 
   EXPECT_CALL(*provider1, DismissSuggestion(_)).Times(0);
   EXPECT_CALL(*provider2, DismissSuggestion(suggestion_id));
   service()->DismissSuggestion(suggestion_id);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectSuggestionInvalidated) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
 
-  MockProvider* provider = MakeProvider(articles_category);
+  MockProvider* provider = RegisterProvider(articles_category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   provider->FireSuggestionsChanged(articles_category, {11, 12, 13});
   ExpectThatSuggestionsAre(articles_category, {11, 12, 13});
 
   std::string suggestion_id = CreateSuggestion(12).id();
   EXPECT_CALL(observer,
               OnSuggestionInvalidated(articles_category, suggestion_id));
   provider->FireSuggestionInvalidated(articles_category, suggestion_id);
@@ skipping 11 matching lines @@
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
 
   // Create and register providers
-  MockProvider* provider1 = MakeProvider(articles_category);
-  MockProvider* provider2 = MakeProvider(offline_pages_category);
+  MockProvider* provider1 = RegisterProvider(articles_category);
+  MockProvider* provider2 = RegisterProvider(offline_pages_category);
   EXPECT_THAT(providers().at(articles_category), Eq(provider1));
   EXPECT_THAT(providers().at(offline_pages_category), Eq(provider2));
 
   // Create and register observer
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   // Send suggestions 1 and 2
   EXPECT_CALL(observer, OnNewSuggestions(articles_category));
   provider1->FireSuggestionsChanged(articles_category, {1, 2});
@@ skipping 35 matching lines @@
   ExpectThatSuggestionsAre(offline_pages_category, std::vector<int>());
   Mock::VerifyAndClearExpectations(&observer);
 
   // Shutdown the service
   EXPECT_CALL(observer, ContentSuggestionsServiceShutdown());
   service()->Shutdown();
   service()->RemoveObserver(&observer);
   // The service will receive two Shutdown() calls.
 }
 
+TEST_F(ContentSuggestionsServiceTest,
+       ShouldNotReturnCategoryInfoForNonexistentCategory) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
+  EXPECT_FALSE(result.has_value());
+}
+
+TEST_F(ContentSuggestionsServiceTest, ShouldReturnCategoryInfo) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = RegisterProvider(category);
+  base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
+  ASSERT_TRUE(result.has_value());
+  CategoryInfo expected = provider->GetCategoryInfo(category);
+  const CategoryInfo& actual = result.value();
+  EXPECT_THAT(expected.title(), Eq(actual.title()));
+  EXPECT_THAT(expected.card_layout(), Eq(actual.card_layout()));
+  EXPECT_THAT(expected.has_more_button(), Eq(actual.has_more_button()));
+}
+
+TEST_F(ContentSuggestionsServiceTest,
+       ShouldRegisterNewCategoryOnNewSuggestions) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = RegisterProvider(category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  // Provider starts providing |new_category| without calling
+  // |OnCategoryStatusChanged|. This is supported for now until further
+  // reconsideration.
+  Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
+  provider->SetProvidedCategories(
+      std::vector<Category>({category, new_category}));
+
+  EXPECT_CALL(observer, OnNewSuggestions(new_category));
+  EXPECT_CALL(observer,
+              OnCategoryStatusChanged(new_category, CategoryStatus::AVAILABLE));
+  provider->FireSuggestionsChanged(new_category, {1, 2});
+
+  ExpectThatSuggestionsAre(new_category, {1, 2});
+  EXPECT_THAT(providers().at(category), Eq(provider));
+  EXPECT_THAT(service()->GetCategoryStatus(category),
+              Eq(CategoryStatus::AVAILABLE));
+  EXPECT_THAT(providers().at(new_category), Eq(provider));
+  EXPECT_THAT(service()->GetCategoryStatus(new_category),
+              Eq(CategoryStatus::AVAILABLE));
+
+  service()->RemoveObserver(&observer);
+}
+
+TEST_F(ContentSuggestionsServiceTest,
+       ShouldRegisterNewCategoryOnCategoryStatusChanged) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = RegisterProvider(category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  // Provider starts providing |new_category| and calls
+  // |OnCategoryStatusChanged|, but the category is not yet available.
+  Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
+  provider->SetProvidedCategories(
+      std::vector<Category>({category, new_category}));
+  EXPECT_CALL(observer, OnCategoryStatusChanged(new_category,
+                                                CategoryStatus::INITIALIZING));
+  provider->FireCategoryStatusChanged(new_category,
+                                      CategoryStatus::INITIALIZING);
+
+  EXPECT_THAT(providers().at(new_category), Eq(provider));
+  ExpectThatSuggestionsAre(new_category, std::vector<int>());
+  EXPECT_THAT(service()->GetCategoryStatus(new_category),
+              Eq(CategoryStatus::INITIALIZING));
+  EXPECT_THAT(service()->GetCategories(),
+              Eq(std::vector<Category>({category, new_category})));
+
+  service()->RemoveObserver(&observer);
+}
+
+TEST_F(ContentSuggestionsServiceTest, ShouldRemoveCategoryWhenNotProvided) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = RegisterProvider(category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  provider->FireSuggestionsChanged(category, {1, 2});
+  ExpectThatSuggestionsAre(category, {1, 2});
+
+  EXPECT_CALL(observer,
+              OnCategoryStatusChanged(category, CategoryStatus::NOT_PROVIDED));
+  provider->FireCategoryStatusChanged(category, CategoryStatus::NOT_PROVIDED);
+
+  EXPECT_THAT(service()->GetCategoryStatus(category),
+              Eq(CategoryStatus::NOT_PROVIDED));
+  EXPECT_TRUE(service()->GetCategories().empty());
+  ExpectThatSuggestionsAre(category, std::vector<int>());
+
+  service()->RemoveObserver(&observer);
+}
+
 }  // namespace ntp_snippets