chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc

   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
  21 namespace policy {
  22
  23 namespace {
  24
  25 // Test cases for the screen magnifier type policy setting.
  26 class ScreenMagnifierPolicyHandlerTest : public testing::Test {
  27  protected:
  28   PolicyMap policy_;
  29   PrefValueMap prefs_;
  30   ScreenMagnifierPolicyHandler handler_;
  31 };
  32
  33 class 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
  45 LoginScreenPowerManagementPolicyHandlerTest::
  46     LoginScreenPowerManagementPolicyHandlerTest() {
  47 }
  48
  49 void LoginScreenPowerManagementPolicyHandlerTest::SetUp() {
  50   chrome_schema_ = Schema::Wrap(GetChromeSchemaData());
  51 }
  52
  53 TEST_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
  59 TEST_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
  78 TEST_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
  97 TEST(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
 104 TEST(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
 117 TEST(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
 132 TEST(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
 148 TEST(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
 163 TEST(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
 179 TEST(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
 197 const 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
 221 TEST(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
 230 TEST(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
 258 TEST(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
 272 TEST(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
 287 TEST(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
 321 TEST(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
 348 TEST_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
 356 TEST_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
 369 TEST_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