webkit/fileapi/file_system_mount_point_provider_unittest.cc

   1 // Copyright (c) 2012 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 <set>
   6 #include <string>
   7
   8 #include "base/basictypes.h"
   9 #include "base/bind.h"
  10 #include "base/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/message_loop.h"
  16 #include "base/message_loop_proxy.h"
  17 #include "base/strings/sys_string_conversions.h"
  18 #include "base/utf_string_conversions.h"
  19 #include "googleurl/src/gurl.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "webkit/fileapi/external_mount_points.h"
  22 #include "webkit/fileapi/file_system_context.h"
  23 #include "webkit/fileapi/file_system_task_runners.h"
  24 #include "webkit/fileapi/file_system_url.h"
  25 #include "webkit/fileapi/file_system_util.h"
  26 #include "webkit/fileapi/mock_file_system_options.h"
  27 #include "webkit/fileapi/sandbox_mount_point_provider.h"
  28 #include "webkit/quota/mock_special_storage_policy.h"
  29
  30 #if defined(OS_CHROMEOS)
  31 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
  32 #endif
  33
  34 namespace fileapi {
  35
  36 namespace {
  37
  38 // PS stands for path separator.
  39 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
  40 #define PS  "\\"
  41 #else
  42 #define PS  "/"
  43 #endif
  44
  45 struct RootPathTestCase {
  46   fileapi::FileSystemType type;
  47   const char* origin_url;
  48   const char* expected_path;
  49 };
  50
  51 const struct RootPathTest {
  52   fileapi::FileSystemType type;
  53   const char* origin_url;
  54   const char* expected_path;
  55 } kRootPathTestCases[] = {
  56   { fileapi::kFileSystemTypeTemporary, "http://foo:1/",
  57     "000" PS "t" },
  58   { fileapi::kFileSystemTypePersistent, "http://foo:1/",
  59     "000" PS "p" },
  60   { fileapi::kFileSystemTypeTemporary, "http://bar.com/",
  61     "001" PS "t" },
  62   { fileapi::kFileSystemTypePersistent, "http://bar.com/",
  63     "001" PS "p" },
  64   { fileapi::kFileSystemTypeTemporary, "https://foo:2/",
  65     "002" PS "t" },
  66   { fileapi::kFileSystemTypePersistent, "https://foo:2/",
  67     "002" PS "p" },
  68   { fileapi::kFileSystemTypeTemporary, "https://bar.com/",
  69     "003" PS "t" },
  70   { fileapi::kFileSystemTypePersistent, "https://bar.com/",
  71     "003" PS "p" },
  72 #if defined(OS_CHROMEOS)
  73   { fileapi::kFileSystemTypeExternal, "chrome-extension://foo/",
  74     "chrome-extension__0" /* unused, only for logging */ },
  75 #endif
  76 };
  77
  78 const struct RootPathFileURITest {
  79   fileapi::FileSystemType type;
  80   const char* origin_url;
  81   const char* expected_path;
  82   const char* virtual_path;
  83 } kRootPathFileURITestCases[] = {
  84   { fileapi::kFileSystemTypeTemporary, "file:///",
  85     "000" PS "t", NULL },
  86   { fileapi::kFileSystemTypePersistent, "file:///",
  87     "000" PS "p", NULL },
  88 };
  89
  90 const struct CheckValidPathTest {
  91   base::FilePath::StringType path;
  92   bool expected_valid;
  93 } kCheckValidPathTestCases[] = {
  94   { FILE_PATH_LITERAL("//tmp/foo.txt"), false, },
  95   { FILE_PATH_LITERAL("//etc/hosts"), false, },
  96   { FILE_PATH_LITERAL("foo.txt"), true, },
  97   { FILE_PATH_LITERAL("a/b/c"), true, },
  98   // Any paths that includes parent references are considered invalid.
  99   { FILE_PATH_LITERAL(".."), false, },
 100   { FILE_PATH_LITERAL("tmp/.."), false, },
 101   { FILE_PATH_LITERAL("a/b/../c/.."), false, },
 102 };
 103
 104 // For External filesystem.
 105 const base::FilePath::CharType kMountPoint[] = FILE_PATH_LITERAL("/tmp/testing");
 106 const base::FilePath::CharType kRootPath[] = FILE_PATH_LITERAL("/tmp");
 107 const base::FilePath::CharType kVirtualPath[] = FILE_PATH_LITERAL("testing");
 108
 109 }  // namespace
 110
 111 class FileSystemMountPointProviderTest : public testing::Test {
 112  public:
 113   FileSystemMountPointProviderTest()
 114       : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 115   }
 116
 117   virtual void SetUp() {
 118     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 119     special_storage_policy_ = new quota::MockSpecialStoragePolicy;
 120   }
 121
 122  protected:
 123   void SetupNewContext(const FileSystemOptions& options) {
 124     scoped_refptr<ExternalMountPoints> external_mount_points(
 125         ExternalMountPoints::CreateRefCounted());
 126     file_system_context_ = new FileSystemContext(
 127         FileSystemTaskRunners::CreateMockTaskRunners(),
 128         external_mount_points.get(),
 129         special_storage_policy_,
 130         NULL,
 131         data_dir_.path(),
 132         options);
 133 #if defined(OS_CHROMEOS)
 134     base::FilePath mount_point_path = base::FilePath(kMountPoint);
 135     external_mount_points->RegisterFileSystem(
 136         mount_point_path.BaseName().AsUTF8Unsafe(),
 137         kFileSystemTypeNativeLocal,
 138         mount_point_path);
 139 #endif
 140   }
 141
 142   FileSystemMountPointProvider* provider(FileSystemType type) {
 143     DCHECK(file_system_context_);
 144     return file_system_context_->GetMountPointProvider(type);
 145   }
 146
 147   bool GetRootPath(const GURL& origin_url,
 148                    fileapi::FileSystemType type,
 149                    bool create,
 150                    base::FilePath* root_path) {
 151     base::FilePath virtual_path = base::FilePath();
 152     if (type == kFileSystemTypeExternal)
 153       virtual_path = base::FilePath(kVirtualPath);
 154     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
 155         origin_url, type, virtual_path);
 156     base::FilePath returned_root_path =
 157         provider(type)->GetFileSystemRootPathOnFileThread(url, create);
 158     if (root_path)
 159       *root_path = returned_root_path;
 160     return !returned_root_path.empty();
 161   }
 162
 163   base::FilePath data_path() const { return data_dir_.path(); }
 164   base::FilePath file_system_path() const {
 165     return data_dir_.path().Append(
 166         SandboxMountPointProvider::kFileSystemDirectory);
 167   }
 168   FileSystemContext* file_system_context() const {
 169     return file_system_context_.get();
 170   }
 171
 172  private:
 173   base::ScopedTempDir data_dir_;
 174   MessageLoop message_loop_;
 175   base::WeakPtrFactory<FileSystemMountPointProviderTest> weak_factory_;
 176
 177   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
 178   scoped_refptr<FileSystemContext> file_system_context_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(FileSystemMountPointProviderTest);
 181 };
 182
 183 TEST_F(FileSystemMountPointProviderTest, GetRootPathCreateAndExamine) {
 184   std::vector<base::FilePath> returned_root_path(
 185       ARRAYSIZE_UNSAFE(kRootPathTestCases));
 186   SetupNewContext(CreateAllowFileAccessOptions());
 187
 188   // Create a new root directory.
 189   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
 190     SCOPED_TRACE(testing::Message() << "RootPath (create) #" << i << " "
 191                  << kRootPathTestCases[i].expected_path);
 192
 193     base::FilePath root_path;
 194     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
 195                             kRootPathTestCases[i].type,
 196                             true /* create */, &root_path));
 197
 198     if (kRootPathTestCases[i].type != kFileSystemTypeExternal) {
 199       base::FilePath expected = file_system_path().AppendASCII(
 200           kRootPathTestCases[i].expected_path);
 201       EXPECT_EQ(expected.value(), root_path.value());
 202       EXPECT_TRUE(file_util::DirectoryExists(root_path));
 203     } else {
 204       // External file system root path is virtual one and does not match
 205       // anything from the actual file system.
 206       EXPECT_EQ(kRootPath, root_path.value());
 207     }
 208     ASSERT_TRUE(returned_root_path.size() > i);
 209     returned_root_path[i] = root_path;
 210   }
 211
 212   // Get the root directory with create=false and see if we get the
 213   // same directory.
 214   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
 215     SCOPED_TRACE(testing::Message() << "RootPath (get) #" << i << " "
 216                  << kRootPathTestCases[i].expected_path);
 217
 218     base::FilePath root_path;
 219     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
 220                             kRootPathTestCases[i].type,
 221                             false /* create */, &root_path));
 222     ASSERT_TRUE(returned_root_path.size() > i);
 223     EXPECT_EQ(returned_root_path[i].value(), root_path.value());
 224   }
 225 }
 226
 227 TEST_F(FileSystemMountPointProviderTest,
 228        GetRootPathCreateAndExamineWithNewProvider) {
 229   std::vector<base::FilePath> returned_root_path(
 230       ARRAYSIZE_UNSAFE(kRootPathTestCases));
 231   SetupNewContext(CreateAllowFileAccessOptions());
 232
 233   GURL origin_url("http://foo.com:1/");
 234
 235   base::FilePath root_path1;
 236   EXPECT_TRUE(GetRootPath(origin_url,
 237                           kFileSystemTypeTemporary, true, &root_path1));
 238
 239   SetupNewContext(CreateDisallowFileAccessOptions());
 240   base::FilePath root_path2;
 241   EXPECT_TRUE(GetRootPath(origin_url,
 242                           kFileSystemTypeTemporary, false, &root_path2));
 243
 244   EXPECT_EQ(root_path1.value(), root_path2.value());
 245 }
 246
 247 TEST_F(FileSystemMountPointProviderTest, GetRootPathGetWithoutCreate) {
 248   SetupNewContext(CreateDisallowFileAccessOptions());
 249
 250   // Try to get a root directory without creating.
 251   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
 252     SCOPED_TRACE(testing::Message() << "RootPath (create=false) #" << i << " "
 253                  << kRootPathTestCases[i].expected_path);
 254     // External type does not check the directory existence.
 255     if (kRootPathTestCases[i].type != kFileSystemTypeExternal) {
 256       EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
 257                               kRootPathTestCases[i].type,
 258                               false /* create */, NULL));
 259     }
 260   }
 261 }
 262
 263 TEST_F(FileSystemMountPointProviderTest, GetRootPathInIncognito) {
 264   SetupNewContext(CreateIncognitoFileSystemOptions());
 265
 266   // Try to get a root directory.
 267   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
 268     SCOPED_TRACE(testing::Message() << "RootPath (incognito) #" << i << " "
 269                  << kRootPathTestCases[i].expected_path);
 270     // External type does not change the behavior in incognito mode.
 271     if (kRootPathTestCases[i].type != kFileSystemTypeExternal) {
 272       EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
 273                               kRootPathTestCases[i].type,
 274                               true /* create */, NULL));
 275     }
 276   }
 277 }
 278
 279 TEST_F(FileSystemMountPointProviderTest, GetRootPathFileURI) {
 280   SetupNewContext(CreateDisallowFileAccessOptions());
 281   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
 282     SCOPED_TRACE(testing::Message() << "RootPathFileURI (disallow) #"
 283                  << i << " " << kRootPathFileURITestCases[i].expected_path);
 284     EXPECT_FALSE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
 285                              kRootPathFileURITestCases[i].type,
 286                              true /* create */, NULL));
 287   }
 288 }
 289
 290 TEST_F(FileSystemMountPointProviderTest, GetRootPathFileURIWithAllowFlag) {
 291   SetupNewContext(CreateAllowFileAccessOptions());
 292   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
 293     SCOPED_TRACE(testing::Message() << "RootPathFileURI (allow) #"
 294                  << i << " " << kRootPathFileURITestCases[i].expected_path);
 295     base::FilePath root_path;
 296     EXPECT_TRUE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
 297                             kRootPathFileURITestCases[i].type,
 298                             true /* create */, &root_path));
 299     base::FilePath expected = file_system_path().AppendASCII(
 300         kRootPathFileURITestCases[i].expected_path);
 301     EXPECT_EQ(expected.value(), root_path.value());
 302     EXPECT_TRUE(file_util::DirectoryExists(root_path));
 303   }
 304 }
 305
 306 }  // namespace fileapi