SuggestionsService support for Desktop

components/suggestions/suggestions_service_unittest.cc

 // Copyright 2014 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/suggestions/suggestions_service.h"
 
 #include <map>
 #include <sstream>
 
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 using ::testing::Return;
 using testing::SetArgPointee;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace {
 
 const char kTestTitle[] = "a title";
 const char kTestUrl[] = "http://go.com";
+const char kTestFaviconUrl[] =
+    "https://s2.googleusercontent.com/s2/favicons?domain_url="
+    "http://go.com&alt=s&sz=32";
 const char kBlacklistUrl[] = "http://blacklist.com";
 const char kBlacklistUrlAlt[] = "http://blacklist-atl.com";
 const int64 kTestDefaultExpiry = 1402200000000000;
 const int64 kTestSetExpiry = 1404792000000000;
 
 scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
     const GURL& url, net::URLFetcherDelegate* delegate,
     const std::string& response_data, net::HttpStatusCode response_code,
     net::URLRequestStatus::Status status) {
   scoped_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
       url, delegate, response_data, response_code, status));
 
   if (response_code == net::HTTP_OK) {
     scoped_refptr<net::HttpResponseHeaders> download_headers(
         new net::HttpResponseHeaders(""));
     download_headers->AddHeader("Content-Type: text/html");
     fetcher->set_response_headers(download_headers);
   }
   return fetcher.Pass();
 }
 
 std::string GetExpectedBlacklistRequestUrl(const GURL& blacklist_url) {
   std::stringstream request_url;
-  request_url << "https://www.google.com/chromesuggestions/blacklist?t=2&url="
+  request_url << suggestions::kSuggestionsBlacklistURLPrefix
               << net::EscapeQueryParamValue(blacklist_url.spec(), true);
   return request_url.str();
 }
 
 // GMock matcher for protobuf equality.
 MATCHER_P(EqualsProto, message, "") {
   // This implementation assumes protobuf serialization is deterministic, which
   // is true in practice but technically not something that code is supposed
   // to rely on.  However, it vastly simplifies the implementation.
   std::string expected_serialized, actual_serialized;
@@ skipping 29 matching lines @@
 
   return profile;
 }
 
 class TestSuggestionsStore : public suggestions::SuggestionsStore {
  public:
   TestSuggestionsStore() {
     cached_suggestions = CreateSuggestionsProfile();
   }
   bool LoadSuggestions(SuggestionsProfile* suggestions) override {
-    if (cached_suggestions.suggestions_size()) {
-      *suggestions = cached_suggestions;
-      return true;
-    }
-    return false;
+    suggestions->CopyFrom(cached_suggestions);
+    return cached_suggestions.suggestions_size();
   }
   bool StoreSuggestions(const SuggestionsProfile& suggestions)
       override {
-    cached_suggestions = suggestions;
+    cached_suggestions.CopyFrom(suggestions);
     return true;
   }
   void ClearSuggestions() override {
     cached_suggestions = SuggestionsProfile();
   }
 
   SuggestionsProfile cached_suggestions;
 };
 
 class MockImageManager : public suggestions::ImageManager {
  public:
   MockImageManager() {}
   virtual ~MockImageManager() {}
   MOCK_METHOD1(Initialize, void(const SuggestionsProfile&));
   MOCK_METHOD2(GetImageForURL,
                void(const GURL&,
                     base::Callback<void(const GURL&, const SkBitmap*)>));
 };
 
 class MockBlacklistStore : public suggestions::BlacklistStore {
  public:
   MOCK_METHOD1(BlacklistUrl, bool(const GURL&));
   MOCK_METHOD0(IsEmpty, bool());
   MOCK_METHOD1(GetTimeUntilReadyForUpload, bool(base::TimeDelta*));
   MOCK_METHOD2(GetTimeUntilURLReadyForUpload,
                bool(const GURL&, base::TimeDelta*));
   MOCK_METHOD1(GetCandidateForUpload, bool(GURL*));
   MOCK_METHOD1(RemoveUrl, bool(const GURL&));
   MOCK_METHOD1(FilterSuggestions, void(SuggestionsProfile*));
+  MOCK_METHOD0(ClearBlacklist, void());
 };
 
 class SuggestionsServiceTest : public testing::Test {
  public:
-  void CheckSuggestionsData(const SuggestionsProfile& suggestions_profile) {
+  void CheckCallback(const SuggestionsProfile& suggestions_profile) {
+    ++suggestions_data_callback_count_;
+  }
+
+  void CheckSuggestionsData() {
+    SuggestionsProfile suggestions_profile;
+    test_suggestions_store_->LoadSuggestions(&suggestions_profile);
     EXPECT_EQ(1, suggestions_profile.suggestions_size());
     EXPECT_EQ(kTestTitle, suggestions_profile.suggestions(0).title());
     EXPECT_EQ(kTestUrl, suggestions_profile.suggestions(0).url());
-    ++suggestions_data_check_count_;
+    EXPECT_EQ(kTestFaviconUrl,
+              suggestions_profile.suggestions(0).favicon_url());
   }
 
   void SetBlacklistFailure() {
     blacklisting_failed_ = true;
   }
 
   void SetUndoBlacklistFailure() {
     undo_blacklisting_failed_ = true;
   }
 
   void ExpectEmptySuggestionsProfile(const SuggestionsProfile& profile) {
     EXPECT_EQ(0, profile.suggestions_size());
     ++suggestions_empty_data_count_;
   }
 
-  int suggestions_data_check_count_;
+  int suggestions_data_callback_count_;
   int suggestions_empty_data_count_;
   bool blacklisting_failed_;
   bool undo_blacklisting_failed_;
 
  protected:
   SuggestionsServiceTest()
-      : suggestions_data_check_count_(0),
+      : suggestions_data_callback_count_(0),
         suggestions_empty_data_count_(0),
         blacklisting_failed_(false),
         undo_blacklisting_failed_(false),
         factory_(NULL, base::Bind(&CreateURLFetcher)),
         mock_thumbnail_manager_(NULL),
         mock_blacklist_store_(NULL),
         test_suggestions_store_(NULL) {}
 
   ~SuggestionsServiceTest() override {}
 
   void SetUp() override {
     request_context_ =
         new net::TestURLRequestContextGetter(io_message_loop_.task_runner());
   }
 
   void FetchSuggestionsDataHelper(SyncState sync_state) {
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMocks());
     EXPECT_TRUE(suggestions_service != NULL);
 
-    // Add some suggestions in the cache.
-    FillSuggestionsStore();
-    SuggestionsProfile suggestions_profile;
-    test_suggestions_store_->LoadSuggestions(&suggestions_profile);
+    SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
 
     // Set up net::FakeURLFetcherFactory.
     factory_.SetFakeResponse(GURL(kSuggestionsURL),
                              suggestions_profile.SerializeAsString(),
                              net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
     // Expectations.
     EXPECT_CALL(*mock_thumbnail_manager_,
                 Initialize(EqualsProto(suggestions_profile)));
     EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_));
     EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
         .WillOnce(Return(false));
 
     // Send the request. The data will be returned to the callback.
     suggestions_service->FetchSuggestionsData(
-        sync_state,
-        base::Bind(&SuggestionsServiceTest::CheckSuggestionsData,
-                   base::Unretained(this)));
+        sync_state, base::Bind(&SuggestionsServiceTest::CheckCallback,
+                               base::Unretained(this)));
 
     // Ensure that CheckSuggestionsData() ran once.
