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 40 matching lines @@
     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) {
+      : ContentSuggestionsProvider(observer, category_factory) {
+    SetProvidedCategories(provided_categories);
+  }
+
+  void SetProvidedCategories(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) {
@@ skipping 283 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 = MakeProvider(category);
+  base::Optional<CategoryInfo> result = service()->GetCategoryInfo(category);
+  EXPECT_TRUE(result.has_value());
+  CategoryInfo expected = provider->GetCategoryInfo(category);
+  const CategoryInfo& actual = result.value();
+  EXPECT_EQ(expected.title(), actual.title());
+  EXPECT_EQ(expected.card_layout(), actual.card_layout());
+  EXPECT_EQ(expected.has_more_button(), actual.has_more_button());
+}
+
+TEST_F(ContentSuggestionsServiceTest,
+       ShouldRegisterNewCategoryOnNewSuggestions) {

[Philipp Keck, 2016/08/18 12:51:58]

OnCategoryStatusChanged has the same ability of adding a category that didn't
exist before. Testing that when the status becomes AVAILABLE is trivial, it's
the same as this test case here, so we probably won't need another one. But
there is the case where a category comes into existence without becoming
AVAILABLE.
So maybe could add a ShouldRegisterNewCategoryOnCategoryStatusChanged and use
SIGNED_OUT or INITIALIZING there.

[vitaliii, 2016/08/18 13:12:35]

Done.

+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = MakeProvider(category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  // Provider starts providing |new_category| without calling
+  // |OnCategoryStatusChanged|.
+  Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
+  provider->SetProvidedCategories(
+      std::vector<Category>({category, new_category}));
+
+  EXPECT_CALL(observer, OnNewSuggestions(new_category)).Times(1);
+  EXPECT_CALL(observer,
+              OnCategoryStatusChanged(new_category, CategoryStatus::AVAILABLE))
+      .Times(1);
+  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, ShouldRemoveCategoryWhenNotProvided) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = MakeProvider(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