chrome/browser/prefs/pref_model_associator_unittest.cc

   1 // Copyright (c) 2011 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 "base/memory/scoped_ptr.h"
   6 #include "base/values.h"
   7 #include "chrome/browser/prefs/pref_model_associator.h"
   8 #include "chrome/browser/prefs/scoped_user_pref_update.h"
   9 #include "chrome/common/pref_names.h"
  10 #include "chrome/test/base/testing_profile.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 class AbstractPreferenceMergeTest : public testing::Test {
  14  protected:
  15   virtual void SetUp() {
  16     pref_service_ = profile_.GetPrefs();
  17   }
  18
  19   void SetContentPattern(DictionaryValue* patterns_dict,
  20                          const std::string& expression,
  21                          const std::string& content_type,
  22                          int setting) {
  23     DictionaryValue* expression_dict;
  24     bool found =
  25         patterns_dict->GetDictionaryWithoutPathExpansion(expression,
  26                                                          &expression_dict);
  27     if (!found) {
  28       expression_dict = new DictionaryValue;
  29       patterns_dict->SetWithoutPathExpansion(expression, expression_dict);
  30     }
  31     expression_dict->SetWithoutPathExpansion(
  32         content_type,
  33         Value::CreateIntegerValue(setting));
  34   }
  35
  36   void SetPrefToEmpty(const std::string& pref_name) {
  37     scoped_ptr<Value> empty_value;
  38     const PrefService::Preference* pref =
  39         pref_service_->FindPreference(pref_name.c_str());
  40     ASSERT_TRUE(pref);
  41     base::Value::Type type = pref->GetType();
  42     if (type == Value::TYPE_DICTIONARY)
  43       empty_value.reset(new DictionaryValue);
  44     else if (type == Value::TYPE_LIST)
  45       empty_value.reset(new ListValue);
  46     else
  47       FAIL();
  48     pref_service_->Set(pref_name.c_str(), *empty_value);
  49   }
  50
  51   TestingProfile profile_;
  52   PrefService* pref_service_;
  53 };
  54
  55 class ListPreferenceMergeTest : public AbstractPreferenceMergeTest {
  56  protected:
  57   ListPreferenceMergeTest() :
  58       server_url0_("http://example.com/server0"),
  59       server_url1_("http://example.com/server1"),
  60       local_url0_("http://example.com/local0"),
  61       local_url1_("http://example.com/local1") {}
  62
  63   virtual void SetUp() {
  64     AbstractPreferenceMergeTest::SetUp();
  65     server_url_list_.Append(Value::CreateStringValue(server_url0_));
  66     server_url_list_.Append(Value::CreateStringValue(server_url1_));
  67   }
  68
  69   std::string server_url0_;
  70   std::string server_url1_;
  71   std::string local_url0_;
  72   std::string local_url1_;
  73   ListValue server_url_list_;
  74 };
  75
  76 TEST_F(ListPreferenceMergeTest, NotListOrDictionary) {
  77   pref_service_->SetString(prefs::kHomePage, local_url0_);
  78   const PrefService::Preference* pref =
  79       pref_service_->FindPreference(prefs::kHomePage);
  80   scoped_ptr<Value> server_value(Value::CreateStringValue(server_url0_));
  81   scoped_ptr<Value> merged_value(
  82       PrefModelAssociator::MergePreference(pref->name(),
  83                                            *pref->GetValue(),
  84                                            *server_value));
  85   EXPECT_TRUE(merged_value->Equals(server_value.get()));
  86 }
  87
  88 TEST_F(ListPreferenceMergeTest, LocalEmpty) {
  89   SetPrefToEmpty(prefs::kURLsToRestoreOnStartup);
  90   const PrefService::Preference* pref =
  91       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
  92   scoped_ptr<Value> merged_value(
  93       PrefModelAssociator::MergePreference(pref->name(),
  94                                            *pref->GetValue(),
  95                                            server_url_list_));
  96   EXPECT_TRUE(merged_value->Equals(&server_url_list_));
  97 }
  98
  99 TEST_F(ListPreferenceMergeTest, ServerNull) {
 100   scoped_ptr<Value> null_value(Value::CreateNullValue());
 101   {
 102     ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
 103     ListValue* local_list_value = update.Get();
 104     local_list_value->Append(Value::CreateStringValue(local_url0_));
 105   }
 106
 107   const PrefService::Preference* pref =
 108       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
 109   scoped_ptr<Value> merged_value(
 110       PrefModelAssociator::MergePreference(pref->name(),
 111                                            *pref->GetValue(),
 112                                            *null_value));
 113   const ListValue* local_list_value =
 114         pref_service_->GetList(prefs::kURLsToRestoreOnStartup);
 115   EXPECT_TRUE(merged_value->Equals(local_list_value));
 116 }
 117
 118 TEST_F(ListPreferenceMergeTest, ServerEmpty) {
 119   scoped_ptr<Value> empty_value(new ListValue);
 120   {
 121     ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
 122     ListValue* local_list_value = update.Get();
 123     local_list_value->Append(Value::CreateStringValue(local_url0_));
 124   }
 125
 126   const PrefService::Preference* pref =
 127       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
 128   scoped_ptr<Value> merged_value(
 129       PrefModelAssociator::MergePreference(pref->name(),
 130                                            *pref->GetValue(),
 131                                            *empty_value));
 132   const ListValue* local_list_value =
 133         pref_service_->GetList(prefs::kURLsToRestoreOnStartup);
 134   EXPECT_TRUE(merged_value->Equals(local_list_value));
 135 }
 136
 137 TEST_F(ListPreferenceMergeTest, Merge) {
 138   {
 139     ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
 140     ListValue* local_list_value = update.Get();
 141     local_list_value->Append(Value::CreateStringValue(local_url0_));
 142     local_list_value->Append(Value::CreateStringValue(local_url1_));
 143   }
 144
 145   const PrefService::Preference* pref =
 146       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
 147   scoped_ptr<Value> merged_value(
 148       PrefModelAssociator::MergePreference(pref->name(),
 149                                            *pref->GetValue(),
 150                                            server_url_list_));
 151
 152   ListValue expected;
 153   expected.Append(Value::CreateStringValue(server_url0_));
 154   expected.Append(Value::CreateStringValue(server_url1_));
 155   expected.Append(Value::CreateStringValue(local_url0_));
 156   expected.Append(Value::CreateStringValue(local_url1_));
 157   EXPECT_TRUE(merged_value->Equals(&expected));
 158 }
 159
 160 TEST_F(ListPreferenceMergeTest, Duplicates) {
 161   {
 162     ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
 163     ListValue* local_list_value = update.Get();
 164     local_list_value->Append(Value::CreateStringValue(local_url0_));
 165     local_list_value->Append(Value::CreateStringValue(server_url0_));
 166     local_list_value->Append(Value::CreateStringValue(server_url1_));
 167   }
 168
 169   const PrefService::Preference* pref =
 170       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
 171   scoped_ptr<Value> merged_value(
 172       PrefModelAssociator::MergePreference(pref->name(),
 173                                            *pref->GetValue(),
 174                                            server_url_list_));
 175
 176   ListValue expected;
 177   expected.Append(Value::CreateStringValue(server_url0_));
 178   expected.Append(Value::CreateStringValue(server_url1_));
 179   expected.Append(Value::CreateStringValue(local_url0_));
 180   EXPECT_TRUE(merged_value->Equals(&expected));
 181 }
 182
 183 TEST_F(ListPreferenceMergeTest, Equals) {
 184   {
 185     ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
 186     ListValue* local_list_value = update.Get();
 187     local_list_value->Append(Value::CreateStringValue(server_url0_));
 188     local_list_value->Append(Value::CreateStringValue(server_url1_));
 189   }
 190
 191   scoped_ptr<Value> original(server_url_list_.DeepCopy());
 192   const PrefService::Preference* pref =
 193       pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
 194   scoped_ptr<Value> merged_value(
 195       PrefModelAssociator::MergePreference(pref->name(),
 196                                            *pref->GetValue(),
 197                                            server_url_list_));
 198   EXPECT_TRUE(merged_value->Equals(original.get()));
 199 }
 200
 201 class DictionaryPreferenceMergeTest : public AbstractPreferenceMergeTest {
 202  protected:
 203   DictionaryPreferenceMergeTest() :
 204       expression0_("expression0"),
 205       expression1_("expression1"),
 206       expression2_("expression2"),
 207       content_type0_("content_type0"),
 208       content_type1_("content_type1") {}
 209
 210   virtual void SetUp() {
 211     AbstractPreferenceMergeTest::SetUp();
 212     SetContentPattern(&server_patterns_, expression0_, content_type0_, 1);
 213     SetContentPattern(&server_patterns_, expression0_, content_type1_, 2);
 214     SetContentPattern(&server_patterns_, expression1_, content_type0_, 1);
 215   }
 216
 217   std::string expression0_;
 218   std::string expression1_;
 219   std::string expression2_;
 220   std::string content_type0_;
 221   std::string content_type1_;
 222   DictionaryValue server_patterns_;
 223 };
 224
 225 TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) {
 226   SetPrefToEmpty(prefs::kContentSettingsPatternPairs);
 227   const PrefService::Preference* pref =
 228       pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
 229   scoped_ptr<Value> merged_value(
 230       PrefModelAssociator::MergePreference(pref->name(),
 231                                            *pref->GetValue(),
 232                                            server_patterns_));
 233   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 234 }
 235
 236 TEST_F(DictionaryPreferenceMergeTest, ServerNull) {
 237   scoped_ptr<Value> null_value(Value::CreateNullValue());
 238   {
 239     DictionaryPrefUpdate update(pref_service_,
 240                                 prefs::kContentSettingsPatternPairs);
 241     DictionaryValue* local_dict_value = update.Get();
 242     SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
 243   }
 244
 245   const PrefService::Preference* pref =
 246       pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
 247   scoped_ptr<Value> merged_value(
 248       PrefModelAssociator::MergePreference(pref->name(),
 249                                            *pref->GetValue(),
 250                                            *null_value));
 251   const DictionaryValue* local_dict_value =
 252       pref_service_->GetDictionary(prefs::kContentSettingsPatternPairs);
 253   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 254 }
 255
 256 TEST_F(DictionaryPreferenceMergeTest, ServerEmpty) {
 257   scoped_ptr<Value> empty_value(new DictionaryValue);
 258   {
 259     DictionaryPrefUpdate update(pref_service_,
 260                                 prefs::kContentSettingsPatternPairs);
 261     DictionaryValue* local_dict_value = update.Get();
 262     SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
 263   }
 264
 265   const PrefService::Preference* pref =
 266       pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
 267   scoped_ptr<Value> merged_value(
 268       PrefModelAssociator::MergePreference(pref->name(),
 269                                            *pref->GetValue(),
 270                                            *empty_value));
 271   const DictionaryValue* local_dict_value =
 272       pref_service_->GetDictionary(prefs::kContentSettingsPatternPairs);
 273   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 274 }
 275
 276 TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) {
 277   {
 278     DictionaryPrefUpdate update(pref_service_,
 279                                 prefs::kContentSettingsPatternPairs);
 280     DictionaryValue* local_dict_value = update.Get();
 281     SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
 282   }
 283
 284   scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 285      prefs::kContentSettingsPatternPairs,
 286       *pref_service_->FindPreference(prefs::kContentSettingsPatternPairs)->
 287           GetValue(),
 288       server_patterns_));
 289
 290   DictionaryValue expected;
 291   SetContentPattern(&expected, expression0_, content_type0_, 1);
 292   SetContentPattern(&expected, expression0_, content_type1_, 2);
 293   SetContentPattern(&expected, expression1_, content_type0_, 1);
 294   SetContentPattern(&expected, expression2_, content_type0_, 1);
 295   EXPECT_TRUE(merged_value->Equals(&expected));
 296 }
 297
 298 TEST_F(DictionaryPreferenceMergeTest, MergeConflicts) {
 299   {
 300     DictionaryPrefUpdate update(pref_service_,
 301                                 prefs::kContentSettingsPatternPairs);
 302     DictionaryValue* local_dict_value = update.Get();
 303     SetContentPattern(local_dict_value, expression0_, content_type0_, 2);
 304     SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
 305     SetContentPattern(local_dict_value, expression1_, content_type1_, 1);
 306     SetContentPattern(local_dict_value, expression2_, content_type0_, 2);
 307   }
 308
 309   scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 310       prefs::kContentSettingsPatternPairs,
 311       *pref_service_->FindPreference(prefs::kContentSettingsPatternPairs)->
 312           GetValue(),
 313       server_patterns_));
 314
 315   DictionaryValue expected;
 316   SetContentPattern(&expected, expression0_, content_type0_, 1);
 317   SetContentPattern(&expected, expression0_, content_type1_, 2);
 318   SetContentPattern(&expected, expression1_, content_type0_, 1);
 319   SetContentPattern(&expected, expression1_, content_type1_, 1);
 320   SetContentPattern(&expected, expression2_, content_type0_, 2);
 321   EXPECT_TRUE(merged_value->Equals(&expected));
 322 }
 323
 324 TEST_F(DictionaryPreferenceMergeTest, Equal) {
 325   {
 326     DictionaryPrefUpdate update(pref_service_,
 327                                 prefs::kContentSettingsPatternPairs);
 328     DictionaryValue* local_dict_value = update.Get();
 329     SetContentPattern(local_dict_value, expression0_, content_type0_, 1);
 330     SetContentPattern(local_dict_value, expression0_, content_type1_, 2);
 331     SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
 332   }
 333
 334   scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 335       prefs::kContentSettingsPatternPairs,
 336       *pref_service_->
 337           FindPreference(prefs::kContentSettingsPatternPairs)->GetValue(),
 338       server_patterns_));
 339   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 340 }
 341
 342 TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) {
 343   {
 344     DictionaryPrefUpdate update(pref_service_,
 345                                 prefs::kContentSettingsPatternPairs);
 346     DictionaryValue* local_dict_value = update.Get();
 347     SetContentPattern(local_dict_value, expression0_, content_type0_, 2);
 348     SetContentPattern(local_dict_value, expression0_, content_type1_, 2);
 349     SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
 350   }
 351
 352   scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 353       prefs::kContentSettingsPatternPairs,
 354       *pref_service_->
 355           FindPreference(prefs::kContentSettingsPatternPairs)->GetValue(),
 356       server_patterns_));
 357   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 358 }
 359
 360 class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest {
 361  protected:
 362   IndividualPreferenceMergeTest() :
 363       url0_("http://example.com/server0"),
 364       url1_("http://example.com/server1"),
 365       expression0_("expression0"),
 366       expression1_("expression1"),
 367       content_type0_("content_type0") {}
 368
 369   virtual void SetUp() {
 370     AbstractPreferenceMergeTest::SetUp();
 371     server_url_list_.Append(Value::CreateStringValue(url0_));
 372     SetContentPattern(&server_patterns_, expression0_, content_type0_, 1);
 373   }
 374
 375   bool MergeListPreference(const char* pref) {
 376     {
 377       ListPrefUpdate update(pref_service_, pref);
 378       ListValue* local_list_value = update.Get();
 379       local_list_value->Append(Value::CreateStringValue(url1_));
 380     }
 381
 382     scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 383         pref,
 384         *pref_service_->GetUserPrefValue(pref),
 385         server_url_list_));
 386
 387     ListValue expected;
 388     expected.Append(Value::CreateStringValue(url0_));
 389     expected.Append(Value::CreateStringValue(url1_));
 390     return merged_value->Equals(&expected);
 391   }
 392
 393   bool MergeDictionaryPreference(const char* pref) {
 394     {
 395       DictionaryPrefUpdate update(pref_service_, pref);
 396       DictionaryValue* local_dict_value = update.Get();
 397       SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
 398     }
 399
 400     scoped_ptr<Value> merged_value(PrefModelAssociator::MergePreference(
 401         pref,
 402         *pref_service_->GetUserPrefValue(pref),
 403         server_patterns_));
 404
 405     DictionaryValue expected;
 406     SetContentPattern(&expected, expression0_, content_type0_, 1);
 407     SetContentPattern(&expected, expression1_, content_type0_, 1);
 408     return merged_value->Equals(&expected);
 409   }
 410
 411   std::string url0_;
 412   std::string url1_;
 413   std::string expression0_;
 414   std::string expression1_;
 415   std::string content_type0_;
 416   ListValue server_url_list_;
 417   DictionaryValue server_patterns_;
 418 };
 419
 420 TEST_F(IndividualPreferenceMergeTest, URLsToRestoreOnStartup) {
 421   EXPECT_TRUE(MergeListPreference(prefs::kURLsToRestoreOnStartup));
 422 }