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