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 TEST(PrefServiceTest, SetTimeDeltaValue_RegularTimeDelta) {
 263   TestingPrefServiceSimple prefs;
 264
 265   // Register a zero time delta as the default.
 266   prefs.registry()->RegisterTimeDeltaPref(kPrefName, base::TimeDelta());
 267   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 268
 269   // Set a time delta and make sure that we can read it without any loss of
 270   // precision.
 271   const base::TimeDelta delta = base::Time::Now() - base::Time();
 272   prefs.SetTimeDelta(kPrefName, delta);
 273   EXPECT_EQ(delta, prefs.GetTimeDelta(kPrefName));
 274 }
 275
 276 TEST(PrefServiceTest, SetTimeDeltaValue_ZeroTimeDelta) {
 277   TestingPrefServiceSimple prefs;
 278
 279   // Register a non-zero time delta as the default.
 280   const base::TimeDelta default_delta =
 281       base::TimeDelta::FromMicroseconds(12345);
 282   prefs.registry()->RegisterTimeDeltaPref(kPrefName, default_delta);
 283   EXPECT_FALSE(prefs.GetTimeDelta(kPrefName).is_zero());
 284
 285   // Set a zero time delta and make sure that it remains zero upon
 286   // deserialization.
 287   prefs.SetTimeDelta(kPrefName, base::TimeDelta());
 288   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 289 }
 290
 291 // A PrefStore which just stores the last write flags that were used to write
 292 // values to it.
 293 class WriteFlagChecker : public TestingPrefStore {
 294  public:
 295   WriteFlagChecker() {}
 296
 297   void ReportValueChanged(const std::string& key, uint32_t flags) override {
 298     SetLastWriteFlags(flags);
 299   }
 300
 301   void SetValue(const std::string& key,
 302                 std::unique_ptr<base::Value> value,
 303                 uint32_t flags) override {
 304     SetLastWriteFlags(flags);
 305   }
 306
 307   void SetValueSilently(const std::string& key,
 308                         std::unique_ptr<base::Value> value,
 309                         uint32_t flags) override {
 310     SetLastWriteFlags(flags);
 311   }
 312
 313   void RemoveValue(const std::string& key, uint32_t flags) override {
 314     SetLastWriteFlags(flags);
 315   }
 316
 317   uint32_t GetLastFlagsAndClear() {
 318     CHECK(last_write_flags_set_);
 319     uint32_t result = last_write_flags_;
 320     last_write_flags_set_ = false;
 321     last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 322     return result;
 323   }
 324
 325   bool last_write_flags_set() { return last_write_flags_set_; }
 326
 327  private:
 328   ~WriteFlagChecker() override {}
 329
 330   void SetLastWriteFlags(uint32_t flags) {
 331     CHECK(!last_write_flags_set_);
 332     last_write_flags_set_ = true;
 333     last_write_flags_ = flags;
 334   }
 335
 336   bool last_write_flags_set_ = false;
 337   uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 338 };
 339
 340 TEST(PrefServiceTest, WriteablePrefStoreFlags) {
 341   scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker);
 342   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
 343   PrefServiceFactory factory;
 344   factory.set_user_prefs(flag_checker);
 345   std::unique_ptr<PrefService> prefs(factory.Create(registry.get()));
 346
 347   // The first 8 bits of write flags are reserved for subclasses. Create a
 348   // custom flag in this range
 349   uint32_t kCustomRegistrationFlag = 1 << 2;
 350
 351   // A map of the registration flags that will be tested and the write flags
 352   // they are expected to convert to.
 353   struct RegistrationToWriteFlags {
 354     const char* pref_name;
 355     uint32_t registration_flags;
 356     uint32_t write_flags;
 357   };
 358   const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
 359       {"none",
 360        PrefRegistry::NO_REGISTRATION_FLAGS,
 361        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 362       {"lossy",
 363        PrefRegistry::LOSSY_PREF,
 364        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
 365       {"custom",
 366        kCustomRegistrationFlag,
 367        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 368       {"lossyandcustom",
 369        PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
 370        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
 371
 372   for (size_t i = 0; i < arraysize(kRegistrationToWriteFlags); ++i) {
 373     RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
 374     registry->RegisterDictionaryPref(entry.pref_name,
 375                                      std::make_unique<base::DictionaryValue>(),
 376                                      entry.registration_flags);
 377
 378     SCOPED_TRACE("Currently testing pref with name: " +
 379                  std::string(entry.pref_name));
 380
 381     prefs->GetMutableUserPref(entry.pref_name, base::Value::Type::DICTIONARY);
 382     EXPECT_TRUE(flag_checker->last_write_flags_set());
 383     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 384
 385     prefs->ReportUserPrefChanged(entry.pref_name);
 386     EXPECT_TRUE(flag_checker->last_write_flags_set());
 387     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 388
 389     prefs->ClearPref(entry.pref_name);
 390     EXPECT_TRUE(flag_checker->last_write_flags_set());
 391     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 392
 393     prefs->SetUserPrefValue(entry.pref_name,
 394                             std::make_unique<base::DictionaryValue>());
 395     EXPECT_TRUE(flag_checker->last_write_flags_set());
 396     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 397   }
 398 }
 399
 400 class PrefServiceSetValueTest : public testing::Test {
 401  protected:
 402   static const char kName[];
 403   static const char kValue[];
 404
 405   PrefServiceSetValueTest() : observer_(&prefs_) {}
 406
 407   TestingPrefServiceSimple prefs_;
 408   MockPrefChangeCallback observer_;
 409 };
 410
 411 const char PrefServiceSetValueTest::kName[] = "name";
 412 const char PrefServiceSetValueTest::kValue[] = "value";
 413
 414 TEST_F(PrefServiceSetValueTest, SetStringValue) {
 415   const char default_string[] = "default";
 416   const base::Value default_value(default_string);
 417   prefs_.registry()->RegisterStringPref(kName, default_string);
 418
 419   PrefChangeRegistrar registrar;
 420   registrar.Init(&prefs_);
 421   registrar.Add(kName, observer_.GetCallback());
 422
 423   // Changing the controlling store from default to user triggers notification.
 424   observer_.Expect(kName, &default_value);
 425   prefs_.Set(kName, default_value);
 426   Mock::VerifyAndClearExpectations(&observer_);
 427
 428   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 429   prefs_.Set(kName, default_value);
 430   Mock::VerifyAndClearExpectations(&observer_);
 431
 432   base::Value new_value(kValue);
 433   observer_.Expect(kName, &new_value);
 434   prefs_.Set(kName, new_value);
 435   Mock::VerifyAndClearExpectations(&observer_);
 436 }
 437
 438 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) {
 439   prefs_.registry()->RegisterDictionaryPref(kName);
 440   PrefChangeRegistrar registrar;
 441   registrar.Init(&prefs_);
 442   registrar.Add(kName, observer_.GetCallback());
 443
 444   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 445   prefs_.RemoveUserPref(kName);
 446   Mock::VerifyAndClearExpectations(&observer_);
 447
 448   base::DictionaryValue new_value;
 449   new_value.SetString(kName, kValue);
 450   observer_.Expect(kName, &new_value);
 451   prefs_.Set(kName, new_value);
 452   Mock::VerifyAndClearExpectations(&observer_);
 453
 454   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 455   prefs_.Set(kName, new_value);
 456   Mock::VerifyAndClearExpectations(&observer_);
 457
 458   base::DictionaryValue empty;
 459   observer_.Expect(kName, &empty);
 460   prefs_.Set(kName, empty);
 461   Mock::VerifyAndClearExpectations(&observer_);
 462 }
 463
 464 TEST_F(PrefServiceSetValueTest, SetListValue) {
 465   prefs_.registry()->RegisterListPref(kName);
 466   PrefChangeRegistrar registrar;
 467   registrar.Init(&prefs_);
 468   registrar.Add(kName, observer_.GetCallback());
 469
 470   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 471   prefs_.RemoveUserPref(kName);
 472   Mock::VerifyAndClearExpectations(&observer_);
 473
 474   base::ListValue new_value;
 475   new_value.AppendString(kValue);
 476   observer_.Expect(kName, &new_value);
 477   prefs_.Set(kName, new_value);
 478   Mock::VerifyAndClearExpectations(&observer_);
 479
 480   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 481   prefs_.Set(kName, new_value);
 482   Mock::VerifyAndClearExpectations(&observer_);
 483
 484   base::ListValue empty;
 485   observer_.Expect(kName, &empty);
 486   prefs_.Set(kName, empty);
 487   Mock::VerifyAndClearExpectations(&observer_);
 488 }