Add ContentSuggestionsService tests.

components/ntp_snippets/content_suggestions_service_unittest.cc

Index: components/ntp_snippets/content_suggestions_service_unittest.cc
diff --git a/components/ntp_snippets/content_suggestions_service_unittest.cc b/components/ntp_snippets/content_suggestions_service_unittest.cc
index 91fd665dc6e7b6cf6643b9adf27a4afe29b6f8af..d70ca3212645aba3cfd037c27305e4b52f984ab6 100644
--- a/components/ntp_snippets/content_suggestions_service_unittest.cc
+++ b/components/ntp_snippets/content_suggestions_service_unittest.cc
@@ -58,8 +58,13 @@ class MockProvider : public ContentSuggestionsProvider {
   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;
     }
@@ -363,4 +368,102 @@ TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
   // 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