[NTP Snippets] Introduce ContentSuggestion::ID

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 281 matching lines @@
   void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
                                Category category,
                                CategoryStatus new_status) override {
     if (category.IsKnownCategory(KnownCategories::ARTICLES) &&
         IsCategoryStatusAvailable(new_status)) {
       loaded_.Signal();
     }
     statuses_[category] = new_status;
   }
 
-  void OnSuggestionInvalidated(ContentSuggestionsProvider* provider,
-                               Category category,
-                               const std::string& suggestion_id) override {}
+  void OnSuggestionInvalidated(
+      ContentSuggestionsProvider* provider,
+      const ContentSuggestion::ID& suggestion_id) override {}
 
   const std::map<Category, CategoryStatus, Category::CompareByID>& statuses()
       const {
     return statuses_;
   }
 
   CategoryStatus StatusForCategory(Category category) const {
     auto it = statuses_.find(category);
     if (it == statuses_.end()) {
       return CategoryStatus::NOT_PROVIDED;
@@ skipping 101 matching lines @@
     base::RunLoop().RunUntilIdle();
     observer_->WaitForLoad();
   }
 
   void ResetSnippetsService(std::unique_ptr<NTPSnippetsService>* service) {
     service->reset();
     observer_.reset();
     *service = MakeSnippetsService();
   }
 
-  std::string MakeArticleID(const NTPSnippetsService& service,
-                            const std::string& within_category_id) {
-    return service.MakeUniqueID(articles_category(), within_category_id);
+  ContentSuggestion::ID MakeArticleID(const std::string& within_category_id) {
+    return ContentSuggestion::ID(articles_category(), within_category_id);
   }
 
   Category articles_category() {
     return category_factory_.FromKnownCategory(KnownCategories::ARTICLES);
   }
 
-  std::string MakeOtherID(const NTPSnippetsService& service,
-                          const std::string& within_category_id) {
-    return service.MakeUniqueID(other_category(), within_category_id);
+  ContentSuggestion::ID MakeOtherID(const std::string& within_category_id) {
+    return ContentSuggestion::ID(other_category(), within_category_id);
   }
 
   Category other_category() { return category_factory_.FromRemoteCategory(2); }
 
  protected:
   const GURL& test_url() { return test_url_; }
   FakeContentSuggestionsProviderObserver& observer() { return *observer_; }
   MockScheduler& mock_scheduler() { return scheduler_; }
   NiceMock<MockImageFetcher>* image_fetcher() { return image_fetcher_; }
 
@@ skipping 155 matching lines @@
 
   LoadFromJSONString(service.get(), json_str);
 
   ASSERT_THAT(observer().SuggestionsForCategory(articles_category()),
               SizeIs(1));
   ASSERT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   const ContentSuggestion& suggestion =
       observer().SuggestionsForCategory(articles_category()).front();
 
-  EXPECT_EQ(MakeArticleID(*service, kSnippetUrl), suggestion.id());
+  EXPECT_EQ(MakeArticleID(kSnippetUrl), suggestion.id());
   EXPECT_EQ(kSnippetTitle, base::UTF16ToUTF8(suggestion.title()));
   EXPECT_EQ(kSnippetText, base::UTF16ToUTF8(suggestion.snippet_text()));
   EXPECT_EQ(GetDefaultCreationTime(), suggestion.publish_date());
   EXPECT_EQ(kSnippetPublisherName,
             base::UTF16ToUTF8(suggestion.publisher_name()));
   EXPECT_EQ(GURL(kSnippetAmpUrl), suggestion.amp_url());
 }
 
 TEST_F(NTPSnippetsServiceTest, MultipleCategories) {
   std::string json_str(
@@ skipping 13 matching lines @@
   EXPECT_THAT(service->GetSnippetsForTesting(other_category()), SizeIs(1));
 
   ASSERT_THAT(observer().SuggestionsForCategory(articles_category()),
               SizeIs(1));
 
   ASSERT_THAT(observer().SuggestionsForCategory(other_category()), SizeIs(1));
 
   {
     const ContentSuggestion& suggestion =
         observer().SuggestionsForCategory(articles_category()).front();
-    EXPECT_EQ(MakeArticleID(*service, std::string(kSnippetUrl) + "/0"),
-              suggestion.id());
+    EXPECT_EQ(MakeArticleID(std::string(kSnippetUrl) + "/0"), suggestion.id());
     EXPECT_EQ(kSnippetTitle, base::UTF16ToUTF8(suggestion.title()));
     EXPECT_EQ(kSnippetText, base::UTF16ToUTF8(suggestion.snippet_text()));
     EXPECT_EQ(GetDefaultCreationTime(), suggestion.publish_date());
     EXPECT_EQ(kSnippetPublisherName,
               base::UTF16ToUTF8(suggestion.publisher_name()));
     EXPECT_EQ(GURL(kSnippetAmpUrl), suggestion.amp_url());
   }
 
   {
     const ContentSuggestion& suggestion =
         observer().SuggestionsForCategory(other_category()).front();
-    EXPECT_EQ(MakeOtherID(*service, std::string(kSnippetUrl) + "/1"),
-              suggestion.id());
+    EXPECT_EQ(MakeOtherID(std::string(kSnippetUrl) + "/1"), suggestion.id());
     EXPECT_EQ(kSnippetTitle, base::UTF16ToUTF8(suggestion.title()));
     EXPECT_EQ(kSnippetText, base::UTF16ToUTF8(suggestion.snippet_text()));
     EXPECT_EQ(GetDefaultCreationTime(), suggestion.publish_date());
     EXPECT_EQ(kSnippetPublisherName,
               base::UTF16ToUTF8(suggestion.publisher_name()));
     EXPECT_EQ(GURL(kSnippetAmpUrl), suggestion.amp_url());
   }
 }
 
 TEST_F(NTPSnippetsServiceTest, Clear) {
@@ skipping 72 matching lines @@
   auto service = MakeSnippetsService();
 
   std::string json_str(
       GetTestJson({GetSnippetWithSources("http://site.com", "Source 1", "")}));
 
   LoadFromJSONString(service.get(), json_str);
 
   ASSERT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   // Dismissing a non-existent snippet shouldn't do anything.
-  service->DismissSuggestion(MakeArticleID(*service, "http://othersite.com"));
+  service->DismissSuggestion(MakeArticleID("http://othersite.com"));
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   // Dismiss the snippet.
-  service->DismissSuggestion(MakeArticleID(*service, kSnippetUrl));
+  service->DismissSuggestion(MakeArticleID(kSnippetUrl));
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // Make sure that fetching the same snippet again does not re-add it.
   LoadFromJSONString(service.get(), json_str);
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // The snippet should stay dismissed even after re-creating the service.
   ResetSnippetsService(&service);
   LoadFromJSONString(service.get(), json_str);
   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(articles_category()), IsEmpty());
   LoadFromJSONString(service.get(), json_str);
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 }
 
 TEST_F(NTPSnippetsServiceTest, GetDismissed) {
   auto service = MakeSnippetsService();
 
   LoadFromJSONString(service.get(), GetTestJson({GetSnippet()}));
 
-  service->DismissSuggestion(MakeArticleID(*service, kSnippetUrl));
+  service->DismissSuggestion(MakeArticleID(kSnippetUrl));
 
   service->GetDismissedSuggestionsForDebugging(
       articles_category(),
       base::Bind(
           [](NTPSnippetsService* service, NTPSnippetsServiceTest* test,
              std::vector<ContentSuggestion> dismissed_suggestions) {
             EXPECT_EQ(1u, dismissed_suggestions.size());
             for (auto& suggestion : dismissed_suggestions) {
-              EXPECT_EQ(test->MakeArticleID(*service, kSnippetUrl),
-                        suggestion.id());
+              EXPECT_EQ(test->MakeArticleID(kSnippetUrl), suggestion.id());
             }
           },
           service.get(), this));
   base::RunLoop().RunUntilIdle();
 
   // There should be no dismissed snippet after clearing the list.
   service->ClearDismissedSuggestionsForDebugging(articles_category());
   service->GetDismissedSuggestionsForDebugging(
       articles_category(),
       base::Bind(
@@ skipping 19 matching lines @@
 }
 
 TEST_F(NTPSnippetsServiceTest, RemoveExpiredDismissedContent) {
   auto service = MakeSnippetsService();
 
   std::string json_str1(GetTestJson({GetExpiredSnippet()}));
   // Load it.
   LoadFromJSONString(service.get(), json_str1);
   // Dismiss the suggestion
   service->DismissSuggestion(
-      service->MakeUniqueID(service->articles_category_, kSnippetUrl));
+      ContentSuggestion::ID(articles_category(), kSnippetUrl));
 
   // Load a different snippet - this will clear the expired dismissed ones.
   std::string json_str2(GetTestJson({GetSnippetWithUrl(kSnippetUrl2)}));
   LoadFromJSONString(service.get(), json_str2);
 
   EXPECT_THAT(service->GetDismissedSnippetsForTesting(articles_category()),
               IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, ExpiredContentNotRemoved) {
@@ skipping 78 matching lines @@
                           base::Bucket(/*min=*/1, /*count=*/2)));
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticlesFetched"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/1),
                           base::Bucket(/*min=*/1, /*count=*/2)));
   EXPECT_THAT(
       tester.GetAllSamples("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded"),
       IsEmpty());
 
   // Dismissing a snippet should decrease the list size. This will only be
   // logged after the next fetch.
-  service->DismissSuggestion(MakeArticleID(*service, kSnippetUrl));
+  service->DismissSuggestion(MakeArticleID(kSnippetUrl));
   LoadFromJSONString(service.get(), GetTestJson({GetSnippet()}));
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticles"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/3),
                           base::Bucket(/*min=*/1, /*count=*/2)));
   // Dismissed snippets shouldn't influence NumArticlesFetched.
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticlesFetched"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/1),
                           base::Bucket(/*min=*/1, /*count=*/3)));
   EXPECT_THAT(
       tester.GetAllSamples("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded"),
@@ skipping 33 matching lines @@
       "http://mashable-amphtml.googleusercontent.com/1",
       "http://t2.gstatic.com/images?q=tbn:3"};
 
   // Add the snippet from the mashable domain.
   LoadFromJSONString(service.get(),
                      GetTestJson({GetSnippetWithUrlAndTimesAndSource(
                          source_urls, source_urls[0], creation, expiry,
                          publishers[0], amp_urls[0])}));
   ASSERT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
   // Dismiss the snippet via the mashable source corpus ID.
