diff options
Diffstat (limited to 'chromium/content/browser/fileapi/external_mount_points_unittest.cc')
-rw-r--r-- | chromium/content/browser/fileapi/external_mount_points_unittest.cc | 515 |
1 files changed, 515 insertions, 0 deletions
diff --git a/chromium/content/browser/fileapi/external_mount_points_unittest.cc b/chromium/content/browser/fileapi/external_mount_points_unittest.cc new file mode 100644 index 00000000000..fa0d1f5bbc2 --- /dev/null +++ b/chromium/content/browser/fileapi/external_mount_points_unittest.cc @@ -0,0 +1,515 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "webkit/browser/fileapi/external_mount_points.h" + +#include <string> + +#include "base/files/file_path.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "webkit/browser/fileapi/file_system_url.h" + +#define FPL FILE_PATH_LITERAL + +#if defined(FILE_PATH_USES_DRIVE_LETTERS) +#define DRIVE FPL("C:") +#else +#define DRIVE +#endif + +using fileapi::FileSystemURL; + +namespace content { + +TEST(ExternalMountPointsTest, AddMountPoint) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + struct TestCase { + // The mount point's name. + const char* const name; + // The mount point's path. + const base::FilePath::CharType* const path; + // Whether the mount point registration should succeed. + bool success; + // Path returned by GetRegisteredPath. NULL if the method is expected to + // fail. + const base::FilePath::CharType* const registered_path; + }; + + const TestCase kTestCases[] = { + // Valid mount point. + { "test", DRIVE FPL("/foo/test"), true, DRIVE FPL("/foo/test") }, + // Valid mount point with only one path component. + { "bbb", DRIVE FPL("/bbb"), true, DRIVE FPL("/bbb") }, + // Existing mount point path is substring of the mount points path. + { "test11", DRIVE FPL("/foo/test11"), true, DRIVE FPL("/foo/test11") }, + // Path substring of an existing path. + { "test1", DRIVE FPL("/foo/test1"), true, DRIVE FPL("/foo/test1") }, + // Empty mount point name and path. + { "", DRIVE FPL(""), false, NULL }, + // Empty mount point name. + { "", DRIVE FPL("/ddd"), false, NULL }, + // Empty mount point path. + { "empty_path", FPL(""), true, FPL("") }, + // Name different from path's base name. + { "not_base_name", DRIVE FPL("/x/y/z"), true, DRIVE FPL("/x/y/z") }, + // References parent. + { "invalid", DRIVE FPL("../foo/invalid"), false, NULL }, + // Relative path. + { "relative", DRIVE FPL("foo/relative"), false, NULL }, + // Existing mount point path. + { "path_exists", DRIVE FPL("/foo/test"), false, NULL }, + // Mount point with the same name exists. + { "test", DRIVE FPL("/foo/a/test_name_exists"), false, + DRIVE FPL("/foo/test") }, + // Child of an existing mount point. + { "a1", DRIVE FPL("/foo/test/a"), false, NULL }, + // Parent of an existing mount point. + { "foo1", DRIVE FPL("/foo"), false, NULL }, + // Bit bigger depth. + { "g", DRIVE FPL("/foo/a/b/c/d/e/f/g"), true, + DRIVE FPL("/foo/a/b/c/d/e/f/g") }, + // Sibling mount point (with similar name) exists. + { "ff", DRIVE FPL("/foo/a/b/c/d/e/ff"), true, + DRIVE FPL("/foo/a/b/c/d/e/ff") }, + // Lexicographically last among existing mount points. + { "yyy", DRIVE FPL("/zzz/yyy"), true, DRIVE FPL("/zzz/yyy") }, + // Parent of the lexicographically last mount point. + { "zzz1", DRIVE FPL("/zzz"), false, NULL }, + // Child of the lexicographically last mount point. + { "xxx1", DRIVE FPL("/zzz/yyy/xxx"), false, NULL }, + // Lexicographically first among existing mount points. + { "b", DRIVE FPL("/a/b"), true, DRIVE FPL("/a/b") }, + // Parent of lexicographically first mount point. + { "a2", DRIVE FPL("/a"), false, NULL }, + // Child of lexicographically last mount point. + { "c1", DRIVE FPL("/a/b/c"), false, NULL }, + // Parent to all of the mount points. + { "root", DRIVE FPL("/"), false, NULL }, + // Path contains .. component. + { "funky", DRIVE FPL("/tt/fun/../funky"), false, NULL }, + // Windows separators. +#if defined(FILE_PATH_USES_WIN_SEPARATORS) + { "win", DRIVE FPL("\\try\\separators\\win"), true, + DRIVE FPL("\\try\\separators\\win") }, + { "win1", DRIVE FPL("\\try/separators\\win1"), true, + DRIVE FPL("\\try/separators\\win1") }, + { "win2", DRIVE FPL("\\try/separators\\win"), false, NULL }, +#else + { "win", DRIVE FPL("\\separators\\win"), false, NULL }, + { "win1", DRIVE FPL("\\try/separators\\win1"), false, NULL }, +#endif + // Win separators, but relative path. + { "win2", DRIVE FPL("try\\separators\\win2"), false, NULL }, + }; + + // Test adding mount points. + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) { + EXPECT_EQ(kTestCases[i].success, + mount_points->RegisterFileSystem( + kTestCases[i].name, + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(kTestCases[i].path))) + << "Adding mount point: " << kTestCases[i].name << " with path " + << kTestCases[i].path; + } + + // Test that final mount point presence state is as expected. + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) { + base::FilePath found_path; + EXPECT_EQ(kTestCases[i].registered_path != NULL, + mount_points->GetRegisteredPath(kTestCases[i].name, &found_path)) + << "Test case: " << i; + + if (kTestCases[i].registered_path) { + base::FilePath expected_path(kTestCases[i].registered_path); + EXPECT_EQ(expected_path.NormalizePathSeparators(), found_path); + } + } +} + +TEST(ExternalMountPointsTest, GetVirtualPath) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + mount_points->RegisterFileSystem("c", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c"))); + // Note that "/a/b/c" < "/a/b/c(1)" < "/a/b/c/". + mount_points->RegisterFileSystem("c(1)", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c(1)"))); + mount_points->RegisterFileSystem("x", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/z/y/x"))); + mount_points->RegisterFileSystem("o", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/m/n/o"))); + // A mount point whose name does not match its path base name. + mount_points->RegisterFileSystem("mount", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/root/foo"))); + // A mount point with an empty path. + mount_points->RegisterFileSystem("empty_path", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath()); + + struct TestCase { + const base::FilePath::CharType* const local_path; + bool success; + const base::FilePath::CharType* const virtual_path; + }; + + const TestCase kTestCases[] = { + // Empty path. + { FPL(""), false, FPL("") }, + // No registered mount point (but is parent to a mount point). + { DRIVE FPL("/a/b"), false, FPL("") }, + // No registered mount point (but is parent to a mount point). + { DRIVE FPL("/z/y"), false, FPL("") }, + // No registered mount point (but is parent to a mount point). + { DRIVE FPL("/m/n"), false, FPL("") }, + // No registered mount point. + { DRIVE FPL("/foo/mount"), false, FPL("") }, + // An existing mount point path is substring. + { DRIVE FPL("/a/b/c1"), false, FPL("") }, + // No leading /. + { DRIVE FPL("a/b/c"), false, FPL("") }, + // Sibling to a root path. + { DRIVE FPL("/a/b/d/e"), false, FPL("") }, + // Sibling to a root path. + { DRIVE FPL("/z/y/v/u"), false, FPL("") }, + // Sibling to a root path. + { DRIVE FPL("/m/n/p/q"), false, FPL("") }, + // Mount point root path. + { DRIVE FPL("/a/b/c"), true, FPL("c") }, + // Mount point root path. + { DRIVE FPL("/z/y/x"), true, FPL("x") }, + // Mount point root path. + { DRIVE FPL("/m/n/o"), true, FPL("o") }, + // Mount point child path. + { DRIVE FPL("/a/b/c/d/e"), true, FPL("c/d/e") }, + // Mount point child path. + { DRIVE FPL("/z/y/x/v/u"), true, FPL("x/v/u") }, + // Mount point child path. + { DRIVE FPL("/m/n/o/p/q"), true, FPL("o/p/q") }, + // Name doesn't match mount point path base name. + { DRIVE FPL("/root/foo/a/b/c"), true, FPL("mount/a/b/c") }, + { DRIVE FPL("/root/foo"), true, FPL("mount") }, + // Mount point contains character whose ASCII code is smaller than file path + // separator's. + { DRIVE FPL("/a/b/c(1)/d/e"), true, FPL("c(1)/d/e") }, +#if defined(FILE_PATH_USES_WIN_SEPARATORS) + // Path with win separators mixed in. + { DRIVE FPL("/a\\b\\c/d"), true, FPL("c/d") }, +#endif + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) { + // Initialize virtual path with a value. + base::FilePath virtual_path(DRIVE FPL("/mount")); + base::FilePath local_path(kTestCases[i].local_path); + EXPECT_EQ(kTestCases[i].success, + mount_points->GetVirtualPath(local_path, &virtual_path)) + << "Resolving " << kTestCases[i].local_path; + + // There are no guarantees for |virtual_path| value if |GetVirtualPath| + // fails. + if (!kTestCases[i].success) + continue; + + base::FilePath expected_virtual_path(kTestCases[i].virtual_path); + EXPECT_EQ(expected_virtual_path.NormalizePathSeparators(), virtual_path) + << "Resolving " << kTestCases[i].local_path; + } +} + +TEST(ExternalMountPointsTest, HandlesFileSystemMountType) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + const GURL test_origin("http://chromium.org"); + const base::FilePath test_path(FPL("/mount")); + + // Should handle External File System. + EXPECT_TRUE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeExternal)); + + // Shouldn't handle the rest. + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeIsolated)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeTemporary)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypePersistent)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeTest)); + // Not even if it's external subtype. + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeNativeLocal)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeRestrictedNativeLocal)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeDrive)); + EXPECT_FALSE(mount_points->HandlesFileSystemMountType( + fileapi::kFileSystemTypeSyncable)); +} + +TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + const GURL kTestOrigin("http://chromium.org"); + + mount_points->RegisterFileSystem("c", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c"))); + mount_points->RegisterFileSystem("c(1)", + fileapi::kFileSystemTypeDrive, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c(1)"))); + mount_points->RegisterFileSystem("empty_path", + fileapi::kFileSystemTypeSyncable, + fileapi::FileSystemMountOption(), + base::FilePath()); + mount_points->RegisterFileSystem("mount", + fileapi::kFileSystemTypeDrive, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/root"))); + + // Try cracking invalid GURL. + FileSystemURL invalid = mount_points->CrackURL(GURL("http://chromium.og")); + EXPECT_FALSE(invalid.is_valid()); + + // Try cracking isolated path. + FileSystemURL isolated = mount_points->CreateCrackedFileSystemURL( + kTestOrigin, fileapi::kFileSystemTypeIsolated, base::FilePath(FPL("c"))); + EXPECT_FALSE(isolated.is_valid()); + + // Try native local which is not cracked. + FileSystemURL native_local = mount_points->CreateCrackedFileSystemURL( + kTestOrigin, + fileapi::kFileSystemTypeNativeLocal, + base::FilePath(FPL("c"))); + EXPECT_FALSE(native_local.is_valid()); + + struct TestCase { + const base::FilePath::CharType* const path; + bool expect_valid; + fileapi::FileSystemType expect_type; + const base::FilePath::CharType* const expect_path; + const char* const expect_fs_id; + }; + + const TestCase kTestCases[] = { + { FPL("c/d/e"), + true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" }, + { FPL("c(1)/d/e"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" }, + { FPL("c(1)"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" }, + { FPL("empty_path/a"), + true, fileapi::kFileSystemTypeSyncable, FPL("a"), "empty_path" }, + { FPL("empty_path"), + true, fileapi::kFileSystemTypeSyncable, FPL(""), "empty_path" }, + { FPL("mount/a/b"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" }, + { FPL("mount"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root"), "mount" }, + { FPL("cc"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL(""), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL(".."), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + // Absolte paths. + { FPL("/c/d/e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/c(1)/d/e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/empty_path"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + // PAth references parent. + { FPL("c/d/../e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/empty_path/a/../b"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, +#if defined(FILE_PATH_USES_WIN_SEPARATORS) + { FPL("c/d\\e"), + true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" }, + { FPL("mount\\a\\b"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" }, +#endif + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) { + FileSystemURL cracked = mount_points->CreateCrackedFileSystemURL( + kTestOrigin, + fileapi::kFileSystemTypeExternal, + base::FilePath(kTestCases[i].path)); + + EXPECT_EQ(kTestCases[i].expect_valid, cracked.is_valid()) + << "Test case index: " << i; + + if (!kTestCases[i].expect_valid) + continue; + + EXPECT_EQ(kTestOrigin, cracked.origin()) + << "Test case index: " << i; + EXPECT_EQ(kTestCases[i].expect_type, cracked.type()) + << "Test case index: " << i; + EXPECT_EQ(base::FilePath( + kTestCases[i].expect_path).NormalizePathSeparators(), cracked.path()) + << "Test case index: " << i; + EXPECT_EQ(base::FilePath(kTestCases[i].path).NormalizePathSeparators(), + cracked.virtual_path()) + << "Test case index: " << i; + EXPECT_EQ(kTestCases[i].expect_fs_id, cracked.filesystem_id()) + << "Test case index: " << i; + EXPECT_EQ(fileapi::kFileSystemTypeExternal, cracked.mount_type()) + << "Test case index: " << i; + } +} + +TEST(ExternalMountPointsTest, CrackVirtualPath) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + const GURL kTestOrigin("http://chromium.org"); + + mount_points->RegisterFileSystem("c", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c"))); + mount_points->RegisterFileSystem("c(1)", + fileapi::kFileSystemTypeDrive, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/a/b/c(1)"))); + mount_points->RegisterFileSystem("empty_path", + fileapi::kFileSystemTypeSyncable, + fileapi::FileSystemMountOption(), + base::FilePath()); + mount_points->RegisterFileSystem("mount", + fileapi::kFileSystemTypeDrive, + fileapi::FileSystemMountOption(), + base::FilePath(DRIVE FPL("/root"))); + + struct TestCase { + const base::FilePath::CharType* const path; + bool expect_valid; + fileapi::FileSystemType expect_type; + const base::FilePath::CharType* const expect_path; + const char* const expect_name; + }; + + const TestCase kTestCases[] = { + { FPL("c/d/e"), + true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" }, + { FPL("c(1)/d/e"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" }, + { FPL("c(1)"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" }, + { FPL("empty_path/a"), + true, fileapi::kFileSystemTypeSyncable, FPL("a"), "empty_path" }, + { FPL("empty_path"), + true, fileapi::kFileSystemTypeSyncable, FPL(""), "empty_path" }, + { FPL("mount/a/b"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" }, + { FPL("mount"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root"), "mount" }, + { FPL("cc"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL(""), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL(".."), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + // Absolte paths. + { FPL("/c/d/e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/c(1)/d/e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/empty_path"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + // PAth references parent. + { FPL("c/d/../e"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, + { FPL("/empty_path/a/../b"), + false, fileapi::kFileSystemTypeUnknown, FPL(""), "" }, +#if defined(FILE_PATH_USES_WIN_SEPARATORS) + { FPL("c/d\\e"), + true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" }, + { FPL("mount\\a\\b"), + true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" }, +#endif + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) { + std::string cracked_name; + fileapi::FileSystemType cracked_type; + std::string cracked_id; + base::FilePath cracked_path; + fileapi::FileSystemMountOption cracked_option; + EXPECT_EQ(kTestCases[i].expect_valid, + mount_points->CrackVirtualPath(base::FilePath(kTestCases[i].path), + &cracked_name, &cracked_type, &cracked_id, &cracked_path, + &cracked_option)) + << "Test case index: " << i; + + if (!kTestCases[i].expect_valid) + continue; + + EXPECT_EQ(kTestCases[i].expect_type, cracked_type) + << "Test case index: " << i; + EXPECT_EQ(base::FilePath( + kTestCases[i].expect_path).NormalizePathSeparators(), cracked_path) + << "Test case index: " << i; + EXPECT_EQ(kTestCases[i].expect_name, cracked_name) + << "Test case index: " << i; + // As of now we don't mount other filesystems with non-empty filesystem_id + // onto external mount points. + EXPECT_TRUE(cracked_id.empty()) << "Test case index: " << i; + } +} + +TEST(ExternalMountPointsTest, MountOption) { + scoped_refptr<fileapi::ExternalMountPoints> mount_points( + fileapi::ExternalMountPoints::CreateRefCounted()); + + mount_points->RegisterFileSystem( + "nosync", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(fileapi::COPY_SYNC_OPTION_NO_SYNC), + base::FilePath(DRIVE FPL("/nosync"))); + mount_points->RegisterFileSystem( + "sync", + fileapi::kFileSystemTypeNativeLocal, + fileapi::FileSystemMountOption(fileapi::COPY_SYNC_OPTION_SYNC), + base::FilePath(DRIVE FPL("/sync"))); + + std::string name; + fileapi::FileSystemType type; + std::string cracked_id; + fileapi::FileSystemMountOption option; + base::FilePath path; + EXPECT_TRUE(mount_points->CrackVirtualPath( + base::FilePath(FPL("nosync/file")), &name, &type, &cracked_id, &path, + &option)); + EXPECT_EQ(fileapi::COPY_SYNC_OPTION_NO_SYNC, option.copy_sync_option()); + EXPECT_TRUE(mount_points->CrackVirtualPath( + base::FilePath(FPL("sync/file")), &name, &type, &cracked_id, &path, + &option)); + EXPECT_EQ(fileapi::COPY_SYNC_OPTION_SYNC, option.copy_sync_option()); +} + +} // namespace content + |