Mojom interface for Preferences

components/prefs/pref_observer_store_unittest.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/prefs/pref_observer_store.h"
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/values.h"
+#include "components/prefs/pref_store_observer_mock.h"
+#include "components/prefs/public/interfaces/preferences.mojom.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// Test implmentation of prefs::mojom::PreferenceManager which simply tracks
+// calls. Allows for testing to be done in process, without mojo IPC.
+class TestPreferenceManager : public prefs::mojom::PreferenceManager {
+ public:
+  TestPreferenceManager()
+      : add_observer_called_(false), set_preferences_called_(false) {}
+  ~TestPreferenceManager() override {}
+
+  bool add_observer_called() { return add_observer_called_; }
+  const std::set<mojo::String>& last_preference_set() {
+    return last_preference_set_;
+  }
+  bool set_preferences_called() { return set_preferences_called_; }
+
+  // prefs::mojom::TestPreferenceManager:
+  void AddObserver(prefs::mojom::PreferenceListPtr preferences,
+                   prefs::mojom::PreferenceObserverPtr client) override;
+  void SetPreferences(prefs::mojom::PreferenceMapPtr preferences) override;
+
+ private:
+  bool add_observer_called_;
+  std::set<mojo::String> last_preference_set_;
+  bool set_preferences_called_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPreferenceManager);
+};
+
+void TestPreferenceManager::AddObserver(
+    prefs::mojom::PreferenceListPtr preferences,
+    prefs::mojom::PreferenceObserverPtr client) {
+  add_observer_called_ = true;
+  last_preference_set_ = preferences->preferences.To<std::set<mojo::String>>();
+}
+
+void TestPreferenceManager::SetPreferences(
+    prefs::mojom::PreferenceMapPtr preferences) {
+  set_preferences_called_ = true;
+}
+
+}  // namespace
+
+class PrefObserverStoreTest : public testing::Test {
+ public:
+  PrefObserverStoreTest() {}
+  ~PrefObserverStoreTest() override {}
+
+  TestPreferenceManager* manager() { return &manager_; }
+  PrefStoreObserverMock* observer() { return &observer_; }
+  PrefObserverStore* store() { return store_.get(); }
+
+  bool Initialized() { return store_->initialized_; }
+  void OnPreferencesChanged(prefs::mojom::PreferenceMapPtr preferences) {
+    store_->OnPreferencesChanged(std::move(preferences));
+  }
+
+  // testing::Test:
+  void SetUp() override;
+  void TearDown() override;
+
+ private:
+  scoped_refptr<PrefObserverStore> store_;
+  TestPreferenceManager manager_;
+  PrefStoreObserverMock observer_;
+  // Required by mojo binding code within PrefObserverStore.
+  base::MessageLoop message_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrefObserverStoreTest);
+};
+
+void PrefObserverStoreTest::SetUp() {
+  store_ = new PrefObserverStore(nullptr);
+  store_->AddObserver(&observer_);
+  store_->prefs_manager_ = &manager_;
+}
+
+void PrefObserverStoreTest::TearDown() {
+  store_->RemoveObserver(&observer_);
+}
+
+// Tests that though initialization has started, that there are no values
+// available until they are set.
+TEST_F(PrefObserverStoreTest, NoCacheUntilValuesSet) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  EXPECT_TRUE(manager()->add_observer_called());
+  EXPECT_EQ(keys.size(), manager()->last_preference_set().size());
+
+  // There should be no values immediately after Init.
+  const base::Value* value = nullptr;
+  EXPECT_FALSE(store()->GetValue("hey", &value));
+  EXPECT_EQ(nullptr, value);
+
+  const int kValue = 42;
+  store()->SetValue(key, base::WrapUnique(new base::FundamentalValue(kValue)),
+                    0);
+  int actual_value;
+  EXPECT_TRUE(store()->GetValue(key, &value));
+  EXPECT_NE(nullptr, value);
+  EXPECT_TRUE(value->GetAsInteger(&actual_value));
+  EXPECT_EQ(kValue, actual_value);
+  EXPECT_TRUE(manager()->set_preferences_called());
+  observer()->VerifyAndResetChangedKey(key);
+}
+
+// Tests that observers are notified upon the completion of initialization, and
+// that values become available.
+TEST_F(PrefObserverStoreTest, Initialization) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  EXPECT_FALSE(Initialized());
+  EXPECT_FALSE(observer()->initialized);
+
+  const int kValue = 42;
+  prefs::mojom::PreferencePtr pref = prefs::mojom::Preference::New();
+  pref->type = prefs::mojom::Preference::PreferenceType::INT;
+  pref->integer_value_ = kValue;
+  prefs::mojom::PreferenceMapPtr pref_map = prefs::mojom::PreferenceMap::New();
+  pref_map->preferences.insert(key, std::move(pref));
+
+  // PreferenceManager notifies of PreferencesChanged, completing
+  // initialization.
+  OnPreferencesChanged(std::move(pref_map));
+  EXPECT_TRUE(Initialized());
+  EXPECT_TRUE(observer()->initialized);
+  EXPECT_TRUE(observer()->initialization_success);
+  observer()->VerifyAndResetChangedKey(key);
+
+  const base::Value* value = nullptr;
+  int actual_value;
+  EXPECT_TRUE(store()->GetValue(key, &value));
+  EXPECT_NE(nullptr, value);
+  EXPECT_TRUE(value->GetAsInteger(&actual_value));
+  EXPECT_EQ(kValue, actual_value);
+  EXPECT_FALSE(manager()->set_preferences_called());
+}
+
+// Tests that values set silently are also set on the preference manager, but
+// that no observers are notified.
+TEST_F(PrefObserverStoreTest, SetValueSilently) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  const int kValue = 42;
+  store()->SetValueSilently(
+      key, base::WrapUnique(new base::FundamentalValue(kValue)), 0);
+  EXPECT_TRUE(manager()->set_preferences_called());
+  EXPECT_TRUE(observer()->changed_keys.empty());
+}
+
+// Test that reporting values changed notifies observers, but not the preference
+// manager.
+TEST_F(PrefObserverStoreTest, ReportValueChanged) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  store()->ReportValueChanged(key, 0);
+  EXPECT_FALSE(manager()->set_preferences_called());
+  observer()->VerifyAndResetChangedKey(key);
+}
+
+// Tests that attempting to set a value for an invalid key does not make
+// changes.
+TEST_F(PrefObserverStoreTest, SetInvalidKey) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  const std::string invalid_key("look");
+  store()->SetValue(invalid_key,
+                    base::WrapUnique(new base::FundamentalValue(42)), 0);
+  EXPECT_FALSE(manager()->set_preferences_called());
+  EXPECT_TRUE(observer()->changed_keys.empty());
+}
+
+// Test that when initialized with multiple keys, that observers receive a
+// notification for each key.
+TEST_F(PrefObserverStoreTest, MultipleKeyInitialization) {
+  std::set<mojo::String> keys;
+  const std::string key1("hey");
+  const std::string key2("listen");
+  keys.insert(key1);
+  keys.insert(key2);
+  store()->Init(keys);
+
+  EXPECT_FALSE(Initialized());
+  EXPECT_FALSE(observer()->initialized);
+
+  const int kValue = 42;
+  prefs::mojom::PreferencePtr pref1 = prefs::mojom::Preference::New();
+  pref1->type = prefs::mojom::Preference::PreferenceType::INT;
+  pref1->integer_value_ = kValue;
+
+  const std::string kStringValue("look");
+  prefs::mojom::PreferencePtr pref2 = prefs::mojom::Preference::New();
+  pref2->type = prefs::mojom::Preference::PreferenceType::STRING;
+  pref2->string_value_ = kStringValue;
+
+  prefs::mojom::PreferenceMapPtr pref_map = prefs::mojom::PreferenceMap::New();
+  pref_map->preferences.insert(key1, std::move(pref1));
+  pref_map->preferences.insert(key2, std::move(pref2));
+
+  // The observer should be notified of all keys set.
+  OnPreferencesChanged(std::move(pref_map));
+  EXPECT_TRUE(Initialized());
+  EXPECT_TRUE(observer()->initialized);
+  EXPECT_EQ(2u, observer()->changed_keys.size());
+  EXPECT_EQ(key1, observer()->changed_keys.front());
+  EXPECT_EQ(key2, observer()->changed_keys.back());
+}
+
+// Tests that if OnPreferencesChanged is received with invalid keys, that they
+// are ignored.
+TEST_F(PrefObserverStoreTest, InvalidInitialization) {
+  std::set<mojo::String> keys;
+  const std::string key("hey");
+  keys.insert(key);
+  store()->Init(keys);
+
+  const std::string kInvalidKey("look");
+  const int kValue = 42;
+  prefs::mojom::PreferencePtr pref = prefs::mojom::Preference::New();
+  pref->type = prefs::mojom::Preference::PreferenceType::INT;
+  pref->integer_value_ = kValue;
+  prefs::mojom::PreferenceMapPtr pref_map = prefs::mojom::PreferenceMap::New();
+  pref_map->preferences.insert(kInvalidKey, std::move(pref));
+
+  OnPreferencesChanged(std::move(pref_map));
+  EXPECT_TRUE(observer()->changed_keys.empty());
+}