[NTP Snippets] Introduce ContentSuggestion::ID

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 <utility>
 #include <vector>
 
@@ skipping 59 matching lines @@
   void FireCategoryStatusChanged(Category category, CategoryStatus new_status) {
     statuses_[category.id()] = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   }
 
   void FireCategoryStatusChangedWithCurrentStatus(Category category) {
     observer()->OnCategoryStatusChanged(this, category,
                                         statuses_[category.id()]);
   }
 
-  void FireSuggestionInvalidated(Category category,
-                                 const std::string& suggestion_id) {
-    observer()->OnSuggestionInvalidated(this, category, suggestion_id);
+  void FireSuggestionInvalidated(const ContentSuggestion::ID& suggestion_id) {
+    observer()->OnSuggestionInvalidated(this, suggestion_id);
   }
 
   MOCK_METHOD3(ClearHistory,
                void(base::Time begin,
                     base::Time end,
                     const base::Callback<bool(const GURL& url)>& filter));
   MOCK_METHOD1(ClearCachedSuggestions, void(Category category));
   MOCK_METHOD2(GetDismissedSuggestionsForDebugging,
                void(Category category,
                     const DismissedSuggestionsCallback& callback));
   MOCK_METHOD1(ClearDismissedSuggestionsForDebugging, void(Category category));
-  MOCK_METHOD1(DismissSuggestion, void(const std::string& suggestion_id));
+  MOCK_METHOD1(DismissSuggestion,
+               void(const ContentSuggestion::ID& suggestion_id));
   MOCK_METHOD2(FetchSuggestionImage,
-               void(const std::string& suggestion_id,
+               void(const ContentSuggestion::ID& suggestion_id,
                     const ImageFetchedCallback& callback));
 
  private:
   std::vector<Category> provided_categories_;
   std::map<int, CategoryStatus> statuses_;
 };
 
 class MockServiceObserver : public ContentSuggestionsService::Observer {
  public:
   MockServiceObserver() = default;
   ~MockServiceObserver() override = default;
 
   MOCK_METHOD1(OnNewSuggestions, void(Category category));
   MOCK_METHOD2(OnCategoryStatusChanged,
                void(Category changed_category, CategoryStatus new_status));
-  MOCK_METHOD2(OnSuggestionInvalidated,
-               void(Category category, const std::string& suggestion_id));
+  MOCK_METHOD1(OnSuggestionInvalidated,
+               void(const ContentSuggestion::ID& suggestion_id));
   MOCK_METHOD0(ContentSuggestionsServiceShutdown, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockServiceObserver);
 };
 
 }  // namespace
 
 class ContentSuggestionsServiceTest : public testing::Test {
  public:
@@ skipping 12 matching lines @@
   // returned by the service for the given |category|.
   void ExpectThatSuggestionsAre(Category category, std::vector<int> numbers) {
     std::vector<Category> categories = service()->GetCategories();
     auto position = std::find(categories.begin(), categories.end(), category);
     if (!numbers.empty()) {
       EXPECT_NE(categories.end(), position);
     }
 
     for (const auto& suggestion :
          service()->GetSuggestionsForCategory(category)) {
-      std::string within_category_id =
-          service()->category_factory()->GetWithinCategoryIDFromUniqueID(
-              suggestion.id());
+      std::string within_category_id = suggestion.id().within_category_id();
       int id;
       ASSERT_TRUE(base::StringToInt(within_category_id, &id));
       auto position = std::find(numbers.begin(), numbers.end(), id);
       if (position == numbers.end()) {
         ADD_FAILURE() << "Unexpected suggestion with ID " << id;
       } else {
         numbers.erase(position);
       }
     }
     for (int number : numbers) {
@@ skipping 39 matching lines @@
     service_.reset(new ContentSuggestionsService(enabled,
                                                  nullptr /* history_service */,
                                                  nullptr /* pref_service */));
   }
 
   ContentSuggestionsService* service() { return service_.get(); }
 
   // Returns a suggestion instance for testing.
   ContentSuggestion CreateSuggestion(Category category, int number) {
     return ContentSuggestion(
-        service()->category_factory()->MakeUniqueID(category,
-                                                    base::IntToString(number)),
+        category, base::IntToString(number),
         GURL("http://testsuggestion/" + base::IntToString(number)));
   }
 
   std::vector<ContentSuggestion> CreateSuggestions(
       Category category,
       const std::vector<int>& numbers) {
     std::vector<ContentSuggestion> result;
     for (int number : numbers) {
       result.push_back(CreateSuggestion(category, number));
     }
@@ skipping 72 matching lines @@
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectFetchSuggestionImage) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider1 = RegisterProvider(articles_category);
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider1->FireSuggestionsChanged(articles_category,
                                     CreateSuggestions(articles_category, {1}));
-  std::string suggestion_id = CreateSuggestion(articles_category, 1).id();
+  ContentSuggestion::ID suggestion_id(articles_category, "1");
 
   EXPECT_CALL(*provider1, FetchSuggestionImage(suggestion_id, _));
   EXPECT_CALL(*provider2, FetchSuggestionImage(_, _)).Times(0);
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
 }
 
 TEST_F(ContentSuggestionsServiceTest,
        ShouldCallbackEmptyImageForUnavailableProvider) {
   // Setup the current thread's MessageLoop.
   base::MessageLoop message_loop;
 
   base::RunLoop run_loop;
   // Assuming there will never be a category with the id below.
-  std::string suggestion_id = "21563|TestID";
+  ContentSuggestion::ID suggestion_id(category_factory()->FromIDValue(21563),
+                                      "TestID");
   EXPECT_CALL(*this, OnImageFetched(Property(&gfx::Image::IsEmpty, Eq(true))))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   service()->FetchSuggestionImage(
       suggestion_id, base::Bind(&ContentSuggestionsServiceTest::OnImageFetched,
                                 base::Unretained(this)));
   run_loop.Run();
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectDismissSuggestion) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider1 = RegisterProvider(articles_category);
   MockProvider* provider2 = RegisterProvider(offline_pages_category);
 
   provider2->FireSuggestionsChanged(
       offline_pages_category, CreateSuggestions(offline_pages_category, {11}));
-  std::string suggestion_id = CreateSuggestion(offline_pages_category, 11).id();
+  ContentSuggestion::ID suggestion_id(offline_pages_category, "11");
 
   EXPECT_CALL(*provider1, DismissSuggestion(_)).Times(0);
   EXPECT_CALL(*provider2, DismissSuggestion(suggestion_id));
   service()->DismissSuggestion(suggestion_id);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectSuggestionInvalidated) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
 
   MockProvider* provider = RegisterProvider(articles_category);
   MockServiceObserver observer;
   service()->AddObserver(&observer);
 
   provider->FireSuggestionsChanged(
       articles_category, CreateSuggestions(articles_category, {11, 12, 13}));
   ExpectThatSuggestionsAre(articles_category, {11, 12, 13});
 
