Add ContentSuggestionsCategoryFactory; Store categories as ints

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 31 matching lines @@
 std::vector<ContentSuggestion> CreateSuggestions(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(ContentSuggestionsCategory provided_category)
+  MockProvider(ContentSuggestionsCategoryFactory* category_factory,
+               ContentSuggestionsCategory provided_category)
       : MockProvider(
+            category_factory,
             std::vector<ContentSuggestionsCategory>({provided_category})){};
 
-  MockProvider(std::vector<ContentSuggestionsCategory> provided_categories)
-      : ContentSuggestionsProvider(provided_categories), observer_(nullptr) {
+  MockProvider(ContentSuggestionsCategoryFactory* category_factory,
+               std::vector<ContentSuggestionsCategory> provided_categories)
+      : ContentSuggestionsProvider(category_factory),
+        observer_(nullptr),
+        provided_categories_(provided_categories) {
     for (ContentSuggestionsCategory category : provided_categories) {
-      statuses_[category] = ContentSuggestionsCategoryStatus::AVAILABLE;
+      statuses_[category.id()] = ContentSuggestionsCategoryStatus::AVAILABLE;
     }
   }
 
+  std::vector<ContentSuggestionsCategory> provided_categories() override {
+    return provided_categories_;
+  }
+
   Observer* observer() { return observer_; }
 
   void SetObserver(Observer* observer) override { observer_ = observer; }
 
   ContentSuggestionsCategoryStatus GetCategoryStatus(
       ContentSuggestionsCategory category) {
-    return statuses_[category];
+    return statuses_[category.id()];
   }
 
   void FireSuggestionsChanged(ContentSuggestionsCategory category,
                               std::vector<int> numbers) {
     observer_->OnNewSuggestions(category, CreateSuggestions(numbers));
   }
 
   void FireCategoryStatusChanged(ContentSuggestionsCategory category,
                                  ContentSuggestionsCategoryStatus new_status) {
-    statuses_[category] = new_status;
+    statuses_[category.id()] = new_status;
     observer_->OnCategoryStatusChanged(category, new_status);
   }
 
   void FireShutdown() {
     observer_->OnProviderShutdown(this);
     observer_ = nullptr;
   }
 
   MOCK_METHOD0(ClearCachedSuggestionsForDebugging, void());
   MOCK_METHOD0(ClearDismissedSuggestionsForDebugging, void());
   MOCK_METHOD1(DismissSuggestion, void(const std::string& suggestion_id));
   MOCK_METHOD2(FetchSuggestionImage,
                void(const std::string& suggestion_id,
                     const ImageFetchedCallback& callback));
 
  private:
   Observer* observer_;
-  std::map<ContentSuggestionsCategory, ContentSuggestionsCategoryStatus>
-      statuses_;
+  std::vector<ContentSuggestionsCategory> provided_categories_;
+  std::map<int, ContentSuggestionsCategoryStatus> statuses_;
 };
 
 class MockServiceObserver : public ContentSuggestionsService::Observer {
  public:
   MOCK_METHOD0(OnNewSuggestions, void());
   MOCK_METHOD2(OnCategoryStatusChanged,
                void(ContentSuggestionsCategory changed_category,
                     ContentSuggestionsCategoryStatus new_status));
   MOCK_METHOD0(ContentSuggestionsServiceShutdown, void());
   ~MockServiceObserver() override {}
@@ skipping 35 matching lines @@
       } else {
         numbers.erase(position);
       }
     }
     for (int number : numbers) {
       ADD_FAILURE() << "Suggestion number " << number
                     << " not present, though expected";
     }
   }
 
-  const std::map<ContentSuggestionsCategory, ContentSuggestionsProvider*>&
+  const std::map<ContentSuggestionsCategory,
+                 ContentSuggestionsProvider*,
+                 ContentSuggestionsService::CompareCategoriesByID>&
   providers() {
     return service()->providers_;
   }
 
