configuration_policy_handler_chromeos_unittest.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
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
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h"
6
7#include "base/callback.h"
8#include "base/memory/scoped_ptr.h"
9#include "base/prefs/pref_value_map.h"
10#include "base/values.h"
11#include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
12#include "chrome/common/pref_names.h"
13#include "components/policy/core/browser/policy_error_map.h"
14#include "components/policy/core/common/external_data_fetcher.h"
15#include "components/policy/core/common/policy_map.h"
16#include "policy/policy_constants.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19namespace policy {
20
21namespace {
22
23// Test cases for the screen magnifier type policy setting.
24class ScreenMagnifierPolicyHandlerTest : public testing::Test {
25 protected:
26  PolicyMap policy_;
27  PrefValueMap prefs_;
28  ScreenMagnifierPolicyHandler handler_;
29};
30
31TEST_F(ScreenMagnifierPolicyHandlerTest, Default) {
32  handler_.ApplyPolicySettings(policy_, &prefs_);
33  EXPECT_FALSE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, NULL));
34  EXPECT_FALSE(prefs_.GetValue(prefs::kScreenMagnifierType, NULL));
35}
36
37TEST_F(ScreenMagnifierPolicyHandlerTest, Disabled) {
38  policy_.Set(key::kScreenMagnifierType,
39              POLICY_LEVEL_MANDATORY,
40              POLICY_SCOPE_USER,
41              base::Value::CreateIntegerValue(0),
42              NULL);
43  handler_.ApplyPolicySettings(policy_, &prefs_);
44
45  const base::Value* enabled = NULL;
46  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, &enabled));
47  ASSERT_TRUE(enabled);
48  EXPECT_TRUE(base::FundamentalValue(false).Equals(enabled));
49
50  const base::Value* type = NULL;
51  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierType, &type));
52  ASSERT_TRUE(type);
53  EXPECT_TRUE(base::FundamentalValue(0).Equals(type));
54}
55
56TEST_F(ScreenMagnifierPolicyHandlerTest, Enabled) {
57  policy_.Set(key::kScreenMagnifierType,
58              POLICY_LEVEL_MANDATORY,
59              POLICY_SCOPE_USER,
60              base::Value::CreateIntegerValue(1),
61              NULL);
62  handler_.ApplyPolicySettings(policy_, &prefs_);
63
64  const base::Value* enabled = NULL;
65  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, &enabled));
66  ASSERT_TRUE(enabled);
67  EXPECT_TRUE(base::FundamentalValue(true).Equals(enabled));
68
69  const base::Value* type = NULL;
70  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierType, &type));
71  ASSERT_TRUE(type);
72  EXPECT_TRUE(base::FundamentalValue(1).Equals(type));
73}
74
75TEST(ExternalDataPolicyHandlerTest, Empty) {
76  PolicyErrorMap errors;
77  EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage)
78                  .CheckPolicySettings(PolicyMap(), &errors));
79  EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty());
80}
81
82TEST(ExternalDataPolicyHandlerTest, WrongType) {
83  PolicyMap policy_map;
84  policy_map.Set(key::kUserAvatarImage,
85                 POLICY_LEVEL_MANDATORY,
86                 POLICY_SCOPE_USER,
87                 new base::FundamentalValue(false),
88                 NULL);
89  PolicyErrorMap errors;
90  EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
91                   .CheckPolicySettings(policy_map, &errors));
92  EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
93}
94
95TEST(ExternalDataPolicyHandlerTest, MissingURL) {
96  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
97  dict->SetString("hash", "1234567890123456789012345678901234567890");
98  PolicyMap policy_map;
99  policy_map.Set(key::kUserAvatarImage,
100                 POLICY_LEVEL_MANDATORY,
101                 POLICY_SCOPE_USER,
102                 dict.release(),
103                 NULL);
104  PolicyErrorMap errors;
105  EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
106                   .CheckPolicySettings(policy_map, &errors));
107  EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
108}
109
110TEST(ExternalDataPolicyHandlerTest, InvalidURL) {
111  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
112  dict->SetString("url", "http://");
113  dict->SetString("hash", "1234567890123456789012345678901234567890");
114  PolicyMap policy_map;
115  policy_map.Set(key::kUserAvatarImage,
116                 POLICY_LEVEL_MANDATORY,
117                 POLICY_SCOPE_USER,
118                 dict.release(),
119                 NULL);
120  PolicyErrorMap errors;
121  EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
122                   .CheckPolicySettings(policy_map, &errors));
123  EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
124}
125
126TEST(ExternalDataPolicyHandlerTest, MissingHash) {
127  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
128  dict->SetString("url", "http://localhost/");
129  PolicyMap policy_map;
130  policy_map.Set(key::kUserAvatarImage,
131                 POLICY_LEVEL_MANDATORY,
132                 POLICY_SCOPE_USER,
133                 dict.release(),
134                 NULL);
135  PolicyErrorMap errors;
136  EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
137                   .CheckPolicySettings(policy_map, &errors));
138  EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
139}
140
141TEST(ExternalDataPolicyHandlerTest, InvalidHash) {
142  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
143  dict->SetString("url", "http://localhost/");
144  dict->SetString("hash", "1234");
145  PolicyMap policy_map;
146  policy_map.Set(key::kUserAvatarImage,
147                 POLICY_LEVEL_MANDATORY,
148                 POLICY_SCOPE_USER,
149                 dict.release(),
150                 NULL);
151  PolicyErrorMap errors;
152  EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
153                   .CheckPolicySettings(policy_map, &errors));
154  EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
155}
156
157TEST(ExternalDataPolicyHandlerTest, Valid) {
158  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
159  dict->SetString("url", "http://localhost/");
160  dict->SetString("hash", "1234567890123456789012345678901234567890");
161  PolicyMap policy_map;
162  policy_map.Set(key::kUserAvatarImage,
163                 POLICY_LEVEL_MANDATORY,
164                 POLICY_SCOPE_USER,
165                 dict.release(),
166                 NULL);
167  PolicyErrorMap errors;
168  EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage)
169                  .CheckPolicySettings(policy_map, &errors));
170  EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty());
171}
172
173const char kLoginScreenPowerManagementPolicy[] =
174    "{"
175    "  \"AC\": {"
176    "    \"Delays\": {"
177    "      \"ScreenDim\": 5000,"
178    "      \"ScreenOff\": 7000,"
179    "      \"Idle\": 9000"
180    "    },"
181    "    \"IdleAction\": \"DoNothing\""
182    "  },"
183    "  \"Battery\": {"
184    "    \"Delays\": {"
185    "      \"ScreenDim\": 1000,"
186    "      \"ScreenOff\": 3000,"
187    "      \"Idle\": 4000"
188    "    },"
189    "    \"IdleAction\": \"DoNothing\""
190    "  },"
191    "  \"LidCloseAction\": \"DoNothing\","
192    "  \"UserActivityScreenDimDelayScale\": 300"
193    "}";
194
195}  // namespace
196
197TEST(NetworkConfigurationPolicyHandlerTest, Empty) {
198  PolicyMap policy_map;
199  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
200      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
201  PolicyErrorMap errors;
202  EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors));
203  EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
204}
205
206TEST(NetworkConfigurationPolicyHandlerTest, ValidONC) {
207  const std::string kTestONC(
208      "{"
209      "  \"NetworkConfigurations\": [{"
210      "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
211      "    \"Type\": \"WiFi\","
212      "    \"Name\": \"some name\","
213      "    \"WiFi\": {"
214      "      \"Security\": \"WEP-PSK\","
215      "      \"SSID\": \"ssid\","
216      "      \"Passphrase\": \"pass\","
217      "    }"
218      "  }]"
219      "}");
220
221  PolicyMap policy_map;
222  policy_map.Set(key::kOpenNetworkConfiguration,
223                 POLICY_LEVEL_MANDATORY,
224                 POLICY_SCOPE_USER,
225                 Value::CreateStringValue(kTestONC),
226                 NULL);
227  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
228      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
229  PolicyErrorMap errors;
230  EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors));
231  EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
232}
233
234TEST(NetworkConfigurationPolicyHandlerTest, WrongType) {
235  PolicyMap policy_map;
236  policy_map.Set(key::kOpenNetworkConfiguration,
237                 POLICY_LEVEL_MANDATORY,
238                 POLICY_SCOPE_USER,
239                 Value::CreateBooleanValue(false),
240                 NULL);
241  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
242      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
243  PolicyErrorMap errors;
244  EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors));
245  EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
246}
247
248TEST(NetworkConfigurationPolicyHandlerTest, JSONParseError) {
249  const std::string kTestONC("I'm not proper JSON!");
250  PolicyMap policy_map;
251  policy_map.Set(key::kOpenNetworkConfiguration,
252                 POLICY_LEVEL_MANDATORY,
253                 POLICY_SCOPE_USER,
254                 Value::CreateStringValue(kTestONC),
255                 NULL);
256  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
257      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
258  PolicyErrorMap errors;
259  EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors));
260  EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
261}
262
263TEST(NetworkConfigurationPolicyHandlerTest, Sanitization) {
264  const std::string kTestONC(
265      "{"
266      "  \"NetworkConfigurations\": [{"
267      "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
268      "    \"Type\": \"WiFi\","
269      "    \"Name\": \"some name\","
270      "    \"WiFi\": {"
271      "      \"Security\": \"WEP-PSK\","
272      "      \"SSID\": \"ssid\","
273      "      \"Passphrase\": \"pass\","
274      "    }"
275      "  }]"
276      "}");
277
278  PolicyMap policy_map;
279  policy_map.Set(key::kOpenNetworkConfiguration,
280                 POLICY_LEVEL_MANDATORY,
281                 POLICY_SCOPE_USER,
282                 Value::CreateStringValue(kTestONC),
283                 NULL);
284  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
285      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
286  PolicyErrorMap errors;
287  handler->PrepareForDisplaying(&policy_map);
288  const Value* sanitized = policy_map.GetValue(key::kOpenNetworkConfiguration);
289  ASSERT_TRUE(sanitized);
290  std::string sanitized_onc;
291  EXPECT_TRUE(sanitized->GetAsString(&sanitized_onc));
292  EXPECT_FALSE(sanitized_onc.empty());
293  EXPECT_EQ(std::string::npos, sanitized_onc.find("pass"));
294}
295
296TEST(PinnedLauncherAppsPolicyHandler, PrefTranslation) {
297  base::ListValue list;
298  PolicyMap policy_map;
299  PrefValueMap prefs;
300  base::ListValue expected_pinned_apps;
301  base::Value* value = NULL;
302  PinnedLauncherAppsPolicyHandler handler;
303
304  policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY,
305                 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
306  handler.ApplyPolicySettings(policy_map, &prefs);
307  EXPECT_TRUE(prefs.GetValue(prefs::kPinnedLauncherApps, &value));
308  EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value));
309
310  base::StringValue entry1("abcdefghijklmnopabcdefghijklmnop");
311  base::DictionaryValue* entry1_dict = new base::DictionaryValue();
312  entry1_dict->Set(ash::kPinnedAppsPrefAppIDPath, entry1.DeepCopy());
313  expected_pinned_apps.Append(entry1_dict);
314  list.Append(entry1.DeepCopy());
315  policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY,
316                 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
317  prefs.Clear();
318  handler.ApplyPolicySettings(policy_map, &prefs);
319  EXPECT_TRUE(prefs.GetValue(prefs::kPinnedLauncherApps, &value));
320  EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value));
321}
322
323TEST(LoginScreenPowerManagementPolicyHandlerTest, Empty) {
324  PolicyMap policy_map;
325  LoginScreenPowerManagementPolicyHandler handler;
326  PolicyErrorMap errors;
327  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
328  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
329}
330
331TEST(LoginScreenPowerManagementPolicyHandlerTest, ValidPolicy) {
332  PolicyMap policy_map;
333  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
334                 POLICY_LEVEL_MANDATORY,
335                 POLICY_SCOPE_USER,
336                 Value::CreateStringValue(kLoginScreenPowerManagementPolicy),
337                 NULL);
338  LoginScreenPowerManagementPolicyHandler handler;
339  PolicyErrorMap errors;
340  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
341  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
342}
343
344TEST(LoginScreenPowerManagementPolicyHandlerTest, WrongType) {
345  PolicyMap policy_map;
346  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
347                 POLICY_LEVEL_MANDATORY,
348                 POLICY_SCOPE_USER,
349                 Value::CreateBooleanValue(false),
350                 NULL);
351  LoginScreenPowerManagementPolicyHandler handler;
352  PolicyErrorMap errors;
353  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
354  EXPECT_FALSE(
355      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
356}
357
358TEST(LoginScreenPowerManagementPolicyHandlerTest, JSONParseError) {
359  const std::string policy("I'm not proper JSON!");
360  PolicyMap policy_map;
361  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
362                 POLICY_LEVEL_MANDATORY,
363                 POLICY_SCOPE_USER,
364                 Value::CreateStringValue(policy),
365                 NULL);
366  LoginScreenPowerManagementPolicyHandler handler;
367  PolicyErrorMap errors;
368  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
369  EXPECT_FALSE(
370      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
371}
372
373}  // namespace policy
374