chrome/browser/search_engines/default_search_policy_handler_unittest.cc

   1 // Copyright 2013 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/memory/scoped_ptr.h"
   6 #include "chrome/browser/policy/configuration_policy_pref_store_test.h"
   7 #include "chrome/browser/search_engines/default_search_policy_handler.h"
   8 #include "chrome/common/pref_names.h"
   9 #include "components/policy/core/browser/configuration_policy_pref_store.h"
  10 #include "policy/policy_constants.h"
  11
  12 namespace policy {
  13
  14 class DefaultSearchPolicyHandlerTest
  15     : public ConfigurationPolicyPrefStoreTest {
  16  public:
  17   DefaultSearchPolicyHandlerTest() {
  18     default_alternate_urls_.AppendString(
  19         "http://www.google.com/#q={searchTerms}");
  20     default_alternate_urls_.AppendString(
  21         "http://www.google.com/search#q={searchTerms}");
  22   }
  23
  24   virtual void SetUp() OVERRIDE {
  25     handler_list_.AddHandler(make_scoped_ptr<ConfigurationPolicyHandler>(
  26         new DefaultSearchPolicyHandler));
  27   }
  28
  29  protected:
  30   static const char kSearchURL[];
  31   static const char kSuggestURL[];
  32   static const char kIconURL[];
  33   static const char kName[];
  34   static const char kKeyword[];
  35   static const char kReplacementKey[];
  36   static const char kImageURL[];
  37   static const char kImageParams[];
  38   static const char kNewTabURL[];
  39
  40   // Build a default search policy by setting search-related keys in |policy| to
  41   // reasonable values. You can update any of the keys after calling this
  42   // method.
  43   void BuildDefaultSearchPolicy(PolicyMap* policy);
  44
  45   base::ListValue default_alternate_urls_;
  46 };
  47
  48 const char DefaultSearchPolicyHandlerTest::kSearchURL[] =
  49     "http://test.com/search?t={searchTerms}";
  50 const char DefaultSearchPolicyHandlerTest::kSuggestURL[] =
  51     "http://test.com/sugg?={searchTerms}";
  52 const char DefaultSearchPolicyHandlerTest::kIconURL[] =
  53     "http://test.com/icon.jpg";
  54 const char DefaultSearchPolicyHandlerTest::kName[] =
  55     "MyName";
  56 const char DefaultSearchPolicyHandlerTest::kKeyword[] =
  57     "MyKeyword";
  58 const char DefaultSearchPolicyHandlerTest::kReplacementKey[] =
  59     "espv";
  60 const char DefaultSearchPolicyHandlerTest::kImageURL[] =
  61     "http://test.com/searchbyimage/upload";
  62 const char DefaultSearchPolicyHandlerTest::kImageParams[] =
  63     "image_content=content,image_url=http://test.com/test.png";
  64 const char DefaultSearchPolicyHandlerTest::kNewTabURL[] =
  65     "http://test.com/newtab";
  66
  67 void DefaultSearchPolicyHandlerTest::
  68     BuildDefaultSearchPolicy(PolicyMap* policy) {
  69   base::ListValue* encodings = new base::ListValue();
  70   encodings->AppendString("UTF-16");
  71   encodings->AppendString("UTF-8");
  72   policy->Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
  73               POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
  74   policy->Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
  75               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL),
  76               NULL);
  77   policy->Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
  78               POLICY_SCOPE_USER, base::Value::CreateStringValue(kName), NULL);
  79   policy->Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
  80               POLICY_SCOPE_USER, base::Value::CreateStringValue(kKeyword),
  81               NULL);
  82   policy->Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
  83               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSuggestURL),
  84               NULL);
  85   policy->Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
  86               POLICY_SCOPE_USER, base::Value::CreateStringValue(kIconURL),
  87               NULL);
  88   policy->Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
  89               POLICY_SCOPE_USER, encodings, NULL);
  90   policy->Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
  91               POLICY_SCOPE_USER, default_alternate_urls_.DeepCopy(), NULL);
  92   policy->Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
  93               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  94               base::Value::CreateStringValue(kReplacementKey), NULL);
  95   policy->Set(key::kDefaultSearchProviderImageURL,
  96               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  97               base::Value::CreateStringValue(kImageURL), NULL);
  98   policy->Set(key::kDefaultSearchProviderImageURLPostParams,
  99               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 100               base::Value::CreateStringValue(kImageParams), NULL);
 101   policy->Set(key::kDefaultSearchProviderNewTabURL,
 102               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 103               base::Value::CreateStringValue(kNewTabURL), NULL);
 104 }
 105
 106 // Checks that if the policy for default search is valid, i.e. there's a
 107 // search URL, that all the elements have been given proper defaults.
 108 TEST_F(DefaultSearchPolicyHandlerTest, MinimallyDefined) {
 109   PolicyMap policy;
 110   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
 111              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
 112   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
 113              POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL),
 114              NULL);
 115   UpdateProviderPolicy(policy);
 116
 117   const base::Value* value = NULL;
 118   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
 119   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 120
 121   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
 122   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 123
 124   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
 125   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 126
 127   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL,
 128                                &value));
 129   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 130
 131   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
 132   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 133
 134   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
 135   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 136
 137   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL,
 138                                &value));
 139   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 140
 141   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
 142                              &value));
 143   EXPECT_TRUE(base::ListValue().Equals(value));
 144
 145   EXPECT_TRUE(
 146       store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
 147       &value));
 148   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 149
 150   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, &value));
 151   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 152
 153   EXPECT_TRUE(store_->GetValue(
 154       prefs::kDefaultSearchProviderSearchURLPostParams, &value));
 155   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 156
 157   EXPECT_TRUE(store_->GetValue(
 158       prefs::kDefaultSearchProviderSuggestURLPostParams, &value));
 159   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 160
 161   EXPECT_TRUE(store_->GetValue(
 162       prefs::kDefaultSearchProviderInstantURLPostParams, &value));
 163   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 164
 165   EXPECT_TRUE(store_->GetValue(
 166       prefs::kDefaultSearchProviderImageURLPostParams, &value));
 167   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 168
 169   EXPECT_TRUE(store_->GetValue(
 170       prefs::kDefaultSearchProviderNewTabURL, &value));
 171   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 172 }
 173
 174 // Checks that for a fully defined search policy, all elements have been
 175 // read properly.
 176 TEST_F(DefaultSearchPolicyHandlerTest, FullyDefined) {
 177   PolicyMap policy;
 178   BuildDefaultSearchPolicy(&policy);
 179   UpdateProviderPolicy(policy);
 180
 181   const base::Value* value = NULL;
 182   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
 183   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 184
 185   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
 186   EXPECT_TRUE(base::StringValue(kName).Equals(value));
 187
 188   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
 189   EXPECT_TRUE(base::StringValue(kKeyword).Equals(value));
 190
 191   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL,
 192                                &value));
 193   EXPECT_TRUE(base::StringValue(kSuggestURL).Equals(value));
 194
 195   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
 196   EXPECT_TRUE(base::StringValue(kIconURL).Equals(value));
 197
 198   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
 199   EXPECT_TRUE(base::StringValue("UTF-16;UTF-8").Equals(value));
 200
 201   EXPECT_TRUE(store_->GetValue(
 202       prefs::kDefaultSearchProviderAlternateURLs, &value));
 203   EXPECT_TRUE(default_alternate_urls_.Equals(value));
 204
 205   EXPECT_TRUE(
 206       store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
 207       &value));
 208   EXPECT_TRUE(base::StringValue(kReplacementKey).Equals(value));
 209
 210   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, &value));
 211   EXPECT_TRUE(base::StringValue(std::string(kImageURL)).Equals(value));
 212
 213   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURLPostParams,
 214                                &value));
 215   EXPECT_TRUE(base::StringValue(std::string(kImageParams)).Equals(value));
 216
 217   EXPECT_TRUE(store_->GetValue(
 218       prefs::kDefaultSearchProviderSearchURLPostParams, &value));
 219   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 220
 221   EXPECT_TRUE(store_->GetValue(
 222       prefs::kDefaultSearchProviderSuggestURLPostParams, &value));
 223   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 224
 225   EXPECT_TRUE(store_->GetValue(
 226       prefs::kDefaultSearchProviderInstantURLPostParams, &value));
 227   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 228 }
 229
 230 // Checks that if the default search policy is missing, that no elements of the
 231 // default search policy will be present.
 232 TEST_F(DefaultSearchPolicyHandlerTest, MissingUrl) {
 233   PolicyMap policy;
 234   BuildDefaultSearchPolicy(&policy);
 235   policy.Erase(key::kDefaultSearchProviderSearchURL);
 236   UpdateProviderPolicy(policy);
 237
 238   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
 239   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
 240   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
 241   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
 242   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
 243   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 244   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
 245                                 NULL));
 246   EXPECT_FALSE(store_->GetValue(
 247       prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
 248   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, NULL));
 249   EXPECT_FALSE(store_->GetValue(
 250       prefs::kDefaultSearchProviderImageURLPostParams, NULL));
 251   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL, NULL));
 252   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderNewTabURL, NULL));
 253 }
 254
 255 // Checks that if the default search policy is invalid, that no elements of the
 256 // default search policy will be present.
 257 TEST_F(DefaultSearchPolicyHandlerTest, Invalid) {
 258   PolicyMap policy;
 259   BuildDefaultSearchPolicy(&policy);
 260   const char bad_search_url[] = "http://test.com/noSearchTerms";
 261   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
 262              POLICY_SCOPE_USER,
 263              base::Value::CreateStringValue(bad_search_url), NULL);
 264   UpdateProviderPolicy(policy);
 265
 266   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
 267   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
 268   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
 269   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
 270   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
 271   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 272   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
 273                                 NULL));
 274   EXPECT_FALSE(store_->GetValue(
 275       prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
 276   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, NULL));
 277   EXPECT_FALSE(store_->GetValue(
 278       prefs::kDefaultSearchProviderImageURLPostParams, NULL));
 279   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL, NULL));
 280   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderNewTabURL, NULL));
 281 }
 282
 283 // Checks that if the default search policy is invalid, that no elements of the
 284 // default search policy will be present.
 285 TEST_F(DefaultSearchPolicyHandlerTest, Disabled) {
 286   PolicyMap policy;
 287   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
 288              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
 289   UpdateProviderPolicy(policy);
 290
 291   const base::Value* value = NULL;
 292   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEnabled, &value));
 293   base::FundamentalValue expected_enabled(false);
 294   EXPECT_TRUE(base::Value::Equals(&expected_enabled, value));
 295   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
 296   base::StringValue expected_search_url((std::string()));
 297   EXPECT_TRUE(base::Value::Equals(&expected_search_url, value));
 298 }
 299
 300 }  // namespace policy