+  ContentSuggestionsCategoryFactory* category_factory() {
+    return service()->category_factory();
+  }
+
+  ContentSuggestionsCategory FromKnownCategory(
+      KnownSuggestionsCategories known_category) {
+    return service()->category_factory()->FromKnownCategory(known_category);
+  }
+
   MOCK_METHOD2(OnImageFetched,
                void(const std::string& suggestion_id, const gfx::Image&));
 
  protected:
   void CreateContentSuggestionsService(
       ContentSuggestionsService::State enabled) {
     ASSERT_FALSE(service_);
     service_.reset(new ContentSuggestionsService(enabled));
   }
 
   ContentSuggestionsService* service() { return service_.get(); }
 
  private:
   std::unique_ptr<ContentSuggestionsService> service_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSuggestionsServiceTest);
 };
 
 class ContentSuggestionsServiceDisabledTest
     : public ContentSuggestionsServiceTest {
  public:
   void SetUp() override {
     CreateContentSuggestionsService(ContentSuggestionsService::State::DISABLED);
   }
 };
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRegisterProvidersAndShutdown) {
   EXPECT_THAT(service()->state(),
               Eq(ContentSuggestionsService::State::ENABLED));
-  MockProvider provider1(ContentSuggestionsCategory::ARTICLES);
-  MockProvider provider2(ContentSuggestionsCategory::OFFLINE_PAGES);
+  ContentSuggestionsCategory articles_category =
+      FromKnownCategory(KnownSuggestionsCategories::ARTICLES);
+  ContentSuggestionsCategory offline_pages_category =
+      FromKnownCategory(KnownSuggestionsCategories::OFFLINE_PAGES);
+  MockProvider provider1(category_factory(), articles_category);
+  MockProvider provider2(category_factory(), offline_pages_category);
   ASSERT_THAT(provider1.observer(), IsNull());
   ASSERT_THAT(provider2.observer(), IsNull());
   ASSERT_THAT(providers(), IsEmpty());
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
 
   service()->RegisterProvider(&provider1);
   EXPECT_THAT(provider1.observer(), NotNull());
-  EXPECT_THAT(providers().count(ContentSuggestionsCategory::OFFLINE_PAGES),
-              Eq(0ul));
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::ARTICLES),
-              Eq(&provider1));
+  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(ContentSuggestionsCategory::ARTICLES));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategories(), ElementsAre(articles_category));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
 
   service()->RegisterProvider(&provider2);
   EXPECT_THAT(provider1.observer(), NotNull());
   EXPECT_THAT(provider2.observer(), NotNull());
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::ARTICLES),
-              Eq(&provider1));
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::OFFLINE_PAGES),
-              Eq(&provider2));
+  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(ContentSuggestionsCategory::ARTICLES,
-                          ContentSuggestionsCategory::OFFLINE_PAGES));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
+              ElementsAre(offline_pages_category, articles_category));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
 
   provider1.FireShutdown();
-  EXPECT_THAT(providers().count(ContentSuggestionsCategory::ARTICLES), Eq(0ul));
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::OFFLINE_PAGES),
-              Eq(&provider2));
+  EXPECT_THAT(providers().count(articles_category), Eq(0ul));
+  EXPECT_THAT(providers().at(offline_pages_category), Eq(&provider2));
   EXPECT_THAT(providers().size(), Eq(1ul));
-  EXPECT_THAT(service()->GetCategories(),
-              ElementsAre(ContentSuggestionsCategory::OFFLINE_PAGES));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      ContentSuggestionsCategoryStatus::NOT_PROVIDED);
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      ContentSuggestionsCategoryStatus::AVAILABLE);
+  EXPECT_THAT(service()->GetCategories(), ElementsAre(offline_pages_category));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              ContentSuggestionsCategoryStatus::NOT_PROVIDED);
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              ContentSuggestionsCategoryStatus::AVAILABLE);
 
   provider2.FireShutdown();
   EXPECT_THAT(providers(), IsEmpty());
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
 }
 
 TEST_F(ContentSuggestionsServiceDisabledTest, ShouldDoNothingWhenDisabled) {
+  ContentSuggestionsCategory articles_category =
+      FromKnownCategory(KnownSuggestionsCategories::ARTICLES);
+  ContentSuggestionsCategory offline_pages_category =
+      FromKnownCategory(KnownSuggestionsCategories::OFFLINE_PAGES);
   EXPECT_THAT(service()->state(),
               Eq(ContentSuggestionsService::State::DISABLED));
-  MockProvider provider1(ContentSuggestionsCategory::ARTICLES);
+  MockProvider provider1(category_factory(), articles_category);
   service()->RegisterProvider(&provider1);
   EXPECT_THAT(providers(), IsEmpty());
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::
-             ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::
-             ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::
+                     ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::
+                     ALL_SUGGESTIONS_EXPLICITLY_DISABLED));
   EXPECT_THAT(service()->GetCategories(), IsEmpty());
