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