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