Introduce 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 69 matching lines @@
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   std::string result;
   EXPECT_FALSE(store_.prefs()->GetString(GetParam().pref_name(), &result));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
   store_.Apply(GetParam().type(),
-              Value::CreateStringValue("http://chromium.org"));
+               Value::CreateStringValue("http://chromium.org"));
+  store_.Completed();
   std::string result;
   EXPECT_TRUE(store_.prefs()->GetString(GetParam().pref_name(), &result));
   EXPECT_EQ(result, "http://chromium.org");
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
         TypeAndName(kPolicyHomePage,
                     prefs::kHomePage),
-        TypeAndName(kPolicyProxyServer,
-                    prefs::kProxyServer),
-        TypeAndName(kPolicyProxyPacUrl,
-                    prefs::kProxyPacUrl),
-        TypeAndName(kPolicyProxyBypassList,
-                    prefs::kProxyBypassList),
         TypeAndName(kPolicyApplicationLocale,
                     prefs::kApplicationLocale),
         TypeAndName(kPolicyApplicationLocale,
                     prefs::kApplicationLocale),
         TypeAndName(kPolicyAuthSchemes,
                     prefs::kAuthSchemes),
         TypeAndName(kPolicyAuthServerWhitelist,
                     prefs::kAuthServerWhitelist),
         TypeAndName(kPolicyAuthNegotiateDelegateWhitelist,
                     prefs::kAuthNegotiateDelegateWhitelist),
@@ skipping 89 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 specified expected values.
+  static void VerifyProxyPrefs(
+      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::ProxyMode& expected_proxy_mode) {
+    std::string string_result;
+
+    if (expected_proxy_server.empty()) {
+      EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer,
+                                            &string_result));
+    } else {
+      EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer,
+                                           &string_result));
+      EXPECT_EQ(expected_proxy_server, string_result);
+    }
+    if (expected_proxy_pac_url.empty()) {
+      EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl,
+                                            &string_result));
+    } else {
+      EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl,
+                                           &string_result));
+      EXPECT_EQ(expected_proxy_pac_url, string_result);
+    }
+    if (expected_proxy_bypass_list.empty()) {
+      EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
+                                            &string_result));
+    } else {
+      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::kProxyMode, &int_result));
+    EXPECT_EQ(expected_proxy_mode, int_result);
+  }
 };
 
 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"));
-  provider->AddPolicy(kPolicyProxyServerMode,
+  provider->AddPolicy(kPolicyProxyMode,
                       Value::CreateIntegerValue(
                           kPolicyManuallyConfiguredProxyMode));
 
   ConfigurationPolicyPrefStore store(provider.get());
+  VerifyProxyPrefs(
+      store, "chromium.org", "", "http://chromium.org/override",
+      ProxyPrefs::FIXED_SERVERS);
+}
 
-  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(kPolicyProxyMode,
+                      Value::CreateIntegerValue(
+                          kPolicyManuallyConfiguredProxyMode));
+  provider->AddPolicy(kPolicyProxyBypassList,
+                      Value::CreateStringValue("http://chromium.org/override"));
+  provider->AddPolicy(kPolicyProxyServer,
+                      Value::CreateStringValue("chromium.org"));
+
+  ConfigurationPolicyPrefStore store(provider.get());
+  VerifyProxyPrefs(
+      store, "chromium.org", "", "http://chromium.org/override",
+      ProxyPrefs::FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyNoProxyServerMode));
+  provider->AddPolicy(kPolicyProxyMode,
+                      Value::CreateIntegerValue(kPolicyNoProxyServerMode));
 
   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);
-}
-
-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"));
-
-  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);
+  VerifyProxyPrefs(store, "", "", "", ProxyPrefs::DISABLED);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyAutoDetectProxyMode));
+  provider->AddPolicy(kPolicyProxyMode,
+                      Value::CreateIntegerValue(kPolicyAutoDetectProxyMode));
 
   ConfigurationPolicyPrefStore store(provider.get());
+  VerifyProxyPrefs(store, "", "", "", 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, AutoDetectPac) {
+  scoped_ptr<MockConfigurationPolicyProvider> provider(
+      new MockConfigurationPolicyProvider());
+  provider->AddPolicy(kPolicyProxyPacUrl,
+                      Value::CreateStringValue("http://short.org/proxy.pac"));
+  provider->AddPolicy(kPolicyProxyMode,
+                      Value::CreateIntegerValue(kPolicyAutoDetectProxyMode));
+
+  ConfigurationPolicyPrefStore store(provider.get());
+  VerifyProxyPrefs(
+      store, "", "http://short.org/proxy.pac", "", ProxyPrefs::PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyBypassList,
-                      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyUseSystemProxyMode));
+  provider->AddPolicy(kPolicyProxyMode,
+                      Value::CreateIntegerValue(kPolicyUseSystemProxyMode));
 
   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));
+  VerifyProxyPrefs(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"));
+TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
+  for (int i = 0; i < NUM_PROXY_MODES; ++i) {
+    scoped_ptr<MockConfigurationPolicyProvider> provider(
+        new MockConfigurationPolicyProvider());
+    provider->AddPolicy(kPolicyProxyMode, Value::CreateIntegerValue(i));
+    // No mode expects all three parameters being set.
+    provider->AddPolicy(kPolicyProxyPacUrl,
+                        Value::CreateStringValue("http://short.org/proxy.pac"));
+    provider->AddPolicy(kPolicyProxyBypassList,
+                        Value::CreateStringValue(
+                            "http://chromium.org/override"));
+    provider->AddPolicy(kPolicyProxyServer,
+                        Value::CreateStringValue("chromium.org"));
 
-  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));
+    ConfigurationPolicyPrefStore store(provider.get());
+    EXPECT_FALSE(store.prefs()->HasKey(prefs::kProxyMode));
+  }
 }
 
 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