-  EXPECT_THAT(service()->GetSuggestionsForCategory(
-                  ContentSuggestionsCategory::ARTICLES),
+  EXPECT_THAT(service()->GetSuggestionsForCategory(articles_category),
               IsEmpty());
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectFetchSuggestionImage) {
-  MockProvider provider1(ContentSuggestionsCategory::ARTICLES);
-  MockProvider provider2(ContentSuggestionsCategory::OFFLINE_PAGES);
+  ContentSuggestionsCategory articles_category =
+      FromKnownCategory(KnownSuggestionsCategories::ARTICLES);
+  ContentSuggestionsCategory offline_pages_category =
+      FromKnownCategory(KnownSuggestionsCategories::OFFLINE_PAGES);
+  MockProvider provider1(category_factory(), articles_category);
+  MockProvider provider2(category_factory(), offline_pages_category);
   service()->RegisterProvider(&provider1);
   service()->RegisterProvider(&provider2);
 
-  provider1.FireSuggestionsChanged(ContentSuggestionsCategory::ARTICLES, {1});
+  provider1.FireSuggestionsChanged(articles_category, {1});
   std::string suggestion_id = CreateSuggestion(1).id();
 
   EXPECT_CALL(provider1, FetchSuggestionImage(suggestion_id, _)).Times(1);
   EXPECT_CALL(provider2, FetchSuggestionImage(_, _)).Times(0);
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
   provider1.FireShutdown();
   provider2.FireShutdown();
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldCallbackEmptyImageForUnavailableProvider) {
   std::string suggestion_id = "TestID";
   EXPECT_CALL(*this, OnImageFetched(suggestion_id,
                                     Property(&gfx::Image::IsEmpty, Eq(true))));
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectDismissSuggestion) {
-  MockProvider provider1(ContentSuggestionsCategory::ARTICLES);
-  MockProvider provider2(ContentSuggestionsCategory::OFFLINE_PAGES);
+  ContentSuggestionsCategory articles_category =
+      FromKnownCategory(KnownSuggestionsCategories::ARTICLES);
+  ContentSuggestionsCategory offline_pages_category =
+      FromKnownCategory(KnownSuggestionsCategories::OFFLINE_PAGES);
+  MockProvider provider1(category_factory(), articles_category);
+  MockProvider provider2(category_factory(), offline_pages_category);
   service()->RegisterProvider(&provider1);
   service()->RegisterProvider(&provider2);
 
-  provider2.FireSuggestionsChanged(ContentSuggestionsCategory::OFFLINE_PAGES,
-                                   {11});
+  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)).Times(1);
   service()->DismissSuggestion(suggestion_id);
   provider1.FireShutdown();
   provider2.FireShutdown();
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
+  ContentSuggestionsCategory articles_category =
+      FromKnownCategory(KnownSuggestionsCategories::ARTICLES);
+  ContentSuggestionsCategory offline_pages_category =
+      FromKnownCategory(KnownSuggestionsCategories::OFFLINE_PAGES);
+
   // Create and register providers
-  MockProvider provider1(ContentSuggestionsCategory::ARTICLES);
-  MockProvider provider2(ContentSuggestionsCategory::OFFLINE_PAGES);
+  MockProvider provider1(category_factory(), articles_category);
+  MockProvider provider2(category_factory(), offline_pages_category);
   service()->RegisterProvider(&provider1);
   service()->RegisterProvider(&provider2);
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::ARTICLES),
-              Eq(&provider1));
-  EXPECT_THAT(providers().at(ContentSuggestionsCategory::OFFLINE_PAGES),
-              Eq(&provider2));
+  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()).Times(1);
-  provider1.FireSuggestionsChanged(ContentSuggestionsCategory::ARTICLES,
-                                   {1, 2});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES, {1, 2});
+  provider1.FireSuggestionsChanged(articles_category, {1, 2});
+  ExpectThatSuggestionsAre(articles_category, {1, 2});
   Mock::VerifyAndClearExpectations(&observer);
 
   // Send them again, make sure they're not reported twice
   EXPECT_CALL(observer, OnNewSuggestions()).Times(1);
