Support server categories in NTPSnippetsService.

components/ntp_snippets/ntp_snippets_service_unittest.cc

 // Copyright 2015 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/ntp_snippets_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 46 matching lines @@
 using testing::_;
 
 namespace ntp_snippets {
 
 namespace {
 
 MATCHER_P(IdEq, value, "") {
   return arg->id() == value;
 }
 
+MATCHER_P(IsCategory, id, "") {
+  return arg.id() == static_cast<int>(id);
+}
+
 const base::Time::Exploded kDefaultCreationTime = {2015, 11, 4, 25, 13, 46, 45};
 const char kTestContentSnippetsServerFormat[] =
     "https://chromereader-pa.googleapis.com/v1/fetch?key=%s";
 
 const char kSnippetUrl[] = "http://localhost/foobar";
 const char kSnippetTitle[] = "Title";
 const char kSnippetText[] = "Snippet";
 const char kSnippetSalientImage[] = "http://localhost/salient_image";
 const char kSnippetPublisherName[] = "Foo News";
 const char kSnippetAmpUrl[] = "http://localhost/amp";
@@ skipping 158 matching lines @@
 class MockScheduler : public NTPSnippetsScheduler {
  public:
   MOCK_METHOD4(Schedule,
                bool(base::TimeDelta period_wifi_charging,
                     base::TimeDelta period_wifi,
                     base::TimeDelta period_fallback,
                     base::Time reschedule_time));
   MOCK_METHOD0(Unschedule, bool());
 };
 
-class WaitForDBLoad {
- public:
-  WaitForDBLoad(MockContentSuggestionsProviderObserver* observer,
-                NTPSnippetsService* service)
-      : observer_(observer) {
-    EXPECT_CALL(*observer_, OnCategoryStatusChanged(_, _, _))
-        .WillOnce(Invoke(this, &WaitForDBLoad::OnCategoryStatusChanged));
-    if (!service->ready())
-      run_loop_.Run();
-  }
-
-  ~WaitForDBLoad() { Mock::VerifyAndClearExpectations(observer_); }
-
- private:
-  void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
-                               Category category,
-                               CategoryStatus new_status) {
-    EXPECT_EQ(new_status, CategoryStatus::AVAILABLE_LOADING);
-    run_loop_.Quit();
-  }
-
-  MockContentSuggestionsProviderObserver* observer_;
-  base::RunLoop run_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(WaitForDBLoad);
-};
+void WaitForDBLoad(MockContentSuggestionsProviderObserver* observer,
+                   NTPSnippetsService* service) {
+  if (service->ready())
+    return;
+  base::RunLoop run_loop;
+  EXPECT_CALL(*observer,
+              OnCategoryStatusChanged(_, IsCategory(KnownCategories::ARTICLES),
+                                      CategoryStatus::AVAILABLE_LOADING))
+      .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  run_loop.Run();
+  Mock::VerifyAndClearExpectations(observer);
+}
 
 class MockImageFetcher : public ImageFetcher {
  public:
   MOCK_METHOD1(SetImageFetcherDelegate, void(ImageFetcherDelegate*));
   MOCK_METHOD1(SetDataUseServiceName, void(DataUseServiceName));
   MOCK_METHOD3(
       StartOrQueueNetworkRequest,
       void(const std::string&,
            const GURL&,
            base::Callback<void(const std::string&, const gfx::Image&)>));
@@ skipping 146 matching lines @@
 
   // When we have no snippets are all, loading the service initiates a fetch.
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ("OK", service()->snippets_fetcher()->last_status());
 }
 
 TEST_F(NTPSnippetsServiceTest, Full) {
   std::string json_str(GetTestJson({GetSnippet()}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
-  const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
+  const NTPSnippet& snippet =
+      *service()->GetSnippetsForTesting(articles_category()).front();
 
   EXPECT_EQ(snippet.id(), kSnippetUrl);
   EXPECT_EQ(snippet.title(), kSnippetTitle);
   EXPECT_EQ(snippet.snippet(), kSnippetText);
   EXPECT_EQ(snippet.salient_image_url(), GURL(kSnippetSalientImage));
   EXPECT_EQ(GetDefaultCreationTime(), snippet.publish_date());
   EXPECT_EQ(snippet.best_source().publisher_name, kSnippetPublisherName);
   EXPECT_EQ(snippet.best_source().amp_url, GURL(kSnippetAmpUrl));
 }
 
 TEST_F(NTPSnippetsServiceTest, Clear) {
   std::string json_str(GetTestJson({GetSnippet()}));
 
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   service()->ClearCachedSuggestions(articles_category());
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, InsertAtFront) {
   std::string first("http://first");
   LoadFromJSONString(GetTestJson({GetSnippetWithUrl(first)}));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), ElementsAre(IdEq(first)));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()),
+              ElementsAre(IdEq(first)));
 
   std::string second("http://second");
   LoadFromJSONString(GetTestJson({GetSnippetWithUrl(second)}));
   // The snippet loaded last should be at the first position in the list now.
