src/chrome/browser/sessions/restore_on_startup_policy_handler_unittest.cc

   1 // Copyright 2013 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 <string>
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/prefs/pref_value_map.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/policy/configuration_policy_handler.h"
  14 #include "chrome/browser/policy/policy_error_map.h"
  15 #include "chrome/browser/policy/policy_map.h"
  16 #include "chrome/browser/prefs/session_startup_pref.h"
  17 #include "chrome/browser/sessions/restore_on_startup_policy_handler.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "grit/generated_resources.h"
  20 #include "policy/policy_constants.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "ui/base/l10n/l10n_util.h"
  23
  24 namespace policy {
  25
  26 class RestoreOnStartupPolicyHandlerTest : public testing::Test {
  27  protected:
  28   void SetPolicyValue(const std::string& policy, base::Value* value) {
  29     policies_.Set(
  30         policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, value, NULL);
  31   }
  32   bool CheckPolicySettings() {
  33     return handler_.CheckPolicySettings(policies_, &errors_);
  34   }
  35   void ApplyPolicySettings() {
  36     handler_.ApplyPolicySettings(policies_, &prefs_);
  37   }
  38   PolicyErrorMap& errors() { return errors_; }
  39   PrefValueMap& prefs() { return prefs_; }
  40
  41  private:
  42   PolicyMap policies_;
  43   PolicyErrorMap errors_;
  44   PrefValueMap prefs_;
  45   RestoreOnStartupPolicyHandler handler_;
  46 };
  47
  48 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) {
  49   // Handler expects an int; pass it a bool.
  50   SetPolicyValue(key::kRestoreOnStartup, new base::FundamentalValue(false));
  51   // Checking should fail and add an error to the error map.
  52   EXPECT_FALSE(CheckPolicySettings());
  53   EXPECT_EQ(1U, errors().size());
  54   EXPECT_EQ(l10n_util::GetStringFUTF16(
  55                 IDS_POLICY_TYPE_ERROR,
  56                 ASCIIToUTF16(ConfigurationPolicyHandler::ValueTypeToString(
  57                     Value::TYPE_INTEGER))),
  58             errors().begin()->second);
  59 }
  60
  61 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) {
  62   // Don't specify a value for the policy.
  63   // Checking should succeed with no errors.
  64   EXPECT_TRUE(CheckPolicySettings());
  65   EXPECT_EQ(0U, errors().size());
  66 }
  67
  68 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) {
  69   // Specify an unknown value for the policy.
  70   int impossible_value = SessionStartupPref::kPrefValueHomePage +
  71                          SessionStartupPref::kPrefValueLast +
  72                          SessionStartupPref::kPrefValueURLs +
  73                          SessionStartupPref::kPrefValueNewTab;
  74   SetPolicyValue(key::kRestoreOnStartup,
  75                  new base::FundamentalValue(impossible_value));
  76   // Checking should succeed but add an error to the error map.
  77   EXPECT_TRUE(CheckPolicySettings());
  78   EXPECT_EQ(1U, errors().size());
  79   EXPECT_EQ(l10n_util::GetStringFUTF16(
  80                 IDS_POLICY_OUT_OF_RANGE_ERROR,
  81                 ASCIIToUTF16(base::IntToString(impossible_value))),
  82             errors().begin()->second);
  83 }
  84
  85 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) {
  86   // Specify the HomePage value.
  87   SetPolicyValue(
  88       key::kRestoreOnStartup,
  89       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
  90   // Checking should succeed but add an error to the error map.
  91   EXPECT_TRUE(CheckPolicySettings());
  92   EXPECT_EQ(1U, errors().size());
  93   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED),
  94             errors().begin()->second);
  95 }
  96
  97 TEST_F(RestoreOnStartupPolicyHandlerTest,
  98        CheckPolicySettings_RestoreLastSession_SessionCookies) {
  99   // Specify the Last value and the Session-Only Cookies value.
 100   SetPolicyValue(
 101       key::kRestoreOnStartup,
 102       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
 103   scoped_ptr<base::ListValue> urls(new base::ListValue);
 104   urls->AppendString("http://foo.com");
 105   SetPolicyValue(key::kCookiesSessionOnlyForUrls, urls.release());
 106   // Checking should succeed but add an error to the error map.
 107   EXPECT_TRUE(CheckPolicySettings());
 108   EXPECT_EQ(1U, errors().size());
 109   EXPECT_TRUE(key::kCookiesSessionOnlyForUrls == errors().begin()->first);
 110   EXPECT_EQ(l10n_util::GetStringFUTF16(IDS_POLICY_OVERRIDDEN,
 111                                        ASCIIToUTF16(key::kRestoreOnStartup)),
 112             errors().begin()->second);
 113 }
 114
 115 TEST_F(RestoreOnStartupPolicyHandlerTest,
 116        CheckPolicySettings_RestoreLastSession_ClearDataOnExit) {
 117   // Specify the Last value and the Clear-Data-On-Exit value.
 118   SetPolicyValue(
 119       key::kRestoreOnStartup,
 120       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
 121   SetPolicyValue(key::kClearSiteDataOnExit, new base::FundamentalValue(true));
 122   // Checking should succeed but add an error to the error map.
 123   EXPECT_TRUE(CheckPolicySettings());
 124   EXPECT_EQ(1U, errors().size());
 125   EXPECT_TRUE(key::kClearSiteDataOnExit == errors().begin()->first);
 126   EXPECT_EQ(l10n_util::GetStringFUTF16(IDS_POLICY_OVERRIDDEN,
 127                                        ASCIIToUTF16(key::kRestoreOnStartup)),
 128             errors().begin()->second);
 129 }
 130
 131 TEST_F(RestoreOnStartupPolicyHandlerTest,
 132        CheckPolicySettings_RestoreLastSession) {
 133   // Specify the Last value without the conflicts.
 134   SetPolicyValue(
 135       key::kRestoreOnStartup,
 136       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
 137   // Checking should succeed with no errors.
 138   EXPECT_TRUE(CheckPolicySettings());
 139   EXPECT_EQ(0U, errors().size());
 140 }
 141
 142 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_URLs) {
 143   // Specify the URLs value.
 144   SetPolicyValue(
 145       key::kRestoreOnStartup,
 146       new base::FundamentalValue(SessionStartupPref::kPrefValueURLs));
 147   // Checking should succeed with no errors.
 148   EXPECT_TRUE(CheckPolicySettings());
 149   EXPECT_EQ(0U, errors().size());
 150 }
 151
 152 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_NewTab) {
 153   // Specify the NewTab value.
 154   SetPolicyValue(
 155       key::kRestoreOnStartup,
 156       new base::FundamentalValue(SessionStartupPref::kPrefValueNewTab));
 157   // Checking should succeed with no errors.
 158   EXPECT_TRUE(CheckPolicySettings());
 159   EXPECT_EQ(0U, errors().size());
 160 }
 161
 162 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NoValue) {
 163   // Don't specify a value for the policy.
 164   ApplyPolicySettings();
 165   // The resulting prefs should be empty.
 166   EXPECT_TRUE(prefs().begin() == prefs().end());
 167 }
 168
 169 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_WrongType) {
 170   // Handler expects an int; pass it a bool.
 171   SetPolicyValue(key::kRestoreOnStartup, new base::FundamentalValue(false));
 172   // The resulting prefs should be empty.
 173   EXPECT_TRUE(prefs().begin() == prefs().end());
 174 }
 175
 176 TEST_F(RestoreOnStartupPolicyHandlerTest, ApplyPolicySettings_NotHomePage) {
 177   // Specify anything except the HomePage value.
 178   int not_home_page = SessionStartupPref::kPrefValueHomePage + 1;
 179   SetPolicyValue(key::kRestoreOnStartup,
 180                  new base::FundamentalValue(not_home_page));
 181   ApplyPolicySettings();
 182   // The resulting prefs should have the value we specified.
 183   int result;
 184   EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result));
 185   EXPECT_EQ(not_home_page, result);
 186 }
 187
 188 TEST_F(RestoreOnStartupPolicyHandlerTest,
 189        ApplyPolicySettings_HomePage_NoHomePageValue) {
 190   // Specify the HomePage value but no HomePageIsNewTabPage value.
 191   SetPolicyValue(
 192       key::kRestoreOnStartup,
 193       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 194   ApplyPolicySettings();
 195   // The resulting prefs should be empty.
 196   EXPECT_TRUE(prefs().begin() == prefs().end());
 197 }
 198
 199 TEST_F(RestoreOnStartupPolicyHandlerTest,
 200        ApplyPolicySettings_HomePage_HomePageValueIsWrongType) {
 201   // Specify the HomePage value and an integer for the home page value.
 202   SetPolicyValue(
 203       key::kRestoreOnStartup,
 204       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 205   SetPolicyValue(
 206       key::kHomepageIsNewTabPage,
 207       new base::FundamentalValue(314159));
 208   ApplyPolicySettings();
 209   // The resulting prefs should be empty.
 210   EXPECT_TRUE(prefs().begin() == prefs().end());
 211 }
 212
 213 TEST_F(RestoreOnStartupPolicyHandlerTest,
 214        ApplyPolicySettings_HomePage_HomePageIsNewTabPage) {
 215   // Specify the HomePage value and the home page as the new tab page.
 216   SetPolicyValue(
 217       key::kRestoreOnStartup,
 218       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 219   SetPolicyValue(
 220       key::kHomepageIsNewTabPage,
 221       new base::FundamentalValue(true));
 222   ApplyPolicySettings();
 223   // The resulting prefs should have the restore value as NTP.
 224   int result;
 225   EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result));
 226   int expected = SessionStartupPref::kPrefValueNewTab;
 227   EXPECT_EQ(expected, result);
 228 }
 229
 230 TEST_F(RestoreOnStartupPolicyHandlerTest,
 231        ApplyPolicySettings_HomePage_HomePageIsNotNewTabPage_NotDefined) {
 232   // Specify the HomePage value but don't specify the home page to use.
 233   SetPolicyValue(
 234       key::kRestoreOnStartup,
 235       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 236   SetPolicyValue(
 237       key::kHomepageIsNewTabPage,
 238       new base::FundamentalValue(false));
 239   ApplyPolicySettings();
 240   // The resulting prefs should be empty.
 241   EXPECT_TRUE(prefs().begin() == prefs().end());
 242 }
 243
 244 TEST_F(RestoreOnStartupPolicyHandlerTest,
 245        ApplyPolicySettings_HomePage_HomePageIsNotNewTabPage_WrongType) {
 246   // Specify the HomePage value but specify a boolean as the home page.
 247   SetPolicyValue(
 248       key::kRestoreOnStartup,
 249       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 250   SetPolicyValue(
 251       key::kHomepageIsNewTabPage,
 252       new base::FundamentalValue(false));
 253   SetPolicyValue(
 254       key::kHomepageLocation,
 255       new base::FundamentalValue(false));
 256   ApplyPolicySettings();
 257   // The resulting prefs should be empty.
 258   EXPECT_TRUE(prefs().begin() == prefs().end());
 259 }
 260
 261 TEST_F(RestoreOnStartupPolicyHandlerTest,
 262        ApplyPolicySettings_HomePage_HomePageIsNotNewTabPage) {
 263   SetPolicyValue(
 264       key::kRestoreOnStartup,
 265       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
 266   SetPolicyValue(key::kHomepageIsNewTabPage, new base::FundamentalValue(false));
 267   SetPolicyValue(key::kHomepageLocation,
 268                  new base::StringValue("http://foo.com"));
 269   ApplyPolicySettings();
 270
 271   // The resulting prefs should have have URLs specified for startup.
 272   int result;
 273   EXPECT_TRUE(prefs().GetInteger(prefs::kRestoreOnStartup, &result));
 274   int expected = SessionStartupPref::kPrefValueURLs;
 275   EXPECT_EQ(expected, result);
 276
 277   // The resulting prefs should have the URL we specified as the home page.
 278   base::Value* url_result;
 279   EXPECT_TRUE(prefs().GetValue(prefs::kURLsToRestoreOnStartup, &url_result));
 280   base::ListValue* url_list_result;
 281   EXPECT_TRUE(url_result->GetAsList(&url_list_result));
 282   EXPECT_EQ(1U, url_list_result->GetSize());
 283   std::string expected_url;
 284   EXPECT_TRUE(url_list_result->GetString(0, &expected_url));
 285   EXPECT_EQ(std::string("http://foo.com"), expected_url);
 286 }
 287
 288 }  // namespace policy