configuration_policy_handler_chromeos_unittest.cc revision f2477e01787aa58f445919b809d89e252beef54f 
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/prefs/pref_value_map.h"
9#include "base/values.h"
10#include "chrome/browser/policy/policy_error_map.h"
11#include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
12#include "chrome/common/pref_names.h"
13#include "components/policy/core/common/external_data_fetcher.h"
14#include "components/policy/core/common/policy_map.h"
15#include "policy/policy_constants.h"
16#include "testing/gtest/include/gtest/gtest.h"
17
18namespace policy {
19
20namespace {
21
22// Test cases for the screen magnifier type policy setting.
23class ScreenMagnifierPolicyHandlerTest : public testing::Test {
24 protected:
25  PolicyMap policy_;
26  PrefValueMap prefs_;
27  ScreenMagnifierPolicyHandler handler_;
28};
29
30TEST_F(ScreenMagnifierPolicyHandlerTest, Default) {
31  handler_.ApplyPolicySettings(policy_, &prefs_);
32  EXPECT_FALSE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, NULL));
33  EXPECT_FALSE(prefs_.GetValue(prefs::kScreenMagnifierType, NULL));
34}
35
36TEST_F(ScreenMagnifierPolicyHandlerTest, Disabled) {
37  policy_.Set(key::kScreenMagnifierType,
38              POLICY_LEVEL_MANDATORY,
39              POLICY_SCOPE_USER,
40              base::Value::CreateIntegerValue(0),
41              NULL);
42  handler_.ApplyPolicySettings(policy_, &prefs_);
43
44  const base::Value* enabled = NULL;
45  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, &enabled));
46  ASSERT_TRUE(enabled);
47  EXPECT_TRUE(base::FundamentalValue(false).Equals(enabled));
48
49  const base::Value* type = NULL;
50  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierType, &type));
51  ASSERT_TRUE(type);
52  EXPECT_TRUE(base::FundamentalValue(0).Equals(type));
53}
54
55TEST_F(ScreenMagnifierPolicyHandlerTest, Enabled) {
56  policy_.Set(key::kScreenMagnifierType,
57              POLICY_LEVEL_MANDATORY,
58              POLICY_SCOPE_USER,
59              base::Value::CreateIntegerValue(1),
60              NULL);
61  handler_.ApplyPolicySettings(policy_, &prefs_);
62
63  const base::Value* enabled = NULL;
64  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierEnabled, &enabled));
65  ASSERT_TRUE(enabled);
66  EXPECT_TRUE(base::FundamentalValue(true).Equals(enabled));
67
68  const base::Value* type = NULL;
69  EXPECT_TRUE(prefs_.GetValue(prefs::kScreenMagnifierType, &type));
70  ASSERT_TRUE(type);
71  EXPECT_TRUE(base::FundamentalValue(1).Equals(type));
72}
73
74const char kLoginScreenPowerManagementPolicy[] =
75    "{"
76    "  \"AC\": {"
77    "    \"Delays\": {"
78    "      \"ScreenDim\": 5000,"
79    "      \"ScreenOff\": 7000,"
80    "      \"Idle\": 9000"
81    "    },"
82    "    \"IdleAction\": \"DoNothing\""
83    "  },"
84    "  \"Battery\": {"
85    "    \"Delays\": {"
86    "      \"ScreenDim\": 1000,"
87    "      \"ScreenOff\": 3000,"
88    "      \"Idle\": 4000"
89    "    },"
90    "    \"IdleAction\": \"DoNothing\""
91    "  },"
92    "  \"LidCloseAction\": \"DoNothing\","
93    "  \"UserActivityScreenDimDelayScale\": 300"
94    "}";
95
96}  // namespace
97
98TEST(NetworkConfigurationPolicyHandlerTest, Empty) {
99  PolicyMap policy_map;
100  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
101      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
102  PolicyErrorMap errors;
103  EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors));
104  EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
105}
106
107TEST(NetworkConfigurationPolicyHandlerTest, ValidONC) {
108  const std::string kTestONC(
109      "{"
110      "  \"NetworkConfigurations\": [{"
111      "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
112      "    \"Type\": \"WiFi\","
113      "    \"Name\": \"some name\","
114      "    \"WiFi\": {"
115      "      \"Security\": \"WEP-PSK\","
116      "      \"SSID\": \"ssid\","
117      "      \"Passphrase\": \"pass\","
118      "    }"
119      "  }]"
120      "}");
121
122  PolicyMap policy_map;
123  policy_map.Set(key::kOpenNetworkConfiguration,
124                 POLICY_LEVEL_MANDATORY,
125                 POLICY_SCOPE_USER,
126                 Value::CreateStringValue(kTestONC),
127                 NULL);
128  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
129      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
130  PolicyErrorMap errors;
131  EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors));
132  EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
133}
134
135TEST(NetworkConfigurationPolicyHandlerTest, WrongType) {
136  PolicyMap policy_map;
137  policy_map.Set(key::kOpenNetworkConfiguration,
138                 POLICY_LEVEL_MANDATORY,
139                 POLICY_SCOPE_USER,
140                 Value::CreateBooleanValue(false),
141                 NULL);
142  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
143      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
144  PolicyErrorMap errors;
145  EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors));
146  EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
147}
148
149TEST(NetworkConfigurationPolicyHandlerTest, JSONParseError) {
150  const std::string kTestONC("I'm not proper JSON!");
151  PolicyMap policy_map;
152  policy_map.Set(key::kOpenNetworkConfiguration,
153                 POLICY_LEVEL_MANDATORY,
154                 POLICY_SCOPE_USER,
155                 Value::CreateStringValue(kTestONC),
156                 NULL);
157  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
158      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
159  PolicyErrorMap errors;
160  EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors));
161  EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
162}
163
164TEST(NetworkConfigurationPolicyHandlerTest, Sanitization) {
165  const std::string kTestONC(
166      "{"
167      "  \"NetworkConfigurations\": [{"
168      "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
169      "    \"Type\": \"WiFi\","
170      "    \"Name\": \"some name\","
171      "    \"WiFi\": {"
172      "      \"Security\": \"WEP-PSK\","
173      "      \"SSID\": \"ssid\","
174      "      \"Passphrase\": \"pass\","
175      "    }"
176      "  }]"
177      "}");
178
179  PolicyMap policy_map;
180  policy_map.Set(key::kOpenNetworkConfiguration,
181                 POLICY_LEVEL_MANDATORY,
182                 POLICY_SCOPE_USER,
183                 Value::CreateStringValue(kTestONC),
184                 NULL);
185  scoped_ptr<NetworkConfigurationPolicyHandler> handler(
186      NetworkConfigurationPolicyHandler::CreateForUserPolicy());
187  PolicyErrorMap errors;
188  handler->PrepareForDisplaying(&policy_map);
189  const Value* sanitized = policy_map.GetValue(key::kOpenNetworkConfiguration);
190  ASSERT_TRUE(sanitized);
191  std::string sanitized_onc;
192  EXPECT_TRUE(sanitized->GetAsString(&sanitized_onc));
193  EXPECT_FALSE(sanitized_onc.empty());
194  EXPECT_EQ(std::string::npos, sanitized_onc.find("pass"));
195}
196
197TEST(PinnedLauncherAppsPolicyHandler, PrefTranslation) {
198  base::ListValue list;
199  PolicyMap policy_map;
200  PrefValueMap prefs;
201  base::ListValue expected_pinned_apps;
202  base::Value* value = NULL;
203  PinnedLauncherAppsPolicyHandler handler;
204
205  policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY,
206                 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
207  handler.ApplyPolicySettings(policy_map, &prefs);
208  EXPECT_TRUE(prefs.GetValue(prefs::kPinnedLauncherApps, &value));
209  EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value));
210
211  base::StringValue entry1("abcdefghijklmnopabcdefghijklmnop");
212  base::DictionaryValue* entry1_dict = new base::DictionaryValue();
213  entry1_dict->Set(ash::kPinnedAppsPrefAppIDPath, entry1.DeepCopy());
214  expected_pinned_apps.Append(entry1_dict);
215  list.Append(entry1.DeepCopy());
216  policy_map.Set(key::kPinnedLauncherApps, POLICY_LEVEL_MANDATORY,
217                 POLICY_SCOPE_USER, list.DeepCopy(), NULL);
218  prefs.Clear();
219  handler.ApplyPolicySettings(policy_map, &prefs);
220  EXPECT_TRUE(prefs.GetValue(prefs::kPinnedLauncherApps, &value));
221  EXPECT_TRUE(base::Value::Equals(&expected_pinned_apps, value));
222}
223
224TEST(LoginScreenPowerManagementPolicyHandlerTest, Empty) {
225  PolicyMap policy_map;
226  LoginScreenPowerManagementPolicyHandler handler;
227  PolicyErrorMap errors;
228  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
229  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
230}
231
232TEST(LoginScreenPowerManagementPolicyHandlerTest, ValidPolicy) {
233  PolicyMap policy_map;
234  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
235                 POLICY_LEVEL_MANDATORY,
236                 POLICY_SCOPE_USER,
237                 Value::CreateStringValue(kLoginScreenPowerManagementPolicy),
238                 NULL);
239  LoginScreenPowerManagementPolicyHandler handler;
240  PolicyErrorMap errors;
241  EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
242  EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
243}
244
245TEST(LoginScreenPowerManagementPolicyHandlerTest, WrongType) {
246  PolicyMap policy_map;
247  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
248                 POLICY_LEVEL_MANDATORY,
249                 POLICY_SCOPE_USER,
250                 Value::CreateBooleanValue(false),
251                 NULL);
252  LoginScreenPowerManagementPolicyHandler handler;
253  PolicyErrorMap errors;
254  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
255  EXPECT_FALSE(
256      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
257}
258
259TEST(LoginScreenPowerManagementPolicyHandlerTest, JSONParseError) {
260  const std::string policy("I'm not proper JSON!");
261  PolicyMap policy_map;
262  policy_map.Set(key::kDeviceLoginScreenPowerManagement,
263                 POLICY_LEVEL_MANDATORY,
264                 POLICY_SCOPE_USER,
265                 Value::CreateStringValue(policy),
266                 NULL);
267  LoginScreenPowerManagementPolicyHandler handler;
268  PolicyErrorMap errors;
269  EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
270  EXPECT_FALSE(
271      errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
272}
273
274}  // namespace policy
275