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
3 // found in the LICENSE file.
4
5 #include "base/bind.h"
6 #include "base/callback.h"
7 #include "base/json/json_reader.h"
8 #include "base/memory/scoped_ptr.h"
9 #include "base/prefs/pref_value_map.h"
10 #include "base/values.h"
11 #include "components/policy/core/browser/configuration_policy_handler.h"
12 #include "components/policy/core/browser/policy_error_map.h"
13 #include "components/policy/core/common/policy_map.h"
14 #include "components/policy/core/common/schema.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16
17 namespace policy {
18
19 namespace {
20
GetIntegerTypeMap(ScopedVector<StringMappingListPolicyHandler::MappingEntry> * result)21 void GetIntegerTypeMap(
22 ScopedVector<StringMappingListPolicyHandler::MappingEntry>* result) {
23 result->push_back(new StringMappingListPolicyHandler::MappingEntry(
24 "one", scoped_ptr<base::Value>(new base::FundamentalValue(1))));
25 result->push_back(new StringMappingListPolicyHandler::MappingEntry(
26 "two", scoped_ptr<base::Value>(new base::FundamentalValue(2))));
27 }
28
29 const char kTestPolicy[] = "unit_test.test_policy";
30 const char kTestPref[] = "unit_test.test_pref";
31
32 class TestSchemaValidatingPolicyHandler : public SchemaValidatingPolicyHandler {
33 public:
TestSchemaValidatingPolicyHandler(const Schema & schema,SchemaOnErrorStrategy strategy)34 TestSchemaValidatingPolicyHandler(const Schema& schema,
35 SchemaOnErrorStrategy strategy)
36 : SchemaValidatingPolicyHandler("PolicyForTesting", schema, strategy) {}
~TestSchemaValidatingPolicyHandler()37 virtual ~TestSchemaValidatingPolicyHandler() {}
38
ApplyPolicySettings(const policy::PolicyMap &,PrefValueMap *)39 virtual void ApplyPolicySettings(const policy::PolicyMap&,
40 PrefValueMap*) OVERRIDE {
41 }
42
CheckAndGetValueForTest(const PolicyMap & policies,scoped_ptr<base::Value> * value)43 bool CheckAndGetValueForTest(const PolicyMap& policies,
44 scoped_ptr<base::Value>* value) {
45 return SchemaValidatingPolicyHandler::CheckAndGetValue(
46 policies, NULL, value);
47 }
48 };
49
50 } // namespace
51
TEST(StringToIntEnumListPolicyHandlerTest,CheckPolicySettings)52 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) {
53 base::ListValue list;
54 PolicyMap policy_map;
55 PolicyErrorMap errors;
56 StringMappingListPolicyHandler handler(
57 kTestPolicy,
58 kTestPref,
59 base::Bind(GetIntegerTypeMap));
60
61 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
62 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
63 errors.Clear();
64 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
65 EXPECT_TRUE(errors.empty());
66
67 list.AppendString("one");
68 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
69 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
70 errors.Clear();
71 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
72 EXPECT_TRUE(errors.empty());
73
74 list.AppendString("invalid");
75 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
76 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
77 errors.Clear();
78 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
79 EXPECT_FALSE(errors.empty());
80 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty());
81
82 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
83 POLICY_SCOPE_USER,
84 base::Value::CreateStringValue("no list"), NULL);
85 errors.Clear();
86 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
87 EXPECT_FALSE(errors.empty());
88 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty());
89 }
90
TEST(StringMappingListPolicyHandlerTest,ApplyPolicySettings)91 TEST(StringMappingListPolicyHandlerTest, ApplyPolicySettings) {
92 base::ListValue list;
93 base::ListValue expected;
94 PolicyMap policy_map;
95 PrefValueMap prefs;
96 base::Value* value;
97 StringMappingListPolicyHandler handler(
98 kTestPolicy,
99 kTestPref,
100 base::Bind(GetIntegerTypeMap));
101
102 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
103 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
104 handler.ApplyPolicySettings(policy_map, &prefs);
105 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
106 EXPECT_TRUE(base::Value::Equals(&expected, value));
107
108 list.AppendString("two");
109 expected.AppendInteger(2);
110 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
111 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
112 handler.ApplyPolicySettings(policy_map, &prefs);
113 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
114 EXPECT_TRUE(base::Value::Equals(&expected, value));
115
116 list.AppendString("invalid");
117 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
118 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
119 handler.ApplyPolicySettings(policy_map, &prefs);
120 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
121 EXPECT_TRUE(base::Value::Equals(&expected, value));
122 }
123
TEST(IntRangePolicyHandler,CheckPolicySettingsClamp)124 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) {
125 PolicyMap policy_map;
126 PolicyErrorMap errors;
127
128 // This tests needs to modify an int policy. The exact policy used and its
129 // semantics outside the test are irrelevant.
130 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true);
131
132 // Check that values lying in the accepted range are not rejected.
133 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
134 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
135 errors.Clear();
136 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
137 EXPECT_TRUE(errors.empty());
138
139 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
140 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
141 errors.Clear();
142 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
143 EXPECT_TRUE(errors.empty());
144
145 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
146 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
147 errors.Clear();
148 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
149 EXPECT_TRUE(errors.empty());
150
151 // Check that values lying outside the accepted range are not rejected
152 // (because clamping is enabled) but do yield a warning message.
153 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
154 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
155 errors.Clear();
156 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
157 EXPECT_FALSE(errors.empty());
158
159 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
160 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
161 errors.Clear();
162 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
163 EXPECT_FALSE(errors.empty());
164
165 // Check that an entirely invalid value is rejected and yields an error
166 // message.
167 policy_map.Set(kTestPolicy,
168 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
169 base::Value::CreateStringValue("invalid"), NULL);
170 errors.Clear();
171 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
172 EXPECT_FALSE(errors.empty());
173 }
174
TEST(IntRangePolicyHandler,CheckPolicySettingsDontClamp)175 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) {
176 PolicyMap policy_map;
177 PolicyErrorMap errors;
178
179 // This tests needs to modify an int policy. The exact policy used and its
180 // semantics outside the test are irrelevant.
181 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false);
182
183 // Check that values lying in the accepted range are not rejected.
184 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
185 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
186 errors.Clear();
187 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
188 EXPECT_TRUE(errors.empty());
189
190 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
191 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
192 errors.Clear();
193 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
194 EXPECT_TRUE(errors.empty());
195
196 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
197 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
198 errors.Clear();
199 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
200 EXPECT_TRUE(errors.empty());
201
202 // Check that values lying outside the accepted range are rejected and yield
203 // an error message.
204 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
205 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
206 errors.Clear();
207 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
208 EXPECT_FALSE(errors.empty());
209
210 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
211 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
212 errors.Clear();
213 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
214 EXPECT_FALSE(errors.empty());
215
216 // Check that an entirely invalid value is rejected and yields an error
217 // message.
218 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
219 base::Value::CreateStringValue("invalid"), NULL);
220 errors.Clear();
221 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
222 EXPECT_FALSE(errors.empty());
223 }
224
TEST(IntRangePolicyHandler,ApplyPolicySettingsClamp)225 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) {
226 PolicyMap policy_map;
227 PrefValueMap prefs;
228 scoped_ptr<base::Value> expected;
229 const base::Value* value;
230
231 // This tests needs to modify an int policy. The exact policy used and its
232 // semantics outside the test are irrelevant.
233 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true);
234
235 // Check that values lying in the accepted range are written to the pref.
236 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
237 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
238 prefs.Clear();
239 handler.ApplyPolicySettings(policy_map, &prefs);
240 expected.reset(base::Value::CreateIntegerValue(0));
241 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
242 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
243
244 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
245 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
246 prefs.Clear();
247 handler.ApplyPolicySettings(policy_map, &prefs);
248 expected.reset(base::Value::CreateIntegerValue(5));
249 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
250 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
251
252 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
253 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
254 prefs.Clear();
255 handler.ApplyPolicySettings(policy_map, &prefs);
256 expected.reset(base::Value::CreateIntegerValue(10));
257 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
258 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
259
260 // Check that values lying outside the accepted range are clamped and written
261 // to the pref.
262 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
263 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
264 prefs.Clear();
265 handler.ApplyPolicySettings(policy_map, &prefs);
266 expected.reset(base::Value::CreateIntegerValue(0));
267 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
268 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
269
270 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
271 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
272 prefs.Clear();
273 handler.ApplyPolicySettings(policy_map, &prefs);
274 expected.reset(base::Value::CreateIntegerValue(10));
275 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
276 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
277 }
278
TEST(IntRangePolicyHandler,ApplyPolicySettingsDontClamp)279 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) {
280 PolicyMap policy_map;
281 PrefValueMap prefs;
282 scoped_ptr<base::Value> expected;
283 const base::Value* value;
284
285 // This tests needs to modify an int policy. The exact policy used and its
286 // semantics outside the test are irrelevant.
287 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true);
288
289 // Check that values lying in the accepted range are written to the pref.
290 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
291 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
292 prefs.Clear();
293 handler.ApplyPolicySettings(policy_map, &prefs);
294 expected.reset(base::Value::CreateIntegerValue(0));
295 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
296 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
297
298 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
299 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
300 prefs.Clear();
301 handler.ApplyPolicySettings(policy_map, &prefs);
302 expected.reset(base::Value::CreateIntegerValue(5));
303 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
304 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
305
306 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
307 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
308 prefs.Clear();
309 handler.ApplyPolicySettings(policy_map, &prefs);
310 expected.reset(base::Value::CreateIntegerValue(10));
311 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
312 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
313 }
314
TEST(IntPercentageToDoublePolicyHandler,CheckPolicySettingsClamp)315 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) {
316 PolicyMap policy_map;
317 PolicyErrorMap errors;
318
319 // This tests needs to modify an int policy. The exact policy used and its
320 // semantics outside the test are irrelevant.
321 IntPercentageToDoublePolicyHandler handler(
322 kTestPolicy, kTestPref, 0, 10, true);
323
324 // Check that values lying in the accepted range are not rejected.
325 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
326 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
327 errors.Clear();
328 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
329 EXPECT_TRUE(errors.empty());
330
331 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
332 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
333 errors.Clear();
334 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
335 EXPECT_TRUE(errors.empty());
336
337 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
338 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
339 errors.Clear();
340 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
341 EXPECT_TRUE(errors.empty());
342
343 // Check that values lying outside the accepted range are not rejected
344 // (because clamping is enabled) but do yield a warning message.
345 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
346 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
347 errors.Clear();
348 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
349 EXPECT_FALSE(errors.empty());
350
351 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
352 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
353 errors.Clear();
354 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
355 EXPECT_FALSE(errors.empty());
356
357 // Check that an entirely invalid value is rejected and yields an error
358 // message.
359 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
360 base::Value::CreateStringValue("invalid"), NULL);
361 errors.Clear();
362 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
363 EXPECT_FALSE(errors.empty());
364 }
365
TEST(IntPercentageToDoublePolicyHandler,CheckPolicySettingsDontClamp)366 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) {
367 PolicyMap policy_map;
368 PolicyErrorMap errors;
369
370 // This tests needs to modify an int policy. The exact policy used and its
371 // semantics outside the test are irrelevant.
372 IntPercentageToDoublePolicyHandler handler(
373 kTestPolicy, kTestPref, 0, 10, false);
374
375 // Check that values lying in the accepted range are not rejected.
376 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
377 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
378 errors.Clear();
379 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
380 EXPECT_TRUE(errors.empty());
381
382 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
383 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
384 errors.Clear();
385 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
386 EXPECT_TRUE(errors.empty());
387
388 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
389 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
390 errors.Clear();
391 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
392 EXPECT_TRUE(errors.empty());
393
394 // Check that values lying outside the accepted range are rejected and yield
395 // an error message.
396 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
397 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
398 errors.Clear();
399 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
400 EXPECT_FALSE(errors.empty());
401
402 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
403 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
404 errors.Clear();
405 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
406 EXPECT_FALSE(errors.empty());
407
408 // Check that an entirely invalid value is rejected and yields an error
409 // message.
410 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
411 base::Value::CreateStringValue("invalid"), NULL);
412 errors.Clear();
413 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
414 EXPECT_FALSE(errors.empty());
415 }
416
TEST(IntPercentageToDoublePolicyHandler,ApplyPolicySettingsClamp)417 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) {
418 PolicyMap policy_map;
419 PrefValueMap prefs;
420 scoped_ptr<base::Value> expected;
421 const base::Value* value;
422
423 // This tests needs to modify an int policy. The exact policy used and its
424 // semantics outside the test are irrelevant.
425 IntPercentageToDoublePolicyHandler handler(
426 kTestPolicy, kTestPref, 0, 10, true);
427
428 // Check that values lying in the accepted range are written to the pref.
429 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
430 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
431 prefs.Clear();
432 handler.ApplyPolicySettings(policy_map, &prefs);
433 expected.reset(base::Value::CreateDoubleValue(0.0));
434 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
435 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
436
437 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
438 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
439 prefs.Clear();
440 handler.ApplyPolicySettings(policy_map, &prefs);
441 expected.reset(base::Value::CreateDoubleValue(0.05));
442 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
443 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
444
445 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
446 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
447 prefs.Clear();
448 handler.ApplyPolicySettings(policy_map, &prefs);
449 expected.reset(base::Value::CreateDoubleValue(0.1));
450 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
451 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
452
453 // Check that values lying outside the accepted range are clamped and written
454 // to the pref.
455 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
456 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
457 prefs.Clear();
458 handler.ApplyPolicySettings(policy_map, &prefs);
459 expected.reset(base::Value::CreateDoubleValue(0.0));
460 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
461 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
462
463 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
464 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
465 prefs.Clear();
466 handler.ApplyPolicySettings(policy_map, &prefs);
467 expected.reset(base::Value::CreateDoubleValue(0.1));
468 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
469 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
470 }
471
TEST(IntPercentageToDoublePolicyHandler,ApplyPolicySettingsDontClamp)472 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) {
473 PolicyMap policy_map;
474 PrefValueMap prefs;
475 scoped_ptr<base::Value> expected;
476 const base::Value* value;
477
478 // This tests needs to modify an int policy. The exact policy used and its
479 // semantics outside the test are irrelevant.
480 IntPercentageToDoublePolicyHandler handler(
481 kTestPolicy, kTestPref, 0, 10, true);
482
483 // Check that values lying in the accepted range are written to the pref.
484 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
485 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
486 prefs.Clear();
487 handler.ApplyPolicySettings(policy_map, &prefs);
488 expected.reset(base::Value::CreateDoubleValue(0.0));
489 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
490 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
491
492 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
493 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
494 prefs.Clear();
495 handler.ApplyPolicySettings(policy_map, &prefs);
496 expected.reset(base::Value::CreateDoubleValue(0.05));
497 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
498 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
499
500 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY,
501 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
502 prefs.Clear();
503 handler.ApplyPolicySettings(policy_map, &prefs);
504 expected.reset(base::Value::CreateDoubleValue(0.1));
505 EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
506 EXPECT_TRUE(base::Value::Equals(expected.get(), value));
507 }
508
TEST(SchemaValidatingPolicyHandlerTest,CheckAndGetValue)509 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) {
510 std::string error;
511 static const char kSchemaJson[] =
512 "{"
513 " \"type\": \"object\","
514 " \"properties\": {"
515 " \"OneToThree\": {"
516 " \"type\": \"integer\","
517 " \"minimum\": 1,"
518 " \"maximum\": 3"
519 " },"
520 " \"Colors\": {"
521 " \"type\": \"string\","
522 " \"enum\": [ \"Red\", \"Green\", \"Blue\" ]"
523 " }"
524 " }"
525 "}";
526 Schema schema = Schema::Parse(kSchemaJson, &error);
527 ASSERT_TRUE(schema.valid()) << error;
528
529 static const char kPolicyMapJson[] =
530 "{"
531 " \"PolicyForTesting\": {"
532 " \"OneToThree\": 2,"
533 " \"Colors\": \"White\""
534 " }"
535 "}";
536 scoped_ptr<base::Value> policy_map_value(base::JSONReader::ReadAndReturnError(
537 kPolicyMapJson, base::JSON_PARSE_RFC, NULL, &error));
538 ASSERT_TRUE(policy_map_value) << error;
539
540 const base::DictionaryValue* policy_map_dict = NULL;
541 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict));
542
543 PolicyMap policy_map;
544 policy_map.LoadFrom(
545 policy_map_dict, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER);
546
547 TestSchemaValidatingPolicyHandler handler(schema, SCHEMA_ALLOW_INVALID);
548 scoped_ptr<base::Value> output_value;
549 ASSERT_TRUE(handler.CheckAndGetValueForTest(policy_map, &output_value));
550 ASSERT_TRUE(output_value);
551
552 base::DictionaryValue* dict = NULL;
553 ASSERT_TRUE(output_value->GetAsDictionary(&dict));
554
555 // Test that CheckAndGetValue() actually dropped invalid properties.
556 int int_value = -1;
557 EXPECT_TRUE(dict->GetInteger("OneToThree", &int_value));
558 EXPECT_EQ(2, int_value);
559 EXPECT_FALSE(dict->HasKey("Colors"));
560 }
561
TEST(SimpleSchemaValidatingPolicyHandlerTest,CheckAndGetValue)562 TEST(SimpleSchemaValidatingPolicyHandlerTest, CheckAndGetValue) {
563 const char policy_name[] = "PolicyForTesting";
564 static const char kSchemaJson[] =
565 "{"
566 " \"type\": \"object\","
567 " \"properties\": {"
568 " \"PolicyForTesting\": {"
569 " \"type\": \"object\","
570 " \"properties\": {"
571 " \"OneToThree\": {"
572 " \"type\": \"integer\","
573 " \"minimum\": 1,"
574 " \"maximum\": 3"
575 " },"
576 " \"Colors\": {"
577 " \"type\": \"string\","
578 " \"enum\": [ \"Red\", \"Green\", \"Blue\" ]"
579 " }"
580 " }"
581 " }"
582 " }"
583 "}";
584 std::string error;
585 Schema schema = Schema::Parse(kSchemaJson, &error);
586 ASSERT_TRUE(schema.valid()) << error;
587
588 static const char kPolicyMapJson[] =
589 "{"
590 " \"PolicyForTesting\": {"
591 " \"OneToThree\": 2,"
592 " \"Colors\": \"Green\""
593 " }"
594 "}";
595 scoped_ptr<base::Value> policy_map_value(base::JSONReader::ReadAndReturnError(
596 kPolicyMapJson, base::JSON_PARSE_RFC, NULL, &error));
597 ASSERT_TRUE(policy_map_value) << error;
598
599 const base::DictionaryValue* policy_map_dict = NULL;
600 ASSERT_TRUE(policy_map_value->GetAsDictionary(&policy_map_dict));
601
602 PolicyMap policy_map_recommended;
603 policy_map_recommended.LoadFrom(
604 policy_map_dict, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER);
605
606 PolicyMap policy_map_mandatory;
607 policy_map_mandatory.LoadFrom(
608 policy_map_dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
609
610 SimpleSchemaValidatingPolicyHandler handler_all(
611 policy_name,
612 kTestPref,
613 schema,
614 SCHEMA_STRICT,
615 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED,
616 SimpleSchemaValidatingPolicyHandler::MANDATORY_ALLOWED);
617
618 SimpleSchemaValidatingPolicyHandler handler_recommended(
619 policy_name,
620 kTestPref,
621 schema,
622 SCHEMA_STRICT,
623 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED,
624 SimpleSchemaValidatingPolicyHandler::MANDATORY_PROHIBITED);
625
626 SimpleSchemaValidatingPolicyHandler handler_mandatory(
627 policy_name,
628 kTestPref,
629 schema,
630 SCHEMA_STRICT,
631 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_PROHIBITED,
632 SimpleSchemaValidatingPolicyHandler::MANDATORY_ALLOWED);
633
634 SimpleSchemaValidatingPolicyHandler handler_none(
635 policy_name,
636 kTestPref,
637 schema,
638 SCHEMA_STRICT,
639 SimpleSchemaValidatingPolicyHandler::RECOMMENDED_PROHIBITED,
640 SimpleSchemaValidatingPolicyHandler::MANDATORY_PROHIBITED);
641
642 const base::Value* value_expected_in_pref;
643 policy_map_dict->Get(policy_name, &value_expected_in_pref);
644
645 PolicyErrorMap errors;
646 PrefValueMap prefs;
647 base::Value* value_set_in_pref;
648
649 EXPECT_TRUE(handler_all.CheckPolicySettings(policy_map_mandatory, &errors));
650 EXPECT_TRUE(errors.empty());
651 prefs.Clear();
652 handler_all.ApplyPolicySettings(policy_map_mandatory, &prefs);
653 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref));
654 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref));
655
656 EXPECT_FALSE(
657 handler_recommended.CheckPolicySettings(policy_map_mandatory, &errors));
658 EXPECT_FALSE(errors.empty());
659 errors.Clear();
660
661 EXPECT_TRUE(
662 handler_mandatory.CheckPolicySettings(policy_map_mandatory, &errors));
663 EXPECT_TRUE(errors.empty());
664 prefs.Clear();
665 handler_mandatory.ApplyPolicySettings(policy_map_mandatory, &prefs);
666 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref));
667 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref));
668
669 EXPECT_FALSE(handler_none.CheckPolicySettings(policy_map_mandatory, &errors));
670 EXPECT_FALSE(errors.empty());
671 errors.Clear();
672
673 EXPECT_TRUE(handler_all.CheckPolicySettings(policy_map_recommended, &errors));
674 EXPECT_TRUE(errors.empty());
675 prefs.Clear();
676 handler_all.ApplyPolicySettings(policy_map_mandatory, &prefs);
677 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref));
678 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref));
679
680 EXPECT_FALSE(
681 handler_mandatory.CheckPolicySettings(policy_map_recommended, &errors));
682 EXPECT_FALSE(errors.empty());
683 errors.Clear();
684
685 EXPECT_TRUE(
686 handler_recommended.CheckPolicySettings(policy_map_recommended, &errors));
687 EXPECT_TRUE(errors.empty());
688 prefs.Clear();
689 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs);
690 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref));
691 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref));
692
693 EXPECT_FALSE(
694 handler_none.CheckPolicySettings(policy_map_recommended, &errors));
695 EXPECT_FALSE(errors.empty());
696 }
697
698 } // namespace policy
699