components/prefs/pref_service_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 <stddef.h>
   6 #include <stdint.h>
   7
   8 #include <string>
   9
  10 #include "base/macros.h"
  11 #include "base/time/time.h"
  12 #include "base/values.h"
  13 #include "components/prefs/json_pref_store.h"
  14 #include "components/prefs/mock_pref_change_callback.h"
  15 #include "components/prefs/pref_change_registrar.h"
  16 #include "components/prefs/pref_registry_simple.h"
  17 #include "components/prefs/pref_service_factory.h"
  18 #include "components/prefs/pref_value_store.h"
  19 #include "components/prefs/testing_pref_service.h"
  20 #include "components/prefs/testing_pref_store.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 using testing::_;
  25 using testing::Mock;
  26
  27 const char kPrefName[] = "pref.name";
  28
  29 TEST(PrefServiceTest, NoObserverFire) {
  30   TestingPrefServiceSimple prefs;
  31
  32   const char pref_name[] = "homepage";
  33   prefs.registry()->RegisterStringPref(pref_name, std::string());
  34
  35   const char new_pref_value[] = "http://www.google.com/";
  36   MockPrefChangeCallback obs(&prefs);
  37   PrefChangeRegistrar registrar;
  38   registrar.Init(&prefs);
  39   registrar.Add(pref_name, obs.GetCallback());
  40
  41   // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
  42   const base::Value expected_value(new_pref_value);
  43   obs.Expect(pref_name, &expected_value);
  44   prefs.SetString(pref_name, new_pref_value);
  45   Mock::VerifyAndClearExpectations(&obs);
  46
  47   // Setting the pref to the same value should not set the pref value a second
  48   // time.
  49   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
  50   prefs.SetString(pref_name, new_pref_value);
  51   Mock::VerifyAndClearExpectations(&obs);
  52
  53   // Clearing the pref should cause the pref to fire.
  54   const base::Value expected_default_value((std::string()));
  55   obs.Expect(pref_name, &expected_default_value);
  56   prefs.ClearPref(pref_name);
  57   Mock::VerifyAndClearExpectations(&obs);
  58
  59   // Clearing the pref again should not cause the pref to fire.
  60   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
  61   prefs.ClearPref(pref_name);
  62   Mock::VerifyAndClearExpectations(&obs);
  63 }
  64
  65 TEST(PrefServiceTest, HasPrefPath) {
  66   TestingPrefServiceSimple prefs;
  67
  68   const char path[] = "fake.path";
  69
  70   // Shouldn't initially have a path.
  71   EXPECT_FALSE(prefs.HasPrefPath(path));
  72
  73   // Register the path. This doesn't set a value, so the path still shouldn't
  74   // exist.
  75   prefs.registry()->RegisterStringPref(path, std::string());
  76   EXPECT_FALSE(prefs.HasPrefPath(path));
  77
  78   // Set a value and make sure we have a path.
  79   prefs.SetString(path, "blah");
  80   EXPECT_TRUE(prefs.HasPrefPath(path));
  81 }
  82
  83 TEST(PrefServiceTest, Observers) {
  84   const char pref_name[] = "homepage";
  85
  86   TestingPrefServiceSimple prefs;
  87   prefs.SetUserPref(pref_name,
  88                     std::make_unique<base::Value>("http://www.cnn.com"));
  89   prefs.registry()->RegisterStringPref(pref_name, std::string());
  90
  91   const char new_pref_value[] = "http://www.google.com/";
  92   const base::Value expected_new_pref_value(new_pref_value);
  93   MockPrefChangeCallback obs(&prefs);
  94   PrefChangeRegistrar registrar;
  95   registrar.Init(&prefs);
  96   registrar.Add(pref_name, obs.GetCallback());
  97
  98   PrefChangeRegistrar registrar_two;
  99   registrar_two.Init(&prefs);
 100
 101   // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
 102   obs.Expect(pref_name, &expected_new_pref_value);
 103   prefs.SetString(pref_name, new_pref_value);
 104   Mock::VerifyAndClearExpectations(&obs);
 105
 106   // Now try adding a second pref observer.
 107   const char new_pref_value2[] = "http://www.youtube.com/";
 108   const base::Value expected_new_pref_value2(new_pref_value2);
 109   MockPrefChangeCallback obs2(&prefs);
 110   obs.Expect(pref_name, &expected_new_pref_value2);
 111   obs2.Expect(pref_name, &expected_new_pref_value2);
 112   registrar_two.Add(pref_name, obs2.GetCallback());
 113   // This should fire the checks in obs and obs2.
 114   prefs.SetString(pref_name, new_pref_value2);
 115   Mock::VerifyAndClearExpectations(&obs);
 116   Mock::VerifyAndClearExpectations(&obs2);
 117
 118   // Set a recommended value.
 119   const base::Value recommended_pref_value("http://www.gmail.com/");
 120   obs.Expect(pref_name, &expected_new_pref_value2);
 121   obs2.Expect(pref_name, &expected_new_pref_value2);
 122   // This should fire the checks in obs and obs2 but with an unchanged value
 123   // as the recommended value is being overridden by the user-set value.
 124   prefs.SetRecommendedPref(pref_name, recommended_pref_value.CreateDeepCopy());
 125   Mock::VerifyAndClearExpectations(&obs);
 126   Mock::VerifyAndClearExpectations(&obs2);
 127
 128   // Make sure obs2 still works after removing obs.
 129   registrar.Remove(pref_name);
 130   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
 131   obs2.Expect(pref_name, &expected_new_pref_value);
 132   // This should only fire the observer in obs2.
 133   prefs.SetString(pref_name, new_pref_value);
 134   Mock::VerifyAndClearExpectations(&obs);
 135   Mock::VerifyAndClearExpectations(&obs2);
 136 }
 137
 138 // Make sure that if a preference changes type, so the wrong type is stored in
 139 // the user pref file, it uses the correct fallback value instead.
 140 TEST(PrefServiceTest, GetValueChangedType) {
 141   const int kTestValue = 10;
 142   TestingPrefServiceSimple prefs;
 143   prefs.registry()->RegisterIntegerPref(kPrefName, kTestValue);
 144
 145   // Check falling back to a recommended value.
 146   prefs.SetUserPref(kPrefName, std::make_unique<base::Value>("not an integer"));
 147   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
 148   ASSERT_TRUE(pref);
 149   const base::Value* value = pref->GetValue();
 150   ASSERT_TRUE(value);
 151   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 152   int actual_int_value = -1;
 153   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 154   EXPECT_EQ(kTestValue, actual_int_value);
 155 }
 156
 157 TEST(PrefServiceTest, GetValueAndGetRecommendedValue) {
 158   const int kDefaultValue = 5;
 159   const int kUserValue = 10;
 160   const int kRecommendedValue = 15;
 161   TestingPrefServiceSimple prefs;
 162   prefs.registry()->RegisterIntegerPref(kPrefName, kDefaultValue);
 163
 164   // Create pref with a default value only.
 165   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
 166   ASSERT_TRUE(pref);
 167
 168   // Check that GetValue() returns the default value.
 169   const base::Value* value = pref->GetValue();
 170   ASSERT_TRUE(value);
 171   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 172   int actual_int_value = -1;
 173   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 174   EXPECT_EQ(kDefaultValue, actual_int_value);
 175
 176   // Check that GetRecommendedValue() returns no value.
 177   value = pref->GetRecommendedValue();
 178   ASSERT_FALSE(value);
 179
 180   // Set a user-set value.
 181   prefs.SetUserPref(kPrefName, std::make_unique<base::Value>(kUserValue));
 182
 183   // Check that GetValue() returns the user-set value.
 184   value = pref->GetValue();
 185   ASSERT_TRUE(value);
 186   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 187   actual_int_value = -1;
 188   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 189   EXPECT_EQ(kUserValue, actual_int_value);
 190
 191   // Check that GetRecommendedValue() returns no value.
 192   value = pref->GetRecommendedValue();
 193   ASSERT_FALSE(value);
 194
 195   // Set a recommended value.
 196   prefs.SetRecommendedPref(kPrefName,
 197                            std::make_unique<base::Value>(kRecommendedValue));
 198
 199   // Check that GetValue() returns the user-set value.
 200   value = pref->GetValue();
 201   ASSERT_TRUE(value);
 202   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 203   actual_int_value = -1;
 204   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 205   EXPECT_EQ(kUserValue, actual_int_value);
 206
 207   // Check that GetRecommendedValue() returns the recommended value.
 208   value = pref->GetRecommendedValue();
 209   ASSERT_TRUE(value);
 210   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 211   actual_int_value = -1;
 212   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 213   EXPECT_EQ(kRecommendedValue, actual_int_value);
 214
 215   // Remove the user-set value.
 216   prefs.RemoveUserPref(kPrefName);
 217
 218   // Check that GetValue() returns the recommended value.
 219   value = pref->GetValue();
 220   ASSERT_TRUE(value);
 221   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 222   actual_int_value = -1;
 223   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 224   EXPECT_EQ(kRecommendedValue, actual_int_value);
 225
 226   // Check that GetRecommendedValue() returns the recommended value.
 227   value = pref->GetRecommendedValue();
 228   ASSERT_TRUE(value);
 229   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 230   actual_int_value = -1;
 231   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 232   EXPECT_EQ(kRecommendedValue, actual_int_value);
 233 }
 234
 235 TEST(PrefServiceTest, SetTimeValue_RegularTime) {
 236   TestingPrefServiceSimple prefs;
 237
 238   // Register a null time as the default.
 239   prefs.registry()->RegisterTimePref(kPrefName, base::Time());
 240   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 241
 242   // Set a time and make sure that we can read it without any loss of precision.
 243   const base::Time time = base::Time::Now();
 244   prefs.SetTime(kPrefName, time);
 245   EXPECT_EQ(time, prefs.GetTime(kPrefName));
 246 }
 247
 248 TEST(PrefServiceTest, SetTimeValue_NullTime) {
 249   TestingPrefServiceSimple prefs;
 250
 251   // Register a non-null time as the default.
 252   const base::Time default_time = base::Time::FromDeltaSinceWindowsEpoch(
 253       base::TimeDelta::FromMicroseconds(12345));
 254   prefs.registry()->RegisterTimePref(kPrefName, default_time);
 255   EXPECT_FALSE(prefs.GetTime(kPrefName).is_null());
 256
 257   // Set a null time and make sure that it remains null upon deserialization.
 258   prefs.SetTime(kPrefName, base::Time());
 259   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 260 }
 261
 262 // A PrefStore which just stores the last write flags that were used to write
 263 // values to it.
 264 class WriteFlagChecker : public TestingPrefStore {
 265  public:
 266   WriteFlagChecker() {}
 267
 268   void ReportValueChanged(const std::string& key, uint32_t flags) override {
 269     SetLastWriteFlags(flags);
 270   }
 271
 272   void SetValue(const std::string& key,
 273                 std::unique_ptr<base::Value> value,
 274                 uint32_t flags) override {
 275     SetLastWriteFlags(flags);
 276   }
 277
 278   void SetValueSilently(const std::string& key,
 279                         std::unique_ptr<base::Value> value,
 280                         uint32_t flags) override {
 281     SetLastWriteFlags(flags);
 282   }
 283
 284   void RemoveValue(const std::string& key, uint32_t flags) override {
 285     SetLastWriteFlags(flags);
 286   }
 287
 288   uint32_t GetLastFlagsAndClear() {
 289     CHECK(last_write_flags_set_);
 290     uint32_t result = last_write_flags_;
 291     last_write_flags_set_ = false;
 292     last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 293     return result;
 294   }
 295
 296   bool last_write_flags_set() { return last_write_flags_set_; }
 297
 298  private:
 299   ~WriteFlagChecker() override {}
 300
 301   void SetLastWriteFlags(uint32_t flags) {
 302     CHECK(!last_write_flags_set_);
 303     last_write_flags_set_ = true;
 304     last_write_flags_ = flags;
 305   }
 306
 307   bool last_write_flags_set_ = false;
 308   uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 309 };
 310
 311 TEST(PrefServiceTest, WriteablePrefStoreFlags) {
 312   scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker);
 313   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
 314   PrefServiceFactory factory;
 315   factory.set_user_prefs(flag_checker);
 316   std::unique_ptr<PrefService> prefs(factory.Create(registry.get()));
 317
 318   // The first 8 bits of write flags are reserved for subclasses. Create a
 319   // custom flag in this range
 320   uint32_t kCustomRegistrationFlag = 1 << 2;
 321
 322   // A map of the registration flags that will be tested and the write flags
 323   // they are expected to convert to.
 324   struct RegistrationToWriteFlags {
 325     const char* pref_name;
 326     uint32_t registration_flags;
 327     uint32_t write_flags;
 328   };
 329   const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
 330       {"none",
 331        PrefRegistry::NO_REGISTRATION_FLAGS,
 332        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 333       {"lossy",
 334        PrefRegistry::LOSSY_PREF,
 335        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
 336       {"custom",
 337        kCustomRegistrationFlag,
 338        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 339       {"lossyandcustom",
 340        PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
 341        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
 342
 343   for (size_t i = 0; i < arraysize(kRegistrationToWriteFlags); ++i) {
 344     RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
 345     registry->RegisterDictionaryPref(entry.pref_name,
 346                                      std::make_unique<base::DictionaryValue>(),
 347                                      entry.registration_flags);
 348
 349     SCOPED_TRACE("Currently testing pref with name: " +
 350                  std::string(entry.pref_name));
 351
 352     prefs->GetMutableUserPref(entry.pref_name, base::Value::Type::DICTIONARY);
 353     EXPECT_TRUE(flag_checker->last_write_flags_set());
 354     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 355
 356     prefs->ReportUserPrefChanged(entry.pref_name);
 357     EXPECT_TRUE(flag_checker->last_write_flags_set());
 358     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 359
 360     prefs->ClearPref(entry.pref_name);
 361     EXPECT_TRUE(flag_checker->last_write_flags_set());
 362     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 363
 364     prefs->SetUserPrefValue(entry.pref_name,
 365                             std::make_unique<base::DictionaryValue>());
 366     EXPECT_TRUE(flag_checker->last_write_flags_set());
 367     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 368   }
 369 }
 370
 371 class PrefServiceSetValueTest : public testing::Test {
 372  protected:
 373   static const char kName[];
 374   static const char kValue[];
 375
 376   PrefServiceSetValueTest() : observer_(&prefs_) {}
 377
 378   TestingPrefServiceSimple prefs_;
 379   MockPrefChangeCallback observer_;
 380 };
 381
 382 const char PrefServiceSetValueTest::kName[] = "name";
 383 const char PrefServiceSetValueTest::kValue[] = "value";
 384
 385 TEST_F(PrefServiceSetValueTest, SetStringValue) {
 386   const char default_string[] = "default";
 387   const base::Value default_value(default_string);
 388   prefs_.registry()->RegisterStringPref(kName, default_string);
 389
 390   PrefChangeRegistrar registrar;
 391   registrar.Init(&prefs_);
 392   registrar.Add(kName, observer_.GetCallback());
 393
 394   // Changing the controlling store from default to user triggers notification.
 395   observer_.Expect(kName, &default_value);
 396   prefs_.Set(kName, default_value);
 397   Mock::VerifyAndClearExpectations(&observer_);
 398
 399   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 400   prefs_.Set(kName, default_value);
 401   Mock::VerifyAndClearExpectations(&observer_);
 402
 403   base::Value new_value(kValue);
 404   observer_.Expect(kName, &new_value);
 405   prefs_.Set(kName, new_value);
 406   Mock::VerifyAndClearExpectations(&observer_);
 407 }
 408
 409 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) {
 410   prefs_.registry()->RegisterDictionaryPref(kName);
 411   PrefChangeRegistrar registrar;
 412   registrar.Init(&prefs_);
 413   registrar.Add(kName, observer_.GetCallback());
 414
 415   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 416   prefs_.RemoveUserPref(kName);
 417   Mock::VerifyAndClearExpectations(&observer_);
 418
 419   base::DictionaryValue new_value;
 420   new_value.SetString(kName, kValue);
 421   observer_.Expect(kName, &new_value);
 422   prefs_.Set(kName, new_value);
 423   Mock::VerifyAndClearExpectations(&observer_);
 424
 425   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 426   prefs_.Set(kName, new_value);
 427   Mock::VerifyAndClearExpectations(&observer_);
 428
 429   base::DictionaryValue empty;
 430   observer_.Expect(kName, &empty);
 431   prefs_.Set(kName, empty);
 432   Mock::VerifyAndClearExpectations(&observer_);
 433 }
 434
 435 TEST_F(PrefServiceSetValueTest, SetListValue) {
 436   prefs_.registry()->RegisterListPref(kName);
 437   PrefChangeRegistrar registrar;
 438   registrar.Init(&prefs_);
 439   registrar.Add(kName, observer_.GetCallback());
 440
 441   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 442   prefs_.RemoveUserPref(kName);
 443   Mock::VerifyAndClearExpectations(&observer_);
 444
 445   base::ListValue new_value;
 446   new_value.AppendString(kValue);
 447   observer_.Expect(kName, &new_value);
 448   prefs_.Set(kName, new_value);
 449   Mock::VerifyAndClearExpectations(&observer_);
 450
 451   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 452   prefs_.Set(kName, new_value);
 453   Mock::VerifyAndClearExpectations(&observer_);
 454
 455   base::ListValue empty;
 456   observer_.Expect(kName, &empty);
 457   prefs_.Set(kName, empty);
 458   Mock::VerifyAndClearExpectations(&observer_);
 459 }