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) { | |
ericu
2012/03/26 18:39:18
Use the new one in file_system_util?
tzik
2012/03/27 02:44:18
Done.
| |
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; | |
ericu
2012/03/26 18:39:18
How about just initializing picked_file_number to
tzik
2012/03/27 02:44:18
I'd like to avoid integer overflow as far as possi
| |
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)) { | |
ericu
2012/03/26 18:39:18
Then you can simplify this to:
if (file_type == t
| |
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); | |
ericu
2012/03/26 18:39:18
And you can EXPECT_GE(0, picked_file_number);
tzik
2012/03/27 02:44:18
picked_file_number and number are unsigned, so it
ericu
2012/03/29 04:22:19
Good point; changing that -1 to kuint64max made it
| |
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 EXPECT_GE(offset, 0); | |
83 EXPECT_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); | |
ericu
2012/03/26 18:39:18
This is probably more readable as EXPECT_GT(writte
tzik
2012/03/27 02:44:18
Done.
| |
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. | |
ericu
2012/03/26 18:39:18
Very nice!
tzik
2012/03/27 02:44:18
:)
| |
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. | |
ericu
2012/03/26 18:39:18
Typo: absence.
| |
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 |