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) {

[Marc Treib, 2016/08/18 15:27:42]

nit: const std::vector<..>& ? (Also in the ctor above)

[vitaliii, 2016/08/18 16:32:12]

Done.

+    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 82 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) {

[Marc Treib, 2016/08/18 15:27:42]

Not your doing, but would you mind renaming this to (maybe) RegisterProvider? As
it is, the test code looks like it's leaking memory.

[vitaliii, 2016/08/18 16:32:12]

Done.

     return MakeProvider(std::vector<Category>({provided_category}));
   }
 
   MockProvider* MakeProvider(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;
   }
@@ skipping 180 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());

[Marc Treib, 2016/08/18 15:27:42]

nit: ASSERT_TRUE so that the test stops if it's null. Otherwise it'll crash
later.

[vitaliii, 2016/08/18 16:32:12]

Done.

+  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) {
+  Category category = FromKnownCategory(KnownCategories::BOOKMARKS);
+  MockProvider* provider = MakeProvider(category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  // Provider starts providing |new_category| without calling
+  // |OnCategoryStatusChanged|.

[Marc Treib, 2016/08/18 15:27:42]

[Mostly to pke:] Is this something we want to support? Shouldn't we require that
the provider calls OnCategoryStatusChanged first?

[Philipp Keck, 2016/08/18 15:29:56]

Last time we talked about this with Tim, we said we support this without
thinking about it further.

I have an item on my todo list to merge these two methods into one. If that goes
well and leads to nicer code, this question is gone anyway. Otherwise, we can
reconsider then.

[Marc Treib, 2016/08/18 15:33:55]

Alright, thanks. Then I'm okay with leaving this as-is for now. Is it worth
adding a comment here?

[vitaliii, 2016/08/18 16:32:13]

Done.

+  Category new_category = FromKnownCategory(KnownCategories::ARTICLES);
+  provider->SetProvidedCategories(
+      std::vector<Category>({category, new_category}));
+
+  EXPECT_CALL(observer, OnNewSuggestions(new_category)).Times(1);

[Marc Treib, 2016/08/18 15:27:42]

.Times(1) isn't necessary, it doesn't do anything (applies everywhere)

[vitaliii, 2016/08/18 16:32:13]

Done.

+  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));

[Marc Treib, 2016/08/18 15:27:43]

EXPECT_EQ or EXPECT_THAT(.., Eq(..))? Either's fine, but please be consistent
within the file.

[vitaliii, 2016/08/18 16:32:13]

Done.

+  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 = MakeProvider(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))
+      .Times(1);
+  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_EQ(service()->GetCategories(),
+            std::vector<Category>({category, new_category}));
+
+  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