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 <string> | 7 #include <string> |
8 | 8 |
9 #include "base/file_path.h" | |
9 #include "base/file_util.h" | 10 #include "base/file_util.h" |
11 #include "base/platform_file.h" | |
10 #include "base/scoped_temp_dir.h" | 12 #include "base/scoped_temp_dir.h" |
13 #include "base/stl_util.h" | |
14 #include "third_party/leveldatabase/src/db/filename.h" | |
15 #include "third_party/leveldatabase/src/include/leveldb/db.h" | |
11 #include "webkit/fileapi/file_system_origin_database.h" | 16 #include "webkit/fileapi/file_system_origin_database.h" |
12 | 17 |
13 namespace fileapi { | 18 namespace fileapi { |
14 | 19 |
20 namespace { | |
21 const FilePath::CharType kFileSystemDirName[] = | |
22 FILE_PATH_LITERAL("File System"); | |
23 const FilePath::CharType kOriginDatabaseName[] = FILE_PATH_LITERAL("Origins"); | |
24 | |
25 std::string FilePathToUTF8(const FilePath& path) { | |
26 #if defined(OS_POSIX) | |
27 return path.value(); | |
28 #elif defined(OS_WIN) | |
29 return base::SysWideToUTF8(path.value()); | |
30 #endif | |
kinuko
2012/03/23 04:01:33
Ditto for ifdefs
tzik
2012/03/23 07:09:00
ditto
| |
31 } | |
32 | |
33 FilePath UTF8ToFilePath(const std::string& path_string) { | |
34 return FilePath::FromUTF8Unsafe(path_string); | |
35 } | |
36 | |
37 void CorruptDatabase(const FilePath& db_path, | |
38 leveldb::FileType type, | |
39 ptrdiff_t offset, | |
40 size_t size) { | |
41 file_util::FileEnumerator file_enum( | |
42 db_path, false /* recursive */, | |
43 static_cast<file_util::FileEnumerator::FileType>( | |
44 file_util::FileEnumerator::DIRECTORIES | | |
45 file_util::FileEnumerator::FILES)); | |
46 FilePath file_path; | |
47 FilePath picked_file_path; | |
48 uint64 picked_file_number = kuint64max; | |
49 | |
50 while (!(file_path = file_enum.Next()).empty()) { | |
51 uint64 number = -1; | |
52 leveldb::FileType file_type; | |
53 EXPECT_TRUE(leveldb::ParseFileName(FilePathToUTF8(file_path.BaseName()), | |
54 &number, &file_type)); | |
55 if (file_type == type && | |
56 (picked_file_number == kuint64max || picked_file_number < number)) { | |
57 picked_file_path = file_path; | |
58 picked_file_number = number; | |
59 } | |
60 } | |
61 | |
62 EXPECT_FALSE(picked_file_path.empty()); | |
63 EXPECT_NE(kuint64max, picked_file_number); | |
64 | |
65 bool created = true; | |
66 base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED; | |
67 base::PlatformFile file = | |
68 CreatePlatformFile(picked_file_path, | |
69 base::PLATFORM_FILE_OPEN | | |
70 base::PLATFORM_FILE_READ | | |
71 base::PLATFORM_FILE_WRITE, | |
72 &created, &error); | |
73 EXPECT_EQ(base::PLATFORM_FILE_OK, error); | |
74 EXPECT_FALSE(created); | |
75 | |
76 std::vector<char> buf(size); | |
77 | |
78 int read_size = base::ReadPlatformFile(file, offset, | |
79 vector_as_array(buf), buf.size()); | |
80 EXPECT_LT(0, read_size); | |
81 EXPECT_GE(buf.size(), static_cast<size_t>(read_size)); | |
82 buf.resize(read_size); | |
83 | |
84 std::transform(buf.begin(), buf.end(), buf.begin(), | |
85 std::logical_not<char>()); | |
86 | |
87 int wrote_size = base::WritePlatformFile(file, offset, | |
88 vector_as_array(buf), buf.size()); | |
89 EXPECT_LE(0, wrote_size); | |
90 EXPECT_EQ(buf.size(), static_cast<size_t>(wrote_size)); | |
91 | |
92 base::ClosePlatformFile(file); | |
93 } | |
94 | |
95 } | |
96 | |
15 TEST(FileSystemOriginDatabaseTest, BasicTest) { | 97 TEST(FileSystemOriginDatabaseTest, BasicTest) { |
16 ScopedTempDir dir; | 98 ScopedTempDir dir; |
17 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 99 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
18 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 100 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
19 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 101 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
102 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
20 | 103 |
21 FileSystemOriginDatabase database(kDBFile); | 104 FileSystemOriginDatabase database(kFSDir); |
22 std::string origin("origin"); | 105 std::string origin("origin"); |
23 | 106 |
24 EXPECT_FALSE(database.HasOriginPath(origin)); | 107 EXPECT_FALSE(database.HasOriginPath(origin)); |
25 // Double-check to make sure that had no side effects. | 108 // Double-check to make sure that had no side effects. |
26 EXPECT_FALSE(database.HasOriginPath(origin)); | 109 EXPECT_FALSE(database.HasOriginPath(origin)); |
27 | 110 |
28 FilePath path0; | 111 FilePath path0; |
29 FilePath path1; | 112 FilePath path1; |
30 | 113 |
31 // Empty strings aren't valid origins. | 114 // Empty strings aren't valid origins. |
32 EXPECT_FALSE(database.GetPathForOrigin(std::string(), &path0)); | 115 EXPECT_FALSE(database.GetPathForOrigin(std::string(), &path0)); |
33 | 116 |
34 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 117 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
35 EXPECT_TRUE(database.HasOriginPath(origin)); | 118 EXPECT_TRUE(database.HasOriginPath(origin)); |
36 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 119 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
37 EXPECT_FALSE(path0.empty()); | 120 EXPECT_FALSE(path0.empty()); |
38 EXPECT_FALSE(path1.empty()); | 121 EXPECT_FALSE(path1.empty()); |
39 EXPECT_EQ(path0, path1); | 122 EXPECT_EQ(path0, path1); |
40 | 123 |
41 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 124 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
42 } | 125 } |
43 | 126 |
44 TEST(FileSystemOriginDatabaseTest, TwoPathTest) { | 127 TEST(FileSystemOriginDatabaseTest, TwoPathTest) { |
45 ScopedTempDir dir; | 128 ScopedTempDir dir; |
46 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 129 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
47 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 130 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
48 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 131 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
132 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
49 | 133 |
50 FileSystemOriginDatabase database(kDBFile); | 134 FileSystemOriginDatabase database(kFSDir); |
51 std::string origin0("origin0"); | 135 std::string origin0("origin0"); |
52 std::string origin1("origin1"); | 136 std::string origin1("origin1"); |
53 | 137 |
54 EXPECT_FALSE(database.HasOriginPath(origin0)); | 138 EXPECT_FALSE(database.HasOriginPath(origin0)); |
55 EXPECT_FALSE(database.HasOriginPath(origin1)); | 139 EXPECT_FALSE(database.HasOriginPath(origin1)); |
56 | 140 |
57 FilePath path0; | 141 FilePath path0; |
58 FilePath path1; | 142 FilePath path1; |
59 EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0)); | 143 EXPECT_TRUE(database.GetPathForOrigin(origin0, &path0)); |
60 EXPECT_TRUE(database.HasOriginPath(origin0)); | 144 EXPECT_TRUE(database.HasOriginPath(origin0)); |
61 EXPECT_FALSE(database.HasOriginPath(origin1)); | 145 EXPECT_FALSE(database.HasOriginPath(origin1)); |
62 EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1)); | 146 EXPECT_TRUE(database.GetPathForOrigin(origin1, &path1)); |
63 EXPECT_TRUE(database.HasOriginPath(origin1)); | 147 EXPECT_TRUE(database.HasOriginPath(origin1)); |
64 EXPECT_FALSE(path0.empty()); | 148 EXPECT_FALSE(path0.empty()); |
65 EXPECT_FALSE(path1.empty()); | 149 EXPECT_FALSE(path1.empty()); |
66 EXPECT_NE(path0, path1); | 150 EXPECT_NE(path0, path1); |
67 | 151 |
68 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 152 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
69 } | 153 } |
70 | 154 |
71 TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) { | 155 TEST(FileSystemOriginDatabaseTest, DropDatabaseTest) { |
72 ScopedTempDir dir; | 156 ScopedTempDir dir; |
73 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 157 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
74 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 158 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
75 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 159 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
160 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
76 | 161 |
77 FileSystemOriginDatabase database(kDBFile); | 162 FileSystemOriginDatabase database(kFSDir); |
78 std::string origin("origin"); | 163 std::string origin("origin"); |
79 | 164 |
80 EXPECT_FALSE(database.HasOriginPath(origin)); | 165 EXPECT_FALSE(database.HasOriginPath(origin)); |
81 | 166 |
82 FilePath path0; | 167 FilePath path0; |
83 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 168 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
84 EXPECT_TRUE(database.HasOriginPath(origin)); | 169 EXPECT_TRUE(database.HasOriginPath(origin)); |
85 EXPECT_FALSE(path0.empty()); | 170 EXPECT_FALSE(path0.empty()); |
86 | 171 |
87 EXPECT_TRUE(file_util::PathExists(kDBFile)); | 172 EXPECT_TRUE(file_util::PathExists(kFSDir.Append(kOriginDatabaseName))); |
88 | 173 |
89 database.DropDatabase(); | 174 database.DropDatabase(); |
90 | 175 |
91 FilePath path1; | 176 FilePath path1; |
92 EXPECT_TRUE(database.HasOriginPath(origin)); | 177 EXPECT_TRUE(database.HasOriginPath(origin)); |
93 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 178 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
94 EXPECT_FALSE(path1.empty()); | 179 EXPECT_FALSE(path1.empty()); |
95 EXPECT_EQ(path0, path1); | 180 EXPECT_EQ(path0, path1); |
96 } | 181 } |
97 | 182 |
98 TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) { | 183 TEST(FileSystemOriginDatabaseTest, DeleteOriginTest) { |
99 ScopedTempDir dir; | 184 ScopedTempDir dir; |
100 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 185 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
101 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 186 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
102 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 187 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
188 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
103 | 189 |
104 FileSystemOriginDatabase database(kDBFile); | 190 FileSystemOriginDatabase database(kFSDir); |
105 std::string origin("origin"); | 191 std::string origin("origin"); |
106 | 192 |
107 EXPECT_FALSE(database.HasOriginPath(origin)); | 193 EXPECT_FALSE(database.HasOriginPath(origin)); |
108 EXPECT_TRUE(database.RemovePathForOrigin(origin)); | 194 EXPECT_TRUE(database.RemovePathForOrigin(origin)); |
109 | 195 |
110 FilePath path0; | 196 FilePath path0; |
111 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); | 197 EXPECT_TRUE(database.GetPathForOrigin(origin, &path0)); |
112 EXPECT_TRUE(database.HasOriginPath(origin)); | 198 EXPECT_TRUE(database.HasOriginPath(origin)); |
113 EXPECT_FALSE(path0.empty()); | 199 EXPECT_FALSE(path0.empty()); |
114 | 200 |
115 EXPECT_TRUE(database.RemovePathForOrigin(origin)); | 201 EXPECT_TRUE(database.RemovePathForOrigin(origin)); |
116 EXPECT_FALSE(database.HasOriginPath(origin)); | 202 EXPECT_FALSE(database.HasOriginPath(origin)); |
117 | 203 |
118 FilePath path1; | 204 FilePath path1; |
119 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); | 205 EXPECT_TRUE(database.GetPathForOrigin(origin, &path1)); |
120 EXPECT_FALSE(path1.empty()); | 206 EXPECT_FALSE(path1.empty()); |
121 EXPECT_NE(path0, path1); | 207 EXPECT_NE(path0, path1); |
122 } | 208 } |
123 | 209 |
124 TEST(FileSystemOriginDatabaseTest, ListOriginsTest) { | 210 TEST(FileSystemOriginDatabaseTest, ListOriginsTest) { |
125 ScopedTempDir dir; | 211 ScopedTempDir dir; |
126 ASSERT_TRUE(dir.CreateUniqueTempDir()); | 212 ASSERT_TRUE(dir.CreateUniqueTempDir()); |
127 const FilePath kDBFile = dir.path().AppendASCII("fsod.db"); | 213 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); |
128 EXPECT_FALSE(file_util::PathExists(kDBFile)); | 214 EXPECT_FALSE(file_util::PathExists(kFSDir)); |
215 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
129 | 216 |
130 std::vector<FileSystemOriginDatabase::OriginRecord> origins; | 217 std::vector<FileSystemOriginDatabase::OriginRecord> origins; |
131 | 218 |
132 FileSystemOriginDatabase database(kDBFile); | 219 FileSystemOriginDatabase database(kFSDir); |
133 EXPECT_TRUE(database.ListAllOrigins(&origins)); | 220 EXPECT_TRUE(database.ListAllOrigins(&origins)); |
134 EXPECT_TRUE(origins.empty()); | 221 EXPECT_TRUE(origins.empty()); |
135 origins.clear(); | 222 origins.clear(); |
136 | 223 |
137 std::string origin0("origin0"); | 224 std::string origin0("origin0"); |
138 std::string origin1("origin1"); | 225 std::string origin1("origin1"); |
139 | 226 |
140 EXPECT_FALSE(database.HasOriginPath(origin0)); | 227 EXPECT_FALSE(database.HasOriginPath(origin0)); |
141 EXPECT_FALSE(database.HasOriginPath(origin1)); | 228 EXPECT_FALSE(database.HasOriginPath(origin1)); |
142 | 229 |
(...skipping 13 matching lines...) Expand all Loading... | |
156 EXPECT_EQ(origins[1].origin, origin1); | 243 EXPECT_EQ(origins[1].origin, origin1); |
157 EXPECT_EQ(origins[1].path, path1); | 244 EXPECT_EQ(origins[1].path, path1); |
158 } else { | 245 } else { |
159 EXPECT_EQ(origins[0].origin, origin1); | 246 EXPECT_EQ(origins[0].origin, origin1); |
160 EXPECT_EQ(origins[0].path, path1); | 247 EXPECT_EQ(origins[0].path, path1); |
161 EXPECT_EQ(origins[1].origin, origin0); | 248 EXPECT_EQ(origins[1].origin, origin0); |
162 EXPECT_EQ(origins[1].path, path0); | 249 EXPECT_EQ(origins[1].path, path0); |
163 } | 250 } |
164 } | 251 } |
165 | 252 |
253 TEST(FileSystemOriginDatabaseTest, DatabaseRecoveryTest) { | |
254 ScopedTempDir dir; | |
255 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
256 const FilePath kFSDir = dir.path().Append(kFileSystemDirName); | |
257 const FilePath kDBDir = kFSDir.Append(kOriginDatabaseName); | |
258 EXPECT_FALSE(file_util::PathExists(kFSDir)); | |
259 EXPECT_TRUE(file_util::CreateDirectory(kFSDir)); | |
260 | |
261 const std::string kOrigins[] = { | |
262 "foo.example.com", | |
263 "bar.example.com", | |
264 "baz.example.com", | |
265 "hoge.example.com", | |
266 "fuga.example.com", | |
267 }; | |
268 | |
269 scoped_ptr<FileSystemOriginDatabase> database( | |
270 new FileSystemOriginDatabase(kFSDir)); | |
271 for (size_t i = 0; i < arraysize(kOrigins); ++i) { | |
272 FilePath path; | |
273 EXPECT_FALSE(database->HasOriginPath(kOrigins[i])); | |
274 EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path)); | |
275 EXPECT_FALSE(path.empty()); | |
276 EXPECT_TRUE(database->GetPathForOrigin(kOrigins[i], &path)); | |
277 | |
278 if (i != 1) | |
279 EXPECT_TRUE(file_util::CreateDirectory(kFSDir.Append(path))); | |
280 } | |
281 database->RemovePathForOrigin(kOrigins[0]); | |
282 database.reset(); | |
283 | |
284 const FilePath kGarbageDir = kFSDir.AppendASCII("foo"); | |
285 const FilePath kGarbageFile = kGarbageDir.AppendASCII("bar"); | |
286 EXPECT_TRUE(file_util::CreateDirectory(kGarbageDir)); | |
287 bool created = false; | |
288 base::PlatformFileError error; | |
289 base::PlatformFile file = base::CreatePlatformFile( | |
290 kGarbageFile, | |
291 base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE, | |
292 &created, &error); | |
293 EXPECT_EQ(base::PLATFORM_FILE_OK, error); | |
294 EXPECT_TRUE(created); | |
295 EXPECT_TRUE(base::ClosePlatformFile(file)); | |
296 | |
297 CorruptDatabase(kDBDir, leveldb::kDescriptorFile, 0, 100); | |
298 | |
299 const std::string kOrigin("piyo.example.org"); | |
300 FilePath path; | |
301 database.reset(new FileSystemOriginDatabase(kFSDir)); | |
302 std::vector<FileSystemOriginDatabase::OriginRecord> origins_in_db; | |
303 EXPECT_TRUE(database->ListAllOrigins(&origins_in_db)); | |
304 EXPECT_EQ(arraysize(kOrigins) - 2, origins_in_db.size()); | |
305 | |
306 EXPECT_FALSE(database->HasOriginPath(kOrigin)); | |
307 EXPECT_TRUE(database->GetPathForOrigin(kOrigin, &path)); | |
308 EXPECT_FALSE(path.empty()); | |
309 EXPECT_TRUE(database->HasOriginPath(kOrigin)); | |
310 | |
311 EXPECT_FALSE(file_util::PathExists(kGarbageFile)); | |
312 EXPECT_FALSE(file_util::PathExists(kGarbageDir)); | |
313 } | |
314 | |
166 } // namespace fileapi | 315 } // namespace fileapi |
OLD | NEW |