components/suggestions/blacklist_store_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/suggestions/blacklist_store.h"
   6
   7 #include <set>
   8 #include <string>
   9
  10 #include "base/memory/scoped_ptr.h"
  11
  12 #include "base/test/histogram_tester.h"
  13 #include "components/pref_registry/testing_pref_service_syncable.h"
  14 #include "components/suggestions/proto/suggestions.pb.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using user_prefs::TestingPrefServiceSyncable;
  18
  19 namespace suggestions {
  20
  21 namespace {
  22
  23 const char kTestUrlA[] = "http://aaa.com/";
  24 const char kTestUrlB[] = "http://bbb.com/";
  25 const char kTestUrlC[] = "http://ccc.com/";
  26 const char kTestUrlD[] = "http://ddd.com/";
  27
  28 SuggestionsProfile CreateSuggestions(std::set<std::string> urls) {
  29   SuggestionsProfile suggestions;
  30   for (std::set<std::string>::iterator it = urls.begin(); it != urls.end();
  31        ++it) {
  32     ChromeSuggestion* suggestion = suggestions.add_suggestions();
  33     suggestion->set_url(*it);
  34   }
  35   return suggestions;
  36 }
  37
  38 void ValidateSuggestions(const SuggestionsProfile& expected,
  39                          const SuggestionsProfile& actual) {
  40   ASSERT_EQ(expected.suggestions_size(), actual.suggestions_size());
  41   for (int i = 0; i < expected.suggestions_size(); ++i) {
  42     EXPECT_EQ(expected.suggestions(i).url(), actual.suggestions(i).url());
  43     EXPECT_EQ(expected.suggestions(i).title(), actual.suggestions(i).title());
  44     EXPECT_EQ(expected.suggestions(i).favicon_url(),
  45               actual.suggestions(i).favicon_url());
  46     EXPECT_EQ(expected.suggestions(i).thumbnail(),
  47               actual.suggestions(i).thumbnail());
  48   }
  49 }
  50
  51 }  // namespace
  52
  53 class BlacklistStoreTest : public testing::Test {
  54  public:
  55   BlacklistStoreTest()
  56     : pref_service_(new user_prefs::TestingPrefServiceSyncable) {}
  57
  58   void SetUp() override {
  59     BlacklistStore::RegisterProfilePrefs(pref_service()->registry());
  60   }
  61
  62   user_prefs::TestingPrefServiceSyncable* pref_service() {
  63     return pref_service_.get();
  64   }
  65
  66  private:
  67   scoped_ptr<user_prefs::TestingPrefServiceSyncable> pref_service_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(BlacklistStoreTest);
  70 };
  71
  72 TEST_F(BlacklistStoreTest, BasicInteractions) {
  73   BlacklistStore blacklist_store(pref_service());
  74
  75   // Create suggestions with A, B and C. C and D will be added to the blacklist.
  76   std::set<std::string> suggested_urls;
  77   suggested_urls.insert(kTestUrlA);
  78   suggested_urls.insert(kTestUrlB);
  79   const SuggestionsProfile suggestions_filtered =
  80       CreateSuggestions(suggested_urls);
  81   suggested_urls.insert(kTestUrlC);
  82   const SuggestionsProfile original_suggestions =
  83       CreateSuggestions(suggested_urls);
  84   SuggestionsProfile suggestions;
  85
  86   // Filter with an empty blacklist.
  87   suggestions.CopyFrom(original_suggestions);
  88   blacklist_store.FilterSuggestions(&suggestions);
  89   ValidateSuggestions(original_suggestions, suggestions);
  90
  91   // Add C and D to the blacklist and filter.
  92   suggestions.CopyFrom(original_suggestions);
  93   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlC)));
  94   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlD)));
  95   blacklist_store.FilterSuggestions(&suggestions);
  96   ValidateSuggestions(suggestions_filtered, suggestions);
  97
  98   // Remove C from the blacklist and filter.
  99   suggestions.CopyFrom(original_suggestions);
 100   EXPECT_TRUE(blacklist_store.RemoveUrl(GURL(kTestUrlC)));
 101   blacklist_store.FilterSuggestions(&suggestions);
 102   ValidateSuggestions(original_suggestions, suggestions);
 103 }
 104
 105 TEST_F(BlacklistStoreTest, BlacklistTwiceSuceeds) {
 106   BlacklistStore blacklist_store(pref_service());
 107   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlA)));
 108   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlA)));
 109 }
 110
 111 TEST_F(BlacklistStoreTest, RemoveUnknownUrlSucceeds) {
 112   BlacklistStore blacklist_store(pref_service());
 113   EXPECT_TRUE(blacklist_store.RemoveUrl(GURL(kTestUrlA)));
 114 }
 115
 116 TEST_F(BlacklistStoreTest, GetFirstUrlFromBlacklist) {
 117   BlacklistStore blacklist_store(pref_service());
 118
 119   // Expect GetFirstUrlFromBlacklist fails when blacklist empty.
 120   GURL retrieved;
 121   EXPECT_FALSE(blacklist_store.GetFirstUrlFromBlacklist(&retrieved));
 122
 123   // Blacklist A and B.
 124   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlA)));
 125   EXPECT_TRUE(blacklist_store.BlacklistUrl(GURL(kTestUrlB)));
 126
 127   // Expect to retrieve A or B.
 128   EXPECT_TRUE(blacklist_store.GetFirstUrlFromBlacklist(&retrieved));
 129   std::string retrieved_string = retrieved.spec();
 130   EXPECT_TRUE(retrieved_string == std::string(kTestUrlA) ||
 131               retrieved_string == std::string(kTestUrlB));
 132 }
 133
 134 TEST_F(BlacklistStoreTest, LogsBlacklistSize) {
 135   base::HistogramTester histogram_tester;
 136
 137   // Create a first store - blacklist is empty at this point.
 138   scoped_ptr<BlacklistStore> blacklist_store(
 139       new BlacklistStore(pref_service()));
 140
 141   histogram_tester.ExpectTotalCount("Suggestions.LocalBlacklistSize", 1);
 142   histogram_tester.ExpectUniqueSample("Suggestions.LocalBlacklistSize", 0, 1);
 143
 144   // Add some content to the blacklist.
 145   EXPECT_TRUE(blacklist_store->BlacklistUrl(GURL(kTestUrlA)));
 146   EXPECT_TRUE(blacklist_store->BlacklistUrl(GURL(kTestUrlB)));
 147
 148   // Create a new BlacklistStore and verify the counts.
 149   blacklist_store.reset(new BlacklistStore(pref_service()));
 150
 151   histogram_tester.ExpectTotalCount("Suggestions.LocalBlacklistSize", 2);
 152   histogram_tester.ExpectBucketCount("Suggestions.LocalBlacklistSize", 0, 1);
 153   histogram_tester.ExpectBucketCount("Suggestions.LocalBlacklistSize", 2, 1);
 154 }
 155
 156 }  // namespace suggestions