pref_change_registrar_unittest.cc 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189
  1. // Copyright (c) 2010 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. #include "components/prefs/pref_change_registrar.h"
  5. #include <memory>
  6. #include "base/bind.h"
  7. #include "base/callback_helpers.h"
  8. #include "components/prefs/pref_observer.h"
  9. #include "components/prefs/pref_registry_simple.h"
  10. #include "components/prefs/testing_pref_service.h"
  11. #include "testing/gmock/include/gmock/gmock.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. using testing::Mock;
  14. using testing::Eq;
  15. namespace base {
  16. namespace {
  17. const char kHomePage[] = "homepage";
  18. const char kHomePageIsNewTabPage[] = "homepage_is_newtabpage";
  19. const char kApplicationLocale[] = "intl.app_locale";
  20. // A mock provider that allows us to capture pref observer changes.
  21. class MockPrefService : public TestingPrefServiceSimple {
  22. public:
  23. MockPrefService() {}
  24. ~MockPrefService() override {}
  25. MOCK_METHOD2(AddPrefObserver, void(const std::string&, PrefObserver*));
  26. MOCK_METHOD2(RemovePrefObserver, void(const std::string&, PrefObserver*));
  27. };
  28. // Due to overloads, base::DoNothing() cannot be passed directly to
  29. // PrefChangeRegistrar::Add() as it is convertible to all callbacks.
  30. base::RepeatingClosure DoNothingClosure() {
  31. return base::DoNothing();
  32. }
  33. } // namespace
  34. class PrefChangeRegistrarTest : public testing::Test {
  35. public:
  36. PrefChangeRegistrarTest() {}
  37. ~PrefChangeRegistrarTest() override {}
  38. protected:
  39. void SetUp() override;
  40. MockPrefService* service() const { return service_.get(); }
  41. private:
  42. std::unique_ptr<MockPrefService> service_;
  43. };
  44. void PrefChangeRegistrarTest::SetUp() {
  45. service_ = std::make_unique<MockPrefService>();
  46. }
  47. TEST_F(PrefChangeRegistrarTest, AddAndRemove) {
  48. PrefChangeRegistrar registrar;
  49. registrar.Init(service());
  50. // Test adding.
  51. EXPECT_CALL(*service(),
  52. AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
  53. EXPECT_CALL(*service(),
  54. AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
  55. registrar.Add("test.pref.1", DoNothingClosure());
  56. registrar.Add("test.pref.2", DoNothingClosure());
  57. EXPECT_FALSE(registrar.IsEmpty());
  58. // Test removing.
  59. Mock::VerifyAndClearExpectations(service());
  60. EXPECT_CALL(*service(),
  61. RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
  62. EXPECT_CALL(*service(),
  63. RemovePrefObserver(Eq(std::string("test.pref.2")), &registrar));
  64. registrar.Remove("test.pref.1");
  65. registrar.Remove("test.pref.2");
  66. EXPECT_TRUE(registrar.IsEmpty());
  67. // Explicitly check the expectations now to make sure that the Removes
  68. // worked (rather than the registrar destructor doing the work).
  69. Mock::VerifyAndClearExpectations(service());
  70. }
  71. TEST_F(PrefChangeRegistrarTest, AutoRemove) {
  72. PrefChangeRegistrar registrar;
  73. registrar.Init(service());
  74. // Setup of auto-remove.
  75. EXPECT_CALL(*service(),
  76. AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
  77. registrar.Add("test.pref.1", DoNothingClosure());
  78. Mock::VerifyAndClearExpectations(service());
  79. EXPECT_FALSE(registrar.IsEmpty());
  80. // Test auto-removing.
  81. EXPECT_CALL(*service(),
  82. RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
  83. }
  84. TEST_F(PrefChangeRegistrarTest, RemoveAll) {
  85. PrefChangeRegistrar registrar;
  86. registrar.Init(service());
  87. EXPECT_CALL(*service(),
  88. AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
  89. EXPECT_CALL(*service(),
  90. AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
  91. registrar.Add("test.pref.1", DoNothingClosure());
  92. registrar.Add("test.pref.2", DoNothingClosure());
  93. Mock::VerifyAndClearExpectations(service());
  94. EXPECT_CALL(*service(),
  95. RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
  96. EXPECT_CALL(*service(),
  97. RemovePrefObserver(Eq(std::string("test.pref.2")), &registrar));
  98. registrar.RemoveAll();
  99. EXPECT_TRUE(registrar.IsEmpty());
  100. // Explicitly check the expectations now to make sure that the RemoveAll
  101. // worked (rather than the registrar destructor doing the work).
  102. Mock::VerifyAndClearExpectations(service());
  103. }
  104. class ObserveSetOfPreferencesTest : public testing::Test {
  105. public:
  106. void SetUp() override {
  107. pref_service_ = std::make_unique<TestingPrefServiceSimple>();
  108. PrefRegistrySimple* registry = pref_service_->registry();
  109. registry->RegisterStringPref(kHomePage, "http://google.com");
  110. registry->RegisterBooleanPref(kHomePageIsNewTabPage, false);
  111. registry->RegisterStringPref(kApplicationLocale, std::string());
  112. }
  113. PrefChangeRegistrar* CreatePrefChangeRegistrar() {
  114. PrefChangeRegistrar* pref_set = new PrefChangeRegistrar();
  115. pref_set->Init(pref_service_.get());
  116. pref_set->Add(kHomePage, DoNothingClosure());
  117. pref_set->Add(kHomePageIsNewTabPage, DoNothingClosure());
  118. return pref_set;
  119. }
  120. MOCK_METHOD1(OnPreferenceChanged, void(const std::string&));
  121. std::unique_ptr<TestingPrefServiceSimple> pref_service_;
  122. };
  123. TEST_F(ObserveSetOfPreferencesTest, IsObserved) {
  124. std::unique_ptr<PrefChangeRegistrar> pref_set(CreatePrefChangeRegistrar());
  125. EXPECT_TRUE(pref_set->IsObserved(kHomePage));
  126. EXPECT_TRUE(pref_set->IsObserved(kHomePageIsNewTabPage));
  127. EXPECT_FALSE(pref_set->IsObserved(kApplicationLocale));
  128. }
  129. TEST_F(ObserveSetOfPreferencesTest, Observe) {
  130. using testing::_;
  131. using testing::Mock;
  132. PrefChangeRegistrar pref_set;
  133. PrefChangeRegistrar::NamedChangeCallback callback =
  134. base::BindRepeating(&ObserveSetOfPreferencesTest::OnPreferenceChanged,
  135. base::Unretained(this));
  136. pref_set.Init(pref_service_.get());
  137. pref_set.Add(kHomePage, callback);
  138. pref_set.Add(kHomePageIsNewTabPage, callback);
  139. EXPECT_CALL(*this, OnPreferenceChanged(kHomePage));
  140. pref_service_->SetUserPref(kHomePage,
  141. std::make_unique<Value>("http://crbug.com"));
  142. Mock::VerifyAndClearExpectations(this);
  143. EXPECT_CALL(*this, OnPreferenceChanged(kHomePageIsNewTabPage));
  144. pref_service_->SetUserPref(kHomePageIsNewTabPage,
  145. std::make_unique<Value>(true));
  146. Mock::VerifyAndClearExpectations(this);
  147. EXPECT_CALL(*this, OnPreferenceChanged(_)).Times(0);
  148. pref_service_->SetUserPref(kApplicationLocale,
  149. std::make_unique<Value>("en_US.utf8"));
  150. Mock::VerifyAndClearExpectations(this);
  151. }
  152. } // namespace base