content/browser/indexed_db/leveldb/leveldb_unittest.cc

   1 // Copyright (c) 2013 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 <algorithm>
   6 #include <cstring>
   7 #include <string>
   8
   9 #include "base/files/file.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/strings/string16.h"
  13 #include "base/strings/string_piece.h"
  14 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
  15 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
  16 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
  17 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "third_party/leveldatabase/env_chromium.h"
  20 #include "third_party/leveldatabase/env_idb.h"
  21
  22 namespace content {
  23
  24 namespace {
  25
  26 class SimpleComparator : public LevelDBComparator {
  27  public:
  28   virtual int Compare(const base::StringPiece& a,
  29                       const base::StringPiece& b) const OVERRIDE {
  30     size_t len = std::min(a.size(), b.size());
  31     return memcmp(a.begin(), b.begin(), len);
  32   }
  33   virtual const char* Name() const OVERRIDE { return "temp_comparator"; }
  34 };
  35
  36 }  // namespace
  37
  38 TEST(LevelDBDatabaseTest, CorruptionTest) {
  39   base::ScopedTempDir temp_directory;
  40   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
  41
  42   const std::string key("key");
  43   const std::string value("value");
  44   std::string put_value;
  45   std::string got_value;
  46   SimpleComparator comparator;
  47
  48   scoped_ptr<LevelDBDatabase> leveldb;
  49   LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
  50   EXPECT_TRUE(leveldb);
  51   put_value = value;
  52   leveldb::Status status = leveldb->Put(key, &put_value);
  53   EXPECT_TRUE(status.ok());
  54   leveldb.Pass();
  55   EXPECT_FALSE(leveldb);
  56
  57   LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
  58   EXPECT_TRUE(leveldb);
  59   bool found = false;
  60   status = leveldb->Get(key, &got_value, &found);
  61   EXPECT_TRUE(status.ok());
  62   EXPECT_TRUE(found);
  63   EXPECT_EQ(value, got_value);
  64   leveldb.Pass();
  65   EXPECT_FALSE(leveldb);
  66
  67   base::FilePath file_path = temp_directory.path().AppendASCII("CURRENT");
  68   base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_WRITE);
  69   file.SetLength(0);
  70   file.Close();
  71
  72   status = LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
  73   EXPECT_FALSE(leveldb);
  74   EXPECT_FALSE(status.ok());
  75
  76   status = LevelDBDatabase::Destroy(temp_directory.path());
  77   EXPECT_TRUE(status.ok());
  78
  79   status = LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
  80   EXPECT_TRUE(status.ok());
  81   EXPECT_TRUE(leveldb);
  82   status = leveldb->Get(key, &got_value, &found);
  83   EXPECT_TRUE(status.ok());
  84   EXPECT_FALSE(found);
  85 }
  86
  87 TEST(LevelDBDatabaseTest, Transaction) {
  88   base::ScopedTempDir temp_directory;
  89   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
  90
  91   const std::string key("key");
  92   std::string got_value;
  93   std::string put_value;
  94   SimpleComparator comparator;
  95
  96   scoped_ptr<LevelDBDatabase> leveldb;
  97   LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
  98   EXPECT_TRUE(leveldb);
  99
 100   const std::string old_value("value");
 101   put_value = old_value;
 102   leveldb::Status status = leveldb->Put(key, &put_value);
 103   EXPECT_TRUE(status.ok());
 104
 105   scoped_refptr<LevelDBTransaction> transaction =
 106       new LevelDBTransaction(leveldb.get());
 107
 108   const std::string new_value("new value");
 109   put_value = new_value;
 110   status = leveldb->Put(key, &put_value);
 111   EXPECT_TRUE(status.ok());
 112
 113   bool found = false;
 114   status = transaction->Get(key, &got_value, &found);
 115   EXPECT_TRUE(status.ok());
 116   EXPECT_TRUE(found);
 117   EXPECT_EQ(comparator.Compare(got_value, old_value), 0);
 118
 119   found = false;
 120   status = leveldb->Get(key, &got_value, &found);
 121   EXPECT_TRUE(status.ok());
 122   EXPECT_TRUE(found);
 123   EXPECT_EQ(comparator.Compare(got_value, new_value), 0);
 124
 125   const std::string added_key("added key");
 126   const std::string added_value("added value");
 127   put_value = added_value;
 128   status = leveldb->Put(added_key, &put_value);
 129   EXPECT_TRUE(status.ok());
 130
 131   status = leveldb->Get(added_key, &got_value, &found);
 132   EXPECT_TRUE(status.ok());
 133   EXPECT_TRUE(found);
 134   EXPECT_EQ(comparator.Compare(got_value, added_value), 0);
 135
 136   status = transaction->Get(added_key, &got_value, &found);
 137   EXPECT_TRUE(status.ok());
 138   EXPECT_FALSE(found);
 139
 140   const std::string another_key("another key");
 141   const std::string another_value("another value");
 142   put_value = another_value;
 143   transaction->Put(another_key, &put_value);
 144
 145   status = transaction->Get(another_key, &got_value, &found);
 146   EXPECT_TRUE(status.ok());
 147   EXPECT_TRUE(found);
 148   EXPECT_EQ(comparator.Compare(got_value, another_value), 0);
 149 }
 150
 151 TEST(LevelDBDatabaseTest, TransactionIterator) {
 152   base::ScopedTempDir temp_directory;
 153   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 154
 155   const std::string key1("key1");
 156   const std::string value1("value1");
 157   const std::string key2("key2");
 158   const std::string value2("value2");
 159   std::string put_value;
 160   SimpleComparator comparator;
 161
 162   scoped_ptr<LevelDBDatabase> leveldb;
 163   LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
 164   EXPECT_TRUE(leveldb);
 165
 166   put_value = value1;
 167   leveldb::Status s = leveldb->Put(key1, &put_value);
 168   EXPECT_TRUE(s.ok());
 169   put_value = value2;
 170   s = leveldb->Put(key2, &put_value);
 171   EXPECT_TRUE(s.ok());
 172
 173   scoped_refptr<LevelDBTransaction> transaction =
 174       new LevelDBTransaction(leveldb.get());
 175
 176   s = leveldb->Remove(key2);
 177   EXPECT_TRUE(s.ok());
 178
 179   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
 180
 181   it->Seek(std::string());
 182
 183   EXPECT_TRUE(it->IsValid());
 184   EXPECT_EQ(comparator.Compare(it->Key(), key1), 0);
 185   EXPECT_EQ(comparator.Compare(it->Value(), value1), 0);
 186
 187   it->Next();
 188
 189   EXPECT_TRUE(it->IsValid());
 190   EXPECT_EQ(comparator.Compare(it->Key(), key2), 0);
 191   EXPECT_EQ(comparator.Compare(it->Value(), value2), 0);
 192
 193   it->Next();
 194
 195   EXPECT_FALSE(it->IsValid());
 196 }
 197
 198 TEST(LevelDBDatabaseTest, TransactionCommitTest) {
 199   base::ScopedTempDir temp_directory;
 200   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 201
 202   const std::string key1("key1");
 203   const std::string key2("key2");
 204   const std::string value1("value1");
 205   const std::string value2("value2");
 206   const std::string value3("value3");
 207
 208   std::string put_value;
 209   std::string got_value;
 210   SimpleComparator comparator;
 211   bool found;
 212
 213   scoped_ptr<LevelDBDatabase> leveldb;
 214   LevelDBDatabase::Open(temp_directory.path(), &comparator, &leveldb);
 215   EXPECT_TRUE(leveldb);
 216
 217   scoped_refptr<LevelDBTransaction> transaction =
 218       new LevelDBTransaction(leveldb.get());
 219
 220   put_value = value1;
 221   transaction->Put(key1, &put_value);
 222
 223   put_value = value2;
 224   transaction->Put(key2, &put_value);
 225
 226   put_value = value3;
 227   transaction->Put(key2, &put_value);
 228
 229   leveldb::Status status = transaction->Commit();
 230   EXPECT_TRUE(status.ok());
 231
 232   status = leveldb->Get(key1, &got_value, &found);
 233   EXPECT_TRUE(status.ok());
 234   EXPECT_TRUE(found);
 235   EXPECT_EQ(value1, got_value);
 236
 237   status = leveldb->Get(key2, &got_value, &found);
 238   EXPECT_TRUE(status.ok());
 239   EXPECT_TRUE(found);
 240   EXPECT_EQ(value3, got_value);
 241 }
 242
 243 TEST(LevelDB, Locking) {
 244   base::ScopedTempDir temp_directory;
 245   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 246
 247   leveldb::Env* env = leveldb::IDBEnv();
 248   base::FilePath file = temp_directory.path().AppendASCII("LOCK");
 249   leveldb::FileLock* lock;
 250   leveldb::Status status = env->LockFile(file.AsUTF8Unsafe(), &lock);
 251   EXPECT_TRUE(status.ok());
 252
 253   status = env->UnlockFile(lock);
 254   EXPECT_TRUE(status.ok());
 255
 256   status = env->LockFile(file.AsUTF8Unsafe(), &lock);
 257   EXPECT_TRUE(status.ok());
 258
 259   leveldb::FileLock* lock2;
 260   status = env->LockFile(file.AsUTF8Unsafe(), &lock2);
 261   EXPECT_FALSE(status.ok());
 262
 263   status = env->UnlockFile(lock);
 264   EXPECT_TRUE(status.ok());
 265 }
 266
 267 }  // namespace content