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