-  EXPECT_THAT(service()->GetSnippetsForTesting(),
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()),
               ElementsAre(IdEq(second), IdEq(first)));
 }
 
 TEST_F(NTPSnippetsServiceTest, LimitNumSnippets) {
   int max_snippet_count = NTPSnippetsService::GetMaxSnippetCountForTesting();
   int snippets_per_load = max_snippet_count / 2 + 1;
   char url_format[] = "http://localhost/%i";
 
   std::vector<std::string> snippets1;
   std::vector<std::string> snippets2;
   for (int i = 0; i < snippets_per_load; i++) {
     snippets1.push_back(GetSnippetWithUrl(base::StringPrintf(url_format, i)));
     snippets2.push_back(GetSnippetWithUrl(
         base::StringPrintf(url_format, snippets_per_load + i)));
   }
 
   LoadFromJSONString(GetTestJson(snippets1));
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(snippets1.size()));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()),
+              SizeIs(snippets1.size()));
 
   LoadFromJSONString(GetTestJson(snippets2));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(max_snippet_count));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()),
+              SizeIs(max_snippet_count));
 }
 
 TEST_F(NTPSnippetsServiceTest, LoadInvalidJson) {
   LoadFromJSONString(GetTestJson({GetInvalidSnippet()}));
   EXPECT_THAT(service()->snippets_fetcher()->last_status(),
               StartsWith("Received invalid JSON"));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, LoadInvalidJsonWithExistingSnippets) {
   LoadFromJSONString(GetTestJson({GetSnippet()}));
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   ASSERT_EQ("OK", service()->snippets_fetcher()->last_status());
 
   LoadFromJSONString(GetTestJson({GetInvalidSnippet()}));
   EXPECT_THAT(service()->snippets_fetcher()->last_status(),
               StartsWith("Received invalid JSON"));
   // This should not have changed the existing snippets.
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 }
 
 TEST_F(NTPSnippetsServiceTest, LoadIncompleteJson) {
   LoadFromJSONString(GetTestJson({GetIncompleteSnippet()}));
   EXPECT_EQ("Invalid / empty list.",
             service()->snippets_fetcher()->last_status());
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, LoadIncompleteJsonWithExistingSnippets) {
   LoadFromJSONString(GetTestJson({GetSnippet()}));
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   LoadFromJSONString(GetTestJson({GetIncompleteSnippet()}));
   EXPECT_EQ("Invalid / empty list.",
             service()->snippets_fetcher()->last_status());
   // This should not have changed the existing snippets.
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 }
 
 TEST_F(NTPSnippetsServiceTest, Dismiss) {
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://site.com"));
   publishers.push_back(std::string("Source 1"));
   amp_urls.push_back(std::string());
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
 
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   // Dismissing a non-existent snippet shouldn't do anything.
   service()->DismissSuggestion(MakeUniqueID("http://othersite.com"));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   // Dismiss the snippet.
   service()->DismissSuggestion(MakeUniqueID(kSnippetUrl));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // Make sure that fetching the same snippet again does not re-add it.
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // The snippet should stay dismissed even after re-creating the service.
   RecreateSnippetsService();
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // The snippet can be added again after clearing dismissed snippets.
   service()->ClearDismissedSuggestionsForDebugging(articles_category());
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
 }
 
 TEST_F(NTPSnippetsServiceTest, GetDismissed) {
   LoadFromJSONString(GetTestJson({GetSnippet()}));
 
   service()->DismissSuggestion(MakeUniqueID(kSnippetUrl));
 
   MockDismissedSuggestionsCallback callback;
 
   EXPECT_CALL(callback, MockRun(_, _))
@@ skipping 24 matching lines @@
       base::Bind(&MockDismissedSuggestionsCallback::Run,
                  base::Unretained(&callback), articles_category()));
 }
 
 TEST_F(NTPSnippetsServiceTest, CreationTimestampParseFail) {
   std::string json_str(GetTestJson({GetSnippetWithTimes(
       "aaa1448459205",
       NTPSnippet::TimeToJsonString(GetDefaultExpirationTime()))}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
-  const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
+  const NTPSnippet& snippet =
+      *service()->GetSnippetsForTesting(articles_category()).front();
   EXPECT_EQ(snippet.id(), kSnippetUrl);
   EXPECT_EQ(snippet.title(), kSnippetTitle);
   EXPECT_EQ(snippet.snippet(), kSnippetText);
   EXPECT_EQ(base::Time::UnixEpoch(), snippet.publish_date());
 }
 
 TEST_F(NTPSnippetsServiceTest, RemoveExpiredContent) {
   std::string json_str(GetTestJson({GetExpiredSnippet()}));
 
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, TestSingleSource) {
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://source1.com"));
   publishers.push_back(std::string("Source 1"));
   amp_urls.push_back(std::string("http://source1.amp.com"));
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
-  const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
+  const NTPSnippet& snippet =
+      *service()->GetSnippetsForTesting(articles_category()).front();
   EXPECT_EQ(snippet.sources().size(), 1u);
   EXPECT_EQ(snippet.id(), kSnippetUrl);
   EXPECT_EQ(snippet.best_source().url, GURL("http://source1.com"));
   EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 1"));
   EXPECT_EQ(snippet.best_source().amp_url, GURL("http://source1.amp.com"));
 }
 
 TEST_F(NTPSnippetsServiceTest, TestSingleSourceWithMalformedUrl) {
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("aaaa"));
   publishers.push_back(std::string("Source 1"));
   amp_urls.push_back(std::string("http://source1.amp.com"));
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, TestSingleSourceWithMissingData) {
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://source1.com"));
   publishers.push_back(std::string());
   amp_urls.push_back(std::string());
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, TestMultipleSources) {
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   publishers.push_back(std::string("Source 1"));
   publishers.push_back(std::string("Source 2"));
   amp_urls.push_back(std::string("http://source1.amp.com"));
   amp_urls.push_back(std::string("http://source2.amp.com"));
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
-  const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
+  const NTPSnippet& snippet =
+      *service()->GetSnippetsForTesting(articles_category()).front();
   // Expect the first source to be chosen
   EXPECT_EQ(snippet.sources().size(), 2u);
   EXPECT_EQ(snippet.id(), kSnippetUrl);
   EXPECT_EQ(snippet.best_source().url, GURL("http://source1.com"));
   EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 1"));
   EXPECT_EQ(snippet.best_source().amp_url, GURL("http://source1.amp.com"));
 }
 
 TEST_F(NTPSnippetsServiceTest, TestMultipleIncompleteSources) {
   // Set Source 2 to have no AMP url, and Source 1 to have no publisher name
   // Source 2 should win since we favor publisher name over amp url
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   publishers.push_back(std::string());
   publishers.push_back(std::string("Source 2"));
   amp_urls.push_back(std::string("http://source1.amp.com"));
   amp_urls.push_back(std::string());
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   {
-    const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+    const NTPSnippet& snippet =
+        *service()->GetSnippetsForTesting(articles_category()).front();
     EXPECT_EQ(snippet.sources().size(), 2u);
     EXPECT_EQ(snippet.id(), kSnippetUrl);
     EXPECT_EQ(snippet.best_source().url, GURL("http://source2.com"));
     EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 2"));
     EXPECT_EQ(snippet.best_source().amp_url, GURL());
   }
 
   service()->ClearCachedSuggestions(articles_category());
   // Set Source 1 to have no AMP url, and Source 2 to have no publisher name
   // Source 1 should win in this case since we prefer publisher name to AMP url
   source_urls.clear();
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   publishers.clear();
   publishers.push_back(std::string("Source 1"));
   publishers.push_back(std::string());
   amp_urls.clear();
   amp_urls.push_back(std::string());
   amp_urls.push_back(std::string("http://source2.amp.com"));
   json_str =
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)});
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   {
-    const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+    const NTPSnippet& snippet =
+        *service()->GetSnippetsForTesting(articles_category()).front();
     EXPECT_EQ(snippet.sources().size(), 2u);
     EXPECT_EQ(snippet.id(), kSnippetUrl);
     EXPECT_EQ(snippet.best_source().url, GURL("http://source1.com"));
     EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 1"));
     EXPECT_EQ(snippet.best_source().amp_url, GURL());
   }
 
   service()->ClearCachedSuggestions(articles_category());
   // Set source 1 to have no AMP url and no source, and source 2 to only have
   // amp url. There should be no snippets since we only add sources we consider
   // complete
   source_urls.clear();
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   publishers.clear();
   publishers.push_back(std::string());
   publishers.push_back(std::string());
   amp_urls.clear();
   amp_urls.push_back(std::string());
   amp_urls.push_back(std::string("http://source2.amp.com"));
   json_str =
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)});
 
   LoadFromJSONString(json_str);
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, TestMultipleCompleteSources) {
   // Test 2 complete sources, we should choose the first complete source
   std::vector<std::string> source_urls, publishers, amp_urls;
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   source_urls.push_back(std::string("http://source3.com"));
   publishers.push_back(std::string("Source 1"));
   publishers.push_back(std::string());
   publishers.push_back(std::string("Source 3"));
   amp_urls.push_back(std::string("http://source1.amp.com"));
   amp_urls.push_back(std::string("http://source2.amp.com"));
   amp_urls.push_back(std::string("http://source3.amp.com"));
   std::string json_str(
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)}));
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   {
-    const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+    const NTPSnippet& snippet =
+        *service()->GetSnippetsForTesting(articles_category()).front();
     EXPECT_EQ(snippet.sources().size(), 3u);
     EXPECT_EQ(snippet.id(), kSnippetUrl);
     EXPECT_EQ(snippet.best_source().url, GURL("http://source1.com"));
     EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 1"));
     EXPECT_EQ(snippet.best_source().amp_url, GURL("http://source1.amp.com"));
   }
 
   // Test 2 complete sources, we should choose the first complete source
   service()->ClearCachedSuggestions(articles_category());
   source_urls.clear();
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   source_urls.push_back(std::string("http://source3.com"));
   publishers.clear();
   publishers.push_back(std::string());
   publishers.push_back(std::string("Source 2"));
   publishers.push_back(std::string("Source 3"));
   amp_urls.clear();
   amp_urls.push_back(std::string("http://source1.amp.com"));
   amp_urls.push_back(std::string("http://source2.amp.com"));
   amp_urls.push_back(std::string("http://source3.amp.com"));
   json_str =
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)});
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   {
-    const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+    const NTPSnippet& snippet =
+        *service()->GetSnippetsForTesting(articles_category()).front();
     EXPECT_EQ(snippet.sources().size(), 3u);
     EXPECT_EQ(snippet.id(), kSnippetUrl);
     EXPECT_EQ(snippet.best_source().url, GURL("http://source2.com"));
     EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 2"));
     EXPECT_EQ(snippet.best_source().amp_url, GURL("http://source2.amp.com"));
   }
 
   // Test 3 complete sources, we should choose the first complete source
   service()->ClearCachedSuggestions(articles_category());
   source_urls.clear();
   source_urls.push_back(std::string("http://source1.com"));
   source_urls.push_back(std::string("http://source2.com"));
   source_urls.push_back(std::string("http://source3.com"));
   publishers.clear();
   publishers.push_back(std::string("Source 1"));
   publishers.push_back(std::string("Source 2"));
   publishers.push_back(std::string("Source 3"));
   amp_urls.clear();
   amp_urls.push_back(std::string());
   amp_urls.push_back(std::string("http://source2.amp.com"));
   amp_urls.push_back(std::string("http://source3.amp.com"));
   json_str =
       GetTestJson({GetSnippetWithSources(source_urls, publishers, amp_urls)});
 
   LoadFromJSONString(json_str);
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   {
-    const NTPSnippet& snippet = *service()->GetSnippetsForTesting().front();
+    const NTPSnippet& snippet =
+        *service()->GetSnippetsForTesting(articles_category()).front();
     EXPECT_EQ(snippet.sources().size(), 3u);
     EXPECT_EQ(snippet.id(), kSnippetUrl);
     EXPECT_EQ(snippet.best_source().url, GURL("http://source2.com"));
     EXPECT_EQ(snippet.best_source().publisher_name, std::string("Source 2"));
     EXPECT_EQ(snippet.best_source().amp_url, GURL("http://source2.amp.com"));
   }
 }
 
 TEST_F(NTPSnippetsServiceTest, LogNumArticlesHistogram) {
   base::HistogramTester tester;
@@ skipping 60 matching lines @@
       "http://mashable.com/2016/05/11/stolen?utm_cid=1"};
   const std::vector<std::string> publishers = {"Mashable", "AOL", "Mashable"};
   const std::vector<std::string> amp_urls = {
       "http://mashable-amphtml.googleusercontent.com/1",
       "http://t2.gstatic.com/images?q=tbn:3",
       "http://t2.gstatic.com/images?q=tbn:3"};
 
   // Add the snippet from the mashable domain.
   LoadFromJSONString(GetTestJson({GetSnippetWithUrlAndTimesAndSources(
       source_urls[0], creation, expiry, source_urls, publishers, amp_urls)}));
