1// Copyright 2014 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 20namespace policy { 21 22namespace { 23 24const char kTestDisabledScheme[] = "kTestDisabledScheme"; 25const char kTestBlacklistValue[] = "kTestBlacklistValue"; 26 27} // namespace 28 29class 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 48TEST_F(URLBlacklistPolicyHandlerTest, 49 CheckPolicySettings_DisabledSchemesUnspecified) { 50 EXPECT_TRUE(CheckPolicy(key::kURLBlacklist, new base::ListValue)); 51 EXPECT_EQ(0U, errors_.size()); 52} 53 54TEST_F(URLBlacklistPolicyHandlerTest, 55 CheckPolicySettings_URLBlacklistUnspecified) { 56 EXPECT_TRUE(CheckPolicy(key::kDisabledSchemes, new base::ListValue)); 57 EXPECT_EQ(0U, errors_.size()); 58} 59 60TEST_F(URLBlacklistPolicyHandlerTest, 61 CheckPolicySettings_DisabledSchemesWrongType) { 62 // The policy expects a list. Give it a boolean. 63 EXPECT_TRUE( 64 CheckPolicy(key::kDisabledSchemes, new base::FundamentalValue(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 71TEST_F(URLBlacklistPolicyHandlerTest, 72 CheckPolicySettings_URLBlacklistWrongType) { 73 // The policy expects a list. Give it a boolean. 74 EXPECT_TRUE( 75 CheckPolicy(key::kURLBlacklist, new base::FundamentalValue(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 82TEST_F(URLBlacklistPolicyHandlerTest, ApplyPolicySettings_NothingSpecified) { 83 ApplyPolicies(); 84 EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL)); 85} 86 87TEST_F(URLBlacklistPolicyHandlerTest, 88 ApplyPolicySettings_DisabledSchemesWrongType) { 89 // The policy expects a list. Give it a boolean. 90 SetPolicy(key::kDisabledSchemes, new base::FundamentalValue(false)); 91 ApplyPolicies(); 92 EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL)); 93} 94 95TEST_F(URLBlacklistPolicyHandlerTest, 96 ApplyPolicySettings_URLBlacklistWrongType) { 97 // The policy expects a list. Give it a boolean. 98 SetPolicy(key::kURLBlacklist, new base::FundamentalValue(false)); 99 ApplyPolicies(); 100 EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, NULL)); 101} 102 103TEST_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 114TEST_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 125TEST_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 141TEST_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 157TEST_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 175TEST_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 193TEST_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 220