OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "testing/gtest/include/gtest/gtest.h" | 5 #include "testing/gtest/include/gtest/gtest.h" |
6 | 6 |
| 7 #include <algorithm> |
7 #include <string> | 8 #include <string> |
8 | 9 |
| 10 #include "base/file_path.h" |
9 #include "base/file_util.h" | 11 #include "base/file_util.h" |
| 12 #include "base/platform_file.h" |
10 #include "base/scoped_temp_dir.h" | 13 #include "base/scoped_temp_dir.h" |
| 14 #include "base/stl_util.h" |
| 15 #include "base/utf_string_conversions.h" |
| 16 #include "third_party/leveldatabase/src/db/filename.h" |
| 17 #include "third_party/leveldatabase/src/include/leveldb/db.h" |
11 #include "webkit/fileapi/file_system_origin_database.h" | 18 #include "webkit/fileapi/file_system_origin_database.h" |
12 | 19 |
13 namespace fileapi { | 20 namespace fileapi { |
14 | 21 |
| 22 namespace { |
| 23 const FilePath::CharType kFileSystemDirName[] = |
| 24 FILE_PATH_LITERAL("File System"); |
| 25 const FilePath::CharType kOriginDatabaseName[] = FILE_PATH_LITERAL("Origins"); |
| 26 |
| 27 std::string FilePathToString(const FilePath& path) { |
| 28 #if defined(OS_POSIX) |
| 29 return path.value(); |
| 30 #elif defined(OS_WIN) |
| 31 return UTF16ToUTF8(path.value()); |
| 32 #endif |
| 33 } |
| 34 |
| 35 FilePath UTF8ToFilePath(const std::string& path_string) { |
| 36 return FilePath::FromUTF8Unsafe(path_string); |
| 37 } |
| 38 |
| 39 void CorruptDatabase(const FilePath& db_path, |
| 40 leveldb::FileType type, |
| 41 ptrdiff_t offset, |
| 42 size_t size) { |
| 43 file_util::FileEnumerator file_enum( |
| 44 db_path, false /* recursive */, |
| 45 static_cast<file_util::FileEnumerator::FileType>( |
| 46 file_util::FileEnumerator::DIRECTORIES | |
| 47 file_util::FileEnumerator::FILES)); |
| 48 FilePath file_path; |
| 49 FilePath picked_file_path; |
| 50 uint64 picked_file_number = kuint64max; |
| 51 |
| 52 while (!(file_path = file_enum.Next()).empty()) { |
| 53 uint64 number = -1; |
| 54 leveldb::FileType file_type; |
| 55 EXPECT_TRUE(leveldb::ParseFileName(FilePathToString(file_path.BaseName()), |
| 56 &number, &file_type)); |
| 57 if (file_type == type && |
| 58 (picked_file_number == kuint64max || picked_file_number < number)) { |
| 59 picked_file_path = file_path; |
| 60 picked_file_number = number; |
| 61 } |
| 62 } |
| 63 |
| 64 EXPECT_FALSE(picked_file_path.empty()); |
| 65 EXPECT_NE(kuint64max, picked_file_number); |
| 66 |
| 67 bool created = true; |
| 68 base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED; |
| 69 base::PlatformFile file = |
| 70 CreatePlatformFile(picked_file_path, |
| 71 base::PLATFORM_FILE_OPEN | |
| 72 base::PLATFORM_FILE_READ | |
| 73 base::PLATFORM_FILE_WRITE, |
| 74 &created, &error); |
| 75 EXPECT_EQ(base::PLATFORM_FILE_OK, error); |
| 76 EXPECT_FALSE(created); |
| 77 |
| 78 base::PlatformFileInfo file_info; |
| 79 EXPECT_TRUE(base::GetPlatformFileInfo(file, &file_info)); |
| 80 if (offset < 0) |
| 81 offset += file_info.size; |
| 82 DCHECK_GE(offset, 0); |
| 83 DCHECK_LE(offset, file_info.size); |
| 84 |
| 85 size = std::min(size, static_cast<size_t>(file_info.size - offset)); |
| 86 |
| 87 std::vector<char> buf(size); |
| 88 int read_size = base::ReadPlatformFile(file, offset, |
| 89 vector_as_array(&buf), buf.size()); |
| 90 EXPECT_LT(0, read_size); |
| 91 EXPECT_GE(buf.size(), static_cast<size_t>(read_size)); |
| 92 buf.resize(read_size); |
| 93 |
| 94 std::transform(buf.begin(), buf.end(), buf.begin(), |
| 95 std::logical_not<char>()); |
| 96 |
| 97 int written_size = base::WritePlatformFile(file, offset, |
| 98 vector_as_array(&buf), buf.size()); |
| 99 EXPECT_LE(0, written_size); |
| 100 EXPECT_EQ(buf.size(), static_cast<size_t>(written_size)); |
| 101 |
| 102 base::ClosePlatformFile(file); |
| 103 } |
| 104 |
| 105 } |
| 106 |
15 TEST(FileSystemOriginDatabaseTest, BasicTest) { | 107 TEST(FileSystemOriginDatabaseTest, BasicTest) { |
16 ScopedTempDir dir; | 108 ScopedTempDir dir; |
17 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 109 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
18 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 110 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
19 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 111 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 112 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
20 | 113 |
21 FileSystemOriginDatabase database(kDBFile); | 114 FileSystemOriginDatabase database(kFSDir); |
22 std::string origin("origin"); | 115 std::string origin("origin"); |
23 | 116 |
24 EXPECT_FALSE(database.HasOriginPath(origin)); | 117 EXPECT_FALSE(database.HasOriginPath(origin)); |
25 // Double-check to make sure that had no side effects. | 118 // Double-check to make sure that had no side effects. |
26 EXPECT_FALSE(database.HasOriginPath(origin)); | 119 EXPECT_FALSE(database.HasOriginPath(origin)); |
27 | 120 |
28 FilePath path0; | 121 FilePath path0; |
29 FilePath path1; | 122 FilePath path1; |
30 | 123 |
31 // Empty strings aren't valid origins. | 124 // Empty strings aren't valid origins. |
32 EXPECT_FALSE(database.GetPathForOrigin(std::string(), &path0)); | 125 EXPECT_FALSE(database.GetPathForOrigin(std::string(), &path0)); |
33 | 126 |
34 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 127 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
35 EXPECT_TRUE(database.HasOriginPath(origin)); | 128 EXPECT_TRUE(database.HasOriginPath(origin)); |
36 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 129 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
37 EXPECT_FALSE(path0.empty()); | 130 EXPECT_FALSE(path0.empty()); |
38 EXPECT_FALSE(path1.empty()); | 131 EXPECT_FALSE(path1.empty()); |
39 EXPECT_EQ(path0, path1); | 132 EXPECT_EQ(path0, path1); |
40 | 133 |
41 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 134 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
42 } | 135 } |
43 | 136 |
44 TEST(FileSystemOriginDatabaseTest, TwoPathTest) { | 137 TEST(FileSystemOriginDatabaseTest, TwoPathTest) { |
45 ScopedTempDir dir; | 138 ScopedTempDir dir; |
46 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 139 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
47 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 140 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
48 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 141 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 142 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
49 | 143 |
50 FileSystemOriginDatabase database(kDBFile); | 144 FileSystemOriginDatabase database(kFSDir); |
51 std::string origin0("origin0"); | 145 std::string origin0("origin0"); |
52 std::string origin1("origin1"); | 146 std::string origin1("origin1"); |
53 | 147 |
54 EXPECT_FALSE(database.HasOriginPath(origin0)); | 148 EXPECT_FALSE(database.HasOriginPath(origin0)); |
55 EXPECT_FALSE(database.HasOriginPath(origin1)); | 149 EXPECT_FALSE(database.HasOriginPath(origin1)); |
56 | 150 |
57 FilePath path0; | 151 FilePath path0; |
58 FilePath path1; | 152 FilePath path1; |
59 EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0)); | 153 EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0)); |
60 EXPECT_TRUE(database.HasOriginPath(origin0)); | 154 EXPECT_TRUE(database.HasOriginPath(origin0)); |
61 EXPECT_FALSE(database.HasOriginPath(origin1)); | 155 EXPECT_FALSE(database.HasOriginPath(origin1)); |
62 EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1)); | 156 EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1)); |
63 EXPECT_TRUE(database.HasOriginPath(origin1)); | 157 EXPECT_TRUE(database.HasOriginPath(origin1)); |
64 EXPECT_FALSE(path0.empty()); | 158 EXPECT_FALSE(path0.empty()); |
65 EXPECT_FALSE(path1.empty()); | 159 EXPECT_FALSE(path1.empty()); |
66 EXPECT_NE(path0, path1); | 160 EXPECT_NE(path0, path1); |
67 | 161 |
68 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 162 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
69 } | 163 } |
70 | 164 |
71 TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) { | 165 TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) { |
72 ScopedTempDir dir; | 166 ScopedTempDir dir; |
73 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 167 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
74 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 168 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
75 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 169 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 170 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
76 | 171 |
77 FileSystemOriginDatabase database(kDBFile); | 172 FileSystemOriginDatabase database(kFSDir); |
78 std::string origin("origin"); | 173 std::string origin("origin"); |
79 | 174 |
80 EXPECT_FALSE(database.HasOriginPath(origin)); | 175 EXPECT_FALSE(database.HasOriginPath(origin)); |
81 | 176 |
82 FilePath path0; | 177 FilePath path0; |
83 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 178 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
84 EXPECT_TRUE(database.HasOriginPath(origin)); | 179 EXPECT_TRUE(database.HasOriginPath(origin)); |
85 EXPECT_FALSE(path0.empty()); | 180 EXPECT_FALSE(path0.empty()); |
86 | 181 |
87 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 182 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
88 | 183 |
89 database.DropDatabase(); | 184 database.DropDatabase(); |
90 | 185 |
91 FilePath path1; | 186 FilePath path1; |
92 EXPECT_TRUE(database.HasOriginPath(origin)); | 187 EXPECT_TRUE(database.HasOriginPath(origin)); |
93 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 188 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
94 EXPECT_FALSE(path1.empty()); | 189 EXPECT_FALSE(path1.empty()); |
95 EXPECT_EQ(path0, path1); | 190 EXPECT_EQ(path0, path1); |
96 } | 191 } |
97 | 192 |
98 TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) { | 193 TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) { |
99 ScopedTempDir dir; | 194 ScopedTempDir dir; |
100 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 195 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
101 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 196 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
102 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 197 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 198 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
103 | 199 |
104 FileSystemOriginDatabase database(kDBFile); | 200 FileSystemOriginDatabase database(kFSDir); |
105 std::string origin("origin"); | 201 std::string origin("origin"); |
106 | 202 |
107 EXPECT_FALSE(database.HasOriginPath(origin)); | 203 EXPECT_FALSE(database.HasOriginPath(origin)); |
108 EXPECT_TRUE(database.RemovePathForOrigin(origin)); | 204 EXPECT_TRUE(database.RemovePathForOrigin(origin)); |
109 | 205 |
110 FilePath path0; | 206 FilePath path0; |
111 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 207 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
112 EXPECT_TRUE(database.HasOriginPath(origin)); | 208 EXPECT_TRUE(database.HasOriginPath(origin)); |
113 EXPECT_FALSE(path0.empty()); | 209 EXPECT_FALSE(path0.empty()); |
114 | 210 |
115 EXPECT_TRUE(database.RemovePathForOrigin(origin)); | 211 EXPECT_TRUE(database.RemovePathForOrigin(origin)); |
116 EXPECT_FALSE(database.HasOriginPath(origin)); | 212 EXPECT_FALSE(database.HasOriginPath(origin)); |
117 | 213 |
118 FilePath path1; | 214 FilePath path1; |
119 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 215 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
120 EXPECT_FALSE(path1.empty()); | 216 EXPECT_FALSE(path1.empty()); |
121 EXPECT_NE(path0, path1); | 217 EXPECT_NE(path0, path1); |
122 } | 218 } |
123 | 219 |
124 TEST(FileSystemOriginDatabaseTest, ListOriginsTest) { | 220 TEST(FileSystemOriginDatabaseTest, ListOriginsTest) { |
125 ScopedTempDir dir; | 221 ScopedTempDir dir; |
126 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 222 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
127 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 223 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
128 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 224 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 225 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
129 | 226 |
130 std::vector<FileSystemOriginDatabase::OriginRecord> origins; | 227 std::vector<FileSystemOriginDatabase::OriginRecord> origins; |
131 | 228 |
132 FileSystemOriginDatabase database(kDBFile); | 229 FileSystemOriginDatabase database(kFSDir); |
133 EXPECT_TRUE(database.ListAllOrigins(&origins)); | 230 EXPECT_TRUE(database.ListAllOrigins(&origins)); |
134 EXPECT_TRUE(origins.empty()); | 231 EXPECT_TRUE(origins.empty()); |
135 origins.clear(); | 232 origins.clear(); |
136 | 233 |
137 std::string origin0("origin0"); | 234 std::string origin0("origin0"); |
138 std::string origin1("origin1"); | 235 std::string origin1("origin1"); |
139 | 236 |
140 EXPECT_FALSE(database.HasOriginPath(origin0)); | 237 EXPECT_FALSE(database.HasOriginPath(origin0)); |
141 EXPECT_FALSE(database.HasOriginPath(origin1)); | 238 EXPECT_FALSE(database.HasOriginPath(origin1)); |
142 | 239 |
(...skipping 13 matching lines...) Expand all Loading... |
156 EXPECT_EQ(origins[1].origin, origin1); | 253 EXPECT_EQ(origins[1].origin, origin1); |
157 EXPECT_EQ(origins[1].path, path1); | 254 EXPECT_EQ(origins[1].path, path1); |
158 } else { | 255 } else { |
159 EXPECT_EQ(origins[0].origin, origin1); | 256 EXPECT_EQ(origins[0].origin, origin1); |
160 EXPECT_EQ(origins[0].path, path1); | 257 EXPECT_EQ(origins[0].path, path1); |
161 EXPECT_EQ(origins[1].origin, origin0); | 258 EXPECT_EQ(origins[1].origin, origin0); |
162 EXPECT_EQ(origins[1].path, path0); | 259 EXPECT_EQ(origins[1].path, path0); |
163 } | 260 } |
164 } | 261 } |
165 | 262 |
| 263 TEST(FileSystemOriginDatabaseTest, DatabaseRecoveryTest) { |
| 264 // Checks if FileSystemOriginDatabase properly handles database corruption. |
| 265 // In this test, we'll register some origins to the origin database, then |
| 266 // corrupt database and its log file. |
| 267 // After repairing, the origin database should be consistent even when some |
| 268 // entries lost. |
| 269 |
| 270 ScopedTempDir dir; |
| 271 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| 272 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
| 273 const FilePath kDBDir = kFSDir.Append(kOriginDatabaseName); |
| 274 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
| 275 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); |
| 276 |
| 277 const std::string kOrigins[] = { |
| 278 "foo.example.com", |
| 279 "bar.example.com", |
| 280 "baz.example.com", |
| 281 "hoge.example.com", |
| 282 "fuga.example.com", |
| 283 }; |
| 284 |
| 285 scoped_ptr<FileSystemOriginDatabase> database( |
| 286 new FileSystemOriginDatabase(kFSDir)); |
| 287 for (size_t i = 0; i < arraysize(kOrigins); ++i) { |
| 288 FilePath path; |
| 289 EXPECT_FALSE(database->HasOriginPath(kOrigins[i])); |
| 290 EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path)); |
| 291 EXPECT_FALSE(path.empty()); |
| 292 EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path)); |
| 293 |
| 294 if (i != 1) |
| 295 EXPECT_TRUE(file_util::CreateDirectory(kFSDir.Append(path))); |
| 296 } |
| 297 database.reset(); |
| 298 |
| 299 const FilePath kGarbageDir = kFSDir.AppendASCII("foo"); |
| 300 const FilePath kGarbageFile = kGarbageDir.AppendASCII("bar"); |
| 301 EXPECT_TRUE(file_util::CreateDirectory(kGarbageDir)); |
| 302 bool created = false; |
| 303 base::PlatformFileError error; |
| 304 base::PlatformFile file = base::CreatePlatformFile( |
| 305 kGarbageFile, |
| 306 base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE, |
| 307 &created, &error); |
| 308 EXPECT_EQ(base::PLATFORM_FILE_OK, error); |
| 309 EXPECT_TRUE(created); |
| 310 EXPECT_TRUE(base::ClosePlatformFile(file)); |
| 311 |
| 312 // Corrupt database itself and last log entry to drop last 1 database |
| 313 // operation. The database should detect the corruption and should recover |
| 314 // its consistency after recovery. |
| 315 CorruptDatabase(kDBDir, leveldb::kDescriptorFile, |
| 316 0, std::numeric_limits<size_t>::max()); |
| 317 CorruptDatabase(kDBDir, leveldb::kLogFile, -1, 1); |
| 318 |
| 319 FilePath path; |
| 320 database.reset(new FileSystemOriginDatabase(kFSDir)); |
| 321 std::vector<FileSystemOriginDatabase::OriginRecord> origins_in_db; |
| 322 EXPECT_TRUE(database->ListAllOrigins(&origins_in_db)); |
| 323 |
| 324 // Expect all but last added origin will be repaired back, and kOrigins[1] |
| 325 // should be dropped due to absense of backing directory. |
| 326 EXPECT_EQ(arraysize(kOrigins) - 2, origins_in_db.size()); |
| 327 |
| 328 const std::string kOrigin("piyo.example.org"); |
| 329 EXPECT_FALSE(database->HasOriginPath(kOrigin)); |
| 330 EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path)); |
| 331 EXPECT_FALSE(path.empty()); |
| 332 EXPECT_TRUE(database->HasOriginPath(kOrigin)); |
| 333 |
| 334 EXPECT_FALSE(file_util::PathExists(kGarbageFile)); |
| 335 EXPECT_FALSE(file_util::PathExists(kGarbageDir)); |
| 336 } |
| 337 |
166 } // namespace fileapi | 338 } // namespace fileapi |
OLD | NEW |