src/chrome/browser/policy/policy_service_impl_unittest.cc

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