Remove deleted offline page suggestions from opened NTPs

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 69 matching lines @@
 
   void FireSuggestionsChanged(Category category, std::vector<int> numbers) {
     observer()->OnNewSuggestions(this, category, CreateSuggestions(numbers));
   }
 
   void FireCategoryStatusChanged(Category category, CategoryStatus new_status) {
     statuses_[category.id()] = new_status;
     observer()->OnCategoryStatusChanged(this, category, new_status);
   }
 
+  void FireSuggestionInvalidated(Category category,
+                                 const std::string& suggestion_id) {
+    observer()->OnSuggestionInvalidated(this, category, suggestion_id);
+  }
+
   MOCK_METHOD1(ClearCachedSuggestionsForDebugging, void(Category category));
   MOCK_METHOD1(GetDismissedSuggestionsForDebugging,
                std::vector<ContentSuggestion>(Category category));
   MOCK_METHOD1(ClearDismissedSuggestionsForDebugging, void(Category category));
   MOCK_METHOD1(DismissSuggestion, void(const std::string& suggestion_id));
   MOCK_METHOD2(FetchSuggestionImage,
                void(const std::string& suggestion_id,
                     const ImageFetchedCallback& callback));
 
  private:
   std::vector<Category> provided_categories_;
   std::map<int, CategoryStatus> statuses_;
 };
 
 class MockServiceObserver : public ContentSuggestionsService::Observer {
  public:
   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_METHOD0(ContentSuggestionsServiceShutdown, void());
   ~MockServiceObserver() override {}
 };
 
 }  // namespace
 
 class ContentSuggestionsServiceTest : public testing::Test {
  public:
   ContentSuggestionsServiceTest() {}
 
@@ skipping 135 matching lines @@
 TEST_F(ContentSuggestionsServiceTest, ShouldRedirectFetchSuggestionImage) {
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
   MockProvider* provider1 = MakeProvider(articles_category);
   MockProvider* provider2 = MakeProvider(offline_pages_category);
 
   provider1->FireSuggestionsChanged(articles_category, {1});
   std::string suggestion_id = CreateSuggestion(1).id();
 
-  EXPECT_CALL(*provider1, FetchSuggestionImage(suggestion_id, _)).Times(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;
@@ skipping 13 matching lines @@
   Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
   Category offline_pages_category =
       FromKnownCategory(KnownCategories::BOOKMARKS);
   MockProvider* provider1 = MakeProvider(articles_category);
   MockProvider* provider2 = MakeProvider(offline_pages_category);
 
   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);
+  EXPECT_CALL(*provider2, DismissSuggestion(suggestion_id));
   service()->DismissSuggestion(suggestion_id);
 }
 
+TEST_F(ContentSuggestionsServiceTest, ShouldRedirectSuggestionInvalidated) {
+  Category articles_category = FromKnownCategory(KnownCategories::ARTICLES);
+
+  MockProvider* provider = MakeProvider(articles_category);
+  MockServiceObserver observer;
+  service()->AddObserver(&observer);
+
+  provider->FireSuggestionsChanged(articles_category, {11, 12, 13});
+  ExpectThatSuggestionsAre(articles_category, {11, 12, 13});
+
+  std::string suggestion_id = CreateSuggestion(12).id();
+  EXPECT_CALL(observer,
+              OnSuggestionInvalidated(articles_category, suggestion_id));
+  provider->FireSuggestionInvalidated(articles_category, 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(1234).id();
+  EXPECT_CALL(observer, OnSuggestionInvalidated(articles_category, unknown_id));
+  provider->FireSuggestionInvalidated(articles_category, 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::BOOKMARKS);
 
   // Create and register providers
   MockProvider* provider1 = MakeProvider(articles_category);
   MockProvider* provider2 = MakeProvider(offline_pages_category);
   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(articles_category)).Times(1);
+  EXPECT_CALL(observer, OnNewSuggestions(articles_category));
   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(articles_category)).Times(1);
+  EXPECT_CALL(observer, OnNewSuggestions(articles_category));
   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(offline_pages_category)).Times(1);
+  EXPECT_CALL(observer, OnNewSuggestions(offline_pages_category));
   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(articles_category)).Times(1);
+  EXPECT_CALL(observer, OnNewSuggestions(articles_category));
   provider1->FireSuggestionsChanged(articles_category, {1});
   ExpectThatSuggestionsAre(articles_category, {1});
   ExpectThatSuggestionsAre(offline_pages_category, {13, 14});
   Mock::VerifyAndClearExpectations(&observer);
 
   // provider2 reports BOOKMARKS as unavailable
   EXPECT_CALL(observer, OnCategoryStatusChanged(
                             offline_pages_category,
-                            CategoryStatus::CATEGORY_EXPLICITLY_DISABLED))
-      .Times(1);
+                            CategoryStatus::CATEGORY_EXPLICITLY_DISABLED));
   provider2->FireCategoryStatusChanged(
       offline_pages_category, CategoryStatus::CATEGORY_EXPLICITLY_DISABLED);
   EXPECT_THAT(service()->GetCategoryStatus(articles_category),
               Eq(CategoryStatus::AVAILABLE));
   EXPECT_THAT(service()->GetCategoryStatus(offline_pages_category),
               Eq(CategoryStatus::CATEGORY_EXPLICITLY_DISABLED));
   ExpectThatSuggestionsAre(articles_category, {1});
   ExpectThatSuggestionsAre(offline_pages_category, std::vector<int>());
   Mock::VerifyAndClearExpectations(&observer);
 
   // Shutdown the service
   EXPECT_CALL(observer, ContentSuggestionsServiceShutdown());
   service()->Shutdown();
   service()->RemoveObserver(&observer);
   // The service will receive two Shutdown() calls.
 }
 
 }  // namespace ntp_snippets