Introduces a search term extraction mechanism working for arbitrary search providers.

chrome/browser/policy/configuration_policy_pref_store_unittest.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/string_util.h"
@@ skipping 538 matching lines @@
     policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER, base::Value::CreateIntegerValue(i));
     provider_.UpdateChromePolicy(policy);
     const base::Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_NO_VALUE,
               store_->GetValue(prefs::kProxy, &value));
   }
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest
-    : public ConfigurationPolicyPrefStoreTest {};
+    : public ConfigurationPolicyPrefStoreTest {
+

[Peter Kasting, 2012/10/04 19:32:43]

Nit: Extra blank line

[beaudoin, 2012/10/04 23:10:45]

Done.

+ public:
+  ConfigurationPolicyPrefStoreDefaultSearchTest() {
+    default_alternate_urls_.AppendString(
+        "http://www.google.com/#q={searchTerms}");
+    default_alternate_urls_.AppendString(
+        "http://www.google.com/search#q={searchTerms}");
+  }
+
+ protected:
+  static const char* const kSearchURL;
+  static const char* const kSuggestURL;
+  static const char* const kIconURL;
+  static const char* const kName;
+  static const char* const kKeyword;
+
+  // Build a default search policy by setting search-related keys in |policy| to
+  // reasonable values. You can update any of the keys after calling this
+  // method.
+  void BuildDefaultSearchPolicy(PolicyMap* policy);
+
+  base::ListValue default_alternate_urls_;
+};
+
+const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kSearchURL =
+    "http://test.com/search?t={searchTerms}";
+const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kSuggestURL =
+    "http://test.com/sugg?={searchTerms}";
+const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kIconURL =
+    "http://test.com/icon.jpg";
+const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kName =
+    "MyName";
+const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kKeyword =
+    "MyKeyword";
+
+void ConfigurationPolicyPrefStoreDefaultSearchTest::
+    BuildDefaultSearchPolicy(PolicyMap* policy) {
+  base::ListValue* encodings = new base::ListValue();
+  encodings->AppendString("UTF-16");
+  encodings->AppendString("UTF-8");
+  policy->Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  policy->Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL));
+  policy->Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(kName));
+  policy->Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(kKeyword));
+  policy->Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(kSuggestURL));
+  policy->Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, base::Value::CreateStringValue(kIconURL));
+  policy->Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, encodings);
+  policy->Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, default_alternate_urls_.DeepCopy());
+}
 
 // Checks that if the policy for default search is valid, i.e. there's a
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   PolicyMap policy;
-  const char* const search_url = "http://test.com/search?t={searchTerms}";
   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(search_url));
+             POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL));
   provider_.UpdateChromePolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
-  EXPECT_TRUE(base::StringValue(search_url).Equals(value));
+  EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderName, &value));
   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
   EXPECT_TRUE(base::StringValue("test.com").Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderInstantURL, &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
+                             &value));
+  EXPECT_TRUE(base::ListValue().Equals(value));
 }
 
 // Checks that for a fully defined search policy, all elements have been
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   PolicyMap policy;
-  const char* const search_url = "http://test.com/search?t={searchTerms}";
-  const char* const suggest_url = "http://test.com/sugg?={searchTerms}";
-  const char* const icon_url = "http://test.com/icon.jpg";
-  const char* const name = "MyName";
-  const char* const keyword = "MyKeyword";
-  base::ListValue* encodings = new base::ListValue();
-  encodings->Append(base::Value::CreateStringValue("UTF-16"));
-  encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
-  policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(search_url));
-  policy.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
-  policy.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
-  policy.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
-  policy.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
-  policy.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, encodings);
+  BuildDefaultSearchPolicy(&policy);
   provider_.UpdateChromePolicy(policy);
 
   const base::Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
-  EXPECT_TRUE(base::StringValue(search_url).Equals(value));
+  EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderName, &value));
-  EXPECT_TRUE(base::StringValue(name).Equals(value));
+  EXPECT_TRUE(base::StringValue(kName).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
-  EXPECT_TRUE(base::StringValue(keyword).Equals(value));
+  EXPECT_TRUE(base::StringValue(kKeyword).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
-  EXPECT_TRUE(base::StringValue(suggest_url).Equals(value));
+  EXPECT_TRUE(base::StringValue(kSuggestURL).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
-  EXPECT_TRUE(base::StringValue(icon_url).Equals(value));
+  EXPECT_TRUE(base::StringValue(kIconURL).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
   EXPECT_TRUE(base::StringValue("UTF-16;UTF-8").Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(
+      prefs::kDefaultSearchProviderAlternateURLs, &value));
+  EXPECT_TRUE(default_alternate_urls_.Equals(value));
 }
 
 // Checks that if the default search policy is missing, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   PolicyMap policy;
-  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
-  const char* const icon_url = "http://test.com/icon.jpg";
-  const char* const name = "MyName";
-  const char* const keyword = "MyKeyword";
-  base::ListValue* encodings = new base::ListValue();
-  encodings->Append(base::Value::CreateStringValue("UTF-16"));
-  encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
-  policy.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
-  policy.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
-  policy.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
-  policy.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
-  policy.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, encodings);
+  BuildDefaultSearchPolicy(&policy);
+  policy.Erase(key::kDefaultSearchProviderSearchURL);
   provider_.UpdateChromePolicy(policy);
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   PolicyMap policy;
+  BuildDefaultSearchPolicy(&policy);
   const char* const bad_search_url = "http://test.com/noSearchTerms";
-  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
-  const char* const icon_url = "http://test.com/icon.jpg";
-  const char* const name = "MyName";
-  const char* const keyword = "MyKeyword";
-  base::ListValue* encodings = new base::ListValue();
-  encodings->Append(base::Value::CreateStringValue("UTF-16"));
-  encodings->Append(base::Value::CreateStringValue("UTF-8"));
-  policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateStringValue(bad_search_url));
-  policy.Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(name));
-  policy.Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(keyword));
-  policy.Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(suggest_url));
-  policy.Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, base::Value::CreateStringValue(icon_url));
-  policy.Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
-             POLICY_SCOPE_USER, encodings);
   provider_.UpdateChromePolicy(policy);
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Disabled) {
   PolicyMap policy;
   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
   provider_.UpdateChromePolicy(policy);
 
@@ skipping 445 matching lines @@
 
   // Any invalid element of the list stops setting the preference.
   policy_values.clear();
   policy_values.push_back("valid1:11.*");
   policy_values.push_back("valid2:11.2.1.*");
   policy_values.push_back("Invalid:");
   AssertNoValue(policy_values);
 }
 
 }  // namespace policy