1// Copyright (c) 2012 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 "components/policy/core/common/policy_service_impl.h" 6 7#include "base/bind.h" 8#include "base/bind_helpers.h" 9#include "base/callback.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/run_loop.h" 12#include "base/values.h" 13#include "components/policy/core/common/external_data_fetcher.h" 14#include "components/policy/core/common/mock_configuration_policy_provider.h" 15#include "components/policy/core/common/mock_policy_service.h" 16#include "policy/policy_constants.h" 17#include "testing/gmock/include/gmock/gmock.h" 18#include "testing/gtest/include/gtest/gtest.h" 19 20using ::testing::AnyNumber; 21using ::testing::Mock; 22using ::testing::Return; 23using ::testing::_; 24 25namespace policy { 26 27namespace { 28 29const char kExtension[] = "extension-id"; 30const char kSameLevelPolicy[] = "policy-same-level-and-scope"; 31const char kDiffLevelPolicy[] = "chrome-diff-level-and-scope"; 32 33// Helper to compare the arguments to an EXPECT_CALL of OnPolicyUpdated() with 34// their expected values. 35MATCHER_P(PolicyEquals, expected, "") { 36 return arg.Equals(*expected); 37} 38 39// Helper to compare the arguments to an EXPECT_CALL of OnPolicyValueUpdated() 40// with their expected values. 41MATCHER_P(ValueEquals, expected, "") { 42 return base::Value::Equals(arg, expected); 43} 44 45// Helper that fills |bundle| with test policies. 46void AddTestPolicies(PolicyBundle* bundle, 47 const char* value, 48 PolicyLevel level, 49 PolicyScope scope) { 50 PolicyMap* policy_map = 51 &bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())); 52 policy_map->Set(kSameLevelPolicy, 53 POLICY_LEVEL_MANDATORY, 54 POLICY_SCOPE_USER, 55 new base::StringValue(value), 56 NULL); 57 policy_map->Set( 58 kDiffLevelPolicy, level, scope, new base::StringValue(value), NULL); 59 policy_map = 60 &bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension)); 61 policy_map->Set(kSameLevelPolicy, 62 POLICY_LEVEL_MANDATORY, 63 POLICY_SCOPE_USER, 64 new base::StringValue(value), 65 NULL); 66 policy_map->Set( 67 kDiffLevelPolicy, level, scope, new base::StringValue(value), NULL); 68} 69 70// Observer class that changes the policy in the passed provider when the 71// callback is invoked. 72class ChangePolicyObserver : public PolicyService::Observer { 73 public: 74 explicit ChangePolicyObserver(MockConfigurationPolicyProvider* provider) 75 : provider_(provider), 76 observer_invoked_(false) {} 77 78 virtual void OnPolicyUpdated(const PolicyNamespace&, 79 const PolicyMap& previous, 80 const PolicyMap& current) OVERRIDE { 81 PolicyMap new_policy; 82 new_policy.Set("foo", 83 POLICY_LEVEL_MANDATORY, 84 POLICY_SCOPE_USER, 85 new base::FundamentalValue(14), 86 NULL); 87 provider_->UpdateChromePolicy(new_policy); 88 observer_invoked_ = true; 89 } 90 91 bool observer_invoked() const { return observer_invoked_; } 92 93 private: 94 MockConfigurationPolicyProvider* provider_; 95 bool observer_invoked_; 96}; 97 98} // namespace 99 100class PolicyServiceTest : public testing::Test { 101 public: 102 PolicyServiceTest() {} 103 virtual void SetUp() OVERRIDE { 104 EXPECT_CALL(provider0_, IsInitializationComplete(_)) 105 .WillRepeatedly(Return(true)); 106 EXPECT_CALL(provider1_, IsInitializationComplete(_)) 107 .WillRepeatedly(Return(true)); 108 EXPECT_CALL(provider2_, IsInitializationComplete(_)) 109 .WillRepeatedly(Return(true)); 110 111 provider0_.Init(); 112 provider1_.Init(); 113 provider2_.Init(); 114 115 policy0_.Set("pre", 116 POLICY_LEVEL_MANDATORY, 117 POLICY_SCOPE_USER, 118 new base::FundamentalValue(13), 119 NULL); 120 provider0_.UpdateChromePolicy(policy0_); 121 122 PolicyServiceImpl::Providers providers; 123 providers.push_back(&provider0_); 124 providers.push_back(&provider1_); 125 providers.push_back(&provider2_); 126 policy_service_.reset(new PolicyServiceImpl(providers)); 127 } 128 129 virtual void TearDown() OVERRIDE { 130 provider0_.Shutdown(); 131 provider1_.Shutdown(); 132 provider2_.Shutdown(); 133 } 134 135 MOCK_METHOD2(OnPolicyValueUpdated, void(const base::Value*, 136 const base::Value*)); 137 138 MOCK_METHOD0(OnPolicyRefresh, void()); 139 140 // Returns true if the policies for namespace |ns| match |expected|. 141 bool VerifyPolicies(const PolicyNamespace& ns, 142 const PolicyMap& expected) { 143 return policy_service_->GetPolicies(ns).Equals(expected); 144 } 145 146 void RunUntilIdle() { 147 base::RunLoop loop; 148 loop.RunUntilIdle(); 149 } 150 151 protected: 152 base::MessageLoop loop_; 153 MockConfigurationPolicyProvider provider0_; 154 MockConfigurationPolicyProvider provider1_; 155 MockConfigurationPolicyProvider provider2_; 156 PolicyMap policy0_; 157 PolicyMap policy1_; 158 PolicyMap policy2_; 159 scoped_ptr<PolicyServiceImpl> policy_service_; 160 161 private: 162 DISALLOW_COPY_AND_ASSIGN(PolicyServiceTest); 163}; 164 165TEST_F(PolicyServiceTest, LoadsPoliciesBeforeProvidersRefresh) { 166 PolicyMap expected; 167 expected.Set("pre", 168 POLICY_LEVEL_MANDATORY, 169 POLICY_SCOPE_USER, 170 new base::FundamentalValue(13), 171 NULL); 172 EXPECT_TRUE(VerifyPolicies( 173 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected)); 174} 175 176TEST_F(PolicyServiceTest, NotifyObservers) { 177 MockPolicyServiceObserver observer; 178 policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer); 179 180 PolicyMap expectedPrevious; 181 expectedPrevious.Set("pre", 182 POLICY_LEVEL_MANDATORY, 183 POLICY_SCOPE_USER, 184 new base::FundamentalValue(13), 185 NULL); 186 187 PolicyMap expectedCurrent; 188 expectedCurrent.CopyFrom(expectedPrevious); 189 expectedCurrent.Set("aaa", 190 POLICY_LEVEL_MANDATORY, 191 POLICY_SCOPE_USER, 192 new base::FundamentalValue(123), 193 NULL); 194 policy0_.Set("aaa", 195 POLICY_LEVEL_MANDATORY, 196 POLICY_SCOPE_USER, 197 new base::FundamentalValue(123), 198 NULL); 199 EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME, 200 std::string()), 201 PolicyEquals(&expectedPrevious), 202 PolicyEquals(&expectedCurrent))); 203 provider0_.UpdateChromePolicy(policy0_); 204 Mock::VerifyAndClearExpectations(&observer); 205 206 // No changes. 207 EXPECT_CALL(observer, OnPolicyUpdated(_, _, _)).Times(0); 208 provider0_.UpdateChromePolicy(policy0_); 209 Mock::VerifyAndClearExpectations(&observer); 210 EXPECT_TRUE(VerifyPolicies( 211 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expectedCurrent)); 212 213 // New policy. 214 expectedPrevious.CopyFrom(expectedCurrent); 215 expectedCurrent.Set("bbb", 216 POLICY_LEVEL_MANDATORY, 217 POLICY_SCOPE_USER, 218 new base::FundamentalValue(456), 219 NULL); 220 policy0_.Set("bbb", 221 POLICY_LEVEL_MANDATORY, 222 POLICY_SCOPE_USER, 223 new base::FundamentalValue(456), 224 NULL); 225 EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME, 226 std::string()), 227 PolicyEquals(&expectedPrevious), 228 PolicyEquals(&expectedCurrent))); 229 provider0_.UpdateChromePolicy(policy0_); 230 Mock::VerifyAndClearExpectations(&observer); 231 232 // Removed policy. 233 expectedPrevious.CopyFrom(expectedCurrent); 234 expectedCurrent.Erase("bbb"); 235 policy0_.Erase("bbb"); 236 EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME, 237 std::string()), 238 PolicyEquals(&expectedPrevious), 239 PolicyEquals(&expectedCurrent))); 240 provider0_.UpdateChromePolicy(policy0_); 241 Mock::VerifyAndClearExpectations(&observer); 242 243 // Changed policy. 244 expectedPrevious.CopyFrom(expectedCurrent); 245 expectedCurrent.Set("aaa", 246 POLICY_LEVEL_MANDATORY, 247 POLICY_SCOPE_USER, 248 new base::FundamentalValue(789), 249 NULL); 250 policy0_.Set("aaa", 251 POLICY_LEVEL_MANDATORY, 252 POLICY_SCOPE_USER, 253 new base::FundamentalValue(789), 254 NULL); 255 256 EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME, 257 std::string()), 258 PolicyEquals(&expectedPrevious), 259 PolicyEquals(&expectedCurrent))); 260 provider0_.UpdateChromePolicy(policy0_); 261 Mock::VerifyAndClearExpectations(&observer); 262 263 // No changes again. 264 EXPECT_CALL(observer, OnPolicyUpdated(_, _, _)).Times(0); 265 provider0_.UpdateChromePolicy(policy0_); 266 Mock::VerifyAndClearExpectations(&observer); 267 EXPECT_TRUE(VerifyPolicies( 268 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expectedCurrent)); 269 270 policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer); 271} 272 273TEST_F(PolicyServiceTest, NotifyObserversInMultipleNamespaces) { 274 const std::string kExtension0("extension-0"); 275 const std::string kExtension1("extension-1"); 276 const std::string kExtension2("extension-2"); 277 MockPolicyServiceObserver chrome_observer; 278 MockPolicyServiceObserver extension_observer; 279 policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &chrome_observer); 280 policy_service_->AddObserver(POLICY_DOMAIN_EXTENSIONS, &extension_observer); 281 282 PolicyMap previous_policy_map; 283 previous_policy_map.Set("pre", 284 POLICY_LEVEL_MANDATORY, 285 POLICY_SCOPE_USER, 286 new base::FundamentalValue(13), 287 NULL); 288 PolicyMap policy_map; 289 policy_map.CopyFrom(previous_policy_map); 290 policy_map.Set("policy", 291 POLICY_LEVEL_MANDATORY, 292 POLICY_SCOPE_USER, 293 new base::StringValue("value"), 294 NULL); 295 296 scoped_ptr<PolicyBundle> bundle(new PolicyBundle()); 297 // The initial setup includes a policy for chrome that is now changing. 298 bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())) 299 .CopyFrom(policy_map); 300 bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0)) 301 .CopyFrom(policy_map); 302 bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1)) 303 .CopyFrom(policy_map); 304 305 const PolicyMap kEmptyPolicyMap; 306 EXPECT_CALL( 307 chrome_observer, 308 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), 309 PolicyEquals(&previous_policy_map), 310 PolicyEquals(&policy_map))); 311 EXPECT_CALL( 312 extension_observer, 313 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0), 314 PolicyEquals(&kEmptyPolicyMap), 315 PolicyEquals(&policy_map))); 316 EXPECT_CALL( 317 extension_observer, 318 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1), 319 PolicyEquals(&kEmptyPolicyMap), 320 PolicyEquals(&policy_map))); 321 provider0_.UpdatePolicy(bundle.Pass()); 322 RunUntilIdle(); 323 Mock::VerifyAndClearExpectations(&chrome_observer); 324 Mock::VerifyAndClearExpectations(&extension_observer); 325 326 // Chrome policy stays the same, kExtension0 is gone, kExtension1 changes, 327 // and kExtension2 is new. 328 previous_policy_map.CopyFrom(policy_map); 329 bundle.reset(new PolicyBundle()); 330 bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())) 331 .CopyFrom(policy_map); 332 policy_map.Set("policy", 333 POLICY_LEVEL_MANDATORY, 334 POLICY_SCOPE_USER, 335 new base::StringValue("another value"), 336 NULL); 337 bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1)) 338 .CopyFrom(policy_map); 339 bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension2)) 340 .CopyFrom(policy_map); 341 342 EXPECT_CALL(chrome_observer, OnPolicyUpdated(_, _, _)).Times(0); 343 EXPECT_CALL( 344 extension_observer, 345 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0), 346 PolicyEquals(&previous_policy_map), 347 PolicyEquals(&kEmptyPolicyMap))); 348 EXPECT_CALL( 349 extension_observer, 350 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1), 351 PolicyEquals(&previous_policy_map), 352 PolicyEquals(&policy_map))); 353 EXPECT_CALL( 354 extension_observer, 355 OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension2), 356 PolicyEquals(&kEmptyPolicyMap), 357 PolicyEquals(&policy_map))); 358 provider0_.UpdatePolicy(bundle.Pass()); 359 RunUntilIdle(); 360 Mock::VerifyAndClearExpectations(&chrome_observer); 361 Mock::VerifyAndClearExpectations(&extension_observer); 362 363 policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &chrome_observer); 364 policy_service_->RemoveObserver(POLICY_DOMAIN_EXTENSIONS, 365 &extension_observer); 366} 367 368TEST_F(PolicyServiceTest, ObserverChangesPolicy) { 369 ChangePolicyObserver observer(&provider0_); 370 policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer); 371 policy0_.Set("aaa", 372 POLICY_LEVEL_MANDATORY, 373 POLICY_SCOPE_USER, 374 new base::FundamentalValue(123), 375 NULL); 376 policy0_.Set("bbb", 377 POLICY_LEVEL_MANDATORY, 378 POLICY_SCOPE_USER, 379 new base::FundamentalValue(1234), 380 NULL); 381 // Should not crash. 382 provider0_.UpdateChromePolicy(policy0_); 383 policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer); 384 EXPECT_TRUE(observer.observer_invoked()); 385} 386 387TEST_F(PolicyServiceTest, Priorities) { 388 PolicyMap expected; 389 expected.Set("pre", 390 POLICY_LEVEL_MANDATORY, 391 POLICY_SCOPE_USER, 392 new base::FundamentalValue(13), 393 NULL); 394 expected.Set("aaa", 395 POLICY_LEVEL_MANDATORY, 396 POLICY_SCOPE_USER, 397 new base::FundamentalValue(0), 398 NULL); 399 policy0_.Set("aaa", 400 POLICY_LEVEL_MANDATORY, 401 POLICY_SCOPE_USER, 402 new base::FundamentalValue(0), 403 NULL); 404 policy1_.Set("aaa", 405 POLICY_LEVEL_MANDATORY, 406 POLICY_SCOPE_USER, 407 new base::FundamentalValue(1), 408 NULL); 409 policy2_.Set("aaa", 410 POLICY_LEVEL_MANDATORY, 411 POLICY_SCOPE_USER, 412 new base::FundamentalValue(2), 413 NULL); 414 provider0_.UpdateChromePolicy(policy0_); 415 provider1_.UpdateChromePolicy(policy1_); 416 provider2_.UpdateChromePolicy(policy2_); 417 EXPECT_TRUE(VerifyPolicies( 418 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected)); 419 420 expected.Set("aaa", 421 POLICY_LEVEL_MANDATORY, 422 POLICY_SCOPE_USER, 423 new base::FundamentalValue(1), 424 NULL); 425 policy0_.Erase("aaa"); 426 provider0_.UpdateChromePolicy(policy0_); 427 EXPECT_TRUE(VerifyPolicies( 428 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected)); 429 430 expected.Set("aaa", 431 POLICY_LEVEL_MANDATORY, 432 POLICY_SCOPE_USER, 433 new base::FundamentalValue(2), 434 NULL); 435 policy1_.Set("aaa", 436 POLICY_LEVEL_RECOMMENDED, 437 POLICY_SCOPE_USER, 438 new base::FundamentalValue(1), 439 NULL); 440 provider1_.UpdateChromePolicy(policy1_); 441 EXPECT_TRUE(VerifyPolicies( 442 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected)); 443} 444 445TEST_F(PolicyServiceTest, PolicyChangeRegistrar) { 446 scoped_ptr<PolicyChangeRegistrar> registrar(new PolicyChangeRegistrar( 447 policy_service_.get(), 448 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))); 449 450 // Starting to observe existing policies doesn't trigger a notification. 451 EXPECT_CALL(*this, OnPolicyValueUpdated(_, _)).Times(0); 452 registrar->Observe("pre", base::Bind( 453 &PolicyServiceTest::OnPolicyValueUpdated, 454 base::Unretained(this))); 455 registrar->Observe("aaa", base::Bind( 456 &PolicyServiceTest::OnPolicyValueUpdated, 457 base::Unretained(this))); 458 RunUntilIdle(); 459 Mock::VerifyAndClearExpectations(this); 460 461 // Changing it now triggers a notification. 462 base::FundamentalValue kValue0(0); 463 EXPECT_CALL(*this, OnPolicyValueUpdated(NULL, ValueEquals(&kValue0))); 464 policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 465 kValue0.DeepCopy(), NULL); 466 provider0_.UpdateChromePolicy(policy0_); 467 Mock::VerifyAndClearExpectations(this); 468 469 // Changing other values doesn't trigger a notification. 470 EXPECT_CALL(*this, OnPolicyValueUpdated(_, _)).Times(0); 471 policy0_.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 472 kValue0.DeepCopy(), NULL); 473 provider0_.UpdateChromePolicy(policy0_); 474 Mock::VerifyAndClearExpectations(this); 475 476 // Modifying the value triggers a notification. 477 base::FundamentalValue kValue1(1); 478 EXPECT_CALL(*this, OnPolicyValueUpdated(ValueEquals(&kValue0), 479 ValueEquals(&kValue1))); 480 policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 481 kValue1.DeepCopy(), NULL); 482 provider0_.UpdateChromePolicy(policy0_); 483 Mock::VerifyAndClearExpectations(this); 484 485 // Removing the value triggers a notification. 486 EXPECT_CALL(*this, OnPolicyValueUpdated(ValueEquals(&kValue1), NULL)); 487 policy0_.Erase("aaa"); 488 provider0_.UpdateChromePolicy(policy0_); 489 Mock::VerifyAndClearExpectations(this); 490 491 // No more notifications after destroying the registrar. 492 EXPECT_CALL(*this, OnPolicyValueUpdated(_, _)).Times(0); 493 registrar.reset(); 494 policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 495 kValue1.DeepCopy(), NULL); 496 policy0_.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 497 kValue1.DeepCopy(), NULL); 498 provider0_.UpdateChromePolicy(policy0_); 499 Mock::VerifyAndClearExpectations(this); 500} 501 502TEST_F(PolicyServiceTest, RefreshPolicies) { 503 EXPECT_CALL(provider0_, RefreshPolicies()).Times(AnyNumber()); 504 EXPECT_CALL(provider1_, RefreshPolicies()).Times(AnyNumber()); 505 EXPECT_CALL(provider2_, RefreshPolicies()).Times(AnyNumber()); 506 507 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 508 policy_service_->RefreshPolicies(base::Bind( 509 &PolicyServiceTest::OnPolicyRefresh, 510 base::Unretained(this))); 511 // Let any queued observer tasks run. 512 RunUntilIdle(); 513 Mock::VerifyAndClearExpectations(this); 514 515 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 516 base::FundamentalValue kValue0(0); 517 policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 518 kValue0.DeepCopy(), NULL); 519 provider0_.UpdateChromePolicy(policy0_); 520 Mock::VerifyAndClearExpectations(this); 521 522 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 523 base::FundamentalValue kValue1(1); 524 policy1_.Set("aaa", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, 525 kValue1.DeepCopy(), NULL); 526 provider1_.UpdateChromePolicy(policy1_); 527 Mock::VerifyAndClearExpectations(this); 528 529 // A provider can refresh more than once after a RefreshPolicies call, but 530 // OnPolicyRefresh should be triggered only after all providers are 531 // refreshed. 532 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 533 policy1_.Set("bbb", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, 534 kValue1.DeepCopy(), NULL); 535 provider1_.UpdateChromePolicy(policy1_); 536 Mock::VerifyAndClearExpectations(this); 537 538 // If another RefreshPolicies() call happens while waiting for a previous 539 // one to complete, then all providers must refresh again. 540 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 541 policy_service_->RefreshPolicies(base::Bind( 542 &PolicyServiceTest::OnPolicyRefresh, 543 base::Unretained(this))); 544 RunUntilIdle(); 545 Mock::VerifyAndClearExpectations(this); 546 547 EXPECT_CALL(*this, OnPolicyRefresh()).Times(0); 548 policy2_.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 549 kValue0.DeepCopy(), NULL); 550 provider2_.UpdateChromePolicy(policy2_); 551 Mock::VerifyAndClearExpectations(this); 552 553 // Providers 0 and 1 must reload again. 554 EXPECT_CALL(*this, OnPolicyRefresh()).Times(2); 555 base::FundamentalValue kValue2(2); 556 policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 557 kValue2.DeepCopy(), NULL); 558 provider0_.UpdateChromePolicy(policy0_); 559 provider1_.UpdateChromePolicy(policy1_); 560 Mock::VerifyAndClearExpectations(this); 561 562 const PolicyMap& policies = policy_service_->GetPolicies( 563 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())); 564 EXPECT_TRUE(base::Value::Equals(&kValue2, policies.GetValue("aaa"))); 565 EXPECT_TRUE(base::Value::Equals(&kValue0, policies.GetValue("bbb"))); 566} 567 568TEST_F(PolicyServiceTest, NamespaceMerge) { 569 scoped_ptr<PolicyBundle> bundle0(new PolicyBundle()); 570 scoped_ptr<PolicyBundle> bundle1(new PolicyBundle()); 571 scoped_ptr<PolicyBundle> bundle2(new PolicyBundle()); 572 573 AddTestPolicies(bundle0.get(), "bundle0", 574 POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER); 575 AddTestPolicies(bundle1.get(), "bundle1", 576 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER); 577 AddTestPolicies(bundle2.get(), "bundle2", 578 POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE); 579 580 provider0_.UpdatePolicy(bundle0.Pass()); 581 provider1_.UpdatePolicy(bundle1.Pass()); 582 provider2_.UpdatePolicy(bundle2.Pass()); 583 RunUntilIdle(); 584 585 PolicyMap expected; 586 // For policies of the same level and scope, the first provider takes 587 // precedence, on every namespace. 588 expected.Set(kSameLevelPolicy, 589 POLICY_LEVEL_MANDATORY, 590 POLICY_SCOPE_USER, 591 new base::StringValue("bundle0"), 592 NULL); 593 // For policies with different levels and scopes, the highest priority 594 // level/scope combination takes precedence, on every namespace. 595 expected.Set(kDiffLevelPolicy, 596 POLICY_LEVEL_MANDATORY, 597 POLICY_SCOPE_MACHINE, 598 new base::StringValue("bundle2"), 599 NULL); 600 EXPECT_TRUE(policy_service_->GetPolicies( 601 PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())).Equals(expected)); 602 EXPECT_TRUE(policy_service_->GetPolicies( 603 PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension)).Equals(expected)); 604} 605 606TEST_F(PolicyServiceTest, IsInitializationComplete) { 607 // |provider0| has all domains initialized. 608 Mock::VerifyAndClearExpectations(&provider1_); 609 Mock::VerifyAndClearExpectations(&provider2_); 610 EXPECT_CALL(provider1_, IsInitializationComplete(_)) 611 .WillRepeatedly(Return(false)); 612 EXPECT_CALL(provider2_, IsInitializationComplete(_)) 613 .WillRepeatedly(Return(false)); 614 PolicyServiceImpl::Providers providers; 615 providers.push_back(&provider0_); 616 providers.push_back(&provider1_); 617 providers.push_back(&provider2_); 618 policy_service_.reset(new PolicyServiceImpl(providers)); 619 EXPECT_FALSE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)); 620 EXPECT_FALSE( 621 policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)); 622 623 // |provider2_| still doesn't have POLICY_DOMAIN_CHROME initialized, so 624 // the initialization status of that domain won't change. 625 MockPolicyServiceObserver observer; 626 policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer); 627 policy_service_->AddObserver(POLICY_DOMAIN_EXTENSIONS, &observer); 628 EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(0); 629 Mock::VerifyAndClearExpectations(&provider1_); 630 EXPECT_CALL(provider1_, IsInitializationComplete(POLICY_DOMAIN_CHROME)) 631 .WillRepeatedly(Return(true)); 632 EXPECT_CALL(provider1_, IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)) 633 .WillRepeatedly(Return(false)); 634 const PolicyMap kPolicyMap; 635 provider1_.UpdateChromePolicy(kPolicyMap); 636 Mock::VerifyAndClearExpectations(&observer); 637 EXPECT_FALSE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)); 638 EXPECT_FALSE( 639 policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)); 640 641 // Same if |provider1_| doesn't have POLICY_DOMAIN_EXTENSIONS initialized. 642 EXPECT_CALL(observer, OnPolicyServiceInitialized(_)).Times(0); 643 Mock::VerifyAndClearExpectations(&provider2_); 644 EXPECT_CALL(provider2_, IsInitializationComplete(POLICY_DOMAIN_CHROME)) 645 .WillRepeatedly(Return(false)); 646 EXPECT_CALL(provider2_, IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)) 647 .WillRepeatedly(Return(true)); 648 provider2_.UpdateChromePolicy(kPolicyMap); 649 Mock::VerifyAndClearExpectations(&observer); 650 EXPECT_FALSE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)); 651 EXPECT_FALSE( 652 policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)); 653 654 // Now initialize POLICY_DOMAIN_CHROME on all the providers. 655 EXPECT_CALL(observer, OnPolicyServiceInitialized(POLICY_DOMAIN_CHROME)); 656 Mock::VerifyAndClearExpectations(&provider2_); 657 EXPECT_CALL(provider2_, IsInitializationComplete(POLICY_DOMAIN_CHROME)) 658 .WillRepeatedly(Return(true)); 659 EXPECT_CALL(provider2_, IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)) 660 .WillRepeatedly(Return(true)); 661 provider2_.UpdateChromePolicy(kPolicyMap); 662 Mock::VerifyAndClearExpectations(&observer); 663 EXPECT_TRUE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)); 664 // Other domains are still not initialized. 665 EXPECT_FALSE( 666 policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)); 667 668 // Initialize the remaining domain. 669 EXPECT_CALL(observer, OnPolicyServiceInitialized(POLICY_DOMAIN_EXTENSIONS)); 670 Mock::VerifyAndClearExpectations(&provider1_); 671 EXPECT_CALL(provider1_, IsInitializationComplete(POLICY_DOMAIN_CHROME)) 672 .WillRepeatedly(Return(true)); 673 EXPECT_CALL(provider1_, IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)) 674 .WillRepeatedly(Return(true)); 675 provider1_.UpdateChromePolicy(kPolicyMap); 676 Mock::VerifyAndClearExpectations(&observer); 677 EXPECT_TRUE(policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)); 678 EXPECT_TRUE( 679 policy_service_->IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS)); 680 681 // Cleanup. 682 policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer); 683 policy_service_->RemoveObserver(POLICY_DOMAIN_EXTENSIONS, &observer); 684} 685 686TEST_F(PolicyServiceTest, FixDeprecatedPolicies) { 687 const PolicyNamespace chrome_namespace(POLICY_DOMAIN_CHROME, std::string()); 688 const PolicyNamespace extension_namespace(POLICY_DOMAIN_EXTENSIONS, "xyz"); 689 690 scoped_ptr<PolicyBundle> policy_bundle(new PolicyBundle()); 691 PolicyMap& policy_map = policy_bundle->Get(chrome_namespace); 692 // Individual proxy policy values in the Chrome namespace should be collected 693 // into a dictionary. 694 policy_map.Set(key::kProxyServerMode, 695 POLICY_LEVEL_MANDATORY, 696 POLICY_SCOPE_USER, 697 new base::FundamentalValue(3), 698 NULL); 699 700 // Both these policies should be ignored, since there's a higher priority 701 // policy available. 702 policy_map.Set(key::kProxyMode, 703 POLICY_LEVEL_RECOMMENDED, 704 POLICY_SCOPE_USER, 705 new base::StringValue("pac_script"), 706 NULL); 707 policy_map.Set(key::kProxyPacUrl, 708 POLICY_LEVEL_RECOMMENDED, 709 POLICY_SCOPE_USER, 710 new base::StringValue("http://example.com/wpad.dat"), 711 NULL); 712 713 // Add a value to a non-Chrome namespace. 714 policy_bundle->Get(extension_namespace).Set(key::kProxyServerMode, 715 POLICY_LEVEL_MANDATORY, 716 POLICY_SCOPE_USER, 717 new base::FundamentalValue(3), 718 NULL); 719 720 // The resulting Chrome namespace map should have the collected policy. 721 PolicyMap expected_chrome; 722 scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue); 723 expected_value->SetInteger(key::kProxyServerMode, 3); 724 expected_chrome.Set(key::kProxySettings, POLICY_LEVEL_MANDATORY, 725 POLICY_SCOPE_USER, expected_value.release(), NULL); 726 727 // The resulting Extensions namespace map shouldn't have been modified. 728 PolicyMap expected_extension; 729 expected_extension.Set(key::kProxyServerMode, 730 POLICY_LEVEL_MANDATORY, 731 POLICY_SCOPE_USER, 732 new base::FundamentalValue(3), 733 NULL); 734 735 provider0_.UpdatePolicy(policy_bundle.Pass()); 736 RunUntilIdle(); 737 738 EXPECT_TRUE(VerifyPolicies(chrome_namespace, expected_chrome)); 739 EXPECT_TRUE(VerifyPolicies(extension_namespace, expected_extension)); 740} 741 742} // namespace policy 743