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/net/pref_proxy_config_service.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/chrome_switches.h"
 

[danno, 2010/12/14 12:48:17]

You changed quite a bit in the logic to apply the proxy policy, but there are no
new test cases here. Unless you know that your code is thoroughly covered by
these tests (I doubt it), then you should add new ones to make sure you are
getting what you expect.

[gfeher, 2010/12/16 10:42:04]

I believe I've left the core logic unchanged. Nevertheless, I've made the
testing of it more complete.

 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),
         pref_name_(pref_name) {}
 
   ConfigurationPolicyType type() const { return type_; }
@@ skipping 218 matching lines @@
   ConfigurationPolicyPrefStore store(provider.get());
 
   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);
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::MANUAL, int_result);
 }
 
 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));
 
   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);
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::DISABLED, int_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);
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::DISABLED, int_result);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyAutoDetectProxyMode));
 
   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_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_TRUE(bool_result);
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::AUTO_DETECT, int_result);
 }
 
 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));
 
   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));
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::SYSTEM, int_result);
 }
 
 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"));
 
   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));
+  int int_result = -1;
+  EXPECT_TRUE(store.prefs()->GetInteger(prefs::kProxyServerMode, &int_result));
+  EXPECT_EQ(PrefProxyConfigService::SYSTEM, int_result);
 }
 
 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