1 // Copyright (c) 2011 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/asynchronous_policy_loader.h"
6 #include "chrome/browser/policy/asynchronous_policy_provider.h"
7 #include "chrome/browser/policy/asynchronous_policy_test_base.h"
8 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
9 #include "chrome/browser/policy/mock_configuration_policy_store.h"
10 #include "testing/gmock/include/gmock/gmock.h"
11
12 using ::testing::_;
13 using ::testing::InSequence;
14 using ::testing::Return;
15
16 namespace policy {
17
18 class MockConfigurationPolicyObserver
19 : public ConfigurationPolicyProvider::Observer {
20 public:
21 MOCK_METHOD0(OnUpdatePolicy, void());
OnProviderGoingAway()22 void OnProviderGoingAway() {}
23 };
24
25 class AsynchronousPolicyLoaderTest : public AsynchronousPolicyTestBase {
26 public:
AsynchronousPolicyLoaderTest()27 AsynchronousPolicyLoaderTest() {}
~AsynchronousPolicyLoaderTest()28 virtual ~AsynchronousPolicyLoaderTest() {}
29
SetUp()30 virtual void SetUp() {
31 AsynchronousPolicyTestBase::SetUp();
32 mock_provider_.reset(new MockConfigurationPolicyProvider());
33 }
34
35 protected:
36 scoped_ptr<MockConfigurationPolicyProvider> mock_provider_;
37
38 private:
39 DISALLOW_COPY_AND_ASSIGN(AsynchronousPolicyLoaderTest);
40 };
41
ACTION(CreateTestDictionary)42 ACTION(CreateTestDictionary) {
43 return new DictionaryValue();
44 }
45
ACTION_P(CreateSequencedTestDictionary,number)46 ACTION_P(CreateSequencedTestDictionary, number) {
47 DictionaryValue* test_dictionary = new DictionaryValue();
48 test_dictionary->SetInteger("id", ++(*number));
49 return test_dictionary;
50 }
51
ACTION(RescheduleImmediatePolicyReload)52 ACTION(RescheduleImmediatePolicyReload) {
53 *arg1 = base::TimeDelta();
54 return false;
55 }
56
TEST_F(AsynchronousPolicyLoaderTest,InitialLoad)57 TEST_F(AsynchronousPolicyLoaderTest, InitialLoad) {
58 DictionaryValue* template_dict(new DictionaryValue());
59 EXPECT_CALL(*delegate_, Load()).WillOnce(Return(template_dict));
60 scoped_refptr<AsynchronousPolicyLoader> loader =
61 new AsynchronousPolicyLoader(delegate_.release(), 10);
62 loader->Init();
63 const DictionaryValue* loaded_dict(loader->policy());
64 EXPECT_TRUE(loaded_dict->Equals(template_dict));
65 }
66
67 // Verify that the fallback policy requests are made.
TEST_F(AsynchronousPolicyLoaderTest,InitialLoadWithFallback)68 TEST_F(AsynchronousPolicyLoaderTest, InitialLoadWithFallback) {
69 int dictionary_number = 0;
70 InSequence s;
71 EXPECT_CALL(*delegate_, Load()).WillOnce(
72 CreateSequencedTestDictionary(&dictionary_number));
73 EXPECT_CALL(*delegate_, Load()).WillOnce(
74 CreateSequencedTestDictionary(&dictionary_number));
75 scoped_refptr<AsynchronousPolicyLoader> loader =
76 new AsynchronousPolicyLoader(delegate_.release(), 10);
77 loader->Init();
78 loop_.RunAllPending();
79 loader->Reload();
80 loop_.RunAllPending();
81
82 const DictionaryValue* loaded_dict(loader->policy());
83 int loaded_number;
84 EXPECT_TRUE(loaded_dict->GetInteger("id", &loaded_number));
85 EXPECT_EQ(dictionary_number, loaded_number);
86 }
87
88 // Ensure that calling stop on the loader stops subsequent reloads from
89 // happening.
TEST_F(AsynchronousPolicyLoaderTest,Stop)90 TEST_F(AsynchronousPolicyLoaderTest, Stop) {
91 ON_CALL(*delegate_, Load()).WillByDefault(CreateTestDictionary());
92 EXPECT_CALL(*delegate_, Load()).Times(1);
93 scoped_refptr<AsynchronousPolicyLoader> loader =
94 new AsynchronousPolicyLoader(delegate_.release(), 10);
95 loader->Init();
96 loop_.RunAllPending();
97 loader->Stop();
98 loop_.RunAllPending();
99 loader->Reload();
100 loop_.RunAllPending();
101 }
102
103 // Verifies that the provider is notified upon policy reload, but only
104 // if the policy changed.
TEST_F(AsynchronousPolicyLoaderTest,ProviderNotificationOnPolicyChange)105 TEST_F(AsynchronousPolicyLoaderTest, ProviderNotificationOnPolicyChange) {
106 InSequence s;
107 MockConfigurationPolicyObserver observer;
108 int dictionary_number_1 = 0;
109 int dictionary_number_2 = 0;
110 EXPECT_CALL(*delegate_, Load()).WillOnce(
111 CreateSequencedTestDictionary(&dictionary_number_1));
112 EXPECT_CALL(*delegate_, Load()).WillOnce(
113 CreateSequencedTestDictionary(&dictionary_number_2));
114 EXPECT_CALL(observer, OnUpdatePolicy()).Times(0);
115 EXPECT_CALL(*delegate_, Load()).WillOnce(
116 CreateSequencedTestDictionary(&dictionary_number_2));
117 EXPECT_CALL(observer, OnUpdatePolicy()).Times(1);
118 EXPECT_CALL(*delegate_, Load()).WillOnce(
119 CreateSequencedTestDictionary(&dictionary_number_1));
120 scoped_refptr<AsynchronousPolicyLoader> loader =
121 new AsynchronousPolicyLoader(delegate_.release(), 10);
122 AsynchronousPolicyProvider provider(NULL, loader);
123 // |registrar| must be declared last so that it is destroyed first.
124 ConfigurationPolicyObserverRegistrar registrar;
125 registrar.Init(&provider, &observer);
126 loop_.RunAllPending();
127 loader->Reload();
128 loop_.RunAllPending();
129 loader->Reload();
130 loop_.RunAllPending();
131 loader->Reload();
132 loop_.RunAllPending();
133 }
134
135 } // namespace policy
136