src/content/browser/fileapi/sandbox_prioritized_origin_database_unittest.cc

   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 #include "base/basictypes.h"
   6 #include "base/file_util.h"
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/platform_file.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "webkit/browser/fileapi/sandbox_origin_database.h"
  11 #include "webkit/browser/fileapi/sandbox_prioritized_origin_database.h"
  12
  13 using fileapi::SandboxOriginDatabase;
  14 using fileapi::SandboxOriginDatabaseInterface;
  15 using fileapi::SandboxPrioritizedOriginDatabase;
  16
  17 namespace content {
  18
  19 TEST(SandboxPrioritizedOriginDatabaseTest, BasicTest) {
  20   base::ScopedTempDir dir;
  21   base::FilePath path;
  22   ASSERT_TRUE(dir.CreateUniqueTempDir());
  23
  24   const std::string kOrigin1("origin1");
  25   const std::string kOrigin2("origin2");
  26
  27   SandboxPrioritizedOriginDatabase database(dir.path(), NULL);
  28
  29   // Set the kOrigin1 as a parimary origin.
  30   EXPECT_TRUE(database.InitializePrimaryOrigin(kOrigin1));
  31
  32   // Add two origins.
  33   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
  34   EXPECT_TRUE(database.GetPathForOrigin(kOrigin2, &path));
  35
  36   // Verify them.
  37   EXPECT_TRUE(database.HasOriginPath(kOrigin1));
  38   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
  39   EXPECT_FALSE(path.empty());
  40   EXPECT_TRUE(database.HasOriginPath(kOrigin2));
  41   EXPECT_TRUE(database.GetPathForOrigin(kOrigin2, &path));
  42   EXPECT_FALSE(path.empty());
  43
  44   std::vector<SandboxOriginDatabaseInterface::OriginRecord> origins;
  45   database.ListAllOrigins(&origins);
  46   ASSERT_EQ(2U, origins.size());
  47   EXPECT_TRUE(origins[0].origin == kOrigin1 ||
  48               origins[1].origin == kOrigin1);
  49   EXPECT_TRUE(origins[0].origin == kOrigin2 ||
  50               origins[1].origin == kOrigin2);
  51   EXPECT_NE(origins[0].path, origins[1].path);
  52
  53   // Try remove path for kOrigin1.
  54   database.RemovePathForOrigin(kOrigin1);
  55
  56   // Verify the removal.
  57   EXPECT_FALSE(database.HasOriginPath(kOrigin1));
  58   EXPECT_TRUE(database.HasOriginPath(kOrigin2));
  59   database.ListAllOrigins(&origins);
  60   ASSERT_EQ(1U, origins.size());
  61   EXPECT_EQ(kOrigin2, origins[0].origin);
  62
  63   // Try remove path for kOrigin2.
  64   database.RemovePathForOrigin(kOrigin2);
  65
  66   // Verify the removal.
  67   EXPECT_FALSE(database.HasOriginPath(kOrigin1));
  68   EXPECT_FALSE(database.HasOriginPath(kOrigin2));
  69   database.ListAllOrigins(&origins);
  70   EXPECT_TRUE(origins.empty());
  71 }
  72
  73 TEST(SandboxPrioritizedOriginDatabaseTest, SetPrimaryLaterTest) {
  74   base::ScopedTempDir dir;
  75   base::FilePath path;
  76   ASSERT_TRUE(dir.CreateUniqueTempDir());
  77
  78   const std::string kOrigin1("origin1");
  79   const std::string kOrigin2("origin2");
  80
  81   SandboxPrioritizedOriginDatabase database(dir.path(), NULL);
  82
  83   EXPECT_TRUE(database.GetPrimaryOrigin().empty());
  84
  85   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
  86   EXPECT_TRUE(database.GetPathForOrigin(kOrigin2, &path));
  87
  88   // Set the kOrigin1 as a parimary origin.
  89   EXPECT_TRUE(database.InitializePrimaryOrigin(kOrigin1));
  90   EXPECT_EQ(kOrigin1, database.GetPrimaryOrigin());
  91
  92   // Regardless of whether it is initialized as primary or not
  93   // they should just work.
  94   EXPECT_TRUE(database.HasOriginPath(kOrigin1));
  95   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
  96   EXPECT_FALSE(path.empty());
  97   EXPECT_TRUE(database.HasOriginPath(kOrigin2));
  98   EXPECT_TRUE(database.GetPathForOrigin(kOrigin2, &path));
  99   EXPECT_FALSE(path.empty());
 100 }
 101
 102 TEST(SandboxPrioritizedOriginDatabaseTest, LostPrimaryOriginFileTest) {
 103   base::ScopedTempDir dir;
 104   base::FilePath path;
 105   ASSERT_TRUE(dir.CreateUniqueTempDir());
 106
 107   const std::string kOrigin1("origin1");
 108   const std::string kData("foo");
 109
 110   SandboxPrioritizedOriginDatabase database(dir.path(), NULL);
 111
 112   EXPECT_TRUE(database.GetPrimaryOrigin().empty());
 113
 114   // Set the kOrigin1 as a parimary origin.
 115   EXPECT_TRUE(database.InitializePrimaryOrigin(kOrigin1));
 116   EXPECT_EQ(kOrigin1, database.GetPrimaryOrigin());
 117
 118   // Make sure it works.
 119   EXPECT_TRUE(database.HasOriginPath(kOrigin1));
 120   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
 121
 122   // Reset the database.
 123   database.DropDatabase();
 124
 125   // kOrigin1 should still be marked as primary.
 126   EXPECT_TRUE(database.HasOriginPath(kOrigin1));
 127   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
 128
 129   // Corrupt the primary origin file.
 130   base::WriteFile(database.primary_origin_file(), kData.data(), kData.size());
 131
 132   // Reset the database.
 133   database.DropDatabase();
 134
 135   // kOrigin1 is no longer marked as primary, and unfortunately we fail
 136   // to find the data for the origin.
 137   EXPECT_FALSE(database.HasOriginPath(kOrigin1));
 138 }
 139
 140 TEST(SandboxPrioritizedOriginDatabaseTest, MigrationTest) {
 141   base::ScopedTempDir dir;
 142   ASSERT_TRUE(dir.CreateUniqueTempDir());
 143
 144   const std::string kOrigin1("origin1");
 145   const std::string kOrigin2("origin2");
 146   const std::string kFakeDirectoryData1("0123456789");
 147   const std::string kFakeDirectoryData2("abcde");
 148   base::FilePath old_dir_db_path1, old_dir_db_path2;
 149   base::FilePath path1, path2;
 150
 151   // Initialize the directory with two origins using the regular
 152   // SandboxOriginDatabase.
 153   {
 154     SandboxOriginDatabase database_old(dir.path(), NULL);
 155     base::FilePath old_db_path = database_old.GetDatabasePath();
 156     EXPECT_FALSE(base::PathExists(old_db_path));
 157
 158     // Initialize paths for kOrigin1 and kOrigin2.
 159     EXPECT_TRUE(database_old.GetPathForOrigin(kOrigin1, &path1));
 160     EXPECT_FALSE(path1.empty());
 161     EXPECT_TRUE(database_old.GetPathForOrigin(kOrigin2, &path2));
 162     EXPECT_FALSE(path2.empty());
 163
 164     EXPECT_TRUE(base::DirectoryExists(old_db_path));
 165
 166     // Populate the origin directory with some fake data.
 167     old_dir_db_path1 = dir.path().Append(path1);
 168     ASSERT_TRUE(base::CreateDirectory(old_dir_db_path1));
 169     EXPECT_EQ(static_cast<int>(kFakeDirectoryData1.size()),
 170               base::WriteFile(old_dir_db_path1.AppendASCII("dummy"),
 171                               kFakeDirectoryData1.data(),
 172                               kFakeDirectoryData1.size()));
 173     old_dir_db_path2 = dir.path().Append(path2);
 174     ASSERT_TRUE(base::CreateDirectory(old_dir_db_path2));
 175     EXPECT_EQ(static_cast<int>(kFakeDirectoryData2.size()),
 176               base::WriteFile(old_dir_db_path2.AppendASCII("dummy"),
 177                               kFakeDirectoryData2.data(),
 178                               kFakeDirectoryData2.size()));
 179   }
 180
 181   // Re-open the directory using sandboxPrioritizedOriginDatabase.
 182   SandboxPrioritizedOriginDatabase database(dir.path(), NULL);
 183
 184   // Set the kOrigin1 as a parimary origin.
 185   // (Trying to initialize another origin should fail).
 186   EXPECT_TRUE(database.InitializePrimaryOrigin(kOrigin1));
 187   EXPECT_FALSE(database.InitializePrimaryOrigin(kOrigin2));
 188
 189   EXPECT_EQ(kOrigin1, database.GetPrimaryOrigin());
 190
 191   // Regardless of whether the origin is registered as primary or not
 192   // it should just work.
 193   EXPECT_TRUE(database.HasOriginPath(kOrigin1));
 194   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path1));
 195   EXPECT_TRUE(database.HasOriginPath(kOrigin2));
 196   EXPECT_TRUE(database.GetPathForOrigin(kOrigin2, &path2));
 197
 198   // The directory content must be kept (or migrated if necessary) as well.
 199   std::string origin_db_data;
 200   base::FilePath dir_db_path = dir.path().Append(path1);
 201   EXPECT_TRUE(base::PathExists(dir_db_path.AppendASCII("dummy")));
 202   EXPECT_TRUE(base::ReadFileToString(
 203       dir_db_path.AppendASCII("dummy"), &origin_db_data));
 204   EXPECT_EQ(kFakeDirectoryData1, origin_db_data);
 205
 206   origin_db_data.clear();
 207   dir_db_path = dir.path().Append(path2);
 208   EXPECT_TRUE(base::PathExists(dir_db_path.AppendASCII("dummy")));
 209   EXPECT_TRUE(base::ReadFileToString(
 210       dir_db_path.AppendASCII("dummy"), &origin_db_data));
 211   EXPECT_EQ(kFakeDirectoryData2, origin_db_data);
 212
 213   // After the migration the kOrigin1 directory database path must be gone.
 214   EXPECT_FALSE(base::PathExists(old_dir_db_path1));
 215   EXPECT_TRUE(base::PathExists(old_dir_db_path2));
 216 }
 217
 218 }  // namespace content