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