src/chrome/browser/net/proxy_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 <string>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/net/proxy_policy_handler.h"
  10 #include "chrome/browser/policy/configuration_policy_pref_store.h"
  11 #include "chrome/browser/policy/configuration_policy_pref_store_unittest.h"
  12 #include "chrome/browser/prefs/proxy_config_dictionary.h"
  13 #include "chrome/browser/prefs/proxy_prefs.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "policy/policy_constants.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace policy {
  19
  20 // Test cases for the proxy policy settings.
  21 class ProxyPolicyHandlerTest
  22     : public ConfigurationPolicyPrefStoreTest {
  23  public:
  24   virtual void SetUp() OVERRIDE {
  25     handler_list_.AddHandler(
  26         make_scoped_ptr<ConfigurationPolicyHandler>(new ProxyPolicyHandler));
  27   }
  28
  29  protected:
  30   // Verify that all the proxy prefs are set to the specified expected values.
  31   void VerifyProxyPrefs(
  32       const std::string& expected_proxy_server,
  33       const std::string& expected_proxy_pac_url,
  34       const std::string& expected_proxy_bypass_list,
  35       const ProxyPrefs::ProxyMode& expected_proxy_mode) {
  36     const base::Value* value = NULL;
  37     ASSERT_TRUE(store_->GetValue(prefs::kProxy, &value));
  38     ASSERT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
  39     ProxyConfigDictionary dict(
  40         static_cast<const base::DictionaryValue*>(value));
  41     std::string s;
  42     if (expected_proxy_server.empty()) {
  43       EXPECT_FALSE(dict.GetProxyServer(&s));
  44     } else {
  45       ASSERT_TRUE(dict.GetProxyServer(&s));
  46       EXPECT_EQ(expected_proxy_server, s);
  47     }
  48     if (expected_proxy_pac_url.empty()) {
  49       EXPECT_FALSE(dict.GetPacUrl(&s));
  50     } else {
  51       ASSERT_TRUE(dict.GetPacUrl(&s));
  52       EXPECT_EQ(expected_proxy_pac_url, s);
  53     }
  54     if (expected_proxy_bypass_list.empty()) {
  55       EXPECT_FALSE(dict.GetBypassList(&s));
  56     } else {
  57       ASSERT_TRUE(dict.GetBypassList(&s));
  58       EXPECT_EQ(expected_proxy_bypass_list, s);
  59     }
  60     ProxyPrefs::ProxyMode mode;
  61     ASSERT_TRUE(dict.GetMode(&mode));
  62     EXPECT_EQ(expected_proxy_mode, mode);
  63   }
  64 };
  65
  66 TEST_F(ProxyPolicyHandlerTest, ManualOptions) {
  67   PolicyMap policy;
  68   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  69              base::Value::CreateStringValue("http://chromium.org/override"),
  70              NULL);
  71   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  72              base::Value::CreateStringValue("chromium.org"), NULL);
  73   policy.Set(
  74       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  75       base::Value::CreateIntegerValue(
  76           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
  77       NULL);
  78   UpdateProviderPolicy(policy);
  79
  80   VerifyProxyPrefs("chromium.org",
  81                    std::string(),
  82                    "http://chromium.org/override",
  83                    ProxyPrefs::MODE_FIXED_SERVERS);
  84 }
  85
  86 TEST_F(ProxyPolicyHandlerTest, ManualOptionsReversedApplyOrder) {
  87   PolicyMap policy;
  88   policy.Set(
  89       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  90       base::Value::CreateIntegerValue(
  91           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
  92       NULL);
  93   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  94              base::Value::CreateStringValue("http://chromium.org/override"),
  95              NULL);
  96   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  97              base::Value::CreateStringValue("chromium.org"), NULL);
  98   UpdateProviderPolicy(policy);
  99
 100   VerifyProxyPrefs("chromium.org",
 101                    std::string(),
 102                    "http://chromium.org/override",
 103                    ProxyPrefs::MODE_FIXED_SERVERS);
 104 }
 105
 106 TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) {
 107   PolicyMap policy;
 108   policy.Set(
 109       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 110       base::Value::CreateIntegerValue(
 111           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
 112       NULL);
 113   UpdateProviderPolicy(policy);
 114
 115   const base::Value* value = NULL;
 116   EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
 117 }
 118
 119 TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) {
 120   PolicyMap policy;
 121   policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 122              base::Value::CreateIntegerValue(
 123                  ProxyPolicyHandler::PROXY_SERVER_MODE),
 124              NULL);
 125   UpdateProviderPolicy(policy);
 126   VerifyProxyPrefs(
 127       std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT);
 128 }
 129
 130 TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) {
 131   PolicyMap policy;
 132   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 133              base::Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName),
 134              NULL);
 135   UpdateProviderPolicy(policy);
 136   VerifyProxyPrefs(
 137       std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT);
 138 }
 139
 140 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) {
 141   PolicyMap policy;
 142   policy.Set(
 143       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 144       base::Value::CreateIntegerValue(
 145           ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE),
 146       NULL);
 147   UpdateProviderPolicy(policy);
 148   VerifyProxyPrefs(std::string(),
 149                    std::string(),
 150                    std::string(),
 151                    ProxyPrefs::MODE_AUTO_DETECT);
 152 }
 153
 154 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) {
 155   PolicyMap policy;
 156   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 157              base::Value::CreateStringValue(
 158                  ProxyPrefs::kAutoDetectProxyModeName),
 159              NULL);
 160   UpdateProviderPolicy(policy);
 161   VerifyProxyPrefs(std::string(),
 162                    std::string(),
 163                    std::string(),
 164                    ProxyPrefs::MODE_AUTO_DETECT);
 165 }
 166
 167 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyMode) {
 168   PolicyMap policy;
 169   policy.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 170              base::Value::CreateStringValue("http://short.org/proxy.pac"),
 171              NULL);
 172   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 173              base::Value::CreateStringValue(
 174                  ProxyPrefs::kPacScriptProxyModeName),
 175              NULL);
 176   UpdateProviderPolicy(policy);
 177   VerifyProxyPrefs(std::string(),
 178                    "http://short.org/proxy.pac",
 179                    std::string(),
 180                    ProxyPrefs::MODE_PAC_SCRIPT);
 181 }
 182
 183 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) {
 184   PolicyMap policy;
 185   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 186              base::Value::CreateStringValue(
 187                  ProxyPrefs::kPacScriptProxyModeName),
 188              NULL);
 189   UpdateProviderPolicy(policy);
 190   const base::Value* value = NULL;
 191   EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
 192 }
 193
 194 // Regression test for http://crbug.com/78016, CPanel returns empty strings
 195 // for unset properties.
 196 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) {
 197   PolicyMap policy;
 198   policy.Set(key::kProxyServer,
 199              POLICY_LEVEL_MANDATORY,
 200              POLICY_SCOPE_USER,
 201              base::Value::CreateStringValue(std::string()),
 202              NULL);
 203   policy.Set(key::kProxyPacUrl,
 204              POLICY_LEVEL_MANDATORY,
 205              POLICY_SCOPE_USER,
 206              base::Value::CreateStringValue("http://short.org/proxy.pac"),
 207              NULL);
 208   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 209              base::Value::CreateStringValue(
 210                  ProxyPrefs::kPacScriptProxyModeName),
 211              NULL);
 212   UpdateProviderPolicy(policy);
 213   VerifyProxyPrefs(std::string(),
 214                    "http://short.org/proxy.pac",
 215                    std::string(),
 216                    ProxyPrefs::MODE_PAC_SCRIPT);
 217 }
 218
 219 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) {
 220   PolicyMap policy;
 221   policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 222       base::Value::CreateIntegerValue(
 223           ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE),
 224       NULL);
 225   UpdateProviderPolicy(policy);
 226   VerifyProxyPrefs(
 227       std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM);
 228 }
 229
 230 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) {
 231   PolicyMap policy;
 232   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 233              base::Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName),
 234              NULL);
 235   UpdateProviderPolicy(policy);
 236   VerifyProxyPrefs(
 237       std::string(), std::string(), std::string(), ProxyPrefs::MODE_SYSTEM);
 238 }
 239
 240 TEST_F(ProxyPolicyHandlerTest,
 241        ProxyModeOverridesProxyServerMode) {
 242   PolicyMap policy;
 243   policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 244              base::Value::CreateIntegerValue(
 245                  ProxyPolicyHandler::PROXY_SERVER_MODE),
 246              NULL);
 247   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 248              base::Value::CreateStringValue(
 249                  ProxyPrefs::kAutoDetectProxyModeName),
 250              NULL);
 251   UpdateProviderPolicy(policy);
 252   VerifyProxyPrefs(std::string(),
 253                    std::string(),
 254                    std::string(),
 255                    ProxyPrefs::MODE_AUTO_DETECT);
 256 }
 257
 258 TEST_F(ProxyPolicyHandlerTest, ProxyInvalid) {
 259   // No mode expects all three parameters being set.
 260   PolicyMap policy;
 261   policy.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 262              base::Value::CreateStringValue("http://short.org/proxy.pac"),
 263              NULL);
 264   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 265              base::Value::CreateStringValue("http://chromium.org/override"),
 266              NULL);
 267   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 268              base::Value::CreateStringValue("chromium.org"), NULL);
 269   for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) {
 270     policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
 271                POLICY_SCOPE_USER, base::Value::CreateIntegerValue(i), NULL);
 272     UpdateProviderPolicy(policy);
 273     const base::Value* value = NULL;
 274     EXPECT_FALSE(store_->GetValue(prefs::kProxy, &value));
 275   }
 276 }
 277
 278 }  // namespace policy