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
20 using ::testing::AnyNumber;
21 using ::testing::Mock;
22 using ::testing::Return;
23 using ::testing::_;
24
25 namespace policy {
26
27 namespace {
28
29 const char kExtension[] = "extension-id";
30 const char kSameLevelPolicy[] = "policy-same-level-and-scope";
31 const 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.
35 MATCHER_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.
41 MATCHER_P(ValueEquals, expected, "") {
42 return base::Value::Equals(arg, expected);
43 }
44
45 // Helper that fills |bundle| with test policies.
AddTestPolicies(PolicyBundle * bundle,const char * value,PolicyLevel level,PolicyScope scope)46 void 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.
67 class ChangePolicyObserver : public PolicyService::Observer {
68 public:
ChangePolicyObserver(MockConfigurationPolicyProvider * provider)69 explicit ChangePolicyObserver(MockConfigurationPolicyProvider* provider)
70 : provider_(provider),
71 observer_invoked_(false) {}
72
OnPolicyUpdated(const PolicyNamespace &,const PolicyMap & previous,const PolicyMap & current)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
observer_invoked() const83 bool observer_invoked() const { return observer_invoked_; }
84
85 private:
86 MockConfigurationPolicyProvider* provider_;
87 bool observer_invoked_;
88 };
89
90 } // namespace
91
92 class PolicyServiceTest : public testing::Test {
93 public:
PolicyServiceTest()94 PolicyServiceTest() {}
SetUp()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
TearDown()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|.
VerifyPolicies(const PolicyNamespace & ns,const PolicyMap & expected)130 bool VerifyPolicies(const PolicyNamespace& ns,
131 const PolicyMap& expected) {
132 return policy_service_->GetPolicies(ns).Equals(expected);
133 }
134
RunUntilIdle()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
TEST_F(PolicyServiceTest,LoadsPoliciesBeforeProvidersRefresh)154 TEST_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
TEST_F(PolicyServiceTest,NotifyObservers)162 TEST_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
TEST_F(PolicyServiceTest,NotifyObserversInMultipleNamespaces)238 TEST_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
TEST_F(PolicyServiceTest,ObserverChangesPolicy)324 TEST_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
TEST_F(PolicyServiceTest,Priorities)337 TEST_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
TEST_F(PolicyServiceTest,PolicyChangeRegistrar)371 TEST_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
TEST_F(PolicyServiceTest,RefreshPolicies)428 TEST_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
TEST_F(PolicyServiceTest,NamespaceMerge)494 TEST_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
TEST_F(PolicyServiceTest,IsInitializationComplete)526 TEST_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
TEST_F(PolicyServiceTest,FixDeprecatedPolicies)606 TEST_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