OLD | NEW |
1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/callback.h" | 6 #include "base/callback.h" |
7 #include "base/json/json_reader.h" | 7 #include "base/json/json_reader.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/prefs/pref_value_map.h" | 9 #include "base/prefs/pref_value_map.h" |
10 #include "base/values.h" | 10 #include "base/values.h" |
11 #include "components/policy/core/browser/configuration_policy_handler.h" | 11 #include "components/policy/core/browser/configuration_policy_handler.h" |
12 #include "components/policy/core/browser/policy_error_map.h" | 12 #include "components/policy/core/browser/policy_error_map.h" |
13 #include "components/policy/core/common/policy_map.h" | 13 #include "components/policy/core/common/policy_map.h" |
| 14 #include "components/policy/core/common/policy_types.h" |
14 #include "components/policy/core/common/schema.h" | 15 #include "components/policy/core/common/schema.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 | 17 |
17 namespace policy { | 18 namespace policy { |
18 | 19 |
19 namespace { | 20 namespace { |
20 | 21 |
21 void GetIntegerTypeMap( | 22 void GetIntegerTypeMap( |
22 ScopedVector<StringMappingListPolicyHandler::MappingEntry>* result) { | 23 ScopedVector<StringMappingListPolicyHandler::MappingEntry>* result) { |
23 result->push_back(new StringMappingListPolicyHandler::MappingEntry( | 24 result->push_back(new StringMappingListPolicyHandler::MappingEntry( |
(...skipping 25 matching lines...) Expand all Loading... |
49 | 50 |
50 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) { | 51 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) { |
51 base::ListValue list; | 52 base::ListValue list; |
52 PolicyMap policy_map; | 53 PolicyMap policy_map; |
53 PolicyErrorMap errors; | 54 PolicyErrorMap errors; |
54 StringMappingListPolicyHandler handler( | 55 StringMappingListPolicyHandler handler( |
55 kTestPolicy, | 56 kTestPolicy, |
56 kTestPref, | 57 kTestPref, |
57 base::Bind(GetIntegerTypeMap)); | 58 base::Bind(GetIntegerTypeMap)); |
58 | 59 |
59 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 60 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
60 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 61 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
61 errors.Clear(); | 62 errors.Clear(); |
62 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 63 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
63 EXPECT_TRUE(errors.empty()); | 64 EXPECT_TRUE(errors.empty()); |
64 | 65 |
65 list.AppendString("one"); | 66 list.AppendString("one"); |
66 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 67 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
67 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 68 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
68 errors.Clear(); | 69 errors.Clear(); |
69 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 70 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
70 EXPECT_TRUE(errors.empty()); | 71 EXPECT_TRUE(errors.empty()); |
71 | 72 |
72 list.AppendString("invalid"); | 73 list.AppendString("invalid"); |
73 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 74 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
74 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 75 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
75 errors.Clear(); | 76 errors.Clear(); |
76 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 77 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
77 EXPECT_FALSE(errors.empty()); | 78 EXPECT_FALSE(errors.empty()); |
78 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); | 79 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); |
79 | 80 |
80 policy_map.Set(kTestPolicy, | 81 policy_map.Set(kTestPolicy, |
81 POLICY_LEVEL_MANDATORY, | 82 POLICY_LEVEL_MANDATORY, |
82 POLICY_SCOPE_USER, | 83 POLICY_SCOPE_USER, |
| 84 POLICY_SOURCE_CLOUD, |
83 new base::StringValue("no list"), | 85 new base::StringValue("no list"), |
84 NULL); | 86 NULL); |
85 errors.Clear(); | 87 errors.Clear(); |
86 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 88 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
87 EXPECT_FALSE(errors.empty()); | 89 EXPECT_FALSE(errors.empty()); |
88 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); | 90 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); |
89 } | 91 } |
90 | 92 |
91 TEST(StringMappingListPolicyHandlerTest, ApplyPolicySettings) { | 93 TEST(StringMappingListPolicyHandlerTest, ApplyPolicySettings) { |
92 base::ListValue list; | 94 base::ListValue list; |
93 base::ListValue expected; | 95 base::ListValue expected; |
94 PolicyMap policy_map; | 96 PolicyMap policy_map; |
95 PrefValueMap prefs; | 97 PrefValueMap prefs; |
96 base::Value* value; | 98 base::Value* value; |
97 StringMappingListPolicyHandler handler( | 99 StringMappingListPolicyHandler handler( |
98 kTestPolicy, | 100 kTestPolicy, |
99 kTestPref, | 101 kTestPref, |
100 base::Bind(GetIntegerTypeMap)); | 102 base::Bind(GetIntegerTypeMap)); |
101 | 103 |
102 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 104 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
103 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 105 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
104 handler.ApplyPolicySettings(policy_map, &prefs); | 106 handler.ApplyPolicySettings(policy_map, &prefs); |
105 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 107 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
106 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 108 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
107 | 109 |
108 list.AppendString("two"); | 110 list.AppendString("two"); |
109 expected.AppendInteger(2); | 111 expected.AppendInteger(2); |
110 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 112 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
111 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 113 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
112 handler.ApplyPolicySettings(policy_map, &prefs); | 114 handler.ApplyPolicySettings(policy_map, &prefs); |
113 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 115 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
114 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 116 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
115 | 117 |
116 list.AppendString("invalid"); | 118 list.AppendString("invalid"); |
117 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, | 119 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
118 POLICY_SCOPE_USER, list.DeepCopy(), NULL); | 120 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); |
119 handler.ApplyPolicySettings(policy_map, &prefs); | 121 handler.ApplyPolicySettings(policy_map, &prefs); |
120 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 122 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
121 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 123 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
122 } | 124 } |
123 | 125 |
124 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) { | 126 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) { |
125 PolicyMap policy_map; | 127 PolicyMap policy_map; |
126 PolicyErrorMap errors; | 128 PolicyErrorMap errors; |
127 | 129 |
128 // This tests needs to modify an int policy. The exact policy used and its | 130 // This tests needs to modify an int policy. The exact policy used and its |
129 // semantics outside the test are irrelevant. | 131 // semantics outside the test are irrelevant. |
130 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 132 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
131 | 133 |
132 // Check that values lying in the accepted range are not rejected. | 134 // Check that values lying in the accepted range are not rejected. |
133 policy_map.Set(kTestPolicy, | 135 policy_map.Set(kTestPolicy, |
134 POLICY_LEVEL_MANDATORY, | 136 POLICY_LEVEL_MANDATORY, |
135 POLICY_SCOPE_USER, | 137 POLICY_SCOPE_USER, |
| 138 POLICY_SOURCE_CLOUD, |
136 new base::FundamentalValue(0), | 139 new base::FundamentalValue(0), |
137 NULL); | 140 NULL); |
138 errors.Clear(); | 141 errors.Clear(); |
139 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 142 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
140 EXPECT_TRUE(errors.empty()); | 143 EXPECT_TRUE(errors.empty()); |
141 | 144 |
142 policy_map.Set(kTestPolicy, | 145 policy_map.Set(kTestPolicy, |
143 POLICY_LEVEL_MANDATORY, | 146 POLICY_LEVEL_MANDATORY, |
144 POLICY_SCOPE_USER, | 147 POLICY_SCOPE_USER, |
| 148 POLICY_SOURCE_CLOUD, |
145 new base::FundamentalValue(5), | 149 new base::FundamentalValue(5), |
146 NULL); | 150 NULL); |
147 errors.Clear(); | 151 errors.Clear(); |
148 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 152 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
149 EXPECT_TRUE(errors.empty()); | 153 EXPECT_TRUE(errors.empty()); |
150 | 154 |
151 policy_map.Set(kTestPolicy, | 155 policy_map.Set(kTestPolicy, |
152 POLICY_LEVEL_MANDATORY, | 156 POLICY_LEVEL_MANDATORY, |
153 POLICY_SCOPE_USER, | 157 POLICY_SCOPE_USER, |
| 158 POLICY_SOURCE_CLOUD, |
154 new base::FundamentalValue(10), | 159 new base::FundamentalValue(10), |
155 NULL); | 160 NULL); |
156 errors.Clear(); | 161 errors.Clear(); |
157 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 162 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
158 EXPECT_TRUE(errors.empty()); | 163 EXPECT_TRUE(errors.empty()); |
159 | 164 |
160 // Check that values lying outside the accepted range are not rejected | 165 // Check that values lying outside the accepted range are not rejected |
161 // (because clamping is enabled) but do yield a warning message. | 166 // (because clamping is enabled) but do yield a warning message. |
162 policy_map.Set(kTestPolicy, | 167 policy_map.Set(kTestPolicy, |
163 POLICY_LEVEL_MANDATORY, | 168 POLICY_LEVEL_MANDATORY, |
164 POLICY_SCOPE_USER, | 169 POLICY_SCOPE_USER, |
| 170 POLICY_SOURCE_CLOUD, |
165 new base::FundamentalValue(-5), | 171 new base::FundamentalValue(-5), |
166 NULL); | 172 NULL); |
167 errors.Clear(); | 173 errors.Clear(); |
168 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 174 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
169 EXPECT_FALSE(errors.empty()); | 175 EXPECT_FALSE(errors.empty()); |
170 | 176 |
171 policy_map.Set(kTestPolicy, | 177 policy_map.Set(kTestPolicy, |
172 POLICY_LEVEL_MANDATORY, | 178 POLICY_LEVEL_MANDATORY, |
173 POLICY_SCOPE_USER, | 179 POLICY_SCOPE_USER, |
| 180 POLICY_SOURCE_CLOUD, |
174 new base::FundamentalValue(15), | 181 new base::FundamentalValue(15), |
175 NULL); | 182 NULL); |
176 errors.Clear(); | 183 errors.Clear(); |
177 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 184 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
178 EXPECT_FALSE(errors.empty()); | 185 EXPECT_FALSE(errors.empty()); |
179 | 186 |
180 // Check that an entirely invalid value is rejected and yields an error | 187 // Check that an entirely invalid value is rejected and yields an error |
181 // message. | 188 // message. |
182 policy_map.Set(kTestPolicy, | 189 policy_map.Set(kTestPolicy, |
183 POLICY_LEVEL_MANDATORY, | 190 POLICY_LEVEL_MANDATORY, |
184 POLICY_SCOPE_USER, | 191 POLICY_SCOPE_USER, |
| 192 POLICY_SOURCE_CLOUD, |
185 new base::StringValue("invalid"), | 193 new base::StringValue("invalid"), |
186 NULL); | 194 NULL); |
187 errors.Clear(); | 195 errors.Clear(); |
188 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 196 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
189 EXPECT_FALSE(errors.empty()); | 197 EXPECT_FALSE(errors.empty()); |
190 } | 198 } |
191 | 199 |
192 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { | 200 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { |
193 PolicyMap policy_map; | 201 PolicyMap policy_map; |
194 PolicyErrorMap errors; | 202 PolicyErrorMap errors; |
195 | 203 |
196 // This tests needs to modify an int policy. The exact policy used and its | 204 // This tests needs to modify an int policy. The exact policy used and its |
197 // semantics outside the test are irrelevant. | 205 // semantics outside the test are irrelevant. |
198 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); | 206 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); |
199 | 207 |
200 // Check that values lying in the accepted range are not rejected. | 208 // Check that values lying in the accepted range are not rejected. |
201 policy_map.Set(kTestPolicy, | 209 policy_map.Set(kTestPolicy, |
202 POLICY_LEVEL_MANDATORY, | 210 POLICY_LEVEL_MANDATORY, |
203 POLICY_SCOPE_USER, | 211 POLICY_SCOPE_USER, |
| 212 POLICY_SOURCE_CLOUD, |
204 new base::FundamentalValue(0), | 213 new base::FundamentalValue(0), |
205 NULL); | 214 NULL); |
206 errors.Clear(); | 215 errors.Clear(); |
207 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 216 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
208 EXPECT_TRUE(errors.empty()); | 217 EXPECT_TRUE(errors.empty()); |
209 | 218 |
210 policy_map.Set(kTestPolicy, | 219 policy_map.Set(kTestPolicy, |
211 POLICY_LEVEL_MANDATORY, | 220 POLICY_LEVEL_MANDATORY, |
212 POLICY_SCOPE_USER, | 221 POLICY_SCOPE_USER, |
| 222 POLICY_SOURCE_CLOUD, |
213 new base::FundamentalValue(5), | 223 new base::FundamentalValue(5), |
214 NULL); | 224 NULL); |
215 errors.Clear(); | 225 errors.Clear(); |
216 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 226 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
217 EXPECT_TRUE(errors.empty()); | 227 EXPECT_TRUE(errors.empty()); |
218 | 228 |
219 policy_map.Set(kTestPolicy, | 229 policy_map.Set(kTestPolicy, |
220 POLICY_LEVEL_MANDATORY, | 230 POLICY_LEVEL_MANDATORY, |
221 POLICY_SCOPE_USER, | 231 POLICY_SCOPE_USER, |
| 232 POLICY_SOURCE_CLOUD, |
222 new base::FundamentalValue(10), | 233 new base::FundamentalValue(10), |
223 NULL); | 234 NULL); |
224 errors.Clear(); | 235 errors.Clear(); |
225 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 236 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
226 EXPECT_TRUE(errors.empty()); | 237 EXPECT_TRUE(errors.empty()); |
227 | 238 |
228 // Check that values lying outside the accepted range are rejected and yield | 239 // Check that values lying outside the accepted range are rejected and yield |
229 // an error message. | 240 // an error message. |
230 policy_map.Set(kTestPolicy, | 241 policy_map.Set(kTestPolicy, |
231 POLICY_LEVEL_MANDATORY, | 242 POLICY_LEVEL_MANDATORY, |
232 POLICY_SCOPE_USER, | 243 POLICY_SCOPE_USER, |
| 244 POLICY_SOURCE_CLOUD, |
233 new base::FundamentalValue(-5), | 245 new base::FundamentalValue(-5), |
234 NULL); | 246 NULL); |
235 errors.Clear(); | 247 errors.Clear(); |
236 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 248 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
237 EXPECT_FALSE(errors.empty()); | 249 EXPECT_FALSE(errors.empty()); |
238 | 250 |
239 policy_map.Set(kTestPolicy, | 251 policy_map.Set(kTestPolicy, |
240 POLICY_LEVEL_MANDATORY, | 252 POLICY_LEVEL_MANDATORY, |
241 POLICY_SCOPE_USER, | 253 POLICY_SCOPE_USER, |
| 254 POLICY_SOURCE_CLOUD, |
242 new base::FundamentalValue(15), | 255 new base::FundamentalValue(15), |
243 NULL); | 256 NULL); |
244 errors.Clear(); | 257 errors.Clear(); |
245 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 258 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
246 EXPECT_FALSE(errors.empty()); | 259 EXPECT_FALSE(errors.empty()); |
247 | 260 |
248 // Check that an entirely invalid value is rejected and yields an error | 261 // Check that an entirely invalid value is rejected and yields an error |
249 // message. | 262 // message. |
250 policy_map.Set(kTestPolicy, | 263 policy_map.Set(kTestPolicy, |
251 POLICY_LEVEL_MANDATORY, | 264 POLICY_LEVEL_MANDATORY, |
252 POLICY_SCOPE_USER, | 265 POLICY_SCOPE_USER, |
| 266 POLICY_SOURCE_CLOUD, |
253 new base::StringValue("invalid"), | 267 new base::StringValue("invalid"), |
254 NULL); | 268 NULL); |
255 errors.Clear(); | 269 errors.Clear(); |
256 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 270 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
257 EXPECT_FALSE(errors.empty()); | 271 EXPECT_FALSE(errors.empty()); |
258 } | 272 } |
259 | 273 |
260 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { | 274 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { |
261 PolicyMap policy_map; | 275 PolicyMap policy_map; |
262 PrefValueMap prefs; | 276 PrefValueMap prefs; |
263 scoped_ptr<base::Value> expected; | 277 scoped_ptr<base::Value> expected; |
264 const base::Value* value; | 278 const base::Value* value; |
265 | 279 |
266 // This tests needs to modify an int policy. The exact policy used and its | 280 // This tests needs to modify an int policy. The exact policy used and its |
267 // semantics outside the test are irrelevant. | 281 // semantics outside the test are irrelevant. |
268 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 282 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
269 | 283 |
270 // Check that values lying in the accepted range are written to the pref. | 284 // Check that values lying in the accepted range are written to the pref. |
271 policy_map.Set(kTestPolicy, | 285 policy_map.Set(kTestPolicy, |
272 POLICY_LEVEL_MANDATORY, | 286 POLICY_LEVEL_MANDATORY, |
273 POLICY_SCOPE_USER, | 287 POLICY_SCOPE_USER, |
| 288 POLICY_SOURCE_CLOUD, |
274 new base::FundamentalValue(0), | 289 new base::FundamentalValue(0), |
275 NULL); | 290 NULL); |
276 prefs.Clear(); | 291 prefs.Clear(); |
277 handler.ApplyPolicySettings(policy_map, &prefs); | 292 handler.ApplyPolicySettings(policy_map, &prefs); |
278 expected.reset(new base::FundamentalValue(0)); | 293 expected.reset(new base::FundamentalValue(0)); |
279 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 294 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
280 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 295 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
281 | 296 |
282 policy_map.Set(kTestPolicy, | 297 policy_map.Set(kTestPolicy, |
283 POLICY_LEVEL_MANDATORY, | 298 POLICY_LEVEL_MANDATORY, |
284 POLICY_SCOPE_USER, | 299 POLICY_SCOPE_USER, |
| 300 POLICY_SOURCE_CLOUD, |
285 new base::FundamentalValue(5), | 301 new base::FundamentalValue(5), |
286 NULL); | 302 NULL); |
287 prefs.Clear(); | 303 prefs.Clear(); |
288 handler.ApplyPolicySettings(policy_map, &prefs); | 304 handler.ApplyPolicySettings(policy_map, &prefs); |
289 expected.reset(new base::FundamentalValue(5)); | 305 expected.reset(new base::FundamentalValue(5)); |
290 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 306 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
291 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 307 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
292 | 308 |
293 policy_map.Set(kTestPolicy, | 309 policy_map.Set(kTestPolicy, |
294 POLICY_LEVEL_MANDATORY, | 310 POLICY_LEVEL_MANDATORY, |
295 POLICY_SCOPE_USER, | 311 POLICY_SCOPE_USER, |
| 312 POLICY_SOURCE_CLOUD, |
296 new base::FundamentalValue(10), | 313 new base::FundamentalValue(10), |
297 NULL); | 314 NULL); |
298 prefs.Clear(); | 315 prefs.Clear(); |
299 handler.ApplyPolicySettings(policy_map, &prefs); | 316 handler.ApplyPolicySettings(policy_map, &prefs); |
300 expected.reset(new base::FundamentalValue(10)); | 317 expected.reset(new base::FundamentalValue(10)); |
301 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 318 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
302 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 319 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
303 | 320 |
304 // Check that values lying outside the accepted range are clamped and written | 321 // Check that values lying outside the accepted range are clamped and written |
305 // to the pref. | 322 // to the pref. |
306 policy_map.Set(kTestPolicy, | 323 policy_map.Set(kTestPolicy, |
307 POLICY_LEVEL_MANDATORY, | 324 POLICY_LEVEL_MANDATORY, |
308 POLICY_SCOPE_USER, | 325 POLICY_SCOPE_USER, |
| 326 POLICY_SOURCE_CLOUD, |
309 new base::FundamentalValue(-5), | 327 new base::FundamentalValue(-5), |
310 NULL); | 328 NULL); |
311 prefs.Clear(); | 329 prefs.Clear(); |
312 handler.ApplyPolicySettings(policy_map, &prefs); | 330 handler.ApplyPolicySettings(policy_map, &prefs); |
313 expected.reset(new base::FundamentalValue(0)); | 331 expected.reset(new base::FundamentalValue(0)); |
314 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 332 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
315 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 333 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
316 | 334 |
317 policy_map.Set(kTestPolicy, | 335 policy_map.Set(kTestPolicy, |
318 POLICY_LEVEL_MANDATORY, | 336 POLICY_LEVEL_MANDATORY, |
319 POLICY_SCOPE_USER, | 337 POLICY_SCOPE_USER, |
| 338 POLICY_SOURCE_CLOUD, |
320 new base::FundamentalValue(15), | 339 new base::FundamentalValue(15), |
321 NULL); | 340 NULL); |
322 prefs.Clear(); | 341 prefs.Clear(); |
323 handler.ApplyPolicySettings(policy_map, &prefs); | 342 handler.ApplyPolicySettings(policy_map, &prefs); |
324 expected.reset(new base::FundamentalValue(10)); | 343 expected.reset(new base::FundamentalValue(10)); |
325 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 344 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
326 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 345 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
327 } | 346 } |
328 | 347 |
329 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { | 348 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { |
330 PolicyMap policy_map; | 349 PolicyMap policy_map; |
331 PrefValueMap prefs; | 350 PrefValueMap prefs; |
332 scoped_ptr<base::Value> expected; | 351 scoped_ptr<base::Value> expected; |
333 const base::Value* value; | 352 const base::Value* value; |
334 | 353 |
335 // This tests needs to modify an int policy. The exact policy used and its | 354 // This tests needs to modify an int policy. The exact policy used and its |
336 // semantics outside the test are irrelevant. | 355 // semantics outside the test are irrelevant. |
337 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 356 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
338 | 357 |
339 // Check that values lying in the accepted range are written to the pref. | 358 // Check that values lying in the accepted range are written to the pref. |
340 policy_map.Set(kTestPolicy, | 359 policy_map.Set(kTestPolicy, |
341 POLICY_LEVEL_MANDATORY, | 360 POLICY_LEVEL_MANDATORY, |
342 POLICY_SCOPE_USER, | 361 POLICY_SCOPE_USER, |
| 362 POLICY_SOURCE_CLOUD, |
343 new base::FundamentalValue(0), | 363 new base::FundamentalValue(0), |
344 NULL); | 364 NULL); |
345 prefs.Clear(); | 365 prefs.Clear(); |
346 handler.ApplyPolicySettings(policy_map, &prefs); | 366 handler.ApplyPolicySettings(policy_map, &prefs); |
347 expected.reset(new base::FundamentalValue(0)); | 367 expected.reset(new base::FundamentalValue(0)); |
348 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 368 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
349 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 369 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
350 | 370 |
351 policy_map.Set(kTestPolicy, | 371 policy_map.Set(kTestPolicy, |
352 POLICY_LEVEL_MANDATORY, | 372 POLICY_LEVEL_MANDATORY, |
353 POLICY_SCOPE_USER, | 373 POLICY_SCOPE_USER, |
| 374 POLICY_SOURCE_CLOUD, |
354 new base::FundamentalValue(5), | 375 new base::FundamentalValue(5), |
355 NULL); | 376 NULL); |
356 prefs.Clear(); | 377 prefs.Clear(); |
357 handler.ApplyPolicySettings(policy_map, &prefs); | 378 handler.ApplyPolicySettings(policy_map, &prefs); |
358 expected.reset(new base::FundamentalValue(5)); | 379 expected.reset(new base::FundamentalValue(5)); |
359 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 380 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
360 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 381 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
361 | 382 |
362 policy_map.Set(kTestPolicy, | 383 policy_map.Set(kTestPolicy, |
363 POLICY_LEVEL_MANDATORY, | 384 POLICY_LEVEL_MANDATORY, |
364 POLICY_SCOPE_USER, | 385 POLICY_SCOPE_USER, |
| 386 POLICY_SOURCE_CLOUD, |
365 new base::FundamentalValue(10), | 387 new base::FundamentalValue(10), |
366 NULL); | 388 NULL); |
367 prefs.Clear(); | 389 prefs.Clear(); |
368 handler.ApplyPolicySettings(policy_map, &prefs); | 390 handler.ApplyPolicySettings(policy_map, &prefs); |
369 expected.reset(new base::FundamentalValue(10)); | 391 expected.reset(new base::FundamentalValue(10)); |
370 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 392 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
371 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 393 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
372 } | 394 } |
373 | 395 |
374 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { | 396 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { |
375 PolicyMap policy_map; | 397 PolicyMap policy_map; |
376 PolicyErrorMap errors; | 398 PolicyErrorMap errors; |
377 | 399 |
378 // This tests needs to modify an int policy. The exact policy used and its | 400 // This tests needs to modify an int policy. The exact policy used and its |
379 // semantics outside the test are irrelevant. | 401 // semantics outside the test are irrelevant. |
380 IntPercentageToDoublePolicyHandler handler( | 402 IntPercentageToDoublePolicyHandler handler( |
381 kTestPolicy, kTestPref, 0, 10, true); | 403 kTestPolicy, kTestPref, 0, 10, true); |
382 | 404 |
383 // Check that values lying in the accepted range are not rejected. | 405 // Check that values lying in the accepted range are not rejected. |
384 policy_map.Set(kTestPolicy, | 406 policy_map.Set(kTestPolicy, |
385 POLICY_LEVEL_MANDATORY, | 407 POLICY_LEVEL_MANDATORY, |
386 POLICY_SCOPE_USER, | 408 POLICY_SCOPE_USER, |
| 409 POLICY_SOURCE_CLOUD, |
387 new base::FundamentalValue(0), | 410 new base::FundamentalValue(0), |
388 NULL); | 411 NULL); |
389 errors.Clear(); | 412 errors.Clear(); |
390 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 413 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
391 EXPECT_TRUE(errors.empty()); | 414 EXPECT_TRUE(errors.empty()); |
392 | 415 |
393 policy_map.Set(kTestPolicy, | 416 policy_map.Set(kTestPolicy, |
394 POLICY_LEVEL_MANDATORY, | 417 POLICY_LEVEL_MANDATORY, |
395 POLICY_SCOPE_USER, | 418 POLICY_SCOPE_USER, |
| 419 POLICY_SOURCE_CLOUD, |
396 new base::FundamentalValue(5), | 420 new base::FundamentalValue(5), |
397 NULL); | 421 NULL); |
398 errors.Clear(); | 422 errors.Clear(); |
399 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 423 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
400 EXPECT_TRUE(errors.empty()); | 424 EXPECT_TRUE(errors.empty()); |
401 | 425 |
402 policy_map.Set(kTestPolicy, | 426 policy_map.Set(kTestPolicy, |
403 POLICY_LEVEL_MANDATORY, | 427 POLICY_LEVEL_MANDATORY, |
404 POLICY_SCOPE_USER, | 428 POLICY_SCOPE_USER, |
| 429 POLICY_SOURCE_CLOUD, |
405 new base::FundamentalValue(10), | 430 new base::FundamentalValue(10), |
406 NULL); | 431 NULL); |
407 errors.Clear(); | 432 errors.Clear(); |
408 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 433 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
409 EXPECT_TRUE(errors.empty()); | 434 EXPECT_TRUE(errors.empty()); |
410 | 435 |
411 // Check that values lying outside the accepted range are not rejected | 436 // Check that values lying outside the accepted range are not rejected |
412 // (because clamping is enabled) but do yield a warning message. | 437 // (because clamping is enabled) but do yield a warning message. |
413 policy_map.Set(kTestPolicy, | 438 policy_map.Set(kTestPolicy, |
414 POLICY_LEVEL_MANDATORY, | 439 POLICY_LEVEL_MANDATORY, |
415 POLICY_SCOPE_USER, | 440 POLICY_SCOPE_USER, |
| 441 POLICY_SOURCE_CLOUD, |
416 new base::FundamentalValue(-5), | 442 new base::FundamentalValue(-5), |
417 NULL); | 443 NULL); |
418 errors.Clear(); | 444 errors.Clear(); |
419 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 445 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
420 EXPECT_FALSE(errors.empty()); | 446 EXPECT_FALSE(errors.empty()); |
421 | 447 |
422 policy_map.Set(kTestPolicy, | 448 policy_map.Set(kTestPolicy, |
423 POLICY_LEVEL_MANDATORY, | 449 POLICY_LEVEL_MANDATORY, |
424 POLICY_SCOPE_USER, | 450 POLICY_SCOPE_USER, |
| 451 POLICY_SOURCE_CLOUD, |
425 new base::FundamentalValue(15), | 452 new base::FundamentalValue(15), |
426 NULL); | 453 NULL); |
427 errors.Clear(); | 454 errors.Clear(); |
428 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 455 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
429 EXPECT_FALSE(errors.empty()); | 456 EXPECT_FALSE(errors.empty()); |
430 | 457 |
431 // Check that an entirely invalid value is rejected and yields an error | 458 // Check that an entirely invalid value is rejected and yields an error |
432 // message. | 459 // message. |
433 policy_map.Set(kTestPolicy, | 460 policy_map.Set(kTestPolicy, |
434 POLICY_LEVEL_MANDATORY, | 461 POLICY_LEVEL_MANDATORY, |
435 POLICY_SCOPE_USER, | 462 POLICY_SCOPE_USER, |
| 463 POLICY_SOURCE_CLOUD, |
436 new base::StringValue("invalid"), | 464 new base::StringValue("invalid"), |
437 NULL); | 465 NULL); |
438 errors.Clear(); | 466 errors.Clear(); |
439 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 467 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
440 EXPECT_FALSE(errors.empty()); | 468 EXPECT_FALSE(errors.empty()); |
441 } | 469 } |
442 | 470 |
443 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { | 471 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { |
444 PolicyMap policy_map; | 472 PolicyMap policy_map; |
445 PolicyErrorMap errors; | 473 PolicyErrorMap errors; |
446 | 474 |
447 // This tests needs to modify an int policy. The exact policy used and its | 475 // This tests needs to modify an int policy. The exact policy used and its |
448 // semantics outside the test are irrelevant. | 476 // semantics outside the test are irrelevant. |
449 IntPercentageToDoublePolicyHandler handler( | 477 IntPercentageToDoublePolicyHandler handler( |
450 kTestPolicy, kTestPref, 0, 10, false); | 478 kTestPolicy, kTestPref, 0, 10, false); |
451 | 479 |
452 // Check that values lying in the accepted range are not rejected. | 480 // Check that values lying in the accepted range are not rejected. |
453 policy_map.Set(kTestPolicy, | 481 policy_map.Set(kTestPolicy, |
454 POLICY_LEVEL_MANDATORY, | 482 POLICY_LEVEL_MANDATORY, |
455 POLICY_SCOPE_USER, | 483 POLICY_SCOPE_USER, |
| 484 POLICY_SOURCE_CLOUD, |
456 new base::FundamentalValue(0), | 485 new base::FundamentalValue(0), |
457 NULL); | 486 NULL); |
458 errors.Clear(); | 487 errors.Clear(); |
459 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 488 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
460 EXPECT_TRUE(errors.empty()); | 489 EXPECT_TRUE(errors.empty()); |
461 | 490 |
462 policy_map.Set(kTestPolicy, | 491 policy_map.Set(kTestPolicy, |
463 POLICY_LEVEL_MANDATORY, | 492 POLICY_LEVEL_MANDATORY, |
464 POLICY_SCOPE_USER, | 493 POLICY_SCOPE_USER, |
| 494 POLICY_SOURCE_CLOUD, |
465 new base::FundamentalValue(5), | 495 new base::FundamentalValue(5), |
466 NULL); | 496 NULL); |
467 errors.Clear(); | 497 errors.Clear(); |
468 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 498 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
469 EXPECT_TRUE(errors.empty()); | 499 EXPECT_TRUE(errors.empty()); |
470 | 500 |
471 policy_map.Set(kTestPolicy, | 501 policy_map.Set(kTestPolicy, |
472 POLICY_LEVEL_MANDATORY, | 502 POLICY_LEVEL_MANDATORY, |
473 POLICY_SCOPE_USER, | 503 POLICY_SCOPE_USER, |
| 504 POLICY_SOURCE_CLOUD, |
474 new base::FundamentalValue(10), | 505 new base::FundamentalValue(10), |
475 NULL); | 506 NULL); |
476 errors.Clear(); | 507 errors.Clear(); |
477 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 508 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
478 EXPECT_TRUE(errors.empty()); | 509 EXPECT_TRUE(errors.empty()); |
479 | 510 |
480 // Check that values lying outside the accepted range are rejected and yield | 511 // Check that values lying outside the accepted range are rejected and yield |
481 // an error message. | 512 // an error message. |
482 policy_map.Set(kTestPolicy, | 513 policy_map.Set(kTestPolicy, |
483 POLICY_LEVEL_MANDATORY, | 514 POLICY_LEVEL_MANDATORY, |
484 POLICY_SCOPE_USER, | 515 POLICY_SCOPE_USER, |
| 516 POLICY_SOURCE_CLOUD, |
485 new base::FundamentalValue(-5), | 517 new base::FundamentalValue(-5), |
486 NULL); | 518 NULL); |
487 errors.Clear(); | 519 errors.Clear(); |
488 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 520 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
489 EXPECT_FALSE(errors.empty()); | 521 EXPECT_FALSE(errors.empty()); |
490 | 522 |
491 policy_map.Set(kTestPolicy, | 523 policy_map.Set(kTestPolicy, |
492 POLICY_LEVEL_MANDATORY, | 524 POLICY_LEVEL_MANDATORY, |
493 POLICY_SCOPE_USER, | 525 POLICY_SCOPE_USER, |
| 526 POLICY_SOURCE_CLOUD, |
494 new base::FundamentalValue(15), | 527 new base::FundamentalValue(15), |
495 NULL); | 528 NULL); |
496 errors.Clear(); | 529 errors.Clear(); |
497 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 530 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
498 EXPECT_FALSE(errors.empty()); | 531 EXPECT_FALSE(errors.empty()); |
499 | 532 |
500 // Check that an entirely invalid value is rejected and yields an error | 533 // Check that an entirely invalid value is rejected and yields an error |
501 // message. | 534 // message. |
502 policy_map.Set(kTestPolicy, | 535 policy_map.Set(kTestPolicy, |
503 POLICY_LEVEL_MANDATORY, | 536 POLICY_LEVEL_MANDATORY, |
504 POLICY_SCOPE_USER, | 537 POLICY_SCOPE_USER, |
| 538 POLICY_SOURCE_CLOUD, |
505 new base::StringValue("invalid"), | 539 new base::StringValue("invalid"), |
506 NULL); | 540 NULL); |
507 errors.Clear(); | 541 errors.Clear(); |
508 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 542 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
509 EXPECT_FALSE(errors.empty()); | 543 EXPECT_FALSE(errors.empty()); |
510 } | 544 } |
511 | 545 |
512 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { | 546 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { |
513 PolicyMap policy_map; | 547 PolicyMap policy_map; |
514 PrefValueMap prefs; | 548 PrefValueMap prefs; |
515 scoped_ptr<base::Value> expected; | 549 scoped_ptr<base::Value> expected; |
516 const base::Value* value; | 550 const base::Value* value; |
517 | 551 |
518 // This tests needs to modify an int policy. The exact policy used and its | 552 // This tests needs to modify an int policy. The exact policy used and its |
519 // semantics outside the test are irrelevant. | 553 // semantics outside the test are irrelevant. |
520 IntPercentageToDoublePolicyHandler handler( | 554 IntPercentageToDoublePolicyHandler handler( |
521 kTestPolicy, kTestPref, 0, 10, true); | 555 kTestPolicy, kTestPref, 0, 10, true); |
522 | 556 |
523 // Check that values lying in the accepted range are written to the pref. | 557 // Check that values lying in the accepted range are written to the pref. |
524 policy_map.Set(kTestPolicy, | 558 policy_map.Set(kTestPolicy, |
525 POLICY_LEVEL_MANDATORY, | 559 POLICY_LEVEL_MANDATORY, |
526 POLICY_SCOPE_USER, | 560 POLICY_SCOPE_USER, |
| 561 POLICY_SOURCE_CLOUD, |
527 new base::FundamentalValue(0), | 562 new base::FundamentalValue(0), |
528 NULL); | 563 NULL); |
529 prefs.Clear(); | 564 prefs.Clear(); |
530 handler.ApplyPolicySettings(policy_map, &prefs); | 565 handler.ApplyPolicySettings(policy_map, &prefs); |
531 expected.reset(new base::FundamentalValue(0.0)); | 566 expected.reset(new base::FundamentalValue(0.0)); |
532 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 567 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
533 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 568 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
534 | 569 |
535 policy_map.Set(kTestPolicy, | 570 policy_map.Set(kTestPolicy, |
536 POLICY_LEVEL_MANDATORY, | 571 POLICY_LEVEL_MANDATORY, |
537 POLICY_SCOPE_USER, | 572 POLICY_SCOPE_USER, |
| 573 POLICY_SOURCE_CLOUD, |
538 new base::FundamentalValue(5), | 574 new base::FundamentalValue(5), |
539 NULL); | 575 NULL); |
540 prefs.Clear(); | 576 prefs.Clear(); |
541 handler.ApplyPolicySettings(policy_map, &prefs); | 577 handler.ApplyPolicySettings(policy_map, &prefs); |
542 expected.reset(new base::FundamentalValue(0.05)); | 578 expected.reset(new base::FundamentalValue(0.05)); |
543 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 579 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
544 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 580 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
545 | 581 |
546 policy_map.Set(kTestPolicy, | 582 policy_map.Set(kTestPolicy, |
547 POLICY_LEVEL_MANDATORY, | 583 POLICY_LEVEL_MANDATORY, |
548 POLICY_SCOPE_USER, | 584 POLICY_SCOPE_USER, |
| 585 POLICY_SOURCE_CLOUD, |
549 new base::FundamentalValue(10), | 586 new base::FundamentalValue(10), |
550 NULL); | 587 NULL); |
551 prefs.Clear(); | 588 prefs.Clear(); |
552 handler.ApplyPolicySettings(policy_map, &prefs); | 589 handler.ApplyPolicySettings(policy_map, &prefs); |
553 expected.reset(new base::FundamentalValue(0.1)); | 590 expected.reset(new base::FundamentalValue(0.1)); |
554 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 591 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
555 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 592 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
556 | 593 |
557 // Check that values lying outside the accepted range are clamped and written | 594 // Check that values lying outside the accepted range are clamped and written |
558 // to the pref. | 595 // to the pref. |
559 policy_map.Set(kTestPolicy, | 596 policy_map.Set(kTestPolicy, |
560 POLICY_LEVEL_MANDATORY, | 597 POLICY_LEVEL_MANDATORY, |
561 POLICY_SCOPE_USER, | 598 POLICY_SCOPE_USER, |
| 599 POLICY_SOURCE_CLOUD, |
562 new base::FundamentalValue(-5), | 600 new base::FundamentalValue(-5), |
563 NULL); | 601 NULL); |
564 prefs.Clear(); | 602 prefs.Clear(); |
565 handler.ApplyPolicySettings(policy_map, &prefs); | 603 handler.ApplyPolicySettings(policy_map, &prefs); |
566 expected.reset(new base::FundamentalValue(0.0)); | 604 expected.reset(new base::FundamentalValue(0.0)); |
567 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 605 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
568 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 606 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
569 | 607 |
570 policy_map.Set(kTestPolicy, | 608 policy_map.Set(kTestPolicy, |
571 POLICY_LEVEL_MANDATORY, | 609 POLICY_LEVEL_MANDATORY, |
572 POLICY_SCOPE_USER, | 610 POLICY_SCOPE_USER, |
| 611 POLICY_SOURCE_CLOUD, |
573 new base::FundamentalValue(15), | 612 new base::FundamentalValue(15), |
574 NULL); | 613 NULL); |
575 prefs.Clear(); | 614 prefs.Clear(); |
576 handler.ApplyPolicySettings(policy_map, &prefs); | 615 handler.ApplyPolicySettings(policy_map, &prefs); |
577 expected.reset(new base::FundamentalValue(0.1)); | 616 expected.reset(new base::FundamentalValue(0.1)); |
578 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 617 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
579 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 618 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
580 } | 619 } |
581 | 620 |
582 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { | 621 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { |
583 PolicyMap policy_map; | 622 PolicyMap policy_map; |
584 PrefValueMap prefs; | 623 PrefValueMap prefs; |
585 scoped_ptr<base::Value> expected; | 624 scoped_ptr<base::Value> expected; |
586 const base::Value* value; | 625 const base::Value* value; |
587 | 626 |
588 // This tests needs to modify an int policy. The exact policy used and its | 627 // This tests needs to modify an int policy. The exact policy used and its |
589 // semantics outside the test are irrelevant. | 628 // semantics outside the test are irrelevant. |
590 IntPercentageToDoublePolicyHandler handler( | 629 IntPercentageToDoublePolicyHandler handler( |
591 kTestPolicy, kTestPref, 0, 10, true); | 630 kTestPolicy, kTestPref, 0, 10, true); |
592 | 631 |
593 // Check that values lying in the accepted range are written to the pref. | 632 // Check that values lying in the accepted range are written to the pref. |
594 policy_map.Set(kTestPolicy, | 633 policy_map.Set(kTestPolicy, |
595 POLICY_LEVEL_MANDATORY, | 634 POLICY_LEVEL_MANDATORY, |
596 POLICY_SCOPE_USER, | 635 POLICY_SCOPE_USER, |
| 636 POLICY_SOURCE_CLOUD, |
597 new base::FundamentalValue(0), | 637 new base::FundamentalValue(0), |
598 NULL); | 638 NULL); |
599 prefs.Clear(); | 639 prefs.Clear(); |
600 handler.ApplyPolicySettings(policy_map, &prefs); | 640 handler.ApplyPolicySettings(policy_map, &prefs); |
601 expected.reset(new base::FundamentalValue(0.0)); | 641 expected.reset(new base::FundamentalValue(0.0)); |
602 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 642 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
603 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 643 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
604 | 644 |
605 policy_map.Set(kTestPolicy, | 645 policy_map.Set(kTestPolicy, |
606 POLICY_LEVEL_MANDATORY, | 646 POLICY_LEVEL_MANDATORY, |
607 POLICY_SCOPE_USER, | 647 POLICY_SCOPE_USER, |
| 648 POLICY_SOURCE_CLOUD, |
608 new base::FundamentalValue(5), | 649 new base::FundamentalValue(5), |
609 NULL); | 650 NULL); |
610 prefs.Clear(); | 651 prefs.Clear(); |
611 handler.ApplyPolicySettings(policy_map, &prefs); | 652 handler.ApplyPolicySettings(policy_map, &prefs); |
612 expected.reset(new base::FundamentalValue(0.05)); | 653 expected.reset(new base::FundamentalValue(0.05)); |
613 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 654 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
614 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 655 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
615 | 656 |
616 policy_map.Set(kTestPolicy, | 657 policy_map.Set(kTestPolicy, |
617 POLICY_LEVEL_MANDATORY, | 658 POLICY_LEVEL_MANDATORY, |
618 POLICY_SCOPE_USER, | 659 POLICY_SCOPE_USER, |
| 660 POLICY_SOURCE_CLOUD, |
619 new base::FundamentalValue(10), | 661 new base::FundamentalValue(10), |
620 NULL); | 662 NULL); |
621 prefs.Clear(); | 663 prefs.Clear(); |
622 handler.ApplyPolicySettings(policy_map, &prefs); | 664 handler.ApplyPolicySettings(policy_map, &prefs); |
623 expected.reset(new base::FundamentalValue(0.1)); | 665 expected.reset(new base::FundamentalValue(0.1)); |
624 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 666 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
625 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 667 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
626 } | 668 } |
627 | 669 |
628 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { | 670 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { |
(...skipping 25 matching lines...) Expand all Loading... |
654 "}"; | 696 "}"; |
655 scoped_ptr<base::Value> policy_map_value = | 697 scoped_ptr<base::Value> policy_map_value = |
656 base::JSONReader::ReadAndReturnError(kPolicyMapJson, base::JSON_PARSE_RFC, | 698 base::JSONReader::ReadAndReturnError(kPolicyMapJson, base::JSON_PARSE_RFC, |
657 NULL, &error); | 699 NULL, &error); |
658 ASSERT_TRUE(policy_map_value) << error; | 700 ASSERT_TRUE(policy_map_value) << error; |
659 | 701 |
660 const base::DictionaryValue* policy_map_dict = NULL; | 702 const base::DictionaryValue* policy_map_dict = NULL; |
661 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict)); | 703 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict)); |
662 | 704 |
663 PolicyMap policy_map; | 705 PolicyMap policy_map; |
664 policy_map.LoadFrom( | 706 policy_map.LoadFrom(policy_map_dict, POLICY_LEVEL_RECOMMENDED, |
665 policy_map_dict, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER); | 707 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD); |
666 | 708 |
667 TestSchemaValidatingPolicyHandler handler(schema, SCHEMA_ALLOW_INVALID); | 709 TestSchemaValidatingPolicyHandler handler(schema, SCHEMA_ALLOW_INVALID); |
668 scoped_ptr<base::Value> output_value; | 710 scoped_ptr<base::Value> output_value; |
669 ASSERT_TRUE(handler.CheckAndGetValueForTest(policy_map, &output_value)); | 711 ASSERT_TRUE(handler.CheckAndGetValueForTest(policy_map, &output_value)); |
670 ASSERT_TRUE(output_value); | 712 ASSERT_TRUE(output_value); |
671 | 713 |
672 base::DictionaryValue* dict = NULL; | 714 base::DictionaryValue* dict = NULL; |
673 ASSERT_TRUE(output_value->GetAsDictionary(&dict)); | 715 ASSERT_TRUE(output_value->GetAsDictionary(&dict)); |
674 | 716 |
675 // Test that CheckAndGetValue() actually dropped invalid properties. | 717 // Test that CheckAndGetValue() actually dropped invalid properties. |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
715 scoped_ptr<base::Value> policy_map_value = | 757 scoped_ptr<base::Value> policy_map_value = |
716 base::JSONReader::ReadAndReturnError(kPolicyMapJson, base::JSON_PARSE_RFC, | 758 base::JSONReader::ReadAndReturnError(kPolicyMapJson, base::JSON_PARSE_RFC, |
717 NULL, &error); | 759 NULL, &error); |
718 ASSERT_TRUE(policy_map_value) << error; | 760 ASSERT_TRUE(policy_map_value) << error; |
719 | 761 |
720 const base::DictionaryValue* policy_map_dict = NULL; | 762 const base::DictionaryValue* policy_map_dict = NULL; |
721 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict)); | 763 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict)); |
722 | 764 |
723 PolicyMap policy_map_recommended; | 765 PolicyMap policy_map_recommended; |
724 policy_map_recommended.LoadFrom( | 766 policy_map_recommended.LoadFrom( |
725 policy_map_dict, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER); | 767 policy_map_dict, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
| 768 POLICY_SOURCE_CLOUD); |
726 | 769 |
727 PolicyMap policy_map_mandatory; | 770 PolicyMap policy_map_mandatory; |
728 policy_map_mandatory.LoadFrom( | 771 policy_map_mandatory.LoadFrom( |
729 policy_map_dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER); | 772 policy_map_dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
| 773 POLICY_SOURCE_CLOUD); |
730 | 774 |
731 SimpleSchemaValidatingPolicyHandler handler_all( | 775 SimpleSchemaValidatingPolicyHandler handler_all( |
732 policy_name, | 776 policy_name, |
733 kTestPref, | 777 kTestPref, |
734 schema, | 778 schema, |
735 SCHEMA_STRICT, | 779 SCHEMA_STRICT, |
736 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED, | 780 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED, |
737 SimpleSchemaValidatingPolicyHandler::MANDATORY_ALLOWED); | 781 SimpleSchemaValidatingPolicyHandler::MANDATORY_ALLOWED); |
738 | 782 |
739 SimpleSchemaValidatingPolicyHandler handler_recommended( | 783 SimpleSchemaValidatingPolicyHandler handler_recommended( |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
810 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); | 854 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); |
811 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); | 855 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); |
812 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); | 856 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); |
813 | 857 |
814 EXPECT_FALSE( | 858 EXPECT_FALSE( |
815 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); | 859 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); |
816 EXPECT_FALSE(errors.empty()); | 860 EXPECT_FALSE(errors.empty()); |
817 } | 861 } |
818 | 862 |
819 } // namespace policy | 863 } // namespace policy |
OLD | NEW |