components/leveldb_proto/testing/fake_db.h

   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 #ifndef COMPONENTS_LEVELDB_PROTO_TESTING_FAKE_DB_H_
   6 #define COMPONENTS_LEVELDB_PROTO_TESTING_FAKE_DB_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/callback.h"
  13 #include "base/files/file_path.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "components/leveldb_proto/proto_database.h"
  16
  17 namespace leveldb_proto {
  18 namespace test {
  19
  20 template <typename T>
  21 class FakeDB : public ProtoDatabase<T> {
  22   using Callback = base::Callback<void(bool)>;
  23
  24  public:
  25   using EntryMap = typename base::hash_map<std::string, T>;
  26
  27   explicit FakeDB(EntryMap* db);
  28   ~FakeDB() override;
  29
  30   // ProtoDatabase implementation.
  31   void Init(const base::FilePath& database_dir,
  32             const typename ProtoDatabase<T>::InitCallback& callback) override;
  33   void UpdateEntries(
  34       scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
  35       scoped_ptr<std::vector<std::string>> keys_to_remove,
  36       const typename ProtoDatabase<T>::UpdateCallback& callback) override;
  37   void LoadEntries(
  38       const typename ProtoDatabase<T>::LoadCallback& callback) override;
  39
  40   base::FilePath& GetDirectory();
  41
  42   void InitCallback(bool success);
  43
  44   void LoadCallback(bool success);
  45
  46   void UpdateCallback(bool success);
  47
  48   static base::FilePath DirectoryForTestDB();
  49
  50  private:
  51   static void RunLoadCallback(
  52       const typename ProtoDatabase<T>::LoadCallback& callback,
  53       scoped_ptr<typename std::vector<T>> entries,
  54       bool success);
  55
  56   base::FilePath dir_;
  57   EntryMap* db_;
  58
  59   Callback init_callback_;
  60   Callback load_callback_;
  61   Callback update_callback_;
  62 };
  63
  64 template <typename T>
  65 FakeDB<T>::FakeDB(EntryMap* db)
  66     : db_(db) {}
  67
  68 template <typename T>
  69 FakeDB<T>::~FakeDB() {}
  70
  71 template <typename T>
  72 void FakeDB<T>::Init(const base::FilePath& database_dir,
  73                      const typename ProtoDatabase<T>::InitCallback& callback) {
  74   dir_ = database_dir;
  75   init_callback_ = callback;
  76 }
  77
  78 template <typename T>
  79 void FakeDB<T>::UpdateEntries(
  80     scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
  81     scoped_ptr<std::vector<std::string>> keys_to_remove,
  82     const typename ProtoDatabase<T>::UpdateCallback& callback) {
  83   for (const auto& pair : *entries_to_save)
  84     (*db_)[pair.first] = pair.second;
  85
  86   for (const auto& key : *keys_to_remove)
  87     db_->erase(key);
  88
  89   update_callback_ = callback;
  90 }
  91
  92 template <typename T>
  93 void FakeDB<T>::LoadEntries(
  94     const typename ProtoDatabase<T>::LoadCallback& callback) {
  95   scoped_ptr<std::vector<T>> entries(new std::vector<T>());
  96   for (const auto& pair : *db_)
  97     entries->push_back(pair.second);
  98
  99   load_callback_ =
 100       base::Bind(RunLoadCallback, callback, base::Passed(&entries));
 101 }
 102
 103 template <typename T>
 104 base::FilePath& FakeDB<T>::GetDirectory() {
 105   return dir_;
 106 }
 107
 108 template <typename T>
 109 void FakeDB<T>::InitCallback(bool success) {
 110   init_callback_.Run(success);
 111   init_callback_.Reset();
 112 }
 113
 114 template <typename T>
 115 void FakeDB<T>::LoadCallback(bool success) {
 116   load_callback_.Run(success);
 117   load_callback_.Reset();
 118 }
 119
 120 template <typename T>
 121 void FakeDB<T>::UpdateCallback(bool success) {
 122   update_callback_.Run(success);
 123   update_callback_.Reset();
 124 }
 125
 126 // static
 127 template <typename T>
 128 void FakeDB<T>::RunLoadCallback(
 129     const typename ProtoDatabase<T>::LoadCallback& callback,
 130     scoped_ptr<typename std::vector<T>> entries,
 131     bool success) {
 132   callback.Run(success, entries.Pass());
 133 }
 134
 135 // static
 136 template <typename T>
 137 base::FilePath FakeDB<T>::DirectoryForTestDB() {
 138   return base::FilePath(FILE_PATH_LITERAL("/fake/path"));
 139 }
 140
 141 }  // namespace test
 142 }  // namespace leveldb_proto
 143
 144 #endif  // COMPONENTS_LEVELDB_PROTO_TESTING_FAKE_DB_H_