-    EXPECT_EQ(1, suggestions_data_check_count_);
+    EXPECT_EQ(1, suggestions_data_callback_count_);
 
     // Let the network request run.
     io_message_loop_.RunUntilIdle();
+
+    CheckSuggestionsData();
   }
 
   SuggestionsService* CreateSuggestionsServiceWithMocks() {
     // These objects are owned by the returned SuggestionsService, but we keep
     // the pointer around for testing.
     test_suggestions_store_ = new TestSuggestionsStore();
     mock_thumbnail_manager_ = new StrictMock<MockImageManager>();
     mock_blacklist_store_ = new StrictMock<MockBlacklistStore>();
     return new SuggestionsService(
         request_context_.get(),
         scoped_ptr<SuggestionsStore>(test_suggestions_store_),
         scoped_ptr<ImageManager>(mock_thumbnail_manager_),
         scoped_ptr<BlacklistStore>(mock_blacklist_store_));
   }
 
-  void FillSuggestionsStore() {
-    test_suggestions_store_->StoreSuggestions(CreateSuggestionsProfile());
-  }
-
   void Blacklist(SuggestionsService* suggestions_service, GURL url) {
     suggestions_service->BlacklistURL(
-        url,
-        base::Bind(&SuggestionsServiceTest::CheckSuggestionsData,
-                   base::Unretained(this)),
+        url, base::Bind(&SuggestionsServiceTest::CheckCallback,
+                        base::Unretained(this)),
         base::Bind(&SuggestionsServiceTest::SetBlacklistFailure,
                    base::Unretained(this)));
   }
 
   void UndoBlacklist(SuggestionsService* suggestions_service, GURL url) {
     suggestions_service->UndoBlacklistURL(
-        url,
-        base::Bind(&SuggestionsServiceTest::CheckSuggestionsData,
-                   base::Unretained(this)),
+        url, base::Bind(&SuggestionsServiceTest::CheckCallback,
+                        base::Unretained(this)),
         base::Bind(&SuggestionsServiceTest::SetUndoBlacklistFailure,
                    base::Unretained(this)));
   }
 
   // Helper for Undo failure tests. Depending on |is_uploaded|, tests either
   // the case where the URL is no longer in the local blacklist or the case
   // in which it's not yet candidate for upload.
   void UndoBlacklistURLFailsHelper(bool is_uploaded) {
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMocks());
@@ skipping 22 matching lines @@
       // URL is not yet candidate for upload.
       base::TimeDelta negative_delay = base::TimeDelta::FromHours(-1);
       EXPECT_CALL(*mock_blacklist_store_,
                   GetTimeUntilURLReadyForUpload(Eq(blacklist_url), _))
           .WillOnce(DoAll(SetArgPointee<1>(negative_delay), Return(true)));
     }
 
     Blacklist(suggestions_service.get(), blacklist_url);
     UndoBlacklist(suggestions_service.get(), blacklist_url);
 
