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