third_party/leveldatabase/env_chromium_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 "base/file_util.h"
   6 #include "base/files/file_enumerator.h"
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/test/test_suite.h"
  10 #include "env_chromium.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "third_party/leveldatabase/env_idb.h"
  13 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  14
  15 using namespace leveldb_env;
  16 using namespace leveldb;
  17
  18 #define FPL FILE_PATH_LITERAL
  19
  20 TEST(ErrorEncoding, OnlyAMethod) {
  21   const MethodID in_method = kSequentialFileRead;
  22   const Status s = MakeIOError("Somefile.txt", "message", in_method);
  23   MethodID method;
  24   int error = -75;
  25   EXPECT_EQ(METHOD_ONLY,
  26             ParseMethodAndError(s.ToString().c_str(), &method, &error));
  27   EXPECT_EQ(in_method, method);
  28   EXPECT_EQ(-75, error);
  29 }
  30
  31 TEST(ErrorEncoding, PlatformFileError) {
  32   const MethodID in_method = kWritableFileClose;
  33   const base::PlatformFileError pfe =
  34       base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
  35   const Status s = MakeIOError("Somefile.txt", "message", in_method, pfe);
  36   MethodID method;
  37   int error;
  38   EXPECT_EQ(METHOD_AND_PFE,
  39             ParseMethodAndError(s.ToString().c_str(), &method, &error));
  40   EXPECT_EQ(in_method, method);
  41   EXPECT_EQ(pfe, error);
  42 }
  43
  44 TEST(ErrorEncoding, Errno) {
  45   const MethodID in_method = kWritableFileFlush;
  46   const int some_errno = ENOENT;
  47   const Status s =
  48       MakeIOError("Somefile.txt", "message", in_method, some_errno);
  49   MethodID method;
  50   int error;
  51   EXPECT_EQ(METHOD_AND_ERRNO,
  52             ParseMethodAndError(s.ToString().c_str(), &method, &error));
  53   EXPECT_EQ(in_method, method);
  54   EXPECT_EQ(some_errno, error);
  55 }
  56
  57 TEST(ErrorEncoding, NoEncodedMessage) {
  58   Status s = Status::IOError("Some message", "from leveldb itself");
  59   MethodID method = kRandomAccessFileRead;
  60   int error = 4;
  61   EXPECT_EQ(NONE, ParseMethodAndError(s.ToString().c_str(), &method, &error));
  62   EXPECT_EQ(kRandomAccessFileRead, method);
  63   EXPECT_EQ(4, error);
  64 }
  65
  66 class MyEnv : public ChromiumEnv {
  67  public:
  68   MyEnv() : directory_syncs_(0) {}
  69   int directory_syncs() { return directory_syncs_; }
  70
  71  protected:
  72   virtual void DidSyncDir(const std::string& fname) {
  73     ++directory_syncs_;
  74     ChromiumEnv::DidSyncDir(fname);
  75   }
  76
  77  private:
  78   int directory_syncs_;
  79 };
  80
  81 TEST(ChromiumEnv, DirectorySyncing) {
  82   MyEnv env;
  83   base::ScopedTempDir dir;
  84   dir.CreateUniqueTempDir();
  85   base::FilePath dir_path = dir.path();
  86   std::string some_data = "some data";
  87   Slice data = some_data;
  88
  89   std::string manifest_file_name =
  90       FilePathToString(dir_path.Append(FILE_PATH_LITERAL("MANIFEST-001")));
  91   WritableFile* manifest_file_ptr;
  92   Status s = env.NewWritableFile(manifest_file_name, &manifest_file_ptr);
  93   EXPECT_TRUE(s.ok());
  94   scoped_ptr<WritableFile> manifest_file(manifest_file_ptr);
  95   manifest_file->Append(data);
  96   EXPECT_EQ(0, env.directory_syncs());
  97   manifest_file->Append(data);
  98   EXPECT_EQ(0, env.directory_syncs());
  99
 100   std::string sst_file_name =
 101       FilePathToString(dir_path.Append(FILE_PATH_LITERAL("000003.sst")));
 102   WritableFile* sst_file_ptr;
 103   s = env.NewWritableFile(sst_file_name, &sst_file_ptr);
 104   EXPECT_TRUE(s.ok());
 105   scoped_ptr<WritableFile> sst_file(sst_file_ptr);
 106   sst_file->Append(data);
 107   EXPECT_EQ(0, env.directory_syncs());
 108
 109   manifest_file->Append(data);
 110   EXPECT_EQ(1, env.directory_syncs());
 111   manifest_file->Append(data);
 112   EXPECT_EQ(1, env.directory_syncs());
 113 }
 114
 115 int CountFilesWithExtension(const base::FilePath& dir,
 116                             const base::FilePath::StringType& extension) {
 117   int matching_files = 0;
 118   base::FileEnumerator dir_reader(
 119       dir, false, base::FileEnumerator::FILES);
 120   for (base::FilePath fname = dir_reader.Next(); !fname.empty();
 121        fname = dir_reader.Next()) {
 122     if (fname.MatchesExtension(extension))
 123       matching_files++;
 124   }
 125   return matching_files;
 126 }
 127
 128 bool GetFirstLDBFile(const base::FilePath& dir, base::FilePath* ldb_file) {
 129   base::FileEnumerator dir_reader(
 130       dir, false, base::FileEnumerator::FILES);
 131   for (base::FilePath fname = dir_reader.Next(); !fname.empty();
 132        fname = dir_reader.Next()) {
 133     if (fname.MatchesExtension(FPL(".ldb"))) {
 134       *ldb_file = fname;
 135       return true;
 136     }
 137   }
 138   return false;
 139 }
 140
 141 TEST(ChromiumEnv, BackupTables) {
 142   Options options;
 143   options.create_if_missing = true;
 144   options.env = IDBEnv();
 145
 146   base::ScopedTempDir scoped_temp_dir;
 147   scoped_temp_dir.CreateUniqueTempDir();
 148   base::FilePath dir = scoped_temp_dir.path();
 149
 150   DB* db;
 151   Status status = DB::Open(options, dir.AsUTF8Unsafe(), &db);
 152   EXPECT_TRUE(status.ok()) << status.ToString();
 153   status = db->Put(WriteOptions(), "key", "value");
 154   EXPECT_TRUE(status.ok()) << status.ToString();
 155   Slice a = "a";
 156   Slice z = "z";
 157   db->CompactRange(&a, &z);
 158   int ldb_files = CountFilesWithExtension(dir, FPL(".ldb"));
 159   int bak_files = CountFilesWithExtension(dir, FPL(".bak"));
 160   EXPECT_GT(ldb_files, 0);
 161   EXPECT_EQ(ldb_files, bak_files);
 162   base::FilePath ldb_file;
 163   EXPECT_TRUE(GetFirstLDBFile(dir, &ldb_file));
 164   delete db;
 165   EXPECT_TRUE(base::DeleteFile(ldb_file, false));
 166   EXPECT_EQ(ldb_files - 1, CountFilesWithExtension(dir, FPL(".ldb")));
 167
 168   // The ldb file deleted above should be restored in Open.
 169   status = leveldb::DB::Open(options, dir.AsUTF8Unsafe(), &db);
 170   EXPECT_TRUE(status.ok()) << status.ToString();
 171   std::string value;
 172   status = db->Get(ReadOptions(), "key", &value);
 173   EXPECT_TRUE(status.ok()) << status.ToString();
 174   EXPECT_EQ("value", value);
 175   delete db;
 176
 177   // Ensure that deleting an ldb file also deletes its backup.
 178   int orig_ldb_files = CountFilesWithExtension(dir, FPL(".ldb"));
 179   int orig_bak_files = CountFilesWithExtension(dir, FPL(".bak"));
 180   EXPECT_GT(ldb_files, 0);
 181   EXPECT_EQ(ldb_files, bak_files);
 182   EXPECT_TRUE(GetFirstLDBFile(dir, &ldb_file));
 183   options.env->DeleteFile(ldb_file.AsUTF8Unsafe());
 184   ldb_files = CountFilesWithExtension(dir, FPL(".ldb"));
 185   bak_files = CountFilesWithExtension(dir, FPL(".bak"));
 186   EXPECT_EQ(orig_ldb_files - 1, ldb_files);
 187   EXPECT_EQ(bak_files, ldb_files);
 188 }
 189
 190 TEST(ChromiumEnv, GetChildrenEmptyDir) {
 191   base::ScopedTempDir scoped_temp_dir;
 192   scoped_temp_dir.CreateUniqueTempDir();
 193   base::FilePath dir = scoped_temp_dir.path();
 194
 195   Env* env = IDBEnv();
 196   std::vector<std::string> result;
 197   leveldb::Status status = env->GetChildren(dir.AsUTF8Unsafe(), &result);
 198   EXPECT_TRUE(status.ok());
 199   EXPECT_EQ(0, result.size());
 200 }
 201
 202 TEST(ChromiumEnv, GetChildrenPriorResults) {
 203   base::ScopedTempDir scoped_temp_dir;
 204   scoped_temp_dir.CreateUniqueTempDir();
 205   base::FilePath dir = scoped_temp_dir.path();
 206
 207   base::FilePath new_file_dir = dir.Append(FPL("tmp_file"));
 208   FILE* f = fopen(new_file_dir.AsUTF8Unsafe().c_str(), "w");
 209   if (f) {
 210     fputs("Temp file contents", f);
 211     fclose(f);
 212   }
 213
 214   Env* env = IDBEnv();
 215   std::vector<std::string> result;
 216   leveldb::Status status = env->GetChildren(dir.AsUTF8Unsafe(), &result);
 217   EXPECT_TRUE(status.ok());
 218   EXPECT_EQ(1, result.size());
 219
 220   // And a second time should also return one result
 221   status = env->GetChildren(dir.AsUTF8Unsafe(), &result);
 222   EXPECT_TRUE(status.ok());
 223   EXPECT_EQ(1, result.size());
 224 }
 225
 226 int main(int argc, char** argv) { return base::TestSuite(argc, argv).Run(); }