src/webkit/browser/fileapi/sandbox_origin_database_unittest.cc

   1 // Copyright (c) 2012 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 <functional>
   7 #include <limits>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/file_util.h"
  12 #include "base/files/file.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/scoped_temp_dir.h"
  15 #include "base/stl_util.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "third_party/leveldatabase/src/db/filename.h"
  18 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  19 #include "webkit/browser/fileapi/sandbox_database_test_helper.h"
  20 #include "webkit/browser/fileapi/sandbox_origin_database.h"
  21 #include "webkit/common/fileapi/file_system_util.h"
  22
  23 namespace fileapi {
  24
  25 namespace {
  26 const base::FilePath::CharType kFileSystemDirName[] =
  27     FILE_PATH_LITERAL("File System");
  28 const base::FilePath::CharType kOriginDatabaseName[] =
  29     FILE_PATH_LITERAL("Origins");
  30 }  // namespace
  31
  32 TEST(SandboxOriginDatabaseTest, BasicTest) {
  33   base::ScopedTempDir dir;
  34   ASSERT_TRUE(dir.CreateUniqueTempDir());
  35   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
  36   EXPECT_FALSE(base::PathExists(kFSDir));
  37   EXPECT_TRUE(base::CreateDirectory(kFSDir));
  38
  39   SandboxOriginDatabase database(kFSDir, NULL);
  40   std::string origin("origin");
  41
  42   EXPECT_FALSE(database.HasOriginPath(origin));
  43   // Double-check to make sure that had no side effects.
  44   EXPECT_FALSE(database.HasOriginPath(origin));
  45
  46   base::FilePath path0;
  47   base::FilePath path1;
  48
  49   // Empty strings aren't valid origins.
  50   EXPECT_FALSE(database.GetPathForOrigin(std::string(), &path0));
  51
  52   EXPECT_TRUE(database.GetPathForOrigin(origin, &path0));
  53   EXPECT_TRUE(database.HasOriginPath(origin));
  54   EXPECT_TRUE(database.GetPathForOrigin(origin, &path1));
  55   EXPECT_FALSE(path0.empty());
  56   EXPECT_FALSE(path1.empty());
  57   EXPECT_EQ(path0, path1);
  58
  59   EXPECT_TRUE(base::PathExists(kFSDir.Append(kOriginDatabaseName)));
  60 }
  61
  62 TEST(SandboxOriginDatabaseTest, TwoPathTest) {
  63   base::ScopedTempDir dir;
  64   ASSERT_TRUE(dir.CreateUniqueTempDir());
  65   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
  66   EXPECT_FALSE(base::PathExists(kFSDir));
  67   EXPECT_TRUE(base::CreateDirectory(kFSDir));
  68
  69   SandboxOriginDatabase database(kFSDir, NULL);
  70   std::string origin0("origin0");
  71   std::string origin1("origin1");
  72
  73   EXPECT_FALSE(database.HasOriginPath(origin0));
  74   EXPECT_FALSE(database.HasOriginPath(origin1));
  75
  76   base::FilePath path0;
  77   base::FilePath path1;
  78   EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0));
  79   EXPECT_TRUE(database.HasOriginPath(origin0));
  80   EXPECT_FALSE(database.HasOriginPath(origin1));
  81   EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1));
  82   EXPECT_TRUE(database.HasOriginPath(origin1));
  83   EXPECT_FALSE(path0.empty());
  84   EXPECT_FALSE(path1.empty());
  85   EXPECT_NE(path0, path1);
  86
  87   EXPECT_TRUE(base::PathExists(kFSDir.Append(kOriginDatabaseName)));
  88 }
  89
  90 TEST(SandboxOriginDatabaseTest, DropDatabaseTest) {
  91   base::ScopedTempDir dir;
  92   ASSERT_TRUE(dir.CreateUniqueTempDir());
  93   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
  94   EXPECT_FALSE(base::PathExists(kFSDir));
  95   EXPECT_TRUE(base::CreateDirectory(kFSDir));
  96
  97   SandboxOriginDatabase database(kFSDir, NULL);
  98   std::string origin("origin");
  99
 100   EXPECT_FALSE(database.HasOriginPath(origin));
 101
 102   base::FilePath path0;
 103   EXPECT_TRUE(database.GetPathForOrigin(origin, &path0));
 104   EXPECT_TRUE(database.HasOriginPath(origin));
 105   EXPECT_FALSE(path0.empty());
 106
 107   EXPECT_TRUE(base::PathExists(kFSDir.Append(kOriginDatabaseName)));
 108
 109   database.DropDatabase();
 110
 111   base::FilePath path1;
 112   EXPECT_TRUE(database.HasOriginPath(origin));
 113   EXPECT_TRUE(database.GetPathForOrigin(origin, &path1));
 114   EXPECT_FALSE(path1.empty());
 115   EXPECT_EQ(path0, path1);
 116 }
 117
 118 TEST(SandboxOriginDatabaseTest, DeleteOriginTest) {
 119   base::ScopedTempDir dir;
 120   ASSERT_TRUE(dir.CreateUniqueTempDir());
 121   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
 122   EXPECT_FALSE(base::PathExists(kFSDir));
 123   EXPECT_TRUE(base::CreateDirectory(kFSDir));
 124
 125   SandboxOriginDatabase database(kFSDir, NULL);
 126   std::string origin("origin");
 127
 128   EXPECT_FALSE(database.HasOriginPath(origin));
 129   EXPECT_TRUE(database.RemovePathForOrigin(origin));
 130
 131   base::FilePath path0;
 132   EXPECT_TRUE(database.GetPathForOrigin(origin, &path0));
 133   EXPECT_TRUE(database.HasOriginPath(origin));
 134   EXPECT_FALSE(path0.empty());
 135
 136   EXPECT_TRUE(database.RemovePathForOrigin(origin));
 137   EXPECT_FALSE(database.HasOriginPath(origin));
 138
 139   base::FilePath path1;
 140   EXPECT_TRUE(database.GetPathForOrigin(origin, &path1));
 141   EXPECT_FALSE(path1.empty());
 142   EXPECT_NE(path0, path1);
 143 }
 144
 145 TEST(SandboxOriginDatabaseTest, ListOriginsTest) {
 146   base::ScopedTempDir dir;
 147   ASSERT_TRUE(dir.CreateUniqueTempDir());
 148   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
 149   EXPECT_FALSE(base::PathExists(kFSDir));
 150   EXPECT_TRUE(base::CreateDirectory(kFSDir));
 151
 152   std::vector<SandboxOriginDatabase::OriginRecord> origins;
 153
 154   SandboxOriginDatabase database(kFSDir, NULL);
 155   EXPECT_TRUE(database.ListAllOrigins(&origins));
 156   EXPECT_TRUE(origins.empty());
 157   origins.clear();
 158
 159   std::string origin0("origin0");
 160   std::string origin1("origin1");
 161
 162   EXPECT_FALSE(database.HasOriginPath(origin0));
 163   EXPECT_FALSE(database.HasOriginPath(origin1));
 164
 165   base::FilePath path0;
 166   base::FilePath path1;
 167   EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0));
 168   EXPECT_TRUE(database.ListAllOrigins(&origins));
 169   EXPECT_EQ(origins.size(), 1UL);
 170   EXPECT_EQ(origins[0].origin, origin0);
 171   EXPECT_EQ(origins[0].path, path0);
 172   origins.clear();
 173   EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1));
 174   EXPECT_TRUE(database.ListAllOrigins(&origins));
 175   EXPECT_EQ(origins.size(), 2UL);
 176   if (origins[0].origin == origin0) {
 177     EXPECT_EQ(origins[0].path, path0);
 178     EXPECT_EQ(origins[1].origin, origin1);
 179     EXPECT_EQ(origins[1].path, path1);
 180   } else {
 181     EXPECT_EQ(origins[0].origin, origin1);
 182     EXPECT_EQ(origins[0].path, path1);
 183     EXPECT_EQ(origins[1].origin, origin0);
 184     EXPECT_EQ(origins[1].path, path0);
 185   }
 186 }
 187
 188 TEST(SandboxOriginDatabaseTest, DatabaseRecoveryTest) {
 189   // Checks if SandboxOriginDatabase properly handles database corruption.
 190   // In this test, we'll register some origins to the origin database, then
 191   // corrupt database and its log file.
 192   // After repairing, the origin database should be consistent even when some
 193   // entries lost.
 194
 195   base::ScopedTempDir dir;
 196   ASSERT_TRUE(dir.CreateUniqueTempDir());
 197   const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
 198   const base::FilePath kDBDir = kFSDir.Append(kOriginDatabaseName);
 199   EXPECT_FALSE(base::PathExists(kFSDir));
 200   EXPECT_TRUE(base::CreateDirectory(kFSDir));
 201
 202   const std::string kOrigins[] = {
 203     "foo.example.com",
 204     "bar.example.com",
 205     "baz.example.com",
 206     "hoge.example.com",
 207     "fuga.example.com",
 208   };
 209
 210   scoped_ptr<SandboxOriginDatabase> database(
 211       new SandboxOriginDatabase(kFSDir, NULL));
 212   for (size_t i = 0; i < arraysize(kOrigins); ++i) {
 213     base::FilePath path;
 214     EXPECT_FALSE(database->HasOriginPath(kOrigins[i]));
 215     EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path));
 216     EXPECT_FALSE(path.empty());
 217     EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path));
 218
 219     if (i != 1)
 220       EXPECT_TRUE(base::CreateDirectory(kFSDir.Append(path)));
 221   }
 222   database.reset();
 223
 224   const base::FilePath kGarbageDir = kFSDir.AppendASCII("foo");
 225   const base::FilePath kGarbageFile = kGarbageDir.AppendASCII("bar");
 226   EXPECT_TRUE(base::CreateDirectory(kGarbageDir));
 227   base::File file(kGarbageFile,
 228                   base::File::FLAG_CREATE | base::File::FLAG_WRITE);
 229   EXPECT_TRUE(file.IsValid());
 230   file.Close();
 231
 232   // Corrupt database itself and last log entry to drop last 1 database
 233   // operation.  The database should detect the corruption and should recover
 234   // its consistency after recovery.
 235   CorruptDatabase(kDBDir, leveldb::kDescriptorFile,
 236                   0, std::numeric_limits<size_t>::max());
 237   CorruptDatabase(kDBDir, leveldb::kLogFile, -1, 1);
 238
 239   base::FilePath path;
 240   database.reset(new SandboxOriginDatabase(kFSDir, NULL));
 241   std::vector<SandboxOriginDatabase::OriginRecord> origins_in_db;
 242   EXPECT_TRUE(database->ListAllOrigins(&origins_in_db));
 243
 244   // Expect all but last added origin will be repaired back, and kOrigins[1]
 245   // should be dropped due to absence of backing directory.
 246   EXPECT_EQ(arraysize(kOrigins) - 2, origins_in_db.size());
 247
 248   const std::string kOrigin("piyo.example.org");
 249   EXPECT_FALSE(database->HasOriginPath(kOrigin));
 250   EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path));
 251   EXPECT_FALSE(path.empty());
 252   EXPECT_TRUE(database->HasOriginPath(kOrigin));
 253
 254   EXPECT_FALSE(base::PathExists(kGarbageFile));
 255   EXPECT_FALSE(base::PathExists(kGarbageDir));
 256 }
 257
 258 TEST(SandboxOriginDatabaseTest, DatabaseRecoveryForMissingDBFileTest) {
 259   const leveldb::FileType kLevelDBFileTypes[] = {
 260     leveldb::kLogFile,
 261     leveldb::kDBLockFile,
 262     leveldb::kTableFile,
 263     leveldb::kDescriptorFile,
 264     leveldb::kCurrentFile,
 265     leveldb::kTempFile,
 266     leveldb::kInfoLogFile,
 267   };
 268
 269   for (size_t i = 0; i < arraysize(kLevelDBFileTypes); ++i) {
 270     base::ScopedTempDir dir;
 271     ASSERT_TRUE(dir.CreateUniqueTempDir());
 272     const base::FilePath kFSDir = dir.path().Append(kFileSystemDirName);
 273     const base::FilePath kDBDir = kFSDir.Append(kOriginDatabaseName);
 274     EXPECT_FALSE(base::PathExists(kFSDir));
 275     EXPECT_TRUE(base::CreateDirectory(kFSDir));
 276
 277     const std::string kOrigin = "foo.example.com";
 278     base::FilePath path;
 279
 280     scoped_ptr<SandboxOriginDatabase> database(
 281         new SandboxOriginDatabase(kFSDir, NULL));
 282     EXPECT_FALSE(database->HasOriginPath(kOrigin));
 283     EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path));
 284     EXPECT_FALSE(path.empty());
 285     EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path));
 286     EXPECT_TRUE(base::CreateDirectory(kFSDir.Append(path)));
 287     database.reset();
 288
 289     DeleteDatabaseFile(kDBDir, kLevelDBFileTypes[i]);
 290
 291     database.reset(new SandboxOriginDatabase(kFSDir, NULL));
 292     std::vector<SandboxOriginDatabase::OriginRecord> origins_in_db;
 293     EXPECT_TRUE(database->ListAllOrigins(&origins_in_db));
 294
 295     const std::string kOrigin2("piyo.example.org");
 296     EXPECT_FALSE(database->HasOriginPath(kOrigin2));
 297     EXPECT_TRUE(database->GetPathForOrigin(kOrigin2, &path));
 298     EXPECT_FALSE(path.empty());
 299     EXPECT_TRUE(database->HasOriginPath(kOrigin2));
 300   }
 301 }
 302
 303 }  // namespace fileapi