-  provider1.FireSuggestionsChanged(ContentSuggestionsCategory::ARTICLES,
-                                   {1, 2});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES, {1, 2});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::OFFLINE_PAGES,
-                           std::vector<int>());
+  provider1.FireSuggestionsChanged(articles_category, {1, 2});
+  ExpectThatSuggestionsAre(articles_category, {1, 2});
+  ExpectThatSuggestionsAre(offline_pages_category, std::vector<int>());
   Mock::VerifyAndClearExpectations(&observer);
 
   // Send suggestions 13 and 14
   EXPECT_CALL(observer, OnNewSuggestions()).Times(1);
-  provider2.FireSuggestionsChanged(ContentSuggestionsCategory::OFFLINE_PAGES,
-                                   {13, 14});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES, {1, 2});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::OFFLINE_PAGES, {13, 14});
+  provider2.FireSuggestionsChanged(offline_pages_category, {13, 14});
+  ExpectThatSuggestionsAre(articles_category, {1, 2});
+  ExpectThatSuggestionsAre(offline_pages_category, {13, 14});
   Mock::VerifyAndClearExpectations(&observer);
 
   // Send suggestion 1 only
   EXPECT_CALL(observer, OnNewSuggestions()).Times(1);
-  provider1.FireSuggestionsChanged(ContentSuggestionsCategory::ARTICLES, {1});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES, {1});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::OFFLINE_PAGES, {13, 14});
+  provider1.FireSuggestionsChanged(articles_category, {1});
+  ExpectThatSuggestionsAre(articles_category, {1});
+  ExpectThatSuggestionsAre(offline_pages_category, {13, 14});
   Mock::VerifyAndClearExpectations(&observer);
 
   // provider2 reports OFFLINE_PAGEs as unavailable
   EXPECT_CALL(
       observer,
       OnCategoryStatusChanged(
-          ContentSuggestionsCategory::OFFLINE_PAGES,
+          offline_pages_category,
           ContentSuggestionsCategoryStatus::CATEGORY_EXPLICITLY_DISABLED))
       .Times(1);
   provider2.FireCategoryStatusChanged(
-      ContentSuggestionsCategory::OFFLINE_PAGES,
+      offline_pages_category,
       ContentSuggestionsCategoryStatus::CATEGORY_EXPLICITLY_DISABLED);
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
   EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::AVAILABLE));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
+      service()->GetCategoryStatus(offline_pages_category),
       Eq(ContentSuggestionsCategoryStatus::CATEGORY_EXPLICITLY_DISABLED));
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES, {1});
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::OFFLINE_PAGES,
-                           std::vector<int>());
+  ExpectThatSuggestionsAre(articles_category, {1});
+  ExpectThatSuggestionsAre(offline_pages_category, std::vector<int>());
   Mock::VerifyAndClearExpectations(&observer);
 
   // Let provider1 shut down
   EXPECT_CALL(observer, OnCategoryStatusChanged(
-                            ContentSuggestionsCategory::ARTICLES,
+                            articles_category,
                             ContentSuggestionsCategoryStatus::NOT_PROVIDED))
       .Times(1);
   provider1.FireShutdown();
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
   EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
+      service()->GetCategoryStatus(offline_pages_category),
       Eq(ContentSuggestionsCategoryStatus::CATEGORY_EXPLICITLY_DISABLED));
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::ARTICLES,
-                           std::vector<int>());
-  ExpectThatSuggestionsAre(ContentSuggestionsCategory::OFFLINE_PAGES,
-                           std::vector<int>());
+  ExpectThatSuggestionsAre(articles_category, std::vector<int>());
+  ExpectThatSuggestionsAre(offline_pages_category, std::vector<int>());
   Mock::VerifyAndClearExpectations(&observer);
 
   // Let provider2 shut down
   provider2.FireShutdown();
   EXPECT_TRUE(providers().empty());
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::ARTICLES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
-  EXPECT_THAT(
-      service()->GetCategoryStatus(ContentSuggestionsCategory::OFFLINE_PAGES),
-      Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(articles_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
+  EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
+              Eq(ContentSuggestionsCategoryStatus::NOT_PROVIDED));
 
   // Shutdown the service
   EXPECT_CALL(observer, ContentSuggestionsServiceShutdown());
   service()->Shutdown();
   service()->RemoveObserver(&observer);
   // The service will receive two Shutdown() calls.
 }
 
+// TODO(pke): Write a test for dynamic sections and ordering.

[Marc Treib, 2016/07/28 11:41:46]

TODOs in the code aren't the best tool for a personal task list ;)

[Philipp Keck, 2016/07/28 13:50:55]

Removed.

+
 }  // namespace ntp_snippets