| // Copyright 2014 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 "chrome/browser/prefs/leveldb_pref_store.h" |
| |
| #include "base/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/path_service.h" |
| #include "base/run_loop.h" |
| #include "base/values.h" |
| #include "chrome/common/chrome_paths.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace { |
| |
| class MockPrefStoreObserver : public PrefStore::Observer { |
| public: |
| MOCK_METHOD1(OnPrefValueChanged, void(const std::string&)); |
| MOCK_METHOD1(OnInitializationCompleted, void(bool)); |
| }; |
| |
| class MockReadErrorDelegate : public PersistentPrefStore::ReadErrorDelegate { |
| public: |
| MOCK_METHOD1(OnError, void(PersistentPrefStore::PrefReadError)); |
| }; |
| |
| } // namespace |
| |
| class LevelDBPrefStoreTest : public testing::Test { |
| protected: |
| virtual void SetUp() OVERRIDE { |
| ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| |
| ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_dir_)); |
| data_dir_ = data_dir_.AppendASCII("prefs"); |
| ASSERT_TRUE(PathExists(data_dir_)); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| Close(); |
| } |
| |
| void Open() { |
| pref_store_ = new LevelDBPrefStore( |
| temp_dir_.path(), message_loop_.message_loop_proxy().get()); |
| EXPECT_EQ(LevelDBPrefStore::PREF_READ_ERROR_NONE, pref_store_->ReadPrefs()); |
| } |
| |
| void Close() { |
| pref_store_ = NULL; |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| void CloseAndReopen() { |
| Close(); |
| Open(); |
| } |
| |
| // The path to temporary directory used to contain the test operations. |
| base::ScopedTempDir temp_dir_; |
| // The path to the directory where the test data is stored in the source tree. |
| base::FilePath data_dir_; |
| // A message loop that we can use as the file thread message loop. |
| base::MessageLoop message_loop_; |
| |
| scoped_refptr<LevelDBPrefStore> pref_store_; |
| }; |
| |
| TEST_F(LevelDBPrefStoreTest, PutAndGet) { |
| Open(); |
| const std::string key = "some.key"; |
| pref_store_->SetValue(key, new base::FundamentalValue(5)); |
| base::FundamentalValue orig_value(5); |
| const base::Value* actual_value; |
| EXPECT_TRUE(pref_store_->GetValue(key, &actual_value)); |
| EXPECT_TRUE(orig_value.Equals(actual_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, PutAndGetPersistent) { |
| Open(); |
| const std::string key = "some.key"; |
| pref_store_->SetValue(key, new base::FundamentalValue(5)); |
| |
| CloseAndReopen(); |
| const base::Value* actual_value = NULL; |
| base::FundamentalValue orig_value(5); |
| EXPECT_TRUE(pref_store_->GetValue(key, &actual_value)); |
| EXPECT_TRUE(orig_value.Equals(actual_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, BasicObserver) { |
| scoped_refptr<LevelDBPrefStore> pref_store = new LevelDBPrefStore( |
| temp_dir_.path(), message_loop_.message_loop_proxy().get()); |
| MockPrefStoreObserver mock_observer; |
| pref_store->AddObserver(&mock_observer); |
| EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs()); |
| testing::Mock::VerifyAndClearExpectations(&mock_observer); |
| |
| const std::string key = "some.key"; |
| EXPECT_CALL(mock_observer, OnPrefValueChanged(key)).Times(1); |
| pref_store->SetValue(key, new base::FundamentalValue(5)); |
| |
| pref_store->RemoveObserver(&mock_observer); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, SetValueSilently) { |
| Open(); |
| |
| MockPrefStoreObserver mock_observer; |
| pref_store_->AddObserver(&mock_observer); |
| const std::string key = "some.key"; |
| EXPECT_CALL(mock_observer, OnPrefValueChanged(key)).Times(0); |
| pref_store_->SetValueSilently(key, new base::FundamentalValue(30)); |
| pref_store_->RemoveObserver(&mock_observer); |
| |
| CloseAndReopen(); |
| base::FundamentalValue value(30); |
| const base::Value* actual_value = NULL; |
| EXPECT_TRUE(pref_store_->GetValue(key, &actual_value)); |
| EXPECT_TRUE(base::Value::Equals(&value, actual_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, GetMutableValue) { |
| Open(); |
| |
| const std::string key = "some.key"; |
| base::DictionaryValue* orig_value = new base::DictionaryValue; |
| orig_value->SetInteger("key2", 25); |
| pref_store_->SetValue(key, orig_value); |
| |
| base::Value* actual_value; |
| EXPECT_TRUE(pref_store_->GetMutableValue(key, &actual_value)); |
| EXPECT_TRUE(orig_value->Equals(actual_value)); |
| base::DictionaryValue* dict_value; |
| ASSERT_TRUE(actual_value->GetAsDictionary(&dict_value)); |
| dict_value->SetInteger("key2", 30); |
| pref_store_->ReportValueChanged(key); |
| |
| // Ensure the new value is stored in memory. |
| const base::Value* retrieved_value; |
| EXPECT_TRUE(pref_store_->GetValue(key, &retrieved_value)); |
| scoped_ptr<base::DictionaryValue> golden_value(new base::DictionaryValue); |
| golden_value->SetInteger("key2", 30); |
| EXPECT_TRUE(base::Value::Equals(golden_value.get(), retrieved_value)); |
| |
| // Ensure the new value is persisted to disk. |
| CloseAndReopen(); |
| EXPECT_TRUE(pref_store_->GetValue(key, &retrieved_value)); |
| EXPECT_TRUE(base::Value::Equals(golden_value.get(), retrieved_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, RemoveFromMemory) { |
| Open(); |
| const std::string key = "some.key"; |
| pref_store_->SetValue(key, new base::FundamentalValue(5)); |
| |
| MockPrefStoreObserver mock_observer; |
| pref_store_->AddObserver(&mock_observer); |
| EXPECT_CALL(mock_observer, OnPrefValueChanged(key)).Times(1); |
| pref_store_->RemoveValue(key); |
| pref_store_->RemoveObserver(&mock_observer); |
| |
| const base::Value* retrieved_value; |
| EXPECT_FALSE(pref_store_->GetValue(key, &retrieved_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, RemoveFromDisk) { |
| Open(); |
| const std::string key = "some.key"; |
| pref_store_->SetValue(key, new base::FundamentalValue(5)); |
| |
| CloseAndReopen(); |
| |
| pref_store_->RemoveValue(key); |
| |
| CloseAndReopen(); |
| |
| const base::Value* retrieved_value; |
| EXPECT_FALSE(pref_store_->GetValue(key, &retrieved_value)); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, OpenAsync) { |
| // First set a key/value with a synchronous connection. |
| Open(); |
| const std::string key = "some.key"; |
| pref_store_->SetValue(key, new base::FundamentalValue(5)); |
| Close(); |
| |
| scoped_refptr<LevelDBPrefStore> pref_store(new LevelDBPrefStore( |
| temp_dir_.path(), message_loop_.message_loop_proxy().get())); |
| MockReadErrorDelegate* delegate = new MockReadErrorDelegate; |
| pref_store->ReadPrefsAsync(delegate); |
| |
| MockPrefStoreObserver mock_observer; |
| pref_store->AddObserver(&mock_observer); |
| EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| base::RunLoop().RunUntilIdle(); |
| pref_store->RemoveObserver(&mock_observer); |
| |
| const base::Value* result; |
| EXPECT_TRUE(pref_store->GetValue("some.key", &result)); |
| int int_value; |
| EXPECT_TRUE(result->GetAsInteger(&int_value)); |
| EXPECT_EQ(5, int_value); |
| |
| pref_store = NULL; |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, OpenAsyncError) { |
| // Open a connection that will lock the database. |
| Open(); |
| |
| // Try to open an async connection to the same database. |
| scoped_refptr<LevelDBPrefStore> pref_store(new LevelDBPrefStore( |
| temp_dir_.path(), message_loop_.message_loop_proxy().get())); |
| MockReadErrorDelegate* delegate = new MockReadErrorDelegate; |
| pref_store->ReadPrefsAsync(delegate); |
| |
| MockPrefStoreObserver mock_observer; |
| pref_store->AddObserver(&mock_observer); |
| EXPECT_CALL(*delegate, |
| OnError(PersistentPrefStore::PREF_READ_ERROR_LEVELDB_IO)) |
| .Times(1); |
| EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| base::RunLoop().RunUntilIdle(); |
| pref_store->RemoveObserver(&mock_observer); |
| |
| EXPECT_TRUE(pref_store->ReadOnly()); |
| EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_LEVELDB_IO, |
| pref_store->GetReadError()); |
| |
| // Sync connection to the database will be closed by the destructor. |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, RepairCorrupt) { |
| // Open a database where CURRENT has no newline. Ensure that repair is called |
| // and there is no error reading the database. |
| base::FilePath corrupted_dir = data_dir_.AppendASCII("corrupted_leveldb"); |
| base::FilePath dest = temp_dir_.path().AppendASCII("corrupted_leveldb"); |
| const bool kRecursive = true; |
| ASSERT_TRUE(CopyDirectory(corrupted_dir, dest, kRecursive)); |
| pref_store_ = |
| new LevelDBPrefStore(dest, message_loop_.message_loop_proxy().get()); |
| EXPECT_EQ(LevelDBPrefStore::PREF_READ_ERROR_LEVELDB_CORRUPTION, |
| pref_store_->ReadPrefs()); |
| } |
| |
| TEST_F(LevelDBPrefStoreTest, Values) { |
| Open(); |
| pref_store_->SetValue("boolean", new base::FundamentalValue(false)); |
| pref_store_->SetValue("integer", new base::FundamentalValue(10)); |
| pref_store_->SetValue("double", new base::FundamentalValue(10.3)); |
| pref_store_->SetValue("string", new base::StringValue("some string")); |
| |
| base::DictionaryValue* dict_value = new base::DictionaryValue; |
| dict_value->Set("boolean", new base::FundamentalValue(true)); |
| scoped_ptr<base::DictionaryValue> golden_dict_value(dict_value->DeepCopy()); |
| pref_store_->SetValue("dictionary", dict_value); |
| |
| base::ListValue* list_value = new base::ListValue; |
| list_value->Set(2, new base::StringValue("string in list")); |
| scoped_ptr<base::ListValue> golden_list_value(list_value->DeepCopy()); |
| pref_store_->SetValue("list", list_value); |
| |
| // Do something nontrivial as well. |
| base::DictionaryValue* compound_value = new base::DictionaryValue; |
| base::ListValue* outer_list = new base::ListValue; |
| base::ListValue* inner_list = new base::ListValue; |
| inner_list->Set(0, new base::FundamentalValue(5)); |
| outer_list->Set(1, inner_list); |
| compound_value->Set("compound_lists", outer_list); |
| scoped_ptr<base::DictionaryValue> golden_compound_value( |
| compound_value->DeepCopy()); |
| pref_store_->SetValue("compound_value", compound_value); |
| |
| CloseAndReopen(); |
| |
| const base::Value* value; |
| EXPECT_TRUE(pref_store_->GetValue("boolean", &value)); |
| EXPECT_TRUE(base::FundamentalValue(false).Equals(value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("integer", &value)); |
| EXPECT_TRUE(base::FundamentalValue(10).Equals(value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("double", &value)); |
| EXPECT_TRUE(base::FundamentalValue(10.3).Equals(value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("string", &value)); |
| EXPECT_TRUE(base::StringValue("some string").Equals(value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("dictionary", &value)); |
| EXPECT_TRUE(base::Value::Equals(golden_dict_value.get(), value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("list", &value)); |
| EXPECT_TRUE(base::Value::Equals(golden_list_value.get(), value)); |
| |
| EXPECT_TRUE(pref_store_->GetValue("compound_value", &value)); |
| EXPECT_TRUE(base::Value::Equals(golden_compound_value.get(), value)); |
| } |