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