components/leveldb_proto/proto_database_impl_unittest.cc

   1 // Copyright 2014 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 "components/leveldb_proto/proto_database_impl.h"
   6
   7 #include <map>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/run_loop.h"
  13 #include "base/threading/thread.h"
  14 #include "components/leveldb_proto/leveldb_database.h"
  15 #include "components/leveldb_proto/testing/proto/test.pb.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 using base::MessageLoop;
  20 using base::ScopedTempDir;
  21 using testing::Invoke;
  22 using testing::Return;
  23 using testing::_;
  24
  25 namespace leveldb_proto {
  26
  27 namespace {
  28
  29 typedef std::map<std::string, TestProto> EntryMap;
  30
  31 class MockDB : public LevelDB {
  32  public:
  33   MOCK_METHOD1(Init, bool(const base::FilePath&));
  34   MOCK_METHOD2(Save, bool(const KeyValueVector&, const KeyVector&));
  35   MOCK_METHOD1(Load, bool(std::vector<std::string>*));
  36
  37   MockDB() {
  38     ON_CALL(*this, Init(_)).WillByDefault(Return(true));
  39     ON_CALL(*this, Save(_, _)).WillByDefault(Return(true));
  40     ON_CALL(*this, Load(_)).WillByDefault(Return(true));
  41   }
  42 };
  43
  44 class MockDatabaseCaller {
  45  public:
  46   MOCK_METHOD1(InitCallback, void(bool));
  47   MOCK_METHOD1(SaveCallback, void(bool));
  48   void LoadCallback(bool success, scoped_ptr<std::vector<TestProto> > entries) {
  49     LoadCallback1(success, entries.get());
  50   }
  51   MOCK_METHOD2(LoadCallback1, void(bool, std::vector<TestProto>*));
  52 };
  53
  54 }  // namespace
  55
  56 EntryMap GetSmallModel() {
  57   EntryMap model;
  58
  59   model["0"].set_id("0");
  60   model["0"].set_data("http://foo.com/1");
  61
  62   model["1"].set_id("1");
  63   model["1"].set_data("http://bar.com/all");
  64
  65   model["2"].set_id("2");
  66   model["2"].set_data("http://baz.com/1");
  67
  68   return model;
  69 }
  70
  71 void ExpectEntryPointersEquals(EntryMap expected,
  72                                const std::vector<TestProto>& actual) {
  73   EXPECT_EQ(expected.size(), actual.size());
  74   for (size_t i = 0; i < actual.size(); i++) {
  75     EntryMap::iterator expected_it = expected.find(actual[i].id());
  76     EXPECT_TRUE(expected_it != expected.end());
  77     std::string serialized_expected = expected_it->second.SerializeAsString();
  78     std::string serialized_actual = actual[i].SerializeAsString();
  79     EXPECT_EQ(serialized_expected, serialized_actual);
  80     expected.erase(expected_it);
  81   }
  82 }
  83
  84 class ProtoDatabaseImplTest : public testing::Test {
  85  public:
  86   virtual void SetUp() {
  87     main_loop_.reset(new MessageLoop());
  88     db_.reset(
  89         new ProtoDatabaseImpl<TestProto>(main_loop_->message_loop_proxy()));
  90   }
  91
  92   virtual void TearDown() {
  93     db_.reset();
  94     base::RunLoop().RunUntilIdle();
  95     main_loop_.reset();
  96   }
  97
  98   scoped_ptr<ProtoDatabaseImpl<TestProto> > db_;
  99   scoped_ptr<MessageLoop> main_loop_;
 100 };
 101
 102 // Test that ProtoDatabaseImpl calls Init on the underlying database and that
 103 // the caller's InitCallback is called with the correct value.
 104 TEST_F(ProtoDatabaseImplTest, TestDBInitSuccess) {
 105   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 106
 107   MockDB* mock_db = new MockDB();
 108   EXPECT_CALL(*mock_db, Init(path)).WillOnce(Return(true));
 109
 110   MockDatabaseCaller caller;
 111   EXPECT_CALL(caller, InitCallback(true));
 112
 113   db_->InitWithDatabase(
 114       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 115       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 116
 117   base::RunLoop().RunUntilIdle();
 118 }
 119
 120 TEST_F(ProtoDatabaseImplTest, TestDBInitFailure) {
 121   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 122
 123   MockDB* mock_db = new MockDB();
 124   EXPECT_CALL(*mock_db, Init(path)).WillOnce(Return(false));
 125
 126   MockDatabaseCaller caller;
 127   EXPECT_CALL(caller, InitCallback(false));
 128
 129   db_->InitWithDatabase(
 130       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 131       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 132
 133   base::RunLoop().RunUntilIdle();
 134 }
 135
 136 ACTION_P(AppendLoadEntries, model) {
 137   std::vector<std::string>* output = arg0;
 138   for (EntryMap::const_iterator it = model.begin(); it != model.end(); ++it) {
 139     output->push_back(it->second.SerializeAsString());
 140   }
 141   return true;
 142 }
 143
 144 ACTION_P(VerifyLoadEntries, expected) {
 145   std::vector<TestProto>* actual = arg1;
 146   ExpectEntryPointersEquals(expected, *actual);
 147 }
 148
 149 // Test that ProtoDatabaseImpl calls Load on the underlying database and that
 150 // the caller's LoadCallback is called with the correct success value. Also
 151 // confirms that on success, the expected entries are passed to the caller's
 152 // LoadCallback.
 153 TEST_F(ProtoDatabaseImplTest, TestDBLoadSuccess) {
 154   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 155
 156   MockDB* mock_db = new MockDB();
 157   MockDatabaseCaller caller;
 158   EntryMap model = GetSmallModel();
 159
 160   EXPECT_CALL(*mock_db, Init(_));
 161   EXPECT_CALL(caller, InitCallback(_));
 162   db_->InitWithDatabase(
 163       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 164       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 165
 166   EXPECT_CALL(*mock_db, Load(_)).WillOnce(AppendLoadEntries(model));
 167   EXPECT_CALL(caller, LoadCallback1(true, _))
 168       .WillOnce(VerifyLoadEntries(testing::ByRef(model)));
 169   db_->LoadEntries(
 170       base::Bind(&MockDatabaseCaller::LoadCallback, base::Unretained(&caller)));
 171
 172   base::RunLoop().RunUntilIdle();
 173 }
 174
 175 TEST_F(ProtoDatabaseImplTest, TestDBLoadFailure) {
 176   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 177
 178   MockDB* mock_db = new MockDB();
 179   MockDatabaseCaller caller;
 180
 181   EXPECT_CALL(*mock_db, Init(_));
 182   EXPECT_CALL(caller, InitCallback(_));
 183   db_->InitWithDatabase(
 184       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 185       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 186
 187   EXPECT_CALL(*mock_db, Load(_)).WillOnce(Return(false));
 188   EXPECT_CALL(caller, LoadCallback1(false, _));
 189   db_->LoadEntries(
 190       base::Bind(&MockDatabaseCaller::LoadCallback, base::Unretained(&caller)));
 191
 192   base::RunLoop().RunUntilIdle();
 193 }
 194
 195 ACTION_P(VerifyUpdateEntries, expected) {
 196   const KeyValueVector actual = arg0;
 197   // Create a vector of TestProto from |actual| to reuse the comparison
 198   // function.
 199   std::vector<TestProto> extracted_entries;
 200   for (KeyValueVector::const_iterator it = actual.begin(); it != actual.end();
 201        ++it) {
 202     TestProto entry;
 203     entry.ParseFromString(it->second);
 204     extracted_entries.push_back(entry);
 205   }
 206   ExpectEntryPointersEquals(expected, extracted_entries);
 207   return true;
 208 }
 209
 210 // Test that ProtoDatabaseImpl calls Save on the underlying database with the
 211 // correct entries to save and that the caller's SaveCallback is called with the
 212 // correct success value.
 213 TEST_F(ProtoDatabaseImplTest, TestDBSaveSuccess) {
 214   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 215
 216   MockDB* mock_db = new MockDB();
 217   MockDatabaseCaller caller;
 218   EntryMap model = GetSmallModel();
 219
 220   EXPECT_CALL(*mock_db, Init(_));
 221   EXPECT_CALL(caller, InitCallback(_));
 222   db_->InitWithDatabase(
 223       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 224       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 225
 226   scoped_ptr<ProtoDatabase<TestProto>::KeyEntryVector> entries(
 227       new ProtoDatabase<TestProto>::KeyEntryVector());
 228   for (EntryMap::iterator it = model.begin(); it != model.end(); ++it) {
 229     entries->push_back(std::make_pair(it->second.id(), it->second));
 230   }
 231   scoped_ptr<KeyVector> keys_to_remove(new KeyVector());
 232
 233   EXPECT_CALL(*mock_db, Save(_, _)).WillOnce(VerifyUpdateEntries(model));
 234   EXPECT_CALL(caller, SaveCallback(true));
 235   db_->UpdateEntries(
 236       entries.Pass(), keys_to_remove.Pass(),
 237       base::Bind(&MockDatabaseCaller::SaveCallback, base::Unretained(&caller)));
 238
 239   base::RunLoop().RunUntilIdle();
 240 }
 241
 242 TEST_F(ProtoDatabaseImplTest, TestDBSaveFailure) {
 243   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 244
 245   MockDB* mock_db = new MockDB();
 246   MockDatabaseCaller caller;
 247   scoped_ptr<ProtoDatabase<TestProto>::KeyEntryVector> entries(
 248       new ProtoDatabase<TestProto>::KeyEntryVector());
 249   scoped_ptr<KeyVector> keys_to_remove(new KeyVector());
 250
 251   EXPECT_CALL(*mock_db, Init(_));
 252   EXPECT_CALL(caller, InitCallback(_));
 253   db_->InitWithDatabase(
 254       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 255       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 256
 257   EXPECT_CALL(*mock_db, Save(_, _)).WillOnce(Return(false));
 258   EXPECT_CALL(caller, SaveCallback(false));
 259   db_->UpdateEntries(
 260       entries.Pass(), keys_to_remove.Pass(),
 261       base::Bind(&MockDatabaseCaller::SaveCallback, base::Unretained(&caller)));
 262
 263   base::RunLoop().RunUntilIdle();
 264 }
 265
 266 // Test that ProtoDatabaseImpl calls Save on the underlying database with the
 267 // correct entries to delete and that the caller's SaveCallback is called with
 268 // the correct success value.
 269 TEST_F(ProtoDatabaseImplTest, TestDBRemoveSuccess) {
 270   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 271
 272   MockDB* mock_db = new MockDB();
 273   MockDatabaseCaller caller;
 274   EntryMap model = GetSmallModel();
 275
 276   EXPECT_CALL(*mock_db, Init(_));
 277   EXPECT_CALL(caller, InitCallback(_));
 278   db_->InitWithDatabase(
 279       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 280       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 281
 282   scoped_ptr<ProtoDatabase<TestProto>::KeyEntryVector> entries(
 283       new ProtoDatabase<TestProto>::KeyEntryVector());
 284   scoped_ptr<KeyVector> keys_to_remove(new KeyVector());
 285   for (EntryMap::iterator it = model.begin(); it != model.end(); ++it) {
 286     keys_to_remove->push_back(it->second.id());
 287   }
 288
 289   KeyVector keys_copy(*keys_to_remove.get());
 290   EXPECT_CALL(*mock_db, Save(_, keys_copy)).WillOnce(Return(true));
 291   EXPECT_CALL(caller, SaveCallback(true));
 292   db_->UpdateEntries(
 293       entries.Pass(), keys_to_remove.Pass(),
 294       base::Bind(&MockDatabaseCaller::SaveCallback, base::Unretained(&caller)));
 295
 296   base::RunLoop().RunUntilIdle();
 297 }
 298
 299 TEST_F(ProtoDatabaseImplTest, TestDBRemoveFailure) {
 300   base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
 301
 302   MockDB* mock_db = new MockDB();
 303   MockDatabaseCaller caller;
 304   scoped_ptr<ProtoDatabase<TestProto>::KeyEntryVector> entries(
 305       new ProtoDatabase<TestProto>::KeyEntryVector());
 306   scoped_ptr<KeyVector> keys_to_remove(new KeyVector());
 307
 308   EXPECT_CALL(*mock_db, Init(_));
 309   EXPECT_CALL(caller, InitCallback(_));
 310   db_->InitWithDatabase(
 311       scoped_ptr<LevelDB>(mock_db), base::FilePath(path),
 312       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 313
 314   EXPECT_CALL(*mock_db, Save(_, _)).WillOnce(Return(false));
 315   EXPECT_CALL(caller, SaveCallback(false));
 316   db_->UpdateEntries(
 317       entries.Pass(), keys_to_remove.Pass(),
 318       base::Bind(&MockDatabaseCaller::SaveCallback, base::Unretained(&caller)));
 319
 320   base::RunLoop().RunUntilIdle();
 321 }
 322
 323 // This tests that normal usage of the real database does not cause any
 324 // threading violations.
 325 TEST(ProtoDatabaseImplThreadingTest, TestDBDestruction) {
 326   base::MessageLoop main_loop;
 327
 328   ScopedTempDir temp_dir;
 329   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 330
 331   base::Thread db_thread("dbthread");
 332   ASSERT_TRUE(db_thread.Start());
 333
 334   scoped_ptr<ProtoDatabaseImpl<TestProto> > db(
 335       new ProtoDatabaseImpl<TestProto>(db_thread.message_loop_proxy()));
 336
 337   MockDatabaseCaller caller;
 338   EXPECT_CALL(caller, InitCallback(_));
 339   db->Init(temp_dir.path(), base::Bind(&MockDatabaseCaller::InitCallback,
 340                                        base::Unretained(&caller)));
 341
 342   db.reset();
 343
 344   base::RunLoop run_loop;
 345   db_thread.message_loop_proxy()->PostTaskAndReply(
 346       FROM_HERE, base::Bind(base::DoNothing), run_loop.QuitClosure());
 347   run_loop.Run();
 348 }
 349
 350 // Test that the LevelDB properly saves entries and that load returns the saved
 351 // entries. If |close_after_save| is true, the database will be closed after
 352 // saving and then re-opened to ensure that the data is properly persisted.
 353 void TestLevelDBSaveAndLoad(bool close_after_save) {
 354   ScopedTempDir temp_dir;
 355   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 356
 357   EntryMap model = GetSmallModel();
 358
 359   KeyValueVector save_entries;
 360   std::vector<std::string> load_entries;
 361   KeyVector remove_keys;
 362
 363   for (EntryMap::iterator it = model.begin(); it != model.end(); ++it) {
 364     save_entries.push_back(
 365         std::make_pair(it->second.id(), it->second.SerializeAsString()));
 366   }
 367
 368   scoped_ptr<LevelDB> db(new LevelDB());
 369   EXPECT_TRUE(db->Init(temp_dir.path()));
 370   EXPECT_TRUE(db->Save(save_entries, remove_keys));
 371
 372   if (close_after_save) {
 373     db.reset(new LevelDB());
 374     EXPECT_TRUE(db->Init(temp_dir.path()));
 375   }
 376
 377   EXPECT_TRUE(db->Load(&load_entries));
 378   // Convert the strings back to TestProto.
 379   std::vector<TestProto> loaded_protos;
 380   for (std::vector<std::string>::iterator it = load_entries.begin();
 381        it != load_entries.end(); ++it) {
 382     TestProto entry;
 383     entry.ParseFromString(*it);
 384     loaded_protos.push_back(entry);
 385   }
 386   ExpectEntryPointersEquals(model, loaded_protos);
 387 }
 388
 389 TEST(ProtoDatabaseImplLevelDBTest, TestDBSaveAndLoad) {
 390   TestLevelDBSaveAndLoad(false);
 391 }
 392
 393 TEST(ProtoDatabaseImplLevelDBTest, TestDBCloseAndReopen) {
 394   TestLevelDBSaveAndLoad(true);
 395 }
 396
 397 }  // namespace leveldb_proto