proxy_policy_handler_unittest.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330
  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. #include "components/proxy_config/proxy_policy_handler.h"
  5. #include <memory>
  6. #include <string>
  7. #include "base/memory/ptr_util.h"
  8. #include "base/values.h"
  9. #include "components/policy/core/browser/configuration_policy_pref_store.h"
  10. #include "components/policy/core/browser/configuration_policy_pref_store_test.h"
  11. #include "components/policy/core/common/policy_service_impl.h"
  12. #include "components/policy/core/common/policy_types.h"
  13. #include "components/policy/core/common/proxy_settings_constants.h"
  14. #include "components/policy/policy_constants.h"
  15. #include "components/proxy_config/proxy_config_dictionary.h"
  16. #include "components/proxy_config/proxy_config_pref_names.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. #include "third_party/abseil-cpp/absl/types/optional.h"
  19. using policy::ConfigurationPolicyHandler;
  20. using policy::ConfigurationPolicyPrefStore;
  21. using policy::ConfigurationPolicyPrefStoreTest;
  22. using policy::kProxyPacMandatory;
  23. using policy::POLICY_LEVEL_MANDATORY;
  24. using policy::POLICY_LEVEL_RECOMMENDED;
  25. using policy::POLICY_SCOPE_USER;
  26. using policy::POLICY_SOURCE_CLOUD;
  27. using policy::PolicyMap;
  28. using policy::PolicyServiceImpl;
  29. using policy::key::kProxyBypassList;
  30. using policy::key::kProxyMode;
  31. using policy::key::kProxyPacUrl;
  32. using policy::key::kProxyServer;
  33. using policy::key::kProxyServerMode;
  34. using policy::key::kProxySettings;
  35. namespace proxy_config {
  36. // Test cases for the proxy policy settings.
  37. class ProxyPolicyHandlerTest : public ConfigurationPolicyPrefStoreTest {
  38. public:
  39. void SetUp() override {
  40. ConfigurationPolicyPrefStoreTest::SetUp();
  41. handler_list_.AddHandler(
  42. base::WrapUnique<ConfigurationPolicyHandler>(new ProxyPolicyHandler));
  43. // Reset the PolicyServiceImpl to one that has the policy fixup
  44. // preprocessor. The previous store must be nulled out first so that it
  45. // removes itself from the service's observer list.
  46. store_ = nullptr;
  47. policy_service_ = std::make_unique<PolicyServiceImpl>(providers_);
  48. store_ = new ConfigurationPolicyPrefStore(
  49. nullptr, policy_service_.get(), &handler_list_, POLICY_LEVEL_MANDATORY);
  50. }
  51. protected:
  52. // Verify that all the proxy prefs are set to the specified expected values.
  53. void VerifyProxyPrefs(const std::string& expected_proxy_server,
  54. const std::string& expected_proxy_pac_url,
  55. absl::optional<bool> expected_proxy_pac_mandatory,
  56. const std::string& expected_proxy_bypass_list,
  57. const ProxyPrefs::ProxyMode& expected_proxy_mode) {
  58. const base::Value* value = nullptr;
  59. ASSERT_TRUE(store_->GetValue(proxy_config::prefs::kProxy, &value));
  60. ASSERT_TRUE(value->is_dict());
  61. ProxyConfigDictionary dict(value->Clone());
  62. std::string s;
  63. bool b;
  64. if (expected_proxy_server.empty()) {
  65. EXPECT_FALSE(dict.GetProxyServer(&s));
  66. } else {
  67. ASSERT_TRUE(dict.GetProxyServer(&s));
  68. EXPECT_EQ(expected_proxy_server, s);
  69. }
  70. if (expected_proxy_pac_url.empty()) {
  71. EXPECT_FALSE(dict.GetPacUrl(&s));
  72. } else {
  73. ASSERT_TRUE(dict.GetPacUrl(&s));
  74. EXPECT_EQ(expected_proxy_pac_url, s);
  75. }
  76. if (!expected_proxy_pac_mandatory) {
  77. EXPECT_FALSE(dict.GetPacMandatory(&b));
  78. } else {
  79. ASSERT_TRUE(dict.GetPacMandatory(&b));
  80. EXPECT_EQ(*expected_proxy_pac_mandatory, b);
  81. }
  82. if (expected_proxy_bypass_list.empty()) {
  83. EXPECT_FALSE(dict.GetBypassList(&s));
  84. } else {
  85. ASSERT_TRUE(dict.GetBypassList(&s));
  86. EXPECT_EQ(expected_proxy_bypass_list, s);
  87. }
  88. ProxyPrefs::ProxyMode mode;
  89. ASSERT_TRUE(dict.GetMode(&mode));
  90. EXPECT_EQ(expected_proxy_mode, mode);
  91. }
  92. };
  93. TEST_F(ProxyPolicyHandlerTest, ManualOptions) {
  94. PolicyMap policy;
  95. policy.Set(kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  96. POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
  97. nullptr);
  98. policy.Set(kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  99. POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
  100. policy.Set(
  101. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  102. POLICY_SOURCE_CLOUD,
  103. base::Value(
  104. ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
  105. nullptr);
  106. UpdateProviderPolicy(policy);
  107. VerifyProxyPrefs("chromium.org", std::string(), absl::nullopt,
  108. "http://chromium.org/override",
  109. ProxyPrefs::MODE_FIXED_SERVERS);
  110. }
  111. TEST_F(ProxyPolicyHandlerTest, ManualOptionsReversedApplyOrder) {
  112. PolicyMap policy;
  113. policy.Set(
  114. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  115. POLICY_SOURCE_CLOUD,
  116. base::Value(
  117. ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
  118. nullptr);
  119. policy.Set(kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  120. POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
  121. nullptr);
  122. policy.Set(kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  123. POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
  124. UpdateProviderPolicy(policy);
  125. VerifyProxyPrefs("chromium.org", std::string(), absl::nullopt,
  126. "http://chromium.org/override",
  127. ProxyPrefs::MODE_FIXED_SERVERS);
  128. }
  129. TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) {
  130. PolicyMap policy;
  131. policy.Set(
  132. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  133. POLICY_SOURCE_CLOUD,
  134. base::Value(
  135. ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
  136. nullptr);
  137. UpdateProviderPolicy(policy);
  138. const base::Value* value = nullptr;
  139. EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value));
  140. }
  141. TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) {
  142. PolicyMap policy;
  143. policy.Set(kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  144. POLICY_SOURCE_CLOUD,
  145. base::Value(ProxyPolicyHandler::PROXY_SERVER_MODE), nullptr);
  146. UpdateProviderPolicy(policy);
  147. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  148. ProxyPrefs::MODE_DIRECT);
  149. }
  150. TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) {
  151. PolicyMap policy;
  152. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  153. POLICY_SOURCE_CLOUD, base::Value(ProxyPrefs::kDirectProxyModeName),
  154. nullptr);
  155. UpdateProviderPolicy(policy);
  156. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  157. ProxyPrefs::MODE_DIRECT);
  158. }
  159. TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) {
  160. PolicyMap policy;
  161. policy.Set(
  162. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  163. POLICY_SOURCE_CLOUD,
  164. base::Value(ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE),
  165. nullptr);
  166. UpdateProviderPolicy(policy);
  167. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  168. ProxyPrefs::MODE_AUTO_DETECT);
  169. }
  170. TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) {
  171. PolicyMap policy;
  172. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  173. POLICY_SOURCE_CLOUD,
  174. base::Value(ProxyPrefs::kAutoDetectProxyModeName), nullptr);
  175. UpdateProviderPolicy(policy);
  176. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  177. ProxyPrefs::MODE_AUTO_DETECT);
  178. }
  179. TEST_F(ProxyPolicyHandlerTest, PacScriptProxyMode) {
  180. PolicyMap policy;
  181. policy.Set(kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  182. POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
  183. nullptr);
  184. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  185. POLICY_SOURCE_CLOUD,
  186. base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
  187. UpdateProviderPolicy(policy);
  188. VerifyProxyPrefs(std::string(), "http://short.org/proxy.pac",
  189. /* expected_proxy_pac_mandatory */ false, std::string(),
  190. ProxyPrefs::MODE_PAC_SCRIPT);
  191. }
  192. // ProxyPacMandatory can be set only via ProxySettings.
  193. TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeWithPacMandatory) {
  194. base::Value proxy_settings(base::Value::Type::DICTIONARY);
  195. proxy_settings.SetStringKey(kProxyPacUrl, "http://short.org/proxy.pac");
  196. proxy_settings.SetStringKey(kProxyMode, ProxyPrefs::kPacScriptProxyModeName);
  197. proxy_settings.SetBoolKey(kProxyPacMandatory, true);
  198. PolicyMap policy;
  199. policy.Set(kProxySettings, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  200. POLICY_SOURCE_CLOUD, std::move(proxy_settings), nullptr);
  201. UpdateProviderPolicy(policy);
  202. VerifyProxyPrefs(std::string(), "http://short.org/proxy.pac",
  203. /* expected_proxy_pac_mandatory */ true, std::string(),
  204. ProxyPrefs::MODE_PAC_SCRIPT);
  205. }
  206. TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) {
  207. PolicyMap policy;
  208. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  209. POLICY_SOURCE_CLOUD,
  210. base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
  211. UpdateProviderPolicy(policy);
  212. const base::Value* value = nullptr;
  213. EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value));
  214. }
  215. // Regression test for http://crbug.com/78016, device management server returns
  216. // empty strings for unset properties.
  217. TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) {
  218. PolicyMap policy;
  219. policy.Set(kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  220. POLICY_SOURCE_CLOUD, base::Value(std::string()), nullptr);
  221. policy.Set(kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  222. POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
  223. nullptr);
  224. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  225. POLICY_SOURCE_CLOUD,
  226. base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
  227. UpdateProviderPolicy(policy);
  228. VerifyProxyPrefs(std::string(), "http://short.org/proxy.pac", false,
  229. std::string(), ProxyPrefs::MODE_PAC_SCRIPT);
  230. }
  231. TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) {
  232. PolicyMap policy;
  233. policy.Set(
  234. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  235. POLICY_SOURCE_CLOUD,
  236. base::Value(ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE),
  237. nullptr);
  238. UpdateProviderPolicy(policy);
  239. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  240. ProxyPrefs::MODE_SYSTEM);
  241. }
  242. TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) {
  243. PolicyMap policy;
  244. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  245. POLICY_SOURCE_CLOUD, base::Value(ProxyPrefs::kSystemProxyModeName),
  246. nullptr);
  247. UpdateProviderPolicy(policy);
  248. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  249. ProxyPrefs::MODE_SYSTEM);
  250. }
  251. TEST_F(ProxyPolicyHandlerTest, ProxyModeOverridesProxyServerMode) {
  252. PolicyMap policy;
  253. policy.Set(kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  254. POLICY_SOURCE_CLOUD,
  255. base::Value(ProxyPolicyHandler::PROXY_SERVER_MODE), nullptr);
  256. policy.Set(kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  257. POLICY_SOURCE_CLOUD,
  258. base::Value(ProxyPrefs::kAutoDetectProxyModeName), nullptr);
  259. UpdateProviderPolicy(policy);
  260. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  261. ProxyPrefs::MODE_AUTO_DETECT);
  262. }
  263. TEST_F(ProxyPolicyHandlerTest, ProxyInvalid) {
  264. // No mode expects all three parameters being set.
  265. PolicyMap policy;
  266. policy.Set(kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  267. POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
  268. nullptr);
  269. policy.Set(kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  270. POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
  271. nullptr);
  272. policy.Set(kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  273. POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
  274. for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) {
  275. policy.Set(kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  276. POLICY_SOURCE_CLOUD, base::Value(i), nullptr);
  277. UpdateProviderPolicy(policy);
  278. const base::Value* value = nullptr;
  279. EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value));
  280. }
  281. }
  282. TEST_F(ProxyPolicyHandlerTest, SeparateProxyPoliciesMerging) {
  283. PolicyMap policy;
  284. // Individual proxy policy values should be collected into a dictionary.
  285. policy.Set(
  286. kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  287. POLICY_SOURCE_CLOUD,
  288. base::Value(ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE),
  289. nullptr);
  290. // Both these policies should be ignored, since there's a higher priority
  291. // policy available.
  292. policy.Set(kProxyMode, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
  293. POLICY_SOURCE_CLOUD, base::Value("pac_script"), nullptr);
  294. policy.Set(kProxyPacUrl, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
  295. POLICY_SOURCE_CLOUD, base::Value("http://example.com/wpad.dat"),
  296. nullptr);
  297. UpdateProviderPolicy(policy);
  298. VerifyProxyPrefs(std::string(), std::string(), absl::nullopt, std::string(),
  299. ProxyPrefs::MODE_SYSTEM);
  300. }
  301. } // namespace proxy_config