1// Copyright 2013 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 <map>
6#include <queue>
7#include <set>
8#include <string>
9#include <vector>
10
11#include "base/files/file_enumerator.h"
12#include "base/files/file_util.h"
13#include "base/files/scoped_temp_dir.h"
14#include "base/logging.h"
15#include "base/message_loop/message_loop.h"
16#include "base/message_loop/message_loop_proxy.h"
17#include "base/time/time.h"
18#include "content/public/test/async_file_test_helper.h"
19#include "content/public/test/test_file_system_context.h"
20#include "content/test/fileapi_test_file_set.h"
21#include "storage/browser/fileapi/dragged_file_util.h"
22#include "storage/browser/fileapi/file_system_context.h"
23#include "storage/browser/fileapi/file_system_operation_context.h"
24#include "storage/browser/fileapi/isolated_context.h"
25#include "storage/browser/fileapi/local_file_util.h"
26#include "storage/browser/fileapi/native_file_util.h"
27#include "testing/gtest/include/gtest/gtest.h"
28
29using content::AsyncFileTestHelper;
30using storage::FileSystemContext;
31using storage::FileSystemOperationContext;
32using storage::FileSystemType;
33using storage::FileSystemURL;
34
35namespace content {
36
37namespace {
38
39typedef AsyncFileTestHelper::FileEntryList FileEntryList;
40
41// Used in DraggedFileUtilTest::SimulateDropFiles().
42// Random root paths in which we create each file/directory of the
43// RegularTestCases (so that we can simulate a drop with files/directories
44// from multiple directories).
45static const base::FilePath::CharType* kRootPaths[] = {
46  FILE_PATH_LITERAL("a"),
47  FILE_PATH_LITERAL("b/c"),
48  FILE_PATH_LITERAL("etc"),
49};
50
51base::FilePath GetTopLevelPath(const base::FilePath& path) {
52  std::vector<base::FilePath::StringType> components;
53  path.GetComponents(&components);
54  return base::FilePath(components[0]);
55}
56
57bool IsDirectoryEmpty(FileSystemContext* context, const FileSystemURL& url) {
58  FileEntryList entries;
59  EXPECT_EQ(base::File::FILE_OK,
60            AsyncFileTestHelper::ReadDirectory(context, url, &entries));
61  return entries.empty();
62}
63
64FileSystemURL GetEntryURL(FileSystemContext* file_system_context,
65                          const FileSystemURL& dir,
66                          const base::FilePath::StringType& name) {
67  return file_system_context->CreateCrackedFileSystemURL(
68      dir.origin(),
69      dir.mount_type(),
70      dir.virtual_path().Append(name));
71}
72
73base::FilePath GetRelativeVirtualPath(const FileSystemURL& root,
74                                      const FileSystemURL& url) {
75  if (root.virtual_path().empty())
76    return url.virtual_path();
77  base::FilePath relative;
78  const bool success = root.virtual_path().AppendRelativePath(
79      url.virtual_path(), &relative);
80  DCHECK(success);
81  return relative;
82}
83
84FileSystemURL GetOtherURL(FileSystemContext* file_system_context,
85                          const FileSystemURL& root,
86                          const FileSystemURL& other_root,
87                          const FileSystemURL& url) {
88  return file_system_context->CreateCrackedFileSystemURL(
89      other_root.origin(),
90      other_root.mount_type(),
91      other_root.virtual_path().Append(GetRelativeVirtualPath(root, url)));
92}
93
94}  // namespace
95
96class DraggedFileUtilTest : public testing::Test {
97 public:
98  DraggedFileUtilTest() {}
99
100  virtual void SetUp() {
101    ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
102    ASSERT_TRUE(partition_dir_.CreateUniqueTempDir());
103    file_util_.reset(new storage::DraggedFileUtil());
104
105    // Register the files/directories of RegularTestCases (with random
106    // root paths) as dropped files.
107    SimulateDropFiles();
108
109    file_system_context_ = CreateFileSystemContextForTesting(
110        NULL /* quota_manager */,
111        partition_dir_.path());
112
113    isolated_context()->AddReference(filesystem_id_);
114  }
115
116  virtual void TearDown() {
117    isolated_context()->RemoveReference(filesystem_id_);
118  }
119
120 protected:
121  storage::IsolatedContext* isolated_context() const {
122    return storage::IsolatedContext::GetInstance();
123  }
124  const base::FilePath& root_path() const {
125    return data_dir_.path();
126  }
127  FileSystemContext* file_system_context() const {
128    return file_system_context_.get();
129  }
130  storage::FileSystemFileUtil* file_util() const { return file_util_.get(); }
131  std::string filesystem_id() const { return filesystem_id_; }
132
133  base::FilePath GetTestCasePlatformPath(
134      const base::FilePath::StringType& path) {
135    return toplevel_root_map_[GetTopLevelPath(base::FilePath(path))]
136        .Append(path).NormalizePathSeparators();
137  }
138
139  base::FilePath GetTestCaseLocalPath(const base::FilePath& path) {
140    base::FilePath relative;
141    if (data_dir_.path().AppendRelativePath(path, &relative))
142      return relative;
143    return path;
144  }
145
146  FileSystemURL GetFileSystemURL(const base::FilePath& path) const {
147    base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(
148        filesystem_id()).Append(path);
149    return file_system_context_->CreateCrackedFileSystemURL(
150        GURL("http://example.com"),
151        storage::kFileSystemTypeIsolated,
152        virtual_path);
153  }
154
155  FileSystemURL GetOtherFileSystemURL(const base::FilePath& path) const {
156    return file_system_context()->CreateCrackedFileSystemURL(
157        GURL("http://example.com"),
158        storage::kFileSystemTypeTemporary,
159        base::FilePath().AppendASCII("dest").Append(path));
160  }
161
162  void VerifyFilesHaveSameContent(const FileSystemURL& url1,
163                                  const FileSystemURL& url2) {
164    // Get the file info and the platform path for url1.
165    base::File::Info info1;
166    ASSERT_EQ(base::File::FILE_OK,
167              AsyncFileTestHelper::GetMetadata(
168                  file_system_context(), url1, &info1));
169    base::FilePath platform_path1;
170    ASSERT_EQ(base::File::FILE_OK,
171              AsyncFileTestHelper::GetPlatformPath(
172                  file_system_context(), url1, &platform_path1));
173
174    // Get the file info and the platform path  for url2.
175    base::File::Info info2;
176    ASSERT_EQ(base::File::FILE_OK,
177              AsyncFileTestHelper::GetMetadata(
178                  file_system_context(), url2, &info2));
179    base::FilePath platform_path2;
180    ASSERT_EQ(base::File::FILE_OK,
181              AsyncFileTestHelper::GetPlatformPath(
182                  file_system_context(), url2, &platform_path2));
183
184    // See if file info matches with the other one.
185    EXPECT_EQ(info1.is_directory, info2.is_directory);
186    EXPECT_EQ(info1.size, info2.size);
187    EXPECT_EQ(info1.is_symbolic_link, info2.is_symbolic_link);
188    EXPECT_NE(platform_path1, platform_path2);
189
190    std::string content1, content2;
191    EXPECT_TRUE(base::ReadFileToString(platform_path1, &content1));
192    EXPECT_TRUE(base::ReadFileToString(platform_path2, &content2));
193    EXPECT_EQ(content1, content2);
194  }
195
196  void VerifyDirectoriesHaveSameContent(const FileSystemURL& root1,
197                                        const FileSystemURL& root2) {
198    base::FilePath root_path1 = root1.path();
199    base::FilePath root_path2 = root2.path();
200
201    FileEntryList entries;
202    std::queue<FileSystemURL> directories;
203
204    directories.push(root1);
205    std::set<base::FilePath> file_set1;
206    while (!directories.empty()) {
207      FileSystemURL dir = directories.front();
208      directories.pop();
209
210      ASSERT_EQ(base::File::FILE_OK,
211                AsyncFileTestHelper::ReadDirectory(
212                    file_system_context(), dir, &entries));
213      for (size_t i = 0; i < entries.size(); ++i) {
214        FileSystemURL url = GetEntryURL(file_system_context(),
215                                        dir, entries[i].name);
216        if (entries[i].is_directory) {
217          directories.push(url);
218          continue;
219        }
220        file_set1.insert(GetRelativeVirtualPath(root1, url));
221      }
222    }
223
224    directories.push(root2);
225    while (!directories.empty()) {
226      FileSystemURL dir = directories.front();
227      directories.pop();
228
229      ASSERT_EQ(base::File::FILE_OK,
230                AsyncFileTestHelper::ReadDirectory(
231                    file_system_context(), dir, &entries));
232      for (size_t i = 0; i < entries.size(); ++i) {
233        FileSystemURL url2 = GetEntryURL(file_system_context(),
234                                         dir, entries[i].name);
235        FileSystemURL url1 = GetOtherURL(file_system_context(),
236                                         root2, root1, url2);
237        if (entries[i].is_directory) {
238          directories.push(url2);
239          EXPECT_EQ(IsDirectoryEmpty(file_system_context(), url1),
240                    IsDirectoryEmpty(file_system_context(), url2));
241          continue;
242        }
243        base::FilePath relative = GetRelativeVirtualPath(root2, url2);
244        EXPECT_TRUE(file_set1.find(relative) != file_set1.end());
245        VerifyFilesHaveSameContent(url1, url2);
246      }
247    }
248  }
249
250  scoped_ptr<storage::FileSystemOperationContext> GetOperationContext() {
251    return make_scoped_ptr(new storage::FileSystemOperationContext(
252                               file_system_context())).Pass();
253  }
254
255
256 private:
257  void SimulateDropFiles() {
258    size_t root_path_index = 0;
259
260    storage::IsolatedContext::FileInfoSet toplevels;
261    for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
262      const FileSystemTestCaseRecord& test_case =
263          kRegularFileSystemTestCases[i];
264      base::FilePath path(test_case.path);
265      base::FilePath toplevel = GetTopLevelPath(path);
266
267      // We create the test case files under one of the kRootPaths
268      // to simulate a drop with multiple directories.
269      if (toplevel_root_map_.find(toplevel) == toplevel_root_map_.end()) {
270        base::FilePath root = root_path().Append(
271            kRootPaths[(root_path_index++) % arraysize(kRootPaths)]);
272        toplevel_root_map_[toplevel] = root;
273        toplevels.AddPath(root.Append(path), NULL);
274      }
275
276      SetUpOneFileSystemTestCase(toplevel_root_map_[toplevel], test_case);
277    }
278
279    // Register the toplevel entries.
280    filesystem_id_ = isolated_context()->RegisterDraggedFileSystem(toplevels);
281  }
282
283  base::ScopedTempDir data_dir_;
284  base::ScopedTempDir partition_dir_;
285  base::MessageLoopForIO message_loop_;
286  std::string filesystem_id_;
287  scoped_refptr<FileSystemContext> file_system_context_;
288  std::map<base::FilePath, base::FilePath> toplevel_root_map_;
289  scoped_ptr<storage::DraggedFileUtil> file_util_;
290  DISALLOW_COPY_AND_ASSIGN(DraggedFileUtilTest);
291};
292
293TEST_F(DraggedFileUtilTest, BasicTest) {
294  for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
295    SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i);
296    const FileSystemTestCaseRecord& test_case =
297        kRegularFileSystemTestCases[i];
298
299    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
300
301    // See if we can query the file info via the isolated FileUtil.
302    // (This should succeed since we have registered all the top-level
303    // entries of the test cases in SetUp())
304    base::File::Info info;
305    base::FilePath platform_path;
306    FileSystemOperationContext context(file_system_context());
307    ASSERT_EQ(base::File::FILE_OK,
308              file_util()->GetFileInfo(&context, url, &info, &platform_path));
309
310    // See if the obtained file info is correct.
311    if (!test_case.is_directory)
312      ASSERT_EQ(test_case.data_file_size, info.size);
313    ASSERT_EQ(test_case.is_directory, info.is_directory);
314    ASSERT_EQ(GetTestCasePlatformPath(test_case.path),
315              platform_path.NormalizePathSeparators());
316  }
317}
318
319TEST_F(DraggedFileUtilTest, UnregisteredPathsTest) {
320  static const FileSystemTestCaseRecord kUnregisteredCases[] = {
321    {true, FILE_PATH_LITERAL("nonexistent"), 0},
322    {true, FILE_PATH_LITERAL("nonexistent/dir foo"), 0},
323    {false, FILE_PATH_LITERAL("nonexistent/false"), 0},
324    {false, FILE_PATH_LITERAL("foo"), 30},
325    {false, FILE_PATH_LITERAL("bar"), 20},
326  };
327
328  for (size_t i = 0; i < arraysize(kUnregisteredCases); ++i) {
329    SCOPED_TRACE(testing::Message() << "Creating kUnregisteredCases " << i);
330    const FileSystemTestCaseRecord& test_case = kUnregisteredCases[i];
331
332    // Prepare the test file/directory.
333    SetUpOneFileSystemTestCase(root_path(), test_case);
334
335    // Make sure regular GetFileInfo succeeds.
336    base::File::Info info;
337    ASSERT_TRUE(base::GetFileInfo(root_path().Append(test_case.path), &info));
338    if (!test_case.is_directory)
339      ASSERT_EQ(test_case.data_file_size, info.size);
340    ASSERT_EQ(test_case.is_directory, info.is_directory);
341  }
342
343  for (size_t i = 0; i < arraysize(kUnregisteredCases); ++i) {
344    SCOPED_TRACE(testing::Message() << "Creating kUnregisteredCases " << i);
345    const FileSystemTestCaseRecord& test_case = kUnregisteredCases[i];
346    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
347
348    // We should not be able to get the valid URL for unregistered files.
349    ASSERT_FALSE(url.is_valid());
350  }
351}
352
353TEST_F(DraggedFileUtilTest, ReadDirectoryTest) {
354  for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
355    const FileSystemTestCaseRecord& test_case =
356        kRegularFileSystemTestCases[i];
357    if (!test_case.is_directory)
358      continue;
359
360    SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i
361                 << ": " << test_case.path);
362
363    // Read entries in the directory to construct the expected results map.
364    typedef std::map<base::FilePath::StringType, storage::DirectoryEntry>
365        EntryMap;
366    EntryMap expected_entry_map;
367
368    base::FilePath dir_path = GetTestCasePlatformPath(test_case.path);
369    base::FileEnumerator file_enum(
370        dir_path, false /* not recursive */,
371        base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
372    base::FilePath current;
373    while (!(current = file_enum.Next()).empty()) {
374      base::FileEnumerator::FileInfo file_info = file_enum.GetInfo();
375      storage::DirectoryEntry entry;
376      entry.is_directory = file_info.IsDirectory();
377      entry.name = current.BaseName().value();
378      entry.size = file_info.GetSize();
379      entry.last_modified_time = file_info.GetLastModifiedTime();
380      expected_entry_map[entry.name] = entry;
381
382#if defined(OS_POSIX)
383      // Creates a symlink for each file/directory.
384      // They should be ignored by ReadDirectory, so we don't add them
385      // to expected_entry_map.
386      base::CreateSymbolicLink(
387          current,
388          dir_path.Append(current.BaseName().AddExtension(
389              FILE_PATH_LITERAL("link"))));
390#endif
391    }
392
393    // Perform ReadDirectory in the isolated filesystem.
394    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
395    FileEntryList entries;
396    ASSERT_EQ(base::File::FILE_OK,
397              AsyncFileTestHelper::ReadDirectory(
398                  file_system_context(), url, &entries));
399
400    EXPECT_EQ(expected_entry_map.size(), entries.size());
401    for (size_t i = 0; i < entries.size(); ++i) {
402      const storage::DirectoryEntry& entry = entries[i];
403      EntryMap::iterator found = expected_entry_map.find(entry.name);
404      EXPECT_TRUE(found != expected_entry_map.end());
405      EXPECT_EQ(found->second.name, entry.name);
406      EXPECT_EQ(found->second.is_directory, entry.is_directory);
407      EXPECT_EQ(found->second.size, entry.size);
408      EXPECT_EQ(found->second.last_modified_time.ToDoubleT(),
409                entry.last_modified_time.ToDoubleT());
410    }
411  }
412}
413
414TEST_F(DraggedFileUtilTest, GetLocalFilePathTest) {
415  for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
416    const FileSystemTestCaseRecord& test_case =
417        kRegularFileSystemTestCases[i];
418    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
419
420    FileSystemOperationContext context(file_system_context());
421
422    base::FilePath local_file_path;
423    EXPECT_EQ(base::File::FILE_OK,
424              file_util()->GetLocalFilePath(&context, url, &local_file_path));
425    EXPECT_EQ(GetTestCasePlatformPath(test_case.path).value(),
426              local_file_path.value());
427  }
428}
429
430TEST_F(DraggedFileUtilTest, CopyOutFileTest) {
431  FileSystemURL src_root = GetFileSystemURL(base::FilePath());
432  FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
433
434  FileEntryList entries;
435  std::queue<FileSystemURL> directories;
436  directories.push(src_root);
437
438  ASSERT_EQ(base::File::FILE_OK,
439            AsyncFileTestHelper::CreateDirectory(file_system_context(),
440                                                 dest_root));
441
442  while (!directories.empty()) {
443    FileSystemURL dir = directories.front();
444    directories.pop();
445    ASSERT_EQ(base::File::FILE_OK,
446              AsyncFileTestHelper::ReadDirectory(file_system_context(),
447                                                 dir, &entries));
448    for (size_t i = 0; i < entries.size(); ++i) {
449      FileSystemURL src_url = GetEntryURL(file_system_context(),
450                                          dir, entries[i].name);
451      FileSystemURL dest_url = GetOtherURL(file_system_context(),
452                                           src_root, dest_root, src_url);
453
454      if (entries[i].is_directory) {
455        ASSERT_EQ(base::File::FILE_OK,
456                  AsyncFileTestHelper::CreateDirectory(file_system_context(),
457                                                       dest_url));
458        directories.push(src_url);
459        continue;
460      }
461      SCOPED_TRACE(testing::Message() << "Testing file copy "
462                   << src_url.path().value());
463      ASSERT_EQ(base::File::FILE_OK,
464                AsyncFileTestHelper::Copy(file_system_context(),
465                                          src_url, dest_url));
466      VerifyFilesHaveSameContent(src_url, dest_url);
467    }
468  }
469}
470
471TEST_F(DraggedFileUtilTest, CopyOutDirectoryTest) {
472  FileSystemURL src_root = GetFileSystemURL(base::FilePath());
473  FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
474
475  ASSERT_EQ(base::File::FILE_OK,
476            AsyncFileTestHelper::CreateDirectory(file_system_context(),
477                                                 dest_root));
478
479  FileEntryList entries;
480  ASSERT_EQ(base::File::FILE_OK,
481            AsyncFileTestHelper::ReadDirectory(file_system_context(),
482                                               src_root, &entries));
483  for (size_t i = 0; i < entries.size(); ++i) {
484    if (!entries[i].is_directory)
485      continue;
486    FileSystemURL src_url = GetEntryURL(file_system_context(),
487                                        src_root, entries[i].name);
488    FileSystemURL dest_url = GetOtherURL(file_system_context(),
489                                         src_root, dest_root, src_url);
490    SCOPED_TRACE(testing::Message() << "Testing file copy "
491                 << src_url.path().value());
492    ASSERT_EQ(base::File::FILE_OK,
493              AsyncFileTestHelper::Copy(file_system_context(),
494                                        src_url, dest_url));
495    VerifyDirectoriesHaveSameContent(src_url, dest_url);
496  }
497}
498
499TEST_F(DraggedFileUtilTest, TouchTest) {
500  for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
501    const FileSystemTestCaseRecord& test_case =
502        kRegularFileSystemTestCases[i];
503    if (test_case.is_directory)
504      continue;
505    SCOPED_TRACE(testing::Message() << test_case.path);
506    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
507
508    base::Time last_access_time = base::Time::FromTimeT(1000);
509    base::Time last_modified_time = base::Time::FromTimeT(2000);
510
511    EXPECT_EQ(base::File::FILE_OK,
512              file_util()->Touch(GetOperationContext().get(), url,
513                                 last_access_time,
514                                 last_modified_time));
515
516    // Verification.
517    base::File::Info info;
518    base::FilePath platform_path;
519    ASSERT_EQ(base::File::FILE_OK,
520              file_util()->GetFileInfo(GetOperationContext().get(), url,
521                                       &info, &platform_path));
522    EXPECT_EQ(last_access_time.ToTimeT(), info.last_accessed.ToTimeT());
523    EXPECT_EQ(last_modified_time.ToTimeT(), info.last_modified.ToTimeT());
524  }
525}
526
527TEST_F(DraggedFileUtilTest, TruncateTest) {
528  for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
529    const FileSystemTestCaseRecord& test_case =
530        kRegularFileSystemTestCases[i];
531    if (test_case.is_directory)
532      continue;
533
534    SCOPED_TRACE(testing::Message() << test_case.path);
535    FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
536
537    // Truncate to 0.
538    base::File::Info info;
539    base::FilePath platform_path;
540    EXPECT_EQ(base::File::FILE_OK,
541              file_util()->Truncate(GetOperationContext().get(), url, 0));
542    ASSERT_EQ(base::File::FILE_OK,
543              file_util()->GetFileInfo(GetOperationContext().get(), url,
544                                       &info, &platform_path));
545    EXPECT_EQ(0, info.size);
546
547    // Truncate (extend) to 999.
548    EXPECT_EQ(base::File::FILE_OK,
549              file_util()->Truncate(GetOperationContext().get(), url, 999));
550    ASSERT_EQ(base::File::FILE_OK,
551              file_util()->GetFileInfo(GetOperationContext().get(), url,
552                                       &info, &platform_path));
553    EXPECT_EQ(999, info.size);
554  }
555}
556
557}  // namespace content
558