chrome/browser/policy/url_blacklist_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 "base/memory/scoped_ptr.h"
   6 #include "base/prefs/pref_value_map.h"
   7 #include "base/values.h"
   8 #include "components/policy/core/browser/policy_error_map.h"
   9 #include "components/policy/core/browser/url_blacklist_policy_handler.h"
  10 #include "components/policy/core/common/policy_map.h"
  11 #include "components/policy/core/common/policy_pref_names.h"
  12 #include "policy/policy_constants.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 // Note: this file should move to components/policy/core/browser, but the
  16 // components_unittests runner does not load the ResourceBundle as
  17 // ChromeTestSuite::Initialize does, which leads to failures using
  18 // PolicyErrorMap.
  19
  20 namespace policy {
  21
  22 namespace {
  23
  24 const char kTestDisabledScheme[] = "kTestDisabledScheme";
  25 const char kTestBlacklistValue[] = "kTestBlacklistValue";
  26
  27 }  // namespace
  28
  29 class URLBlacklistPolicyHandlerTest : public testing::Test {
  30  protected:
  31   void SetPolicy(const std::string& key, base::Value* value) {
  32     policies_.Set(key, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, value, NULL);
  33   }
  34   bool CheckPolicy(const std::string& key, base::Value* value) {
  35     SetPolicy(key, value);
  36     return handler_.CheckPolicySettings(policies_, &errors_);
  37   }
  38   void ApplyPolicies() {
  39     handler_.ApplyPolicySettings(policies_, &prefs_);
  40   }
  41
  42   URLBlacklistPolicyHandler handler_;
  43   PolicyErrorMap errors_;
  44   PolicyMap policies_;
  45   PrefValueMap prefs_;
  46 };
  47
  48 TEST_F(URLBlacklistPolicyHandlerTest,
  49        CheckPolicySettings_DisabledSchemesUnspecified) {
  50   EXPECT_TRUE(CheckPolicy(key::kURLBlacklist, new base::ListValue));
  51   EXPECT_EQ(0U, errors_.size());
  52 }
  53
  54 TEST_F(URLBlacklistPolicyHandlerTest,
  55        CheckPolicySettings_URLBlacklistUnspecified) {
  56   EXPECT_TRUE(CheckPolicy(key::kDisabledSchemes, new base::ListValue));
  57   EXPECT_EQ(0U, errors_.size());
  58 }
  59
  60 TEST_F(URLBlacklistPolicyHandlerTest,
  61        CheckPolicySettings_DisabledSchemesWrongType) {
  62   // The policy expects a list. Give it a boolean.
  63   EXPECT_TRUE(CheckPolicy(key::kDisabledSchemes,
  64                           base::Value::CreateBooleanValue(false)));
  65   EXPECT_EQ(1U, errors_.size());
  66   const std::string expected = key::kDisabledSchemes;
  67   const std::string actual = errors_.begin()->first;
  68   EXPECT_EQ(expected, actual);
  69 }
  70
  71 TEST_F(URLBlacklistPolicyHandlerTest,
  72        CheckPolicySettings_URLBlacklistWrongType) {
  73   // The policy expects a list. Give it a boolean.
  74   EXPECT_TRUE(CheckPolicy(key::kURLBlacklist,
  75                           base::Value::CreateBooleanValue(false)));
  76   EXPECT_EQ(1U, errors_.size());
  77   const std::string expected = key::kURLBlacklist;
  78   const std::string actual = errors_.begin()->first;
  79   EXPECT_EQ(expected, actual);
  80 }
  81
  82 TEST_F(URLBlacklistPolicyHandlerTest, ApplyPolicySettings_NothingSpecified) {
  83   ApplyPolicies();
  84   EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL));
  85 }
  86
  87 TEST_F(URLBlacklistPolicyHandlerTest,
  88        ApplyPolicySettings_DisabledSchemesWrongType) {
  89   // The policy expects a list. Give it a boolean.
  90   SetPolicy(key::kDisabledSchemes, base::Value::CreateBooleanValue(false));
  91   ApplyPolicies();
  92   EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL));
  93 }
  94
  95 TEST_F(URLBlacklistPolicyHandlerTest,
  96        ApplyPolicySettings_URLBlacklistWrongType) {
  97   // The policy expects a list. Give it a boolean.
  98   SetPolicy(key::kURLBlacklist, base::Value::CreateBooleanValue(false));
  99   ApplyPolicies();
 100   EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL));
 101 }
 102
 103 TEST_F(URLBlacklistPolicyHandlerTest,
 104        ApplyPolicySettings_DisabledSchemesEmpty) {
 105   SetPolicy(key::kDisabledSchemes, new base::ListValue);
 106   ApplyPolicies();
 107   base::Value* out;
 108   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 109   base::ListValue* out_list;
 110   EXPECT_TRUE(out->GetAsList(&out_list));
 111   EXPECT_EQ(0U, out_list->GetSize());
 112 }
 113
 114 TEST_F(URLBlacklistPolicyHandlerTest,
 115        ApplyPolicySettings_URLBlacklistEmpty) {
 116   SetPolicy(key::kURLBlacklist, new base::ListValue);
 117   ApplyPolicies();
 118   base::Value* out;
 119   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 120   base::ListValue* out_list;
 121   EXPECT_TRUE(out->GetAsList(&out_list));
 122   EXPECT_EQ(0U, out_list->GetSize());
 123 }
 124
 125 TEST_F(URLBlacklistPolicyHandlerTest,
 126        ApplyPolicySettings_DisabledSchemesWrongElementType) {
 127   // The policy expects string-valued elements. Give it booleans.
 128   scoped_ptr<base::ListValue> in(new base::ListValue);
 129   in->AppendBoolean(false);
 130   SetPolicy(key::kDisabledSchemes, in.release());
 131   ApplyPolicies();
 132
 133   // The element should be skipped.
 134   base::Value* out;
 135   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 136   base::ListValue* out_list;
 137   EXPECT_TRUE(out->GetAsList(&out_list));
 138   EXPECT_EQ(0U, out_list->GetSize());
 139 }
 140
 141 TEST_F(URLBlacklistPolicyHandlerTest,
 142        ApplyPolicySettings_URLBlacklistWrongElementType) {
 143   // The policy expects string-valued elements. Give it booleans.
 144   scoped_ptr<base::ListValue> in(new base::ListValue);
 145   in->AppendBoolean(false);
 146   SetPolicy(key::kURLBlacklist, in.release());
 147   ApplyPolicies();
 148
 149   // The element should be skipped.
 150   base::Value* out;
 151   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 152   base::ListValue* out_list;
 153   EXPECT_TRUE(out->GetAsList(&out_list));
 154   EXPECT_EQ(0U, out_list->GetSize());
 155 }
 156
 157 TEST_F(URLBlacklistPolicyHandlerTest,
 158        ApplyPolicySettings_DisabledSchemesSuccessful) {
 159   scoped_ptr<base::ListValue> in_disabled_schemes(new base::ListValue);
 160   in_disabled_schemes->AppendString(kTestDisabledScheme);
 161   SetPolicy(key::kDisabledSchemes, in_disabled_schemes.release());
 162   ApplyPolicies();
 163
 164   base::Value* out;
 165   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 166   base::ListValue* out_list;
 167   EXPECT_TRUE(out->GetAsList(&out_list));
 168   EXPECT_EQ(1U, out_list->GetSize());
 169
 170   std::string out_string;
 171   EXPECT_TRUE(out_list->GetString(0U, &out_string));
 172   EXPECT_EQ(kTestDisabledScheme + std::string("://*"), out_string);
 173 }
 174
 175 TEST_F(URLBlacklistPolicyHandlerTest,
 176        ApplyPolicySettings_URLBlacklistSuccessful) {
 177   scoped_ptr<base::ListValue> in_url_blacklist(new base::ListValue);
 178   in_url_blacklist->AppendString(kTestBlacklistValue);
 179   SetPolicy(key::kURLBlacklist, in_url_blacklist.release());
 180   ApplyPolicies();
 181
 182   base::Value* out;
 183   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 184   base::ListValue* out_list;
 185   EXPECT_TRUE(out->GetAsList(&out_list));
 186   EXPECT_EQ(1U, out_list->GetSize());
 187
 188   std::string out_string;
 189   EXPECT_TRUE(out_list->GetString(0U, &out_string));
 190   EXPECT_EQ(kTestBlacklistValue, out_string);
 191 }
 192
 193 TEST_F(URLBlacklistPolicyHandlerTest, ApplyPolicySettings_MergeSuccessful) {
 194   scoped_ptr<base::ListValue> in_disabled_schemes(new base::ListValue);
 195   in_disabled_schemes->AppendString(kTestDisabledScheme);
 196   SetPolicy(key::kDisabledSchemes, in_disabled_schemes.release());
 197
 198   scoped_ptr<base::ListValue> in_url_blacklist(new base::ListValue);
 199   in_url_blacklist->AppendString(kTestBlacklistValue);
 200   SetPolicy(key::kURLBlacklist, in_url_blacklist.release());
 201
 202   ApplyPolicies();
 203
 204   base::Value* out;
 205   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
 206   base::ListValue* out_list;
 207   EXPECT_TRUE(out->GetAsList(&out_list));
 208   EXPECT_EQ(2U, out_list->GetSize());
 209
 210   std::string out1;
 211   EXPECT_TRUE(out_list->GetString(0U, &out1));
 212   EXPECT_EQ(kTestDisabledScheme + std::string("://*"), out1);
 213
 214   std::string out2;
 215   EXPECT_TRUE(out_list->GetString(1U, &out2));
 216   EXPECT_EQ(kTestBlacklistValue, out2);
 217 }
 218
 219 }  // namespace policy