-    EXPECT_EQ(1, suggestions_data_check_count_);
+    EXPECT_EQ(1, suggestions_data_callback_count_);
     EXPECT_FALSE(blacklisting_failed_);
     EXPECT_TRUE(undo_blacklisting_failed_);
   }
 
  protected:
   base::MessageLoopForIO io_message_loop_;
   net::FakeURLFetcherFactory factory_;
   // Only used if the SuggestionsService is built with mocks. Not owned.
   MockImageManager* mock_thumbnail_manager_;
   MockBlacklistStore* mock_blacklist_store_;
@@ skipping 10 matching lines @@
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncNotInitializedEnabled) {
   FetchSuggestionsDataHelper(NOT_INITIALIZED_ENABLED);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncDisabled) {
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
-  FillSuggestionsStore();
-
   // Send the request. Cache is cleared and empty data will be returned to the
   // callback.
   suggestions_service->FetchSuggestionsData(
       SYNC_OR_HISTORY_SYNC_DISABLED,
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
@@ skipping 15 matching lines @@
 
   // (Testing only) wait until suggestion fetch is complete.
   io_message_loop_.RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingResponseNotOK) {
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
-  // Add some suggestions in the cache.
-  FillSuggestionsStore();
-
   // Fake a non-200 response code.
   factory_.SetFakeResponse(GURL(kSuggestionsURL), "irrelevant",
                            net::HTTP_BAD_REQUEST,
                            net::URLRequestStatus::SUCCESS);
 
   // Expect that an upload to the blacklist is scheduled.
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
@@ skipping 38 matching lines @@
   Blacklist(suggestions_service.get(), blacklist_url);
 
   // Wait on the upload task. This only works when the scheduling task is not
   // for future execution (note how both the SuggestionsService's scheduling
   // delay and the BlacklistStore's candidacy delay are zero). Then wait on
   // the blacklist request, then again on the next blacklist scheduling task.
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
 
-  // Ensure that CheckSuggestionsData() ran once.
-  EXPECT_EQ(1, suggestions_data_check_count_);
+  EXPECT_EQ(1, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
+  CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURLFails) {
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   GURL blacklist_url(kBlacklistUrl);
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklist_url)))
       .WillOnce(Return(false));
 
   Blacklist(suggestions_service.get(), blacklist_url);
 
   EXPECT_TRUE(blacklisting_failed_);
