| 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 |
|---|
Chromium Code Reviews
Issue 6532019:
New policy protobuf protocol. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src