| OLD | NEW |
|---|
| (Empty) |
| 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 "base/files/scoped_temp_dir.h" | |
| 6 #include "base/memory/scoped_ptr.h" | |
| 7 #include "base/strings/string_split.h" | |
| 8 #include "base/strings/string_util.h" | |
| 9 #include "base/strings/utf_string_conversions.h" | |
| 10 #include "base/time/time.h" | |
| 11 #include "components/pref_registry/pref_registry_syncable.h" | |
| 12 #include "components/pref_registry/testing_pref_service_syncable.h" | |
| 13 #include "components/search_engines/default_search_manager.h" | |
| 14 #include "components/search_engines/search_engines_pref_names.h" | |
| 15 #include "components/search_engines/template_url_data.h" | |
| 16 #include "components/search_engines/template_url_prepopulate_data.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 namespace { | |
| 20 // A dictionary to hold all data related to the Default Search Engine. | |
| 21 // Eventually, this should replace all the data stored in the | |
| 22 // default_search_provider.* prefs. | |
| 23 const char kDefaultSearchProviderData[] = | |
| 24 "default_search_provider_data.template_url_data"; | |
| 25 | |
| 26 // Checks that the two TemplateURLs are similar. Does not check the id, the | |
| 27 // date_created or the last_modified time. Neither pointer should be NULL. | |
| 28 void ExpectSimilar(const TemplateURLData* expected, | |
| 29 const TemplateURLData* actual) { | |
| 30 ASSERT_TRUE(expected != NULL); | |
| 31 ASSERT_TRUE(actual != NULL); | |
| 32 | |
| 33 EXPECT_EQ(expected->short_name, actual->short_name); | |
| 34 EXPECT_EQ(expected->keyword(), actual->keyword()); | |
| 35 EXPECT_EQ(expected->url(), actual->url()); | |
| 36 EXPECT_EQ(expected->suggestions_url, actual->suggestions_url); | |
| 37 EXPECT_EQ(expected->favicon_url, actual->favicon_url); | |
| 38 EXPECT_EQ(expected->alternate_urls, actual->alternate_urls); | |
| 39 EXPECT_EQ(expected->show_in_default_list, actual->show_in_default_list); | |
| 40 EXPECT_EQ(expected->safe_for_autoreplace, actual->safe_for_autoreplace); | |
| 41 EXPECT_EQ(expected->input_encodings, actual->input_encodings); | |
| 42 EXPECT_EQ(expected->search_terms_replacement_key, | |
| 43 actual->search_terms_replacement_key); | |
| 44 } | |
| 45 | |
| 46 // TODO(caitkp): TemplateURLData-ify this. | |
| 47 void SetOverrides(user_prefs::TestingPrefServiceSyncable* prefs, bool update) { | |
| 48 prefs->SetUserPref(prefs::kSearchProviderOverridesVersion, | |
| 49 base::Value::CreateIntegerValue(1)); | |
| 50 base::ListValue* overrides = new base::ListValue; | |
| 51 scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue); | |
| 52 | |
| 53 entry->SetString("name", update ? "new_foo" : "foo"); | |
| 54 entry->SetString("keyword", update ? "new_fook" : "fook"); | |
| 55 entry->SetString("search_url", "http://foo.com/s?q={searchTerms}"); | |
| 56 entry->SetString("favicon_url", "http://foi.com/favicon.ico"); | |
| 57 entry->SetString("encoding", "UTF-8"); | |
| 58 entry->SetInteger("id", 1001); | |
| 59 entry->SetString("suggest_url", "http://foo.com/suggest?q={searchTerms}"); | |
| 60 entry->SetString("instant_url", "http://foo.com/instant?q={searchTerms}"); | |
| 61 base::ListValue* alternate_urls = new base::ListValue; | |
| 62 alternate_urls->AppendString("http://foo.com/alternate?q={searchTerms}"); | |
| 63 entry->Set("alternate_urls", alternate_urls); | |
| 64 entry->SetString("search_terms_replacement_key", "espv"); | |
| 65 overrides->Append(entry->DeepCopy()); | |
| 66 | |
| 67 entry.reset(new base::DictionaryValue); | |
| 68 entry->SetInteger("id", 1002); | |
| 69 entry->SetString("name", update ? "new_bar" : "bar"); | |
| 70 entry->SetString("keyword", update ? "new_bark" : "bark"); | |
| 71 entry->SetString("encoding", std::string()); | |
| 72 overrides->Append(entry->DeepCopy()); | |
| 73 entry->SetInteger("id", 1003); | |
| 74 entry->SetString("name", "baz"); | |
| 75 entry->SetString("keyword", "bazk"); | |
| 76 entry->SetString("encoding", "UTF-8"); | |
| 77 overrides->Append(entry->DeepCopy()); | |
| 78 prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides); | |
| 79 } | |
| 80 | |
| 81 void SetPolicy(user_prefs::TestingPrefServiceSyncable* prefs, | |
| 82 bool enabled, | |
| 83 TemplateURLData* data) { | |
| 84 if (enabled) { | |
| 85 EXPECT_FALSE(data->keyword().empty()); | |
| 86 EXPECT_FALSE(data->url().empty()); | |
| 87 } | |
| 88 scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue); | |
| 89 entry->SetString(DefaultSearchManager::kShortName, data->short_name); | |
| 90 entry->SetString(DefaultSearchManager::kKeyword, data->keyword()); | |
| 91 entry->SetString(DefaultSearchManager::kURL, data->url()); | |
| 92 entry->SetString(DefaultSearchManager::kFaviconURL, data->favicon_url.spec()); | |
| 93 entry->SetString(DefaultSearchManager::kSuggestionsURL, | |
| 94 data->suggestions_url); | |
| 95 entry->SetBoolean(DefaultSearchManager::kSafeForAutoReplace, | |
| 96 data->safe_for_autoreplace); | |
| 97 scoped_ptr<base::ListValue> alternate_urls(new base::ListValue); | |
| 98 for (std::vector<std::string>::const_iterator it = | |
| 99 data->alternate_urls.begin(); | |
| 100 it != data->alternate_urls.end(); | |
| 101 ++it) { | |
| 102 alternate_urls->AppendString(*it); | |
| 103 } | |
| 104 entry->Set(DefaultSearchManager::kAlternateURLs, alternate_urls.release()); | |
| 105 | |
| 106 scoped_ptr<base::ListValue> encodings(new base::ListValue); | |
| 107 for (std::vector<std::string>::const_iterator it = | |
| 108 data->input_encodings.begin(); | |
| 109 it != data->input_encodings.end(); | |
| 110 ++it) { | |
| 111 encodings->AppendString(*it); | |
| 112 } | |
| 113 entry->Set(DefaultSearchManager::kInputEncodings, encodings.release()); | |
| 114 | |
| 115 entry->SetString(DefaultSearchManager::kSearchTermsReplacementKey, | |
| 116 data->search_terms_replacement_key); | |
| 117 entry->SetBoolean(DefaultSearchManager::kDisabledByPolicy, !enabled); | |
| 118 prefs->SetManagedPref(kDefaultSearchProviderData, entry.release()); | |
| 119 } | |
| 120 | |
| 121 scoped_ptr<TemplateURLData> GenerateDummyTemplateURLData(std::string type) { | |
| 122 scoped_ptr<TemplateURLData> data(new TemplateURLData()); | |
| 123 data->short_name = base::UTF8ToUTF16(std::string(type).append("name")); | |
| 124 data->SetKeyword(base::UTF8ToUTF16(std::string(type).append("key"))); | |
| 125 data->SetURL(std::string("http://").append(type).append("foo/{searchTerms}")); | |
| 126 data->suggestions_url = std::string("http://").append(type).append("sugg"); | |
| 127 data->alternate_urls.push_back( | |
| 128 std::string("http://").append(type).append("foo/alt")); | |
| 129 data->favicon_url = GURL("http://icon1"); | |
| 130 data->safe_for_autoreplace = true; | |
| 131 data->show_in_default_list = true; | |
| 132 base::SplitString("UTF-8;UTF-16", ';', &data->input_encodings); | |
| 133 data->date_created = base::Time(); | |
| 134 data->last_modified = base::Time(); | |
| 135 return data.Pass(); | |
| 136 } | |
| 137 | |
| 138 } // namespace | |
| 139 | |
| 140 class DefaultSearchManagerTest : public testing::Test { | |
| 141 public: | |
| 142 DefaultSearchManagerTest() {}; | |
| 143 | |
| 144 virtual void SetUp() OVERRIDE { | |
| 145 pref_service_.reset(new user_prefs::TestingPrefServiceSyncable); | |
| 146 DefaultSearchManager::RegisterProfilePrefs(pref_service_->registry()); | |
| 147 TemplateURLPrepopulateData::RegisterProfilePrefs(pref_service_->registry()); | |
| 148 } | |
| 149 | |
| 150 user_prefs::TestingPrefServiceSyncable* pref_service() { | |
| 151 return pref_service_.get(); | |
| 152 } | |
| 153 | |
| 154 private: | |
| 155 scoped_ptr<user_prefs::TestingPrefServiceSyncable> pref_service_; | |
| 156 | |
| 157 DISALLOW_COPY_AND_ASSIGN(DefaultSearchManagerTest); | |
| 158 }; | |
| 159 | |
| 160 // Test that a TemplateURLData object is properly written and read from Prefs. | |
| 161 TEST_F(DefaultSearchManagerTest, ReadAndWritePref) { | |
| 162 DefaultSearchManager manager(pref_service(), | |
| 163 DefaultSearchManager::ObserverCallback()); | |
| 164 TemplateURLData data; | |
| 165 data.short_name = base::UTF8ToUTF16("name1"); | |
| 166 data.SetKeyword(base::UTF8ToUTF16("key1")); | |
| 167 data.SetURL("http://foo1/{searchTerms}"); | |
| 168 data.suggestions_url = "http://sugg1"; | |
| 169 data.alternate_urls.push_back("http://foo1/alt"); | |
| 170 data.favicon_url = GURL("http://icon1"); | |
| 171 data.safe_for_autoreplace = true; | |
| 172 data.show_in_default_list = true; | |
| 173 base::SplitString("UTF-8;UTF-16", ';', &data.input_encodings); | |
| 174 data.date_created = base::Time(); | |
| 175 data.last_modified = base::Time(); | |
| 176 | |
| 177 manager.SetUserSelectedDefaultSearchEngine(data); | |
| 178 TemplateURLData* read_data = manager.GetDefaultSearchEngine(NULL); | |
| 179 ExpectSimilar(&data, read_data); | |
| 180 } | |
| 181 | |
| 182 // Test DefaultSearchmanager handles user-selected DSEs correctly. | |
| 183 TEST_F(DefaultSearchManagerTest, DefaultSearchSetByUserPref) { | |
| 184 size_t default_search_index = 0; | |
| 185 DefaultSearchManager manager(pref_service(), | |
| 186 DefaultSearchManager::ObserverCallback()); | |
| 187 ScopedVector<TemplateURLData> prepopulated_urls = | |
| 188 TemplateURLPrepopulateData::GetPrepopulatedEngines(pref_service(), | |
| 189 &default_search_index); | |
| 190 DefaultSearchManager::Source source = DefaultSearchManager::FROM_POLICY; | |
| 191 // If no user pref is set, we should use the pre-populated values. | |
| 192 ExpectSimilar(prepopulated_urls[default_search_index], | |
| 193 manager.GetDefaultSearchEngine(&source)); | |
| 194 EXPECT_EQ(DefaultSearchManager::FROM_FALLBACK, source); | |
| 195 | |
| 196 // Setting a user pref overrides the pre-populated values. | |
| 197 scoped_ptr<TemplateURLData> data = GenerateDummyTemplateURLData("user"); | |
| 198 manager.SetUserSelectedDefaultSearchEngine(*data.get()); | |
| 199 | |
| 200 ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 201 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 202 | |
| 203 // Updating the user pref (externally to this instance of | |
| 204 // DefaultSearchManager) triggers an update. | |
| 205 scoped_ptr<TemplateURLData> new_data = GenerateDummyTemplateURLData("user2"); | |
| 206 DefaultSearchManager other_manager(pref_service(), | |
| 207 DefaultSearchManager::ObserverCallback()); | |
| 208 other_manager.SetUserSelectedDefaultSearchEngine(*new_data.get()); | |
| 209 | |
| 210 ExpectSimilar(new_data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 211 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 212 | |
| 213 // Clearing the user pref should cause the default search to revert to the | |
| 214 // prepopulated vlaues. | |
| 215 manager.ClearUserSelectedDefaultSearchEngine(); | |
| 216 ExpectSimilar(prepopulated_urls[default_search_index], | |
| 217 manager.GetDefaultSearchEngine(&source)); | |
| 218 EXPECT_EQ(DefaultSearchManager::FROM_FALLBACK, source); | |
| 219 } | |
| 220 | |
| 221 // Test that DefaultSearch manager detects changes to kSearchProviderOverrides. | |
| 222 TEST_F(DefaultSearchManagerTest, DefaultSearchSetByOverrides) { | |
| 223 SetOverrides(pref_service(), false); | |
| 224 size_t default_search_index = 0; | |
| 225 DefaultSearchManager manager(pref_service(), | |
| 226 DefaultSearchManager::ObserverCallback()); | |
| 227 ScopedVector<TemplateURLData> prepopulated_urls = | |
| 228 TemplateURLPrepopulateData::GetPrepopulatedEngines(pref_service(), | |
| 229 &default_search_index); | |
| 230 | |
| 231 DefaultSearchManager::Source source = DefaultSearchManager::FROM_POLICY; | |
| 232 TemplateURLData first_default(*manager.GetDefaultSearchEngine(&source)); | |
| 233 ExpectSimilar(prepopulated_urls[default_search_index], &first_default); | |
| 234 EXPECT_EQ(DefaultSearchManager::FROM_FALLBACK, source); | |
| 235 | |
| 236 // Update the overrides: | |
| 237 SetOverrides(pref_service(), true); | |
| 238 prepopulated_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines( | |
| 239 pref_service(), &default_search_index); | |
| 240 | |
| 241 // Make sure DefaultSearchManager updated: | |
| 242 ExpectSimilar(prepopulated_urls[default_search_index], | |
| 243 manager.GetDefaultSearchEngine(&source)); | |
| 244 EXPECT_EQ(DefaultSearchManager::FROM_FALLBACK, source); | |
| 245 EXPECT_NE(manager.GetDefaultSearchEngine(NULL)->short_name, | |
| 246 first_default.short_name); | |
| 247 EXPECT_NE(manager.GetDefaultSearchEngine(NULL)->keyword(), | |
| 248 first_default.keyword()); | |
| 249 } | |
| 250 | |
| 251 // Test DefaultSearchManager handles policy-enforced DSEs correctly. | |
| 252 TEST_F(DefaultSearchManagerTest, DefaultSearchSetByPolicy) { | |
| 253 DefaultSearchManager manager(pref_service(), | |
| 254 DefaultSearchManager::ObserverCallback()); | |
| 255 scoped_ptr<TemplateURLData> data = GenerateDummyTemplateURLData("user"); | |
| 256 manager.SetUserSelectedDefaultSearchEngine(*data.get()); | |
| 257 | |
| 258 DefaultSearchManager::Source source = DefaultSearchManager::FROM_FALLBACK; | |
| 259 ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 260 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 261 | |
| 262 scoped_ptr<TemplateURLData> policy_data = | |
| 263 GenerateDummyTemplateURLData("policy"); | |
| 264 SetPolicy(pref_service(), true, policy_data.get()); | |
| 265 | |
| 266 ExpectSimilar(policy_data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 267 EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source); | |
| 268 | |
| 269 TemplateURLData null_policy_data; | |
| 270 SetPolicy(pref_service(), false, &null_policy_data); | |
| 271 EXPECT_EQ(NULL, manager.GetDefaultSearchEngine(&source)); | |
| 272 EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source); | |
| 273 | |
| 274 pref_service()->RemoveManagedPref(kDefaultSearchProviderData); | |
| 275 ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 276 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 277 } | |
| 278 | |
| 279 // Test DefaultSearchManager handles extension-controlled DSEs correctly. | |
| 280 TEST_F(DefaultSearchManagerTest, DefaultSearchSetByExtension) { | |
| 281 DefaultSearchManager manager(pref_service(), | |
| 282 DefaultSearchManager::ObserverCallback()); | |
| 283 scoped_ptr<TemplateURLData> data = GenerateDummyTemplateURLData("user"); | |
| 284 manager.SetUserSelectedDefaultSearchEngine(*data); | |
| 285 | |
| 286 DefaultSearchManager::Source source = DefaultSearchManager::FROM_FALLBACK; | |
| 287 ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 288 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 289 | |
| 290 // Extension trumps prefs: | |
| 291 scoped_ptr<TemplateURLData> extension_data_1 = | |
| 292 GenerateDummyTemplateURLData("ext1"); | |
| 293 manager.SetExtensionControlledDefaultSearchEngine(*extension_data_1); | |
| 294 | |
| 295 ExpectSimilar(extension_data_1.get(), | |
| 296 manager.GetDefaultSearchEngine(&source)); | |
| 297 EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source); | |
| 298 | |
| 299 // Policy trumps extension: | |
| 300 scoped_ptr<TemplateURLData> policy_data = | |
| 301 GenerateDummyTemplateURLData("policy"); | |
| 302 SetPolicy(pref_service(), true, policy_data.get()); | |
| 303 | |
| 304 ExpectSimilar(policy_data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 305 EXPECT_EQ(DefaultSearchManager::FROM_POLICY, source); | |
| 306 pref_service()->RemoveManagedPref(kDefaultSearchProviderData); | |
| 307 | |
| 308 // Extensions trump each other: | |
| 309 scoped_ptr<TemplateURLData> extension_data_2 = | |
| 310 GenerateDummyTemplateURLData("ext2"); | |
| 311 scoped_ptr<TemplateURLData> extension_data_3 = | |
| 312 GenerateDummyTemplateURLData("ext3"); | |
| 313 manager.SetExtensionControlledDefaultSearchEngine(*extension_data_2); | |
| 314 manager.SetExtensionControlledDefaultSearchEngine(*extension_data_3); | |
| 315 | |
| 316 ExpectSimilar(extension_data_3.get(), | |
| 317 manager.GetDefaultSearchEngine(&source)); | |
| 318 EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source); | |
| 319 | |
| 320 manager.ClearExtensionControlledDefaultSearchEngine(); | |
| 321 | |
| 322 ExpectSimilar(data.get(), manager.GetDefaultSearchEngine(&source)); | |
| 323 EXPECT_EQ(DefaultSearchManager::FROM_USER, source); | |
| 324 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 382663004:
Componentize tests under search_engines (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src