Implement ProtoDatabase::GetEntry

components/leveldb_proto/proto_database_impl_unittest.cc

 // 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 "components/leveldb_proto/proto_database_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 24 matching lines @@
 
 typedef std::map<std::string, TestProto> EntryMap;
 
 const char kTestLevelDBClientName[] = "Test";
 
 class MockDB : public LevelDB {
  public:
   MOCK_METHOD1(Init, bool(const base::FilePath&));
   MOCK_METHOD2(Save, bool(const KeyValueVector&, const KeyVector&));
   MOCK_METHOD1(Load, bool(std::vector<std::string>*));
+  MOCK_METHOD3(Get, bool(const std::string&, bool*, std::string*));
 
-  MockDB() : LevelDB(kTestLevelDBClientName) {
-    ON_CALL(*this, Init(_)).WillByDefault(Return(true));
-    ON_CALL(*this, Save(_, _)).WillByDefault(Return(true));
-    ON_CALL(*this, Load(_)).WillByDefault(Return(true));
-  }
+  MockDB() : LevelDB(kTestLevelDBClientName) {}
 };
 
 class MockDatabaseCaller {
  public:
   MOCK_METHOD1(InitCallback, void(bool));
   MOCK_METHOD1(DestroyCallback, void(bool));
   MOCK_METHOD1(SaveCallback, void(bool));
   void LoadCallback(bool success,
                     std::unique_ptr<std::vector<TestProto>> entries) {
     LoadCallback1(success, entries.get());
   }
   MOCK_METHOD2(LoadCallback1, void(bool, std::vector<TestProto>*));
+  void GetCallback(bool success, std::unique_ptr<TestProto> entry) {
+    GetCallback1(success, entry.get());
+  }
+  MOCK_METHOD2(GetCallback1, void(bool, TestProto*));
 };
 
 }  // namespace
 
 EntryMap GetSmallModel() {
   EntryMap model;
 
   model["0"].set_id("0");
   model["0"].set_data("http://foo.com/1");
 
@@ skipping 122 matching lines @@
       base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
 
   EXPECT_CALL(*mock_db, Load(_)).WillOnce(Return(false));
   EXPECT_CALL(caller, LoadCallback1(false, _));
   db_->LoadEntries(
       base::Bind(&MockDatabaseCaller::LoadCallback, base::Unretained(&caller)));
 
   base::RunLoop().RunUntilIdle();
 }
 
+ACTION_P(SetGetEntry, model) {
+  const std::string& key = arg0;
+  bool* found = arg1;
+  std::string* output = arg2;
+  auto it = model.find(key);
+  if (it == model.end()) {
+    *found = false;
+  } else {
+    *found = true;
+    *output = it->second.SerializeAsString();
+  }
+  return true;
+}
+
+ACTION_P(VerifyGetEntry, expected) {
+  TestProto* actual = arg1;
+  EXPECT_EQ(expected.SerializeAsString(), actual->SerializeAsString());
+}
+
+TEST_F(ProtoDatabaseImplTest, TestDBGetSuccess) {
+  base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
+
+  MockDB* mock_db = new MockDB();
+  MockDatabaseCaller caller;
+  EntryMap model = GetSmallModel();
+
+  EXPECT_CALL(*mock_db, Init(_));
+  EXPECT_CALL(caller, InitCallback(_));
+  db_->InitWithDatabase(
+      base::WrapUnique(mock_db), path,
+      base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
+
+  std::string key("1");
+  ASSERT_TRUE(model.count(key));
+  EXPECT_CALL(*mock_db, Get(key, _, _)).WillOnce(SetGetEntry(model));
+  EXPECT_CALL(caller, GetCallback1(true, _))
+      .WillOnce(VerifyGetEntry(model[key]));
+  db_->GetEntry(key, base::Bind(&MockDatabaseCaller::GetCallback,
+                                base::Unretained(&caller)));
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ProtoDatabaseImplTest, TestDBGetNotFound) {
+  base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
+
+  MockDB* mock_db = new MockDB();
+  MockDatabaseCaller caller;
+  EntryMap model = GetSmallModel();
+
+  EXPECT_CALL(*mock_db, Init(_));
+  EXPECT_CALL(caller, InitCallback(_));
+  db_->InitWithDatabase(
+      base::WrapUnique(mock_db), path,
+      base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
+
+  std::string key("does_not_exist");
+  ASSERT_FALSE(model.count(key));
+  EXPECT_CALL(*mock_db, Get(key, _, _)).WillOnce(SetGetEntry(model));
+  EXPECT_CALL(caller, GetCallback1(true, nullptr));
+  db_->GetEntry(key, base::Bind(&MockDatabaseCaller::GetCallback,
+                                base::Unretained(&caller)));
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ProtoDatabaseImplTest, TestDBGetFailure) {
+  base::FilePath path(FILE_PATH_LITERAL("/fake/path"));
+
+  MockDB* mock_db = new MockDB();
+  MockDatabaseCaller caller;
+  EntryMap model = GetSmallModel();
+
+  EXPECT_CALL(*mock_db, Init(_));
+  EXPECT_CALL(caller, InitCallback(_));
+  db_->InitWithDatabase(
+      base::WrapUnique(mock_db), path,
+      base::Bind(&MockDatabaseCaller::InitCallback, base::Unretained(&caller)));
+
+  std::string key("does_not_exist");
+  ASSERT_FALSE(model.count(key));
+  EXPECT_CALL(*mock_db, Get(key, _, _)).WillOnce(Return(false));
+  EXPECT_CALL(caller, GetCallback1(false, nullptr));
+  db_->GetEntry(key, base::Bind(&MockDatabaseCaller::GetCallback,
+                                base::Unretained(&caller)));
+
+  base::RunLoop().RunUntilIdle();
+}
+
 ACTION_P(VerifyUpdateEntries, expected) {
   const KeyValueVector actual = arg0;
   // Create a vector of TestProto from |actual| to reuse the comparison
   // function.
   std::vector<TestProto> extracted_entries;
   for (const auto& pair : actual) {
     TestProto entry;
     if (!entry.ParseFromString(pair.second)) {
       ADD_FAILURE() << "Unable to deserialize the protobuf";
       return false;
@@ skipping 258 matching lines @@
 
   ASSERT_TRUE(db->Save(save_entries, remove_keys));
 
   std::vector<std::string> second_load_entries;
 
   ASSERT_TRUE(db->Load(&second_load_entries));
   EXPECT_EQ(1u, second_load_entries.size());
 }
 
 }  // namespace leveldb_proto