-  service->DismissSuggestion(MakeArticleID(*service, source_urls[0]));
+  service->DismissSuggestion(MakeArticleID(source_urls[0]));
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
 
   // The same article from the AOL domain should now be detected as dismissed.
   LoadFromJSONString(service.get(),
                      GetTestJson({GetSnippetWithUrlAndTimesAndSource(
                          source_urls, source_urls[1], creation, expiry,
                          publishers[1], amp_urls[1])}));
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
 }
 
@@ skipping 32 matching lines @@
   gfx::Image image;
   MockFunction<void(const gfx::Image&)> image_fetched;
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
         .WillOnce(WithArgs<0, 2>(Invoke(ServeOneByOneImage)));
     EXPECT_CALL(image_fetched, Call(_)).WillOnce(SaveArg<0>(&image));
   }
 
   service->FetchSuggestionImage(
-      MakeArticleID(*service, kSnippetUrl),
+      MakeArticleID(kSnippetUrl),
       base::Bind(&MockFunction<void(const gfx::Image&)>::Call,
                  base::Unretained(&image_fetched)));
   base::RunLoop().RunUntilIdle();
   // Check that the image by ServeOneByOneImage is really served.
   EXPECT_EQ(1, image.Width());
 }
 
 TEST_F(NTPSnippetsServiceTest, EmptyImageReturnedForNonExistentId) {
   auto service = MakeSnippetsService();
 
   // Create a non-empty image so that we can test the image gets updated.
   gfx::Image image = gfx::test::CreateImage(1, 1);
   MockFunction<void(const gfx::Image&)> image_fetched;
   EXPECT_CALL(image_fetched, Call(_)).WillOnce(SaveArg<0>(&image));
 
   service->FetchSuggestionImage(
-      MakeArticleID(*service, kSnippetUrl2),
+      MakeArticleID(kSnippetUrl2),
       base::Bind(&MockFunction<void(const gfx::Image&)>::Call,
                  base::Unretained(&image_fetched)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(image.IsEmpty());
 }
 
 TEST_F(NTPSnippetsServiceTest, ClearHistoryRemovesAllSuggestions) {
   auto service = MakeSnippetsService();
 
   std::string first_snippet = GetSnippetWithUrl("http://url1.com");
   std::string second_snippet = GetSnippetWithUrl("http://url2.com");
   std::string json_str = GetTestJson({first_snippet, second_snippet});
   LoadFromJSONString(service.get(), json_str);
   ASSERT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(2));
 
-  service->DismissSuggestion(MakeArticleID(*service, "http://url1.com"));
+  service->DismissSuggestion(MakeArticleID("http://url1.com"));
   ASSERT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
   ASSERT_THAT(service->GetDismissedSnippetsForTesting(articles_category()),
               SizeIs(1));
 
   base::Time begin = base::Time::FromTimeT(123),
              end = base::Time::FromTimeT(456);
   base::Callback<bool(const GURL& url)> filter;
   service->ClearHistory(begin, end, filter);
 
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
   EXPECT_THAT(service->GetDismissedSnippetsForTesting(articles_category()),
               IsEmpty());
 }
 
 }  // namespace ntp_snippets