-  ASSERT_THAT(service()->GetSnippetsForTesting(), SizeIs(1));
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), SizeIs(1));
   // Dismiss the snippet via the mashable source corpus ID.
   service()->DismissSuggestion(MakeUniqueID(source_urls[0]));
-  EXPECT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // The same article from the AOL domain should now be detected as dismissed.
   LoadFromJSONString(GetTestJson({GetSnippetWithUrlAndTimesAndSources(
       source_urls[1], creation, expiry, source_urls, publishers, amp_urls)}));
-  ASSERT_THAT(service()->GetSnippetsForTesting(), IsEmpty());
+  ASSERT_THAT(service()->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, StatusChanges) {
   // Simulate user signed out
   SetUpFetchResponse(GetTestJson({GetSnippet()}));
   EXPECT_CALL(observer(),
               OnCategoryStatusChanged(_, _, CategoryStatus::SIGNED_OUT));
   service()->OnDisabledReasonChanged(DisabledReason::SIGNED_OUT);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NTPSnippetsService::State::DISABLED, service()->state_);
-  EXPECT_THAT(service()->GetSnippetsForTesting(),
+  EXPECT_THAT(service()->GetSnippetsForTesting(articles_category()),
               IsEmpty());  // No fetch should be made.
 
   // Simulate user sign in. The service should be ready again and load snippets.
   SetUpFetchResponse(GetTestJson({GetSnippet()}));
   EXPECT_CALL(observer(),
               OnCategoryStatusChanged(_, _, CategoryStatus::AVAILABLE_LOADING));
   EXPECT_CALL(mock_scheduler(), Schedule(_, _, _, _)).Times(1);
   service()->OnDisabledReasonChanged(DisabledReason::NONE);
   EXPECT_CALL(observer(),
               OnCategoryStatusChanged(_, _, CategoryStatus::AVAILABLE));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(NTPSnippetsService::State::READY, service()->state_);
-  EXPECT_FALSE(service()->GetSnippetsForTesting().empty());
+  EXPECT_FALSE(service()->GetSnippetsForTesting(articles_category()).empty());
 }
 
 TEST_F(NTPSnippetsServiceTest, ImageReturnedWithTheSameId) {
   LoadFromJSONString(GetTestJson({GetSnippet()}));
 
   gfx::Image image;
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
       .WillOnce(testing::WithArgs<0, 2>(Invoke(ServeOneByOneImage)));
   testing::MockFunction<void(const std::string&, const gfx::Image&)>
       image_fetched;
@@ skipping 23 matching lines @@
       MakeUniqueID(kSnippetUrl2),
       base::Bind(&testing::MockFunction<void(const std::string&,
                                               const gfx::Image&)>::Call,
                  base::Unretained(&image_fetched)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(image.IsEmpty());
 }
 
 }  // namespace ntp_snippets