-  EXPECT_EQ(0, suggestions_data_check_count_);
+  EXPECT_EQ(0, suggestions_data_callback_count_);
 }
 
 // Initial blacklist request fails, triggering a second which succeeds.
 TEST_F(SuggestionsServiceTest, BlacklistURLRequestFails) {
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service->set_blacklist_delay(no_delay);
 
@@ skipping 25 matching lines @@
       .WillOnce(DoAll(SetArgPointee<0>(no_delay), Return(true)))
       .WillOnce(Return(false));
   EXPECT_CALL(*mock_blacklist_store_, GetCandidateForUpload(_))
       .WillOnce(DoAll(SetArgPointee<0>(blacklist_url), Return(true)))
       .WillOnce(DoAll(SetArgPointee<0>(blacklist_url_alt), Return(true)));
   EXPECT_CALL(*mock_blacklist_store_, RemoveUrl(Eq(blacklist_url_alt)))
       .WillOnce(Return(true));
 
   // Blacklist call, first request attempt.
   Blacklist(suggestions_service.get(), blacklist_url);
-  EXPECT_EQ(1, suggestions_data_check_count_);
+  EXPECT_EQ(1, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
 
   // Wait for the first scheduling, the first request, the second scheduling,
   // second request and the third scheduling. Again, note that calling
   // RunUntilIdle on the MessageLoop only works when the task is not posted for
   // the future.
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
+  CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURL) {
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   // Ensure scheduling the request doesn't happen before undo.
   base::TimeDelta delay = base::TimeDelta::FromHours(1);
   suggestions_service->set_blacklist_delay(delay);
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
@@ skipping 12 matching lines @@
   // Undo expectations.
   EXPECT_CALL(*mock_blacklist_store_,
               GetTimeUntilURLReadyForUpload(Eq(blacklist_url), _))
       .WillOnce(DoAll(SetArgPointee<1>(delay), Return(true)));
   EXPECT_CALL(*mock_blacklist_store_, RemoveUrl(Eq(blacklist_url)))
     .WillOnce(Return(true));
 
   Blacklist(suggestions_service.get(), blacklist_url);
   UndoBlacklist(suggestions_service.get(), blacklist_url);
 
-  EXPECT_EQ(2, suggestions_data_check_count_);
+  EXPECT_EQ(2, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
   EXPECT_FALSE(undo_blacklisting_failed_);
 }
 
+TEST_F(SuggestionsServiceTest, ClearBlacklist) {
+  scoped_ptr<SuggestionsService> suggestions_service(
+      CreateSuggestionsServiceWithMocks());
+  EXPECT_TRUE(suggestions_service != NULL);
+  // Ensure scheduling the request doesn't happen before undo.
+  base::TimeDelta delay = base::TimeDelta::FromHours(1);
+  suggestions_service->set_blacklist_delay(delay);
+  SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
+  GURL blacklist_url(kBlacklistUrl);
+
+  factory_.SetFakeResponse(GURL(suggestions::kSuggestionsBlacklistClearURL),
+                           suggestions_profile.SerializeAsString(),
+                           net::HTTP_OK, net::URLRequestStatus::SUCCESS);
+
+  // Blacklist expectations.
+  EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklist_url)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mock_thumbnail_manager_,
+              Initialize(EqualsProto(suggestions_profile)))
+      .Times(AnyNumber());
+  EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
+      .WillOnce(DoAll(SetArgPointee<0>(delay), Return(true)));
+  EXPECT_CALL(*mock_blacklist_store_, ClearBlacklist());
+
+  Blacklist(suggestions_service.get(), blacklist_url);
+  suggestions_service->ClearBlacklist(base::Bind(
+      &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
+
+  EXPECT_EQ(2, suggestions_data_callback_count_);
+  EXPECT_FALSE(blacklisting_failed_);
+}
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURLFailsIfNotInBlacklist) {
   UndoBlacklistURLFailsHelper(true);
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURLFailsIfAlreadyCandidate) {
   UndoBlacklistURLFailsHelper(false);
 }
 
 TEST_F(SuggestionsServiceTest, GetBlacklistedUrl) {
@@ skipping 43 matching lines @@
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   SuggestionsProfile suggestions =
       CreateSuggestionsProfileWithExpiryTimestamps();
   suggestions_service->SetDefaultExpiryTimestamp(&suggestions,
                                                  kTestDefaultExpiry);
   EXPECT_EQ(kTestSetExpiry, suggestions.suggestions(0).expiry_ts());
   EXPECT_EQ(kTestDefaultExpiry, suggestions.suggestions(1).expiry_ts());
 }
 }  // namespace suggestions