OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h
" | 5 #include "chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h
" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
| 8 #include <utility> |
8 | 9 |
9 #include "base/callback.h" | 10 #include "base/callback.h" |
10 #include "base/json/json_reader.h" | 11 #include "base/json/json_reader.h" |
11 #include "base/macros.h" | 12 #include "base/macros.h" |
| 13 #include "base/memory/ptr_util.h" |
12 #include "base/values.h" | 14 #include "base/values.h" |
13 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h" | 15 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h" |
14 #include "chrome/common/pref_names.h" | 16 #include "chrome/common/pref_names.h" |
15 #include "components/policy/core/browser/policy_error_map.h" | 17 #include "components/policy/core/browser/policy_error_map.h" |
16 #include "components/policy/core/common/external_data_fetcher.h" | 18 #include "components/policy/core/common/external_data_fetcher.h" |
17 #include "components/policy/core/common/policy_map.h" | 19 #include "components/policy/core/common/policy_map.h" |
18 #include "components/policy/core/common/policy_types.h" | 20 #include "components/policy/core/common/policy_types.h" |
19 #include "components/policy/core/common/schema.h" | 21 #include "components/policy/core/common/schema.h" |
20 #include "components/prefs/pref_value_map.h" | 22 #include "components/prefs/pref_value_map.h" |
21 #include "policy/policy_constants.h" | 23 #include "policy/policy_constants.h" |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 } | 56 } |
55 | 57 |
56 TEST_F(ScreenMagnifierPolicyHandlerTest, Default) { | 58 TEST_F(ScreenMagnifierPolicyHandlerTest, Default) { |
57 handler_.ApplyPolicySettings(policy_, &prefs_); | 59 handler_.ApplyPolicySettings(policy_, &prefs_); |
58 EXPECT_FALSE( | 60 EXPECT_FALSE( |
59 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, NULL)); | 61 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, NULL)); |
60 EXPECT_FALSE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, NULL)); | 62 EXPECT_FALSE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, NULL)); |
61 } | 63 } |
62 | 64 |
63 TEST_F(ScreenMagnifierPolicyHandlerTest, Disabled) { | 65 TEST_F(ScreenMagnifierPolicyHandlerTest, Disabled) { |
64 policy_.Set(key::kScreenMagnifierType, | 66 policy_.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY, |
65 POLICY_LEVEL_MANDATORY, | 67 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
66 POLICY_SCOPE_USER, | 68 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
67 POLICY_SOURCE_CLOUD, | |
68 new base::FundamentalValue(0), | |
69 NULL); | |
70 handler_.ApplyPolicySettings(policy_, &prefs_); | 69 handler_.ApplyPolicySettings(policy_, &prefs_); |
71 | 70 |
72 const base::Value* enabled = NULL; | 71 const base::Value* enabled = NULL; |
73 EXPECT_TRUE( | 72 EXPECT_TRUE( |
74 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled)); | 73 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled)); |
75 ASSERT_TRUE(enabled); | 74 ASSERT_TRUE(enabled); |
76 EXPECT_TRUE(base::FundamentalValue(false).Equals(enabled)); | 75 EXPECT_TRUE(base::FundamentalValue(false).Equals(enabled)); |
77 | 76 |
78 const base::Value* type = NULL; | 77 const base::Value* type = NULL; |
79 EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type)); | 78 EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type)); |
80 ASSERT_TRUE(type); | 79 ASSERT_TRUE(type); |
81 EXPECT_TRUE(base::FundamentalValue(0).Equals(type)); | 80 EXPECT_TRUE(base::FundamentalValue(0).Equals(type)); |
82 } | 81 } |
83 | 82 |
84 TEST_F(ScreenMagnifierPolicyHandlerTest, Enabled) { | 83 TEST_F(ScreenMagnifierPolicyHandlerTest, Enabled) { |
85 policy_.Set(key::kScreenMagnifierType, | 84 policy_.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY, |
86 POLICY_LEVEL_MANDATORY, | 85 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
87 POLICY_SCOPE_USER, | 86 base::WrapUnique(new base::FundamentalValue(1)), nullptr); |
88 POLICY_SOURCE_CLOUD, | |
89 new base::FundamentalValue(1), | |
90 NULL); | |
91 handler_.ApplyPolicySettings(policy_, &prefs_); | 87 handler_.ApplyPolicySettings(policy_, &prefs_); |
92 | 88 |
93 const base::Value* enabled = NULL; | 89 const base::Value* enabled = NULL; |
94 EXPECT_TRUE( | 90 EXPECT_TRUE( |
95 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled)); | 91 prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled)); |
96 ASSERT_TRUE(enabled); | 92 ASSERT_TRUE(enabled); |
97 EXPECT_TRUE(base::FundamentalValue(true).Equals(enabled)); | 93 EXPECT_TRUE(base::FundamentalValue(true).Equals(enabled)); |
98 | 94 |
99 const base::Value* type = NULL; | 95 const base::Value* type = NULL; |
100 EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type)); | 96 EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type)); |
101 ASSERT_TRUE(type); | 97 ASSERT_TRUE(type); |
102 EXPECT_TRUE(base::FundamentalValue(1).Equals(type)); | 98 EXPECT_TRUE(base::FundamentalValue(1).Equals(type)); |
103 } | 99 } |
104 | 100 |
105 TEST(ExternalDataPolicyHandlerTest, Empty) { | 101 TEST(ExternalDataPolicyHandlerTest, Empty) { |
106 PolicyErrorMap errors; | 102 PolicyErrorMap errors; |
107 EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 103 EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
108 .CheckPolicySettings(PolicyMap(), &errors)); | 104 .CheckPolicySettings(PolicyMap(), &errors)); |
109 EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty()); | 105 EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty()); |
110 } | 106 } |
111 | 107 |
112 TEST(ExternalDataPolicyHandlerTest, WrongType) { | 108 TEST(ExternalDataPolicyHandlerTest, WrongType) { |
113 PolicyMap policy_map; | 109 PolicyMap policy_map; |
114 policy_map.Set(key::kUserAvatarImage, | 110 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
115 POLICY_LEVEL_MANDATORY, | 111 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
116 POLICY_SCOPE_USER, | 112 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
117 POLICY_SOURCE_CLOUD, | |
118 new base::FundamentalValue(false), | |
119 NULL); | |
120 PolicyErrorMap errors; | 113 PolicyErrorMap errors; |
121 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 114 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
122 .CheckPolicySettings(policy_map, &errors)); | 115 .CheckPolicySettings(policy_map, &errors)); |
123 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); | 116 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); |
124 } | 117 } |
125 | 118 |
126 TEST(ExternalDataPolicyHandlerTest, MissingURL) { | 119 TEST(ExternalDataPolicyHandlerTest, MissingURL) { |
127 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); | 120 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
128 dict->SetString("hash", "1234567890123456789012345678901234567890"); | 121 dict->SetString("hash", "1234567890123456789012345678901234567890"); |
129 PolicyMap policy_map; | 122 PolicyMap policy_map; |
130 policy_map.Set(key::kUserAvatarImage, | 123 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
131 POLICY_LEVEL_MANDATORY, | 124 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, std::move(dict), |
132 POLICY_SCOPE_USER, | 125 nullptr); |
133 POLICY_SOURCE_CLOUD, | |
134 dict.release(), | |
135 NULL); | |
136 PolicyErrorMap errors; | 126 PolicyErrorMap errors; |
137 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 127 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
138 .CheckPolicySettings(policy_map, &errors)); | 128 .CheckPolicySettings(policy_map, &errors)); |
139 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); | 129 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); |
140 } | 130 } |
141 | 131 |
142 TEST(ExternalDataPolicyHandlerTest, InvalidURL) { | 132 TEST(ExternalDataPolicyHandlerTest, InvalidURL) { |
143 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); | 133 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
144 dict->SetString("url", "http://"); | 134 dict->SetString("url", "http://"); |
145 dict->SetString("hash", "1234567890123456789012345678901234567890"); | 135 dict->SetString("hash", "1234567890123456789012345678901234567890"); |
146 PolicyMap policy_map; | 136 PolicyMap policy_map; |
147 policy_map.Set(key::kUserAvatarImage, | 137 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
148 POLICY_LEVEL_MANDATORY, | 138 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, std::move(dict), |
149 POLICY_SCOPE_USER, | 139 nullptr); |
150 POLICY_SOURCE_CLOUD, | |
151 dict.release(), | |
152 NULL); | |
153 PolicyErrorMap errors; | 140 PolicyErrorMap errors; |
154 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 141 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
155 .CheckPolicySettings(policy_map, &errors)); | 142 .CheckPolicySettings(policy_map, &errors)); |
156 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); | 143 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); |
157 } | 144 } |
158 | 145 |
159 TEST(ExternalDataPolicyHandlerTest, MissingHash) { | 146 TEST(ExternalDataPolicyHandlerTest, MissingHash) { |
160 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); | 147 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
161 dict->SetString("url", "http://localhost/"); | 148 dict->SetString("url", "http://localhost/"); |
162 PolicyMap policy_map; | 149 PolicyMap policy_map; |
163 policy_map.Set(key::kUserAvatarImage, | 150 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
164 POLICY_LEVEL_MANDATORY, | 151 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, std::move(dict), |
165 POLICY_SCOPE_USER, | 152 nullptr); |
166 POLICY_SOURCE_CLOUD, | |
167 dict.release(), | |
168 NULL); | |
169 PolicyErrorMap errors; | 153 PolicyErrorMap errors; |
170 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 154 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
171 .CheckPolicySettings(policy_map, &errors)); | 155 .CheckPolicySettings(policy_map, &errors)); |
172 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); | 156 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); |
173 } | 157 } |
174 | 158 |
175 TEST(ExternalDataPolicyHandlerTest, InvalidHash) { | 159 TEST(ExternalDataPolicyHandlerTest, InvalidHash) { |
176 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); | 160 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
177 dict->SetString("url", "http://localhost/"); | 161 dict->SetString("url", "http://localhost/"); |
178 dict->SetString("hash", "1234"); | 162 dict->SetString("hash", "1234"); |
179 PolicyMap policy_map; | 163 PolicyMap policy_map; |
180 policy_map.Set(key::kUserAvatarImage, | 164 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
181 POLICY_LEVEL_MANDATORY, | 165 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, std::move(dict), |
182 POLICY_SCOPE_USER, | 166 nullptr); |
183 POLICY_SOURCE_CLOUD, | |
184 dict.release(), | |
185 NULL); | |
186 PolicyErrorMap errors; | 167 PolicyErrorMap errors; |
187 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 168 EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
188 .CheckPolicySettings(policy_map, &errors)); | 169 .CheckPolicySettings(policy_map, &errors)); |
189 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); | 170 EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty()); |
190 } | 171 } |
191 | 172 |
192 TEST(ExternalDataPolicyHandlerTest, Valid) { | 173 TEST(ExternalDataPolicyHandlerTest, Valid) { |
193 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); | 174 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
194 dict->SetString("url", "http://localhost/"); | 175 dict->SetString("url", "http://localhost/"); |
195 dict->SetString( | 176 dict->SetString( |
196 "hash", | 177 "hash", |
197 "1234567890123456789012345678901234567890123456789012345678901234"); | 178 "1234567890123456789012345678901234567890123456789012345678901234"); |
198 PolicyMap policy_map; | 179 PolicyMap policy_map; |
199 policy_map.Set(key::kUserAvatarImage, | 180 policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY, |
200 POLICY_LEVEL_MANDATORY, | 181 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, std::move(dict), |
201 POLICY_SCOPE_USER, | 182 nullptr); |
202 POLICY_SOURCE_CLOUD, | |
203 dict.release(), | |
204 NULL); | |
205 PolicyErrorMap errors; | 183 PolicyErrorMap errors; |
206 EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage) | 184 EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage) |
207 .CheckPolicySettings(policy_map, &errors)); | 185 .CheckPolicySettings(policy_map, &errors)); |
208 EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty()); | 186 EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty()); |
209 } | 187 } |
210 | 188 |
211 const char kLoginScreenPowerManagementPolicy[] = | 189 const char kLoginScreenPowerManagementPolicy[] = |
212 "{" | 190 "{" |
213 " \"AC\": {" | 191 " \"AC\": {" |
214 " \"Delays\": {" | 192 " \"Delays\": {" |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 " \"Name\": \"some name\"," | 228 " \"Name\": \"some name\"," |
251 " \"WiFi\": {" | 229 " \"WiFi\": {" |
252 " \"Security\": \"WEP-PSK\"," | 230 " \"Security\": \"WEP-PSK\"," |
253 " \"SSID\": \"ssid\"," | 231 " \"SSID\": \"ssid\"," |
254 " \"Passphrase\": \"pass\"," | 232 " \"Passphrase\": \"pass\"," |
255 " }" | 233 " }" |
256 " }]" | 234 " }]" |
257 "}"); | 235 "}"); |
258 | 236 |
259 PolicyMap policy_map; | 237 PolicyMap policy_map; |
260 policy_map.Set(key::kOpenNetworkConfiguration, | 238 policy_map.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY, |
261 POLICY_LEVEL_MANDATORY, | 239 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
262 POLICY_SCOPE_USER, | 240 base::WrapUnique(new base::StringValue(kTestONC)), nullptr); |
263 POLICY_SOURCE_CLOUD, | |
264 new base::StringValue(kTestONC), | |
265 NULL); | |
266 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( | 241 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( |
267 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); | 242 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); |
268 PolicyErrorMap errors; | 243 PolicyErrorMap errors; |
269 EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors)); | 244 EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors)); |
270 EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); | 245 EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); |
271 } | 246 } |
272 | 247 |
273 TEST(NetworkConfigurationPolicyHandlerTest, WrongType) { | 248 TEST(NetworkConfigurationPolicyHandlerTest, WrongType) { |
274 PolicyMap policy_map; | 249 PolicyMap policy_map; |
275 policy_map.Set(key::kOpenNetworkConfiguration, | 250 policy_map.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY, |
276 POLICY_LEVEL_MANDATORY, | 251 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
277 POLICY_SCOPE_USER, | 252 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
278 POLICY_SOURCE_CLOUD, | |
279 new base::FundamentalValue(false), | |
280 NULL); | |
281 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( | 253 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( |
282 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); | 254 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); |
283 PolicyErrorMap errors; | 255 PolicyErrorMap errors; |
284 EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors)); | 256 EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors)); |
285 EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); | 257 EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); |
286 } | 258 } |
287 | 259 |
288 TEST(NetworkConfigurationPolicyHandlerTest, JSONParseError) { | 260 TEST(NetworkConfigurationPolicyHandlerTest, JSONParseError) { |
289 const std::string kTestONC("I'm not proper JSON!"); | 261 const std::string kTestONC("I'm not proper JSON!"); |
290 PolicyMap policy_map; | 262 PolicyMap policy_map; |
291 policy_map.Set(key::kOpenNetworkConfiguration, | 263 policy_map.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY, |
292 POLICY_LEVEL_MANDATORY, | 264 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
293 POLICY_SCOPE_USER, | 265 base::WrapUnique(new base::StringValue(kTestONC)), nullptr); |
294 POLICY_SOURCE_CLOUD, | |
295 new base::StringValue(kTestONC), | |
296 NULL); | |
297 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( | 266 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( |
298 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); | 267 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); |
299 PolicyErrorMap errors; | 268 PolicyErrorMap errors; |
300 EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors)); | 269 EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors)); |
301 EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); | 270 EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty()); |
302 } | 271 } |
303 | 272 |
304 TEST(NetworkConfigurationPolicyHandlerTest, Sanitization) { | 273 TEST(NetworkConfigurationPolicyHandlerTest, Sanitization) { |
305 const std::string kTestONC( | 274 const std::string kTestONC( |
306 "{" | 275 "{" |
307 " \"NetworkConfigurations\": [{" | 276 " \"NetworkConfigurations\": [{" |
308 " \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\"," | 277 " \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\"," |
309 " \"Type\": \"WiFi\"," | 278 " \"Type\": \"WiFi\"," |
310 " \"Name\": \"some name\"," | 279 " \"Name\": \"some name\"," |
311 " \"WiFi\": {" | 280 " \"WiFi\": {" |
312 " \"Security\": \"WEP-PSK\"," | 281 " \"Security\": \"WEP-PSK\"," |
313 " \"SSID\": \"ssid\"," | 282 " \"SSID\": \"ssid\"," |
314 " \"Passphrase\": \"pass\"," | 283 " \"Passphrase\": \"pass\"," |
315 " }" | 284 " }" |
316 " }]" | 285 " }]" |
317 "}"); | 286 "}"); |
318 | 287 |
319 PolicyMap policy_map; | 288 PolicyMap policy_map; |
320 policy_map.Set(key::kOpenNetworkConfiguration, | 289 policy_map.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY, |
321 POLICY_LEVEL_MANDATORY, | 290 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
322 POLICY_SCOPE_USER, | 291 base::WrapUnique(new base::StringValue(kTestONC)), nullptr); |
323 POLICY_SOURCE_CLOUD, | |
324 new base::StringValue(kTestONC), | |
325 NULL); | |
326 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( | 292 std::unique_ptr<NetworkConfigurationPolicyHandler> handler( |
327 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); | 293 NetworkConfigurationPolicyHandler::CreateForUserPolicy()); |
328 PolicyErrorMap errors; | 294 PolicyErrorMap errors; |
329 handler->PrepareForDisplaying(&policy_map); | 295 handler->PrepareForDisplaying(&policy_map); |
330 const base::Value* sanitized = | 296 const base::Value* sanitized = |
331 policy_map.GetValue(key::kOpenNetworkConfiguration); | 297 policy_map.GetValue(key::kOpenNetworkConfiguration); |
332 ASSERT_TRUE(sanitized); | 298 ASSERT_TRUE(sanitized); |
333 std::string sanitized_onc; | 299 std::string sanitized_onc; |
334 EXPECT_TRUE(sanitized->GetAsString(&sanitized_onc)); | 300 EXPECT_TRUE(sanitized->GetAsString(&sanitized_onc)); |
335 EXPECT_FALSE(sanitized_onc.empty()); | 301 EXPECT_FALSE(sanitized_onc.empty()); |
336 EXPECT_EQ(std::string::npos, sanitized_onc.find("pass")); | 302 EXPECT_EQ(std::string::npos, sanitized_onc.find("pass")); |
337 } | 303 } |
338 | 304 |
339 TEST(PinnedLauncherAppsPolicyHandler, PrefTranslation) { | 305 TEST(PinnedLauncherAppsPolicyHandler, PrefTranslation) { |
340 base::ListValue list; | 306 base::ListValue list; |
341 PolicyMap policy_map; | 307 PolicyMap policy_map; |
342 PrefValueMap prefs; | 308 PrefValueMap prefs; |
343 base::ListValue expected_pinned_apps; | 309 base::ListValue expected_pinned_apps; |
344 base::Value* value = NULL; | 310 base::Value* value = NULL; |
345 PinnedLauncherAppsPolicyHandler handler; | 311 PinnedLauncherAppsPolicyHandler handler; |
346 | 312 |
347 policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY, | 313 policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY, |
348 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, list.DeepCopy(), | 314 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), |
349 nullptr); | 315 nullptr); |
350 handler.ApplyPolicySettings(policy_map, &prefs); | 316 handler.ApplyPolicySettings(policy_map, &prefs); |
351 EXPECT_TRUE(prefs.GetValue(prefs::kPolicyPinnedLauncherApps, &value)); | 317 EXPECT_TRUE(prefs.GetValue(prefs::kPolicyPinnedLauncherApps, &value)); |
352 EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value)); | 318 EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value)); |
353 | 319 |
354 base::StringValue entry1("abcdefghijklmnopabcdefghijklmnop"); | 320 base::StringValue entry1("abcdefghijklmnopabcdefghijklmnop"); |
355 base::DictionaryValue* entry1_dict = new base::DictionaryValue(); | 321 base::DictionaryValue* entry1_dict = new base::DictionaryValue(); |
356 entry1_dict->Set(ash::kPinnedAppsPrefAppIDPath, entry1.DeepCopy()); | 322 entry1_dict->Set(ash::kPinnedAppsPrefAppIDPath, entry1.DeepCopy()); |
357 expected_pinned_apps.Append(entry1_dict); | 323 expected_pinned_apps.Append(entry1_dict); |
358 list.Append(entry1.DeepCopy()); | 324 list.Append(entry1.DeepCopy()); |
359 policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY, | 325 policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY, |
360 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, list.DeepCopy(), | 326 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), |
361 nullptr); | 327 nullptr); |
362 prefs.Clear(); | 328 prefs.Clear(); |
363 handler.ApplyPolicySettings(policy_map, &prefs); | 329 handler.ApplyPolicySettings(policy_map, &prefs); |
364 EXPECT_TRUE(prefs.GetValue(prefs::kPolicyPinnedLauncherApps, &value)); | 330 EXPECT_TRUE(prefs.GetValue(prefs::kPolicyPinnedLauncherApps, &value)); |
365 EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value)); | 331 EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value)); |
366 } | 332 } |
367 | 333 |
368 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, Empty) { | 334 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, Empty) { |
369 PolicyMap policy_map; | 335 PolicyMap policy_map; |
370 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); | 336 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); |
371 PolicyErrorMap errors; | 337 PolicyErrorMap errors; |
372 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 338 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
373 EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); | 339 EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); |
374 } | 340 } |
375 | 341 |
376 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, ValidPolicy) { | 342 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, ValidPolicy) { |
377 PolicyMap policy_map; | 343 PolicyMap policy_map; |
378 policy_map.Set( | 344 policy_map.Set(key::kDeviceLoginScreenPowerManagement, POLICY_LEVEL_MANDATORY, |
379 key::kDeviceLoginScreenPowerManagement, POLICY_LEVEL_MANDATORY, | 345 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
380 POLICY_SCOPE_USER, | 346 base::JSONReader::Read(kLoginScreenPowerManagementPolicy), |
381 POLICY_SOURCE_CLOUD, | 347 nullptr); |
382 base::JSONReader::Read(kLoginScreenPowerManagementPolicy).release(), | |
383 NULL); | |
384 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); | 348 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); |
385 PolicyErrorMap errors; | 349 PolicyErrorMap errors; |
386 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 350 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
387 EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); | 351 EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); |
388 } | 352 } |
389 | 353 |
390 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, WrongType) { | 354 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, WrongType) { |
391 PolicyMap policy_map; | 355 PolicyMap policy_map; |
392 policy_map.Set(key::kDeviceLoginScreenPowerManagement, | 356 policy_map.Set(key::kDeviceLoginScreenPowerManagement, POLICY_LEVEL_MANDATORY, |
393 POLICY_LEVEL_MANDATORY, | 357 POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
394 POLICY_SCOPE_USER, | 358 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
395 POLICY_SOURCE_CLOUD, | |
396 new base::FundamentalValue(false), | |
397 NULL); | |
398 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); | 359 LoginScreenPowerManagementPolicyHandler handler(chrome_schema_); |
399 PolicyErrorMap errors; | 360 PolicyErrorMap errors; |
400 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 361 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
401 EXPECT_FALSE( | 362 EXPECT_FALSE( |
402 errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); | 363 errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty()); |
403 } | 364 } |
404 | 365 |
405 } // namespace policy | 366 } // namespace policy |
OLD | NEW |