-  std::string suggestion_id = CreateSuggestion(articles_category, 12).id();
-  EXPECT_CALL(observer,
-              OnSuggestionInvalidated(articles_category, suggestion_id));
-  provider->FireSuggestionInvalidated(articles_category, suggestion_id);
+  ContentSuggestion::ID suggestion_id(articles_category, "12");
+  EXPECT_CALL(observer, OnSuggestionInvalidated(suggestion_id));
+  provider->FireSuggestionInvalidated(suggestion_id);
   ExpectThatSuggestionsAre(articles_category, {11, 13});
   Mock::VerifyAndClearExpectations(&observer);
 
   // Unknown IDs must be forwarded (though no change happens to the service's
   // internal data structures) because previously opened UIs, which can still
   // show the invalidated suggestion, must be notified.
-  std::string unknown_id = CreateSuggestion(articles_category, 1234).id();
-  EXPECT_CALL(observer, OnSuggestionInvalidated(articles_category, unknown_id));
-  provider->FireSuggestionInvalidated(articles_category, unknown_id);
+  ContentSuggestion::ID unknown_id(articles_category, "1234");
+  EXPECT_CALL(observer, OnSuggestionInvalidated(unknown_id));
+  provider->FireSuggestionInvalidated(unknown_id);
   ExpectThatSuggestionsAre(articles_category, {11, 13});
   Mock::VerifyAndClearExpectations(&observer);
 
   service()->RemoveObserver(&observer);
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardSuggestions) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::DOWNLOADS);
@@ skipping 192 matching lines @@
   EXPECT_THAT(service()->GetCategories(), ElementsAre(bookmarks, remote));
   // Dismiss the second suggestion; now bookmarks should go back to the end.
   service()->DismissSuggestion(CreateSuggestion(bookmarks, 2).id());
   EXPECT_THAT(service()->GetCategories(), ElementsAre(remote, bookmarks));
 
   // Same thing, but invalidate instead of dismissing.
   bookmarks_provider->FireSuggestionsChanged(
       bookmarks, CreateSuggestions(bookmarks, {1, 2}));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(bookmarks, remote));
   bookmarks_provider->FireSuggestionInvalidated(
-      bookmarks, CreateSuggestion(bookmarks, 1).id());
+      ContentSuggestion::ID(bookmarks, "1"));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(bookmarks, remote));
   bookmarks_provider->FireSuggestionInvalidated(
-      bookmarks, CreateSuggestion(bookmarks, 2).id());
+      ContentSuggestion::ID(bookmarks, "2"));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(remote, bookmarks));
 
   // Same thing, but now the bookmarks category updates "naturally".
   bookmarks_provider->FireSuggestionsChanged(
       bookmarks, CreateSuggestions(bookmarks, {1, 2}));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(bookmarks, remote));
   bookmarks_provider->FireSuggestionsChanged(bookmarks,
                                              CreateSuggestions(bookmarks, {1}));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(bookmarks, remote));
   bookmarks_provider->FireSuggestionsChanged(
       bookmarks, CreateSuggestions(bookmarks, std::vector<int>()));
   EXPECT_THAT(service()->GetCategories(), ElementsAre(remote, bookmarks));
 }
 
 TEST_F(ContentSuggestionsServiceTest, ShouldForwardClearHistory) {
   Category category = FromKnownCategory(KnownCategories::DOWNLOADS);
   MockProvider* provider = RegisterProvider(category);
   base::Time begin = base::Time::FromTimeT(123),
              end = base::Time::FromTimeT(456);
   EXPECT_CALL(*provider, ClearHistory(begin, end, _));
   base::Callback<bool(const GURL& url)> filter;
   service()->ClearHistory(begin, end, filter);
 }
 
 }  // namespace ntp_snippets