Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(493)

Side by Side Diff: chrome/browser/policy/cloud_policy_cache_unittest.cc

Issue 6532019: New policy protobuf protocol. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix memory leaks by introducing PolicyMap Created 9 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
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/cloud_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/cloud_policy.pb.h"
16 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
17 // TODO(jkummerow): remove this import when removing old DMPC test cases.
18 #include "chrome/browser/policy/proto/device_management_constants.h"
19 #include "chrome/browser/policy/proto/device_management_local.pb.h"
20 #include "testing/gtest/include/gtest/gtest.h"
21
22 namespace policy {
23
24 // Decodes a CloudPolicySettings object into two maps with mandatory and
25 // recommended settings, respectively. The implementation is generated code
26 // in policy/cloud_policy_generated.cc.
27 void DecodePolicy(const em::CloudPolicySettings& policy,
28 PolicyMap* mandatory, PolicyMap* recommended);
29
30 // The implementations of these methods are in cloud_policy_generated.cc.
31 Value* DecodeIntegerValue(google::protobuf::int64 value);
32 ListValue* DecodeStringList(const em::StringList& string_list);
33
34 // Tests the device management policy cache.
35 class CloudPolicyCacheTest : public testing::Test {
36 protected:
37 CloudPolicyCacheTest()
38 : loop_(MessageLoop::TYPE_UI),
39 ui_thread_(BrowserThread::UI, &loop_),
40 file_thread_(BrowserThread::FILE, &loop_) {}
41
42 void SetUp() {
43 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
44 }
45
46 void TearDown() {
47 loop_.RunAllPending();
48 }
49
50 // Creates a (signed) CloudPolicyResponse setting the given |homepage| and
51 // featuring the given |timestamp| (as issued by the server).
52 // Mildly hacky special feature: pass an empty string as |homepage| to get
53 // a completely empty policy.
54 em::CloudPolicyResponse* CreateHomepagePolicy(
55 const std::string& homepage,
56 const base::Time& timestamp,
57 const em::PolicyOptions::PolicyMode policy_mode) {
58 em::SignedCloudPolicyResponse signed_response;
59 if (homepage != "") {
60 em::CloudPolicySettings* settings = signed_response.mutable_settings();
61 em::HomepageLocationProto* homepagelocation_proto =
62 settings->mutable_homepagelocation();
63 homepagelocation_proto->set_homepagelocation(homepage);
64 homepagelocation_proto->mutable_policy_options()->set_mode(policy_mode);
65 }
66 signed_response.set_timestamp(timestamp.ToTimeT());
67 std::string serialized_signed_response;
68 EXPECT_TRUE(signed_response.SerializeToString(&serialized_signed_response));
69
70 em::CloudPolicyResponse* response = new em::CloudPolicyResponse;
71 response->set_signed_response(serialized_signed_response);
72 // TODO(jkummerow): Set proper certificate_chain and signature (when
73 // implementing support for signature verification).
74 response->set_signature("TODO");
75 response->add_certificate_chain("TODO");
76 return response;
77 }
78
79 void WritePolicy(const em::CloudPolicyResponse& policy) {
80 std::string data;
81 em::CachedCloudPolicyResponse cached_policy;
82 cached_policy.mutable_cloud_policy()->CopyFrom(policy);
83 EXPECT_TRUE(cached_policy.SerializeToString(&data));
84 int size = static_cast<int>(data.size());
85 EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size));
86 }
87
88 FilePath test_file() {
89 return temp_dir_.path().AppendASCII("CloudPolicyCacheTest");
90 }
91
92 MessageLoop loop_;
93
94 private:
95 ScopedTempDir temp_dir_;
96 BrowserThread ui_thread_;
97 BrowserThread file_thread_;
98 };
99
100 TEST_F(CloudPolicyCacheTest, DecodePolicy) {
101 em::CloudPolicySettings settings;
102 settings.mutable_homepagelocation()->set_homepagelocation("chromium.org");
103 settings.mutable_javascriptenabled()->set_javascriptenabled(true);
104 settings.mutable_javascriptenabled()->mutable_policy_options()->set_mode(
105 em::PolicyOptions::MANDATORY);
106 settings.mutable_policyrefreshrate()->set_policyrefreshrate(5);
107 settings.mutable_policyrefreshrate()->mutable_policy_options()->set_mode(
108 em::PolicyOptions::RECOMMENDED);
109 PolicyMap mandatory_policy;
110 PolicyMap recommended_policy;
111 DecodePolicy(settings, &mandatory_policy, &recommended_policy);
112 PolicyMap mandatory;
113 mandatory.Set(kPolicyHomepageLocation,
114 Value::CreateStringValue("chromium.org"));
115 mandatory.Set(kPolicyJavascriptEnabled, Value::CreateBooleanValue(true));
116 PolicyMap recommended;
117 recommended.Set(kPolicyPolicyRefreshRate, Value::CreateIntegerValue(5));
118 EXPECT_TRUE(mandatory.Equals(mandatory_policy));
119 EXPECT_TRUE(recommended.Equals(recommended_policy));
120 }
121
122 TEST_F(CloudPolicyCacheTest, DecodeIntegerValue) {
123 const int min = std::numeric_limits<int>::min();
124 const int max = std::numeric_limits<int>::max();
125 scoped_ptr<Value> value(
126 DecodeIntegerValue(static_cast<google::protobuf::int64>(42)));
127 ASSERT_TRUE(value.get());
128 EXPECT_TRUE(value->Equals(Value::CreateIntegerValue(42)));
129 value.reset(
130 DecodeIntegerValue(static_cast<google::protobuf::int64>(min - 1LL)));
131 EXPECT_EQ(NULL, value.get());
132 value.reset(DecodeIntegerValue(static_cast<google::protobuf::int64>(min)));
133 ASSERT_TRUE(value.get());
134 EXPECT_TRUE(value->Equals(Value::CreateIntegerValue(min)));
135 value.reset(
136 DecodeIntegerValue(static_cast<google::protobuf::int64>(max + 1LL)));
137 EXPECT_EQ(NULL, value.get());
138 value.reset(DecodeIntegerValue(static_cast<google::protobuf::int64>(max)));
139 ASSERT_TRUE(value.get());
140 EXPECT_TRUE(value->Equals(Value::CreateIntegerValue(max)));
141 }
142
143 TEST_F(CloudPolicyCacheTest, DecodeStringList) {
144 em::StringList string_list;
145 string_list.add_entries("ponies");
146 string_list.add_entries("more ponies");
147 scoped_ptr<ListValue> decoded(DecodeStringList(string_list));
148 ListValue expected;
149 expected.Append(Value::CreateStringValue("ponies"));
150 expected.Append(Value::CreateStringValue("more ponies"));
151 EXPECT_TRUE(decoded->Equals(&expected));
152 }
153
154 TEST_F(CloudPolicyCacheTest, Empty) {
155 CloudPolicyCache cache(test_file());
156 PolicyMap empty;
157 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
158 EXPECT_TRUE(empty.Equals(*cache.GetRecommendedPolicy()));
159 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
160 }
161
162 TEST_F(CloudPolicyCacheTest, LoadNoFile) {
163 CloudPolicyCache cache(test_file());
164 cache.LoadPolicyFromFile();
165 PolicyMap empty;
166 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
167 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
168 }
169
170 TEST_F(CloudPolicyCacheTest, RejectFuture) {
171 scoped_ptr<em::CloudPolicyResponse> policy_response(
172 CreateHomepagePolicy("", base::Time::NowFromSystemTime() +
173 base::TimeDelta::FromMinutes(5),
174 em::PolicyOptions::MANDATORY));
175 WritePolicy(*policy_response);
176 CloudPolicyCache cache(test_file());
177 cache.LoadPolicyFromFile();
178 PolicyMap empty;
179 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
180 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
181 }
182
183 TEST_F(CloudPolicyCacheTest, LoadWithFile) {
184 scoped_ptr<em::CloudPolicyResponse> policy_response(
185 CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
186 em::PolicyOptions::MANDATORY));
187 WritePolicy(*policy_response);
188 CloudPolicyCache cache(test_file());
189 cache.LoadPolicyFromFile();
190 PolicyMap empty;
191 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
192 EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
193 EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
194 }
195
196 TEST_F(CloudPolicyCacheTest, LoadWithData) {
197 scoped_ptr<em::CloudPolicyResponse> policy(
198 CreateHomepagePolicy("http://www.example.com",
199 base::Time::NowFromSystemTime(),
200 em::PolicyOptions::MANDATORY));
201 WritePolicy(*policy);
202 CloudPolicyCache cache(test_file());
203 cache.LoadPolicyFromFile();
204 PolicyMap expected;
205 expected.Set(kPolicyHomepageLocation,
206 Value::CreateStringValue("http://www.example.com"));
207 EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
208 }
209
210 TEST_F(CloudPolicyCacheTest, SetPolicy) {
211 CloudPolicyCache cache(test_file());
212 scoped_ptr<em::CloudPolicyResponse> policy(
213 CreateHomepagePolicy("http://www.example.com",
214 base::Time::NowFromSystemTime(),
215 em::PolicyOptions::MANDATORY));
216 EXPECT_TRUE(cache.SetPolicy(*policy));
217 scoped_ptr<em::CloudPolicyResponse> policy2(
218 CreateHomepagePolicy("http://www.example.com",
219 base::Time::NowFromSystemTime(),
220 em::PolicyOptions::MANDATORY));
221 EXPECT_FALSE(cache.SetPolicy(*policy2));
222 PolicyMap expected;
223 expected.Set(kPolicyHomepageLocation,
224 Value::CreateStringValue("http://www.example.com"));
225 PolicyMap empty;
226 EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
227 EXPECT_TRUE(empty.Equals(*cache.GetRecommendedPolicy()));
228 policy.reset(CreateHomepagePolicy("http://www.example.com",
229 base::Time::NowFromSystemTime(),
230 em::PolicyOptions::RECOMMENDED));
231 EXPECT_TRUE(cache.SetPolicy(*policy));
232 EXPECT_TRUE(expected.Equals(*cache.GetRecommendedPolicy()));
233 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
234 }
235
236 TEST_F(CloudPolicyCacheTest, ResetPolicy) {
237 CloudPolicyCache cache(test_file());
238
239 scoped_ptr<em::CloudPolicyResponse> policy(
240 CreateHomepagePolicy("http://www.example.com",
241 base::Time::NowFromSystemTime(),
242 em::PolicyOptions::MANDATORY));
243 EXPECT_TRUE(cache.SetPolicy(*policy));
244 PolicyMap expected;
245 expected.Set(kPolicyHomepageLocation,
246 Value::CreateStringValue("http://www.example.com"));
247 EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
248
249 scoped_ptr<em::CloudPolicyResponse> empty_policy(
250 CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
251 em::PolicyOptions::MANDATORY));
252 EXPECT_TRUE(cache.SetPolicy(*empty_policy));
253 PolicyMap empty;
254 EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
255 }
256
257 TEST_F(CloudPolicyCacheTest, PersistPolicy) {
258 {
259 CloudPolicyCache cache(test_file());
260 scoped_ptr<em::CloudPolicyResponse> policy(
261 CreateHomepagePolicy("http://www.example.com",
262 base::Time::NowFromSystemTime(),
263 em::PolicyOptions::MANDATORY));
264 cache.SetPolicy(*policy);
265 }
266
267 loop_.RunAllPending();
268
269 EXPECT_TRUE(file_util::PathExists(test_file()));
270 CloudPolicyCache cache(test_file());
271 cache.LoadPolicyFromFile();
272 PolicyMap expected;
273 expected.Set(kPolicyHomepageLocation,
274 Value::CreateStringValue("http://www.example.com"));
275 EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
276 }
277
278 TEST_F(CloudPolicyCacheTest, FreshPolicyOverride) {
279 scoped_ptr<em::CloudPolicyResponse> policy(
280 CreateHomepagePolicy("http://www.example.com",
281 base::Time::NowFromSystemTime(),
282 em::PolicyOptions::MANDATORY));
283 WritePolicy(*policy);
284
285 CloudPolicyCache cache(test_file());
286 scoped_ptr<em::CloudPolicyResponse> updated_policy(
287 CreateHomepagePolicy("http://www.chromium.org",
288 base::Time::NowFromSystemTime(),
289 em::PolicyOptions::MANDATORY));
290 EXPECT_TRUE(cache.SetPolicy(*updated_policy));
291
292 cache.LoadPolicyFromFile();
293 PolicyMap expected;
294 expected.Set(kPolicyHomepageLocation,
295 Value::CreateStringValue("http://www.chromium.org"));
296 EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
297 }
298
299 } // namespace policy
300
301 // ==================================================================
302 // Everything below this line can go when we phase out support for
303 // the old (trusted testing/pilot program) policy format.
304
305 // This is a (slightly updated) copy of the old
306 // device_management_policy_cache_unittest.cc. The new CloudPolicyCache
307 // supports the old DMPC's interface for now (until it is phased out), so for
308 // this transitional period, we keep these old test cases but apply them to the
309 // new implementation (CPC).
310
311 namespace policy {
312
313 // Wraps base functionaly for the test cases.
314 class DeviceManagementPolicyCacheTestBase : public testing::Test {
315 protected:
316 // Add a string policy setting to a policy response message.
317 void AddStringPolicy(em::DevicePolicyResponse* policy,
318 const std::string& name,
319 const std::string& value) {
320 em::DevicePolicySetting* setting = policy->add_setting();
321 setting->set_policy_key(kChromeDevicePolicySettingKey);
322 em::GenericSetting* policy_value = setting->mutable_policy_value();
323 em::GenericNamedValue* named_value = policy_value->add_named_value();
324 named_value->set_name(name);
325 em::GenericValue* value_container = named_value->mutable_value();
326 value_container->set_value_type(em::GenericValue::VALUE_TYPE_STRING);
327 value_container->set_string_value(value);
328 }
329 };
330
331 // Tests the device management policy cache.
332 class DeviceManagementPolicyCacheTest
333 : public DeviceManagementPolicyCacheTestBase {
334 protected:
335 DeviceManagementPolicyCacheTest()
336 : loop_(MessageLoop::TYPE_UI),
337 ui_thread_(BrowserThread::UI, &loop_),
338 file_thread_(BrowserThread::FILE, &loop_) {}
339
340 void SetUp() {
341 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
342 }
343
344 void TearDown() {
345 loop_.RunAllPending();
346 }
347
348 void WritePolicy(const em::DevicePolicyResponse& policy,
349 const base::Time& timestamp) {
350 std::string data;
351 em::CachedCloudPolicyResponse cached_policy;
352 cached_policy.mutable_device_policy()->CopyFrom(policy);
353 cached_policy.set_timestamp(timestamp.ToTimeT());
354 EXPECT_TRUE(cached_policy.SerializeToString(&data));
355 int size = static_cast<int>(data.size());
356 EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size));
357 }
358
359 FilePath test_file() {
360 return temp_dir_.path().AppendASCII("DeviceManagementPolicyCacheTest");
361 }
362
363 protected:
364 MessageLoop loop_;
365
366 private:
367 ScopedTempDir temp_dir_;
368 BrowserThread ui_thread_;
369 BrowserThread file_thread_;
370 };
371
372 TEST_F(DeviceManagementPolicyCacheTest, Empty) {
373 CloudPolicyCache cache(test_file());
374 DictionaryValue empty;
375 scoped_ptr<Value> policy(cache.GetDevicePolicy());
376 EXPECT_TRUE(empty.Equals(policy.get()));
377 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
378 }
379
380 TEST_F(DeviceManagementPolicyCacheTest, LoadNoFile) {
381 CloudPolicyCache cache(test_file());
382 cache.LoadPolicyFromFile();
383 DictionaryValue empty;
384 scoped_ptr<Value> policy(cache.GetDevicePolicy());
385 EXPECT_TRUE(empty.Equals(policy.get()));
386 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
387 }
388
389 TEST_F(DeviceManagementPolicyCacheTest, RejectFuture) {
390 em::DevicePolicyResponse policy_response;
391 WritePolicy(policy_response, base::Time::NowFromSystemTime() +
392 base::TimeDelta::FromMinutes(5));
393 CloudPolicyCache cache(test_file());
394 cache.LoadPolicyFromFile();
395 DictionaryValue empty;
396 scoped_ptr<Value> policy(cache.GetDevicePolicy());
397 EXPECT_TRUE(empty.Equals(policy.get()));
398 EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
399 }
400
401 TEST_F(DeviceManagementPolicyCacheTest, LoadWithFile) {
402 em::DevicePolicyResponse policy_response;
403 WritePolicy(policy_response, base::Time::NowFromSystemTime());
404 CloudPolicyCache cache(test_file());
405 cache.LoadPolicyFromFile();
406 DictionaryValue empty;
407 scoped_ptr<Value> policy(cache.GetDevicePolicy());
408 EXPECT_TRUE(empty.Equals(policy.get()));
409 EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
410 EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
411 }
412
413 TEST_F(DeviceManagementPolicyCacheTest, LoadWithData) {
414 em::DevicePolicyResponse policy;
415 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
416 WritePolicy(policy, base::Time::NowFromSystemTime());
417 CloudPolicyCache cache(test_file());
418 cache.LoadPolicyFromFile();
419 DictionaryValue expected;
420 expected.Set("HomepageLocation",
421 Value::CreateStringValue("http://www.example.com"));
422 scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
423 EXPECT_TRUE(expected.Equals(policy_value.get()));
424 }
425
426 TEST_F(DeviceManagementPolicyCacheTest, SetDevicePolicy) {
427 CloudPolicyCache cache(test_file());
428 em::DevicePolicyResponse policy;
429 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
430 EXPECT_TRUE(cache.SetDevicePolicy(policy));
431 em::DevicePolicyResponse policy2;
432 AddStringPolicy(&policy2, "HomepageLocation", "http://www.example.com");
433 EXPECT_FALSE(cache.SetDevicePolicy(policy2));
434 DictionaryValue expected;
435 expected.Set("HomepageLocation",
436 Value::CreateStringValue("http://www.example.com"));
437 scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
438 EXPECT_TRUE(expected.Equals(policy_value.get()));
439 }
440
441 TEST_F(DeviceManagementPolicyCacheTest, ResetPolicy) {
442 CloudPolicyCache cache(test_file());
443
444 em::DevicePolicyResponse policy;
445 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
446 EXPECT_TRUE(cache.SetDevicePolicy(policy));
447 DictionaryValue expected;
448 expected.Set("HomepageLocation",
449 Value::CreateStringValue("http://www.example.com"));
450 scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
451 EXPECT_TRUE(expected.Equals(policy_value.get()));
452
453 EXPECT_TRUE(cache.SetDevicePolicy(em::DevicePolicyResponse()));
454 policy_value.reset(cache.GetDevicePolicy());
455 DictionaryValue empty;
456 EXPECT_TRUE(empty.Equals(policy_value.get()));
457 }
458
459 TEST_F(DeviceManagementPolicyCacheTest, PersistPolicy) {
460 {
461 CloudPolicyCache cache(test_file());
462 em::DevicePolicyResponse policy;
463 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
464 cache.SetDevicePolicy(policy);
465 }
466
467 loop_.RunAllPending();
468
469 EXPECT_TRUE(file_util::PathExists(test_file()));
470 CloudPolicyCache cache(test_file());
471 cache.LoadPolicyFromFile();
472 DictionaryValue expected;
473 expected.Set("HomepageLocation",
474 Value::CreateStringValue("http://www.example.com"));
475 scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
476 EXPECT_TRUE(expected.Equals(policy_value.get()));
477 }
478
479 TEST_F(DeviceManagementPolicyCacheTest, FreshPolicyOverride) {
480 em::DevicePolicyResponse policy;
481 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
482 WritePolicy(policy, base::Time::NowFromSystemTime());
483
484 CloudPolicyCache cache(test_file());
485 em::DevicePolicyResponse updated_policy;
486 AddStringPolicy(&updated_policy, "HomepageLocation",
487 "http://www.chromium.org");
488 EXPECT_TRUE(cache.SetDevicePolicy(updated_policy));
489
490 cache.LoadPolicyFromFile();
491 DictionaryValue expected;
492 expected.Set("HomepageLocation",
493 Value::CreateStringValue("http://www.chromium.org"));
494 scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
495 EXPECT_TRUE(expected.Equals(policy_value.get()));
496 }
497
498 // Tests proper decoding of policy values.
499 class DeviceManagementPolicyCacheDecodeTest
500 : public DeviceManagementPolicyCacheTestBase {
501 protected:
502 void DecodeAndCheck(Value* expected_value_ptr) {
503 scoped_ptr<Value> expected_value(expected_value_ptr);
504 scoped_ptr<Value> decoded_value(
505 CloudPolicyCache::DecodeValue(value_));
506 if (expected_value_ptr) {
507 ASSERT_TRUE(decoded_value.get());
508 EXPECT_TRUE(decoded_value->Equals(expected_value.get()));
509 } else {
510 ASSERT_FALSE(decoded_value.get());
511 }
512 }
513
514 DictionaryValue* DecodeDevicePolicy(const em::DevicePolicyResponse policy) {
515 return CloudPolicyCache::DecodeDevicePolicy(policy);
516 }
517
518 em::GenericValue value_;
519 };
520
521 TEST_F(DeviceManagementPolicyCacheDecodeTest, Bool) {
522 value_.set_value_type(em::GenericValue::VALUE_TYPE_BOOL);
523 value_.set_bool_value(true);
524 DecodeAndCheck(Value::CreateBooleanValue(true));
525 }
526
527 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64) {
528 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64);
529 value_.set_int64_value(42);
530 DecodeAndCheck(Value::CreateIntegerValue(42));
531 }
532
533 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64Overflow) {
534 const int min = std::numeric_limits<int>::min();
535 const int max = std::numeric_limits<int>::max();
536 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64);
537 value_.set_int64_value(min - 1LL);
538 DecodeAndCheck(NULL);
539 value_.set_int64_value(max + 1LL);
540 DecodeAndCheck(NULL);
541 value_.set_int64_value(min);
542 DecodeAndCheck(Value::CreateIntegerValue(min));
543 value_.set_int64_value(max);
544 DecodeAndCheck(Value::CreateIntegerValue(max));
545 }
546
547 TEST_F(DeviceManagementPolicyCacheDecodeTest, String) {
548 value_.set_value_type(em::GenericValue::VALUE_TYPE_STRING);
549 value_.set_string_value("ponies!");
550 DecodeAndCheck(Value::CreateStringValue("ponies!"));
551 }
552
553 TEST_F(DeviceManagementPolicyCacheDecodeTest, Double) {
554 value_.set_value_type(em::GenericValue::VALUE_TYPE_DOUBLE);
555 value_.set_double_value(0.42L);
556 DecodeAndCheck(Value::CreateDoubleValue(0.42L));
557 }
558
559 TEST_F(DeviceManagementPolicyCacheDecodeTest, Bytes) {
560 std::string data("binary ponies.");
561 value_.set_value_type(em::GenericValue::VALUE_TYPE_BYTES);
562 value_.set_bytes_value(data);
563 DecodeAndCheck(
564 BinaryValue::CreateWithCopiedBuffer(data.c_str(), data.size()));
565 }
566
567 TEST_F(DeviceManagementPolicyCacheDecodeTest, BoolArray) {
568 value_.set_value_type(em::GenericValue::VALUE_TYPE_BOOL_ARRAY);
569 value_.add_bool_array(false);
570 value_.add_bool_array(true);
571 ListValue* list = new ListValue;
572 list->Append(Value::CreateBooleanValue(false));
573 list->Append(Value::CreateBooleanValue(true));
574 DecodeAndCheck(list);
575 }
576
577 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64Array) {
578 value_.set_value_type(em::GenericValue::VALUE_TYPE_INT64_ARRAY);
579 value_.add_int64_array(42);
580 value_.add_int64_array(17);
581 ListValue* list = new ListValue;
582 list->Append(Value::CreateIntegerValue(42));
583 list->Append(Value::CreateIntegerValue(17));
584 DecodeAndCheck(list);
585 }
586
587 TEST_F(DeviceManagementPolicyCacheDecodeTest, StringArray) {
588 value_.set_value_type(em::GenericValue::VALUE_TYPE_STRING_ARRAY);
589 value_.add_string_array("ponies");
590 value_.add_string_array("more ponies");
591 ListValue* list = new ListValue;
592 list->Append(Value::CreateStringValue("ponies"));
593 list->Append(Value::CreateStringValue("more ponies"));
594 DecodeAndCheck(list);
595 }
596
597 TEST_F(DeviceManagementPolicyCacheDecodeTest, DoubleArray) {
598 value_.set_value_type(em::GenericValue::VALUE_TYPE_DOUBLE_ARRAY);
599 value_.add_double_array(0.42L);
600 value_.add_double_array(0.17L);
601 ListValue* list = new ListValue;
602 list->Append(Value::CreateDoubleValue(0.42L));
603 list->Append(Value::CreateDoubleValue(0.17L));
604 DecodeAndCheck(list);
605 }
606
607 TEST_F(DeviceManagementPolicyCacheDecodeTest, DecodePolicy) {
608 em::DevicePolicyResponse policy;
609 AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
610 scoped_ptr<Value> decoded(DecodeDevicePolicy(policy));
611 DictionaryValue expected;
612 expected.Set("HomepageLocation",
613 Value::CreateStringValue("http://www.example.com"));
614 EXPECT_TRUE(expected.Equals(decoded.get()));
615 }
616
617 } // namespace policy
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698