Intorduce a separate preference for 'proxy server mode'

chrome/browser/policy/configuration_policy_pref_store_unittest.cc

 // Copyright (c) 2010 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 <gtest/gtest.h>
 
 #include "base/file_path.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/chrome_switches.h"
 
 namespace policy {
 
 // Holds a set of test parameters, consisting of pref name and policy type.
 class TypeAndName {
  public:
   TypeAndName(ConfigurationPolicyType type, const char* pref_name)
       : type_(type),
@@ skipping 196 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
         TypeAndName(kPolicyRestoreOnStartup,
                     prefs::kRestoreOnStartup)));
 
 // Test cases for the proxy policy settings.
 class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
+ protected:
+  // Verify that all the proxy prefs are set to the speicifed expected values.
+  void VerifyEnabledProxyPrefs(
+      const ConfigurationPolicyPrefStore& store,
+      const std::string& expected_proxy_server,
+      const std::string& expected_proxy_pac_url,
+      const std::string& expected_proxy_bypass_list,
+      const ProxyPrefs::ProxyServerMode& expected_proxy_mode) {
+    std::string string_result;
+
+    EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+    EXPECT_EQ(expected_proxy_server, string_result);
+    EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+    EXPECT_EQ(expected_proxy_pac_url, string_result);
+    EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+    EXPECT_EQ(expected_proxy_bypass_list, string_result);
+    int int_result = -1;
+    EXPECT_TRUE(
+        store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+    EXPECT_EQ(expected_proxy_mode, int_result);
+  }
+
+  // Verify that kProxyServerMode is set to its expected value, and all the
+  // other proxy prefs are unset.
+  void VerifyDisabledProxyPrefs(
+      const ConfigurationPolicyPrefStore& store,
+      const ProxyPrefs::ProxyServerMode& expected_proxy_mode) {
+    std::string string_result;
+    EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+    EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+    EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
+                                          &string_result));
+    int int_result = -1;
+    EXPECT_TRUE(
+        store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+    EXPECT_EQ(expected_proxy_mode, int_result);
+  }
+
+  void AddProxyPolicies(
+      MockConfigurationPolicyProvider* provider,
+      const std::string& proxy_server,
+      const std::string& proxy_pac_url,
+      const std::string& proxy_bypass_list) {
+    provider->AddPolicy(kPolicyProxyBypassList,
+                        Value::CreateStringValue(proxy_bypass_list));
+    provider->AddPolicy(kPolicyProxyPacUrl,
+                        Value::CreateStringValue(proxy_pac_url));
+    provider->AddPolicy(kPolicyProxyServer,
+                        Value::CreateStringValue(proxy_server));
+  }
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(kPolicyProxyPacUrl,
-                      Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider->AddPolicy(kPolicyProxyServer,
-                      Value::CreateStringValue("chromium.org"));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyManuallyConfiguredProxyMode));
+                      Value::CreateIntegerValue(ProxyPrefs::MANUAL));
 
   ConfigurationPolicyPrefStore store(provider.get());
+  VerifyEnabledProxyPrefs(
+      store,
+      "chromium.org",
+      "http://short.org/proxy.pac",
+      "http://chromium.org/override",
+      ProxyPrefs::MANUAL);
+}
 
-  std::string string_result;
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                       &string_result));
-  EXPECT_EQ("http://chromium.org/override", string_result);
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_EQ("http://short.org/proxy.pac", string_result);
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  EXPECT_EQ("chromium.org", string_result);
-  bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_FALSE(bool_result);
+TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
+  scoped_ptr<MockConfigurationPolicyProvider> provider(
+      new MockConfigurationPolicyProvider());
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(ProxyPrefs::MANUAL));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
+
+  ConfigurationPolicyPrefStore store(provider.get());
+  VerifyEnabledProxyPrefs(
+      store,
+      "chromium.org",
+      "http://short.org/proxy.pac",
+      "http://chromium.org/override",
+      ProxyPrefs::MANUAL);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyNoProxyServerMode));
+                      Value::CreateIntegerValue(ProxyPrefs::DISABLED));
 
   ConfigurationPolicyPrefStore store(provider.get());
-
-  std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_TRUE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_FALSE(bool_result);
+  VerifyDisabledProxyPrefs(store, ProxyPrefs::DISABLED);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyNoProxyServerMode));
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
+                      Value::CreateIntegerValue(ProxyPrefs::DISABLED));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
 
   ConfigurationPolicyPrefStore store(provider.get());
-
-  std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_TRUE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_FALSE(bool_result);
+  VerifyDisabledProxyPrefs(store, ProxyPrefs::DISABLED);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyAutoDetectProxyMode));
+                      Value::CreateIntegerValue(ProxyPrefs::AUTO_DETECT));
 
   ConfigurationPolicyPrefStore store(provider.get());
+  VerifyEnabledProxyPrefs(
+      store,
+      "chromium.org",
+      "http://short.org/proxy.pac",
+      "http://chromium.org/override",
+      ProxyPrefs::AUTO_DETECT);
+}
 
-  std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_TRUE(bool_result);
+TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectReversedApplyOrder) {
+  scoped_ptr<MockConfigurationPolicyProvider> provider(
+      new MockConfigurationPolicyProvider());
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(ProxyPrefs::AUTO_DETECT));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
+
+  ConfigurationPolicyPrefStore store(provider.get());
+  VerifyEnabledProxyPrefs(
+      store,
+      "chromium.org",
+      "http://short.org/proxy.pac",
+      "http://chromium.org/override",
+      ProxyPrefs::AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyUseSystemProxyMode));
+                      Value::CreateIntegerValue(ProxyPrefs::SYSTEM));
 
   ConfigurationPolicyPrefStore store(provider.get());
-
-  std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  VerifyDisabledProxyPrefs(store, ProxyPrefs::SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyUseSystemProxyMode));
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
+                      Value::CreateIntegerValue(ProxyPrefs::SYSTEM));
+  AddProxyPolicies(provider.get(),
+                   "chromium.org",
+                   "http://short.org/proxy.pac",
+                   "http://chromium.org/override");
 
   ConfigurationPolicyPrefStore store(provider.get());
-
-  std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
-  bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  VerifyDisabledProxyPrefs(store, ProxyPrefs::SYSTEM);
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
 };
 
 // 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) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   scoped_ptr<MockConfigurationPolicyProvider> provider(
@@ skipping 245 matching lines @@
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
   store_.Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
   // Disabling AutoFill should switch the pref to managed.
   bool result = true;
   EXPECT_TRUE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
   EXPECT_FALSE(result);
 }
 
 }  // namespace policy