OLD | NEW |
| (Empty) |
1 // Copyright (c) 2010 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/device_management_policy_cache.h" | |
6 | |
7 #include <limits> | |
8 #include <string> | |
9 | |
10 #include "base/file_util.h" | |
11 #include "base/message_loop.h" | |
12 #include "base/scoped_temp_dir.h" | |
13 #include "base/values.h" | |
14 #include "chrome/browser/browser_thread.h" | |
15 #include "chrome/browser/policy/proto/device_management_constants.h" | |
16 #include "chrome/browser/policy/proto/device_management_local.pb.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 | |
19 namespace policy { | |
20 | |
21 // Wraps base functionaly for the test cases. | |
22 class DeviceManagementPolicyCacheTestBase : public testing::Test { | |
23 protected: | |
24 // Add a string policy setting to a policy response message. | |
25 void AddStringPolicy(em::DevicePolicyResponse* policy, | |
26 const std::string& name, | |
27 const std::string& value) { | |
28 em::DevicePolicySetting* setting = policy->add_setting(); | |
29 setting->set_policy_key(kChromeDevicePolicySettingKey); | |
30 em::GenericSetting* policy_value = setting->mutable_policy_value(); | |
31 em::GenericNamedValue* named_value = policy_value->add_named_value(); | |
32 named_value->set_name(name); | |
33 em::GenericValue* value_container = named_value->mutable_value(); | |
34 value_container->set_value_type(em::GenericValue::VALUE_TYPE_STRING); | |
35 value_container->set_string_value(value); | |
36 } | |
37 }; | |
38 | |
39 // Tests the device management policy cache. | |
40 class DeviceManagementPolicyCacheTest | |
41 : public DeviceManagementPolicyCacheTestBase { | |
42 protected: | |
43 DeviceManagementPolicyCacheTest() | |
44 : loop_(MessageLoop::TYPE_UI), | |
45 ui_thread_(BrowserThread::UI, &loop_), | |
46 file_thread_(BrowserThread::FILE, &loop_) {} | |
47 | |
48 void SetUp() { | |
49 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | |
50 } | |
51 | |
52 void TearDown() { | |
53 loop_.RunAllPending(); | |
54 } | |
55 | |
56 void WritePolicy(const em::DevicePolicyResponse& policy, | |
57 const base::Time& timestamp) { | |
58 std::string data; | |
59 em::CachedDevicePolicyResponse cached_policy; | |
60 cached_policy.mutable_policy()->CopyFrom(policy); | |
61 cached_policy.set_timestamp(timestamp.ToInternalValue()); | |
62 EXPECT_TRUE(cached_policy.SerializeToString(&data)); | |
63 int size = static_cast<int>(data.size()); | |
64 EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size)); | |
65 } | |
66 | |
67 FilePath test_file() { | |
68 return temp_dir_.path().AppendASCII("DeviceManagementPolicyCacheTest"); | |
69 } | |
70 | |
71 protected: | |
72 MessageLoop loop_; | |
73 | |
74 private: | |
75 ScopedTempDir temp_dir_; | |
76 BrowserThread ui_thread_; | |
77 BrowserThread file_thread_; | |
78 }; | |
79 | |
80 TEST_F(DeviceManagementPolicyCacheTest, Empty) { | |
81 DeviceManagementPolicyCache cache(test_file()); | |
82 DictionaryValue empty; | |
83 scoped_ptr<Value> policy(cache.GetPolicy()); | |
84 EXPECT_TRUE(empty.Equals(policy.get())); | |
85 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time()); | |
86 } | |
87 | |
88 TEST_F(DeviceManagementPolicyCacheTest, LoadNoFile) { | |
89 DeviceManagementPolicyCache cache(test_file()); | |
90 cache.LoadPolicyFromFile(); | |
91 DictionaryValue empty; | |
92 scoped_ptr<Value> policy(cache.GetPolicy()); | |
93 EXPECT_TRUE(empty.Equals(policy.get())); | |
94 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time()); | |
95 } | |
96 | |
97 TEST_F(DeviceManagementPolicyCacheTest, RejectFuture) { | |
98 em::DevicePolicyResponse policy_response; | |
99 WritePolicy(policy_response, base::Time::NowFromSystemTime() + | |
100 base::TimeDelta::FromMinutes(5)); | |
101 DeviceManagementPolicyCache cache(test_file()); | |
102 cache.LoadPolicyFromFile(); | |
103 DictionaryValue empty; | |
104 scoped_ptr<Value> policy(cache.GetPolicy()); | |
105 EXPECT_TRUE(empty.Equals(policy.get())); | |
106 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time()); | |
107 } | |
108 | |
109 TEST_F(DeviceManagementPolicyCacheTest, LoadWithFile) { | |
110 em::DevicePolicyResponse policy_response; | |
111 WritePolicy(policy_response, base::Time::NowFromSystemTime()); | |
112 DeviceManagementPolicyCache cache(test_file()); | |
113 cache.LoadPolicyFromFile(); | |
114 DictionaryValue empty; | |
115 scoped_ptr<Value> policy(cache.GetPolicy()); | |
116 EXPECT_TRUE(empty.Equals(policy.get())); | |
117 EXPECT_NE(base::Time(), cache.last_policy_refresh_time()); | |
118 EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time()); | |
119 } | |
120 | |
121 TEST_F(DeviceManagementPolicyCacheTest, LoadWithData) { | |
122 em::DevicePolicyResponse policy; | |
123 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
124 WritePolicy(policy, base::Time::NowFromSystemTime()); | |
125 DeviceManagementPolicyCache cache(test_file()); | |
126 cache.LoadPolicyFromFile(); | |
127 DictionaryValue expected; | |
128 expected.Set("HomepageLocation", | |
129 Value::CreateStringValue("http://www.example.com")); | |
130 scoped_ptr<Value> policy_value(cache.GetPolicy()); | |
131 EXPECT_TRUE(expected.Equals(policy_value.get())); | |
132 } | |
133 | |
134 TEST_F(DeviceManagementPolicyCacheTest, SetPolicy) { | |
135 DeviceManagementPolicyCache cache(test_file()); | |
136 em::DevicePolicyResponse policy; | |
137 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
138 EXPECT_TRUE(cache.SetPolicy(policy)); | |
139 em::DevicePolicyResponse policy2; | |
140 AddStringPolicy(&policy2, "HomepageLocation", "http://www.example.com"); | |
141 EXPECT_FALSE(cache.SetPolicy(policy2)); | |
142 DictionaryValue expected; | |
143 expected.Set("HomepageLocation", | |
144 Value::CreateStringValue("http://www.example.com")); | |
145 scoped_ptr<Value> policy_value(cache.GetPolicy()); | |
146 EXPECT_TRUE(expected.Equals(policy_value.get())); | |
147 } | |
148 | |
149 TEST_F(DeviceManagementPolicyCacheTest, ResetPolicy) { | |
150 DeviceManagementPolicyCache cache(test_file()); | |
151 | |
152 em::DevicePolicyResponse policy; | |
153 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
154 EXPECT_TRUE(cache.SetPolicy(policy)); | |
155 DictionaryValue expected; | |
156 expected.Set("HomepageLocation", | |
157 Value::CreateStringValue("http://www.example.com")); | |
158 scoped_ptr<Value> policy_value(cache.GetPolicy()); | |
159 EXPECT_TRUE(expected.Equals(policy_value.get())); | |
160 | |
161 EXPECT_TRUE(cache.SetPolicy(em::DevicePolicyResponse())); | |
162 policy_value.reset(cache.GetPolicy()); | |
163 DictionaryValue empty; | |
164 EXPECT_TRUE(empty.Equals(policy_value.get())); | |
165 } | |
166 | |
167 TEST_F(DeviceManagementPolicyCacheTest, PersistPolicy) { | |
168 { | |
169 DeviceManagementPolicyCache cache(test_file()); | |
170 em::DevicePolicyResponse policy; | |
171 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
172 cache.SetPolicy(policy); | |
173 } | |
174 | |
175 loop_.RunAllPending(); | |
176 | |
177 EXPECT_TRUE(file_util::PathExists(test_file())); | |
178 DeviceManagementPolicyCache cache(test_file()); | |
179 cache.LoadPolicyFromFile(); | |
180 DictionaryValue expected; | |
181 expected.Set("HomepageLocation", | |
182 Value::CreateStringValue("http://www.example.com")); | |
183 scoped_ptr<Value> policy_value(cache.GetPolicy()); | |
184 EXPECT_TRUE(expected.Equals(policy_value.get())); | |
185 } | |
186 | |
187 TEST_F(DeviceManagementPolicyCacheTest, FreshPolicyOverride) { | |
188 em::DevicePolicyResponse policy; | |
189 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
190 WritePolicy(policy, base::Time::NowFromSystemTime()); | |
191 | |
192 DeviceManagementPolicyCache cache(test_file()); | |
193 em::DevicePolicyResponse updated_policy; | |
194 AddStringPolicy(&updated_policy, "HomepageLocation", | |
195 "http://www.chromium.org"); | |
196 EXPECT_TRUE(cache.SetPolicy(updated_policy)); | |
197 | |
198 cache.LoadPolicyFromFile(); | |
199 DictionaryValue expected; | |
200 expected.Set("HomepageLocation", | |
201 Value::CreateStringValue("http://www.chromium.org")); | |
202 scoped_ptr<Value> policy_value(cache.GetPolicy()); | |
203 EXPECT_TRUE(expected.Equals(policy_value.get())); | |
204 } | |
205 | |
206 // Tests proper decoding of policy values. | |
207 class DeviceManagementPolicyCacheDecodeTest | |
208 : public DeviceManagementPolicyCacheTestBase { | |
209 protected: | |
210 void DecodeAndCheck(Value* expected_value_ptr) { | |
211 scoped_ptr<Value> expected_value(expected_value_ptr); | |
212 scoped_ptr<Value> decoded_value( | |
213 DeviceManagementPolicyCache::DecodeValue(value_)); | |
214 if (expected_value_ptr) { | |
215 ASSERT_TRUE(decoded_value.get()); | |
216 EXPECT_TRUE(decoded_value->Equals(expected_value.get())); | |
217 } else { | |
218 ASSERT_FALSE(decoded_value.get()); | |
219 } | |
220 } | |
221 | |
222 em::GenericValue value_; | |
223 }; | |
224 | |
225 TEST_F(DeviceManagementPolicyCacheDecodeTest, Bool) { | |
226 value_.set_value_type(em::GenericValue::VALUE_TYPE_BOOL); | |
227 value_.set_bool_value(true); | |
228 DecodeAndCheck(Value::CreateBooleanValue(true)); | |
229 } | |
230 | |
231 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64) { | |
232 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64); | |
233 value_.set_int64_value(42); | |
234 DecodeAndCheck(Value::CreateIntegerValue(42)); | |
235 } | |
236 | |
237 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64Overflow) { | |
238 const int min = std::numeric_limits<int>::min(); | |
239 const int max = std::numeric_limits<int>::max(); | |
240 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64); | |
241 value_.set_int64_value(min - 1LL); | |
242 DecodeAndCheck(NULL); | |
243 value_.set_int64_value(max + 1LL); | |
244 DecodeAndCheck(NULL); | |
245 value_.set_int64_value(min); | |
246 DecodeAndCheck(Value::CreateIntegerValue(min)); | |
247 value_.set_int64_value(max); | |
248 DecodeAndCheck(Value::CreateIntegerValue(max)); | |
249 } | |
250 | |
251 TEST_F(DeviceManagementPolicyCacheDecodeTest, String) { | |
252 value_.set_value_type(em::GenericValue::VALUE_TYPE_STRING); | |
253 value_.set_string_value("ponies!"); | |
254 DecodeAndCheck(Value::CreateStringValue("ponies!")); | |
255 } | |
256 | |
257 TEST_F(DeviceManagementPolicyCacheDecodeTest, Double) { | |
258 value_.set_value_type(em::GenericValue::VALUE_TYPE_DOUBLE); | |
259 value_.set_double_value(0.42L); | |
260 DecodeAndCheck(Value::CreateDoubleValue(0.42L)); | |
261 } | |
262 | |
263 TEST_F(DeviceManagementPolicyCacheDecodeTest, Bytes) { | |
264 std::string data("binary ponies."); | |
265 value_.set_value_type(em::GenericValue::VALUE_TYPE_BYTES); | |
266 value_.set_bytes_value(data); | |
267 DecodeAndCheck( | |
268 BinaryValue::CreateWithCopiedBuffer(data.c_str(), data.size())); | |
269 } | |
270 | |
271 TEST_F(DeviceManagementPolicyCacheDecodeTest, BoolArray) { | |
272 value_.set_value_type(em::GenericValue::VALUE_TYPE_BOOL_ARRAY); | |
273 value_.add_bool_array(false); | |
274 value_.add_bool_array(true); | |
275 ListValue* list = new ListValue; | |
276 list->Append(Value::CreateBooleanValue(false)); | |
277 list->Append(Value::CreateBooleanValue(true)); | |
278 DecodeAndCheck(list); | |
279 } | |
280 | |
281 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64Array) { | |
282 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64_ARRAY); | |
283 value_.add_int64_array(42); | |
284 value_.add_int64_array(17); | |
285 ListValue* list = new ListValue; | |
286 list->Append(Value::CreateIntegerValue(42)); | |
287 list->Append(Value::CreateIntegerValue(17)); | |
288 DecodeAndCheck(list); | |
289 } | |
290 | |
291 TEST_F(DeviceManagementPolicyCacheDecodeTest, StringArray) { | |
292 value_.set_value_type(em::GenericValue::VALUE_TYPE_STRING_ARRAY); | |
293 value_.add_string_array("ponies"); | |
294 value_.add_string_array("more ponies"); | |
295 ListValue* list = new ListValue; | |
296 list->Append(Value::CreateStringValue("ponies")); | |
297 list->Append(Value::CreateStringValue("more ponies")); | |
298 DecodeAndCheck(list); | |
299 } | |
300 | |
301 TEST_F(DeviceManagementPolicyCacheDecodeTest, DoubleArray) { | |
302 value_.set_value_type(em::GenericValue::VALUE_TYPE_DOUBLE_ARRAY); | |
303 value_.add_double_array(0.42L); | |
304 value_.add_double_array(0.17L); | |
305 ListValue* list = new ListValue; | |
306 list->Append(Value::CreateDoubleValue(0.42L)); | |
307 list->Append(Value::CreateDoubleValue(0.17L)); | |
308 DecodeAndCheck(list); | |
309 } | |
310 | |
311 TEST_F(DeviceManagementPolicyCacheDecodeTest, DecodePolicy) { | |
312 em::DevicePolicyResponse policy; | |
313 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com"); | |
314 scoped_ptr<Value> decoded(DeviceManagementPolicyCache::DecodePolicy(policy)); | |
315 DictionaryValue expected; | |
316 expected.Set("HomepageLocation", | |
317 Value::CreateStringValue("http://www.example.com")); | |
318 EXPECT_TRUE(expected.Equals(decoded.get())); | |
319 } | |
320 | |
321 } // namespace policy | |
OLD | NEW |