Offline blacklisting for SuggestionsService.

chrome/browser/search/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 "chrome/browser/search/suggestions/suggestions_service.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/history/history_types.h"
+#include "chrome/browser/search/suggestions/blacklist_store.h"
 #include "chrome/browser/search/suggestions/proto/suggestions.pb.h"
 #include "chrome/browser/search/suggestions/suggestions_service_factory.h"
 #include "chrome/browser/search/suggestions/suggestions_store.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
@@ skipping 57 matching lines @@
   return profile.Pass();
 }
 
 class MockSuggestionsStore : public suggestions::SuggestionsStore {
  public:
   MOCK_METHOD1(LoadSuggestions, bool(SuggestionsProfile*));
   MOCK_METHOD1(StoreSuggestions, bool(const SuggestionsProfile&));
   MOCK_METHOD0(ClearSuggestions, void());
 };
 
+class MockBlacklistStore : public suggestions::BlacklistStore {
+ public:
+  MOCK_METHOD1(BlacklistUrl, bool(const GURL&));
+  MOCK_METHOD1(RemoveUrl, bool(const GURL&));
+  MOCK_METHOD1(FilterSuggestions, void(SuggestionsProfile*));
+};
+
 }  // namespace
 
 class SuggestionsServiceTest : public testing::Test {
  public:
   void CheckSuggestionsData(const SuggestionsProfile& 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_;
   }
@@ skipping 40 matching lines @@
   }
 
   SuggestionsService* CreateSuggestionsService() {
     SuggestionsServiceFactory* suggestions_service_factory =
         SuggestionsServiceFactory::GetInstance();
     return suggestions_service_factory->GetForProfile(profile_.get());
   }
 
   // Should not be called more than once per test since it stashes the
   // SuggestionsStore in |mock_suggestions_store_|.
-  SuggestionsService* CreateSuggestionsServiceWithMockStore() {
+  SuggestionsService* CreateSuggestionsServiceWithMocks() {
     mock_suggestions_store_ = new StrictMock<MockSuggestionsStore>();
+    mock_blacklist_store_ = new MockBlacklistStore();
     return new SuggestionsService(
-        profile_.get(), scoped_ptr<SuggestionsStore>(mock_suggestions_store_));
+        profile_.get(), scoped_ptr<SuggestionsStore>(mock_suggestions_store_),
+        scoped_ptr<BlacklistStore>(mock_blacklist_store_));
   }
 
   void FetchSuggestionsDataNoTimeoutHelper(bool interleaved_requests) {
     // Field trial enabled with a specific suggestions URL.
     EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
                      kFakeBlacklistSuffix);
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMockStore());
     EXPECT_TRUE(suggestions_service != NULL);
     scoped_ptr<SuggestionsProfile> suggestions_profile(
@@ skipping 30 matching lines @@
 
     // (Testing only) wait until suggestion fetch is complete.
     base::MessageLoop::current()->RunUntilIdle();
 
     // Ensure that CheckSuggestionsData() ran twice.
     EXPECT_EQ(2, suggestions_data_check_count_);
   }
 
  protected:
   net::FakeURLFetcherFactory factory_;
-  // Only used if the SuggestionsService is built with a MockSuggestionsStore.
-  // Not owned.
+  // Only used if the SuggestionsService is built with a mocks. Not owned.
   MockSuggestionsStore* mock_suggestions_store_;
+  MockBlacklistStore* mock_blacklist_store_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<base::FieldTrialList> field_trial_list_;
   scoped_refptr<base::FieldTrial> field_trial_;
   TestingProfile::Builder profile_builder_;
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(SuggestionsServiceTest);
 };
@@ skipping 13 matching lines @@
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoTimeoutInterleaved) {
   FetchSuggestionsDataNoTimeoutHelper(true);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataRequestError) {
   // Field trial enabled with a specific suggestions URL.
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
                    kFakeBlacklistSuffix);
   scoped_ptr<SuggestionsService> suggestions_service(
-      CreateSuggestionsServiceWithMockStore());
+      CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Fake a request error.
   std::string expected_url =
       std::string(kFakeSuggestionsURL) + kFakeSuggestionsSuffix;
   factory_.SetFakeResponse(GURL(expected_url), "irrelevant", net::HTTP_OK,
                            net::URLRequestStatus::FAILED);
 
   // Set up expectations on the SuggestionsStore.
   EXPECT_CALL(*mock_suggestions_store_, LoadSuggestions(_))
       .WillOnce(Return(true));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->FetchSuggestionsData(
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // (Testing only) wait until suggestion fetch is complete.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataResponseNotOK) {
   // Field trial enabled with a specific suggestions URL.
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
                    kFakeBlacklistSuffix);
   scoped_ptr<SuggestionsService> suggestions_service(
-      CreateSuggestionsServiceWithMockStore());
+      CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Response code != 200.
   std::string expected_url =
       std::string(kFakeSuggestionsURL) + kFakeSuggestionsSuffix;
   factory_.SetFakeResponse(GURL(expected_url), "irrelevant",
                            net::HTTP_BAD_REQUEST,
                            net::URLRequestStatus::SUCCESS);
 
   // Set up expectations on the SuggestionsStore.
   EXPECT_CALL(*mock_suggestions_store_, ClearSuggestions());
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->FetchSuggestionsData(
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // (Testing only) wait until suggestion fetch is complete.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
                    kFakeBlacklistSuffix);
   scoped_ptr<SuggestionsService> suggestions_service(
-      CreateSuggestionsServiceWithMockStore());
+      CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   std::string expected_url(kFakeSuggestionsURL);
   expected_url.append(kFakeBlacklistSuffix)
       .append(net::EscapeQueryParamValue(GURL(kBlacklistUrl).spec(), true));
   scoped_ptr<SuggestionsProfile> suggestions_profile(
       CreateSuggestionsProfile());
   factory_.SetFakeResponse(GURL(expected_url),
                            suggestions_profile->SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
@@ skipping 10 matching lines @@
                  base::Unretained(this)));
 
   // (Testing only) wait until blacklist request is complete.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Ensure that CheckSuggestionsData() ran once.
   EXPECT_EQ(1, suggestions_data_check_count_);
 }
 
 }  // namespace suggestions