webkit/fileapi/local_file_util_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 <string>
   6
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/message_loop.h"
  10 #include "base/message_loop_proxy.h"
  11 #include "base/platform_file.h"
  12 #include "base/strings/sys_string_conversions.h"
  13 #include "base/utf_string_conversions.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "webkit/fileapi/async_file_test_helper.h"
  16 #include "webkit/fileapi/file_system_context.h"
  17 #include "webkit/fileapi/file_system_file_util.h"
  18 #include "webkit/fileapi/file_system_operation_context.h"
  19 #include "webkit/fileapi/file_system_types.h"
  20 #include "webkit/fileapi/local_file_system_test_helper.h"
  21 #include "webkit/fileapi/local_file_util.h"
  22 #include "webkit/fileapi/native_file_util.h"
  23
  24 namespace fileapi {
  25
  26 // TODO(dmikurube): Cover all public methods in LocalFileUtil.
  27 class LocalFileUtilTest : public testing::Test {
  28  public:
  29   LocalFileUtilTest()
  30       : test_helper_(GURL("http://foo/"), kFileSystemTypeTest) {}
  31
  32   virtual void SetUp() {
  33     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
  34     test_helper_.SetUp(data_dir_.path());
  35   }
  36
  37   virtual void TearDown() {
  38     test_helper_.TearDown();
  39   }
  40
  41  protected:
  42   FileSystemOperationContext* NewContext() {
  43     FileSystemOperationContext* context = test_helper_.NewOperationContext();
  44     return context;
  45   }
  46
  47   LocalFileUtil* FileUtil() {
  48     return static_cast<LocalFileUtil*>(test_helper_.file_util());
  49   }
  50
  51   FileSystemURL Path(const std::string& file_name) {
  52     return test_helper_.CreateURLFromUTF8(file_name);
  53   }
  54
  55   base::FilePath LocalPath(const char *file_name) {
  56     return test_helper_.GetLocalPathFromASCII(file_name);
  57   }
  58
  59   bool FileExists(const char *file_name) {
  60     return file_util::PathExists(LocalPath(file_name)) &&
  61         !file_util::DirectoryExists(LocalPath(file_name));
  62   }
  63
  64   bool DirectoryExists(const char *file_name) {
  65     return file_util::DirectoryExists(LocalPath(file_name));
  66   }
  67
  68   int64 GetSize(const char *file_name) {
  69     base::PlatformFileInfo info;
  70     file_util::GetFileInfo(LocalPath(file_name), &info);
  71     return info.size;
  72   }
  73
  74   base::PlatformFileError CreateFile(const char* file_name,
  75       base::PlatformFile* file_handle, bool* created) {
  76     int file_flags = base::PLATFORM_FILE_CREATE |
  77         base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_ASYNC;
  78
  79     scoped_ptr<FileSystemOperationContext> context(NewContext());
  80     return FileUtil()->CreateOrOpen(
  81         context.get(),
  82         Path(file_name),
  83         file_flags, file_handle, created);
  84   }
  85
  86   base::PlatformFileError EnsureFileExists(const char* file_name,
  87       bool* created) {
  88     scoped_ptr<FileSystemOperationContext> context(NewContext());
  89     return FileUtil()->EnsureFileExists(
  90         context.get(),
  91         Path(file_name), created);
  92   }
  93
  94   const LocalFileSystemTestOriginHelper& test_helper() const {
  95     return test_helper_;
  96   }
  97
  98   FileSystemContext* file_system_context() {
  99     return test_helper_.file_system_context();
 100   }
 101
 102  private:
 103   scoped_ptr<LocalFileUtil> local_file_util_;
 104   base::ScopedTempDir data_dir_;
 105   MessageLoop message_loop_;
 106   LocalFileSystemTestOriginHelper test_helper_;
 107
 108   DISALLOW_COPY_AND_ASSIGN(LocalFileUtilTest);
 109 };
 110
 111 TEST_F(LocalFileUtilTest, CreateAndClose) {
 112   const char *file_name = "test_file";
 113   base::PlatformFile file_handle;
 114   bool created;
 115   ASSERT_EQ(base::PLATFORM_FILE_OK,
 116             CreateFile(file_name, &file_handle, &created));
 117   ASSERT_TRUE(created);
 118
 119   EXPECT_TRUE(FileExists(file_name));
 120   EXPECT_EQ(0, GetSize(file_name));
 121
 122   scoped_ptr<FileSystemOperationContext> context(NewContext());
 123   EXPECT_EQ(base::PLATFORM_FILE_OK,
 124       FileUtil()->Close(context.get(), file_handle));
 125 }
 126
 127 TEST_F(LocalFileUtilTest, EnsureFileExists) {
 128   const char *file_name = "foobar";
 129   bool created;
 130   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(file_name, &created));
 131   ASSERT_TRUE(created);
 132
 133   EXPECT_TRUE(FileExists(file_name));
 134   EXPECT_EQ(0, GetSize(file_name));
 135
 136   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(file_name, &created));
 137   EXPECT_FALSE(created);
 138 }
 139
 140 TEST_F(LocalFileUtilTest, TouchFile) {
 141   const char *file_name = "test_file";
 142   base::PlatformFile file_handle;
 143   bool created;
 144   ASSERT_EQ(base::PLATFORM_FILE_OK,
 145             CreateFile(file_name, &file_handle, &created));
 146   ASSERT_TRUE(created);
 147
 148   scoped_ptr<FileSystemOperationContext> context(NewContext());
 149
 150   base::PlatformFileInfo info;
 151   ASSERT_TRUE(file_util::GetFileInfo(LocalPath(file_name), &info));
 152   const base::Time new_accessed =
 153       info.last_accessed + base::TimeDelta::FromHours(10);
 154   const base::Time new_modified =
 155       info.last_modified + base::TimeDelta::FromHours(5);
 156
 157   EXPECT_EQ(base::PLATFORM_FILE_OK,
 158             FileUtil()->Touch(context.get(), Path(file_name),
 159                               new_accessed, new_modified));
 160
 161   ASSERT_TRUE(file_util::GetFileInfo(LocalPath(file_name), &info));
 162   EXPECT_EQ(new_accessed, info.last_accessed);
 163   EXPECT_EQ(new_modified, info.last_modified);
 164
 165   EXPECT_EQ(base::PLATFORM_FILE_OK,
 166             FileUtil()->Close(context.get(), file_handle));
 167 }
 168
 169 TEST_F(LocalFileUtilTest, TouchDirectory) {
 170   const char *dir_name = "test_dir";
 171   scoped_ptr<FileSystemOperationContext> context(NewContext());
 172   ASSERT_EQ(base::PLATFORM_FILE_OK,
 173             FileUtil()->CreateDirectory(context.get(),
 174                                         Path(dir_name),
 175                                         false /* exclusive */,
 176                                         false /* recursive */));
 177
 178   base::PlatformFileInfo info;
 179   ASSERT_TRUE(file_util::GetFileInfo(LocalPath(dir_name), &info));
 180   const base::Time new_accessed =
 181       info.last_accessed + base::TimeDelta::FromHours(10);
 182   const base::Time new_modified =
 183       info.last_modified + base::TimeDelta::FromHours(5);
 184
 185   EXPECT_EQ(base::PLATFORM_FILE_OK,
 186             FileUtil()->Touch(context.get(), Path(dir_name),
 187                               new_accessed, new_modified));
 188
 189   ASSERT_TRUE(file_util::GetFileInfo(LocalPath(dir_name), &info));
 190   EXPECT_EQ(new_accessed, info.last_accessed);
 191   EXPECT_EQ(new_modified, info.last_modified);
 192 }
 193
 194 TEST_F(LocalFileUtilTest, Truncate) {
 195   const char *file_name = "truncated";
 196   bool created;
 197   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(file_name, &created));
 198   ASSERT_TRUE(created);
 199
 200   scoped_ptr<FileSystemOperationContext> context;
 201
 202   context.reset(NewContext());
 203   ASSERT_EQ(base::PLATFORM_FILE_OK,
 204       FileUtil()->Truncate(context.get(), Path(file_name), 1020));
 205
 206   EXPECT_TRUE(FileExists(file_name));
 207   EXPECT_EQ(1020, GetSize(file_name));
 208 }
 209
 210 TEST_F(LocalFileUtilTest, CopyFile) {
 211   const char *from_file = "fromfile";
 212   const char *to_file1 = "tofile1";
 213   const char *to_file2 = "tofile2";
 214   bool created;
 215   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
 216   ASSERT_TRUE(created);
 217
 218   scoped_ptr<FileSystemOperationContext> context;
 219   context.reset(NewContext());
 220   ASSERT_EQ(base::PLATFORM_FILE_OK,
 221       FileUtil()->Truncate(context.get(), Path(from_file), 1020));
 222
 223   EXPECT_TRUE(FileExists(from_file));
 224   EXPECT_EQ(1020, GetSize(from_file));
 225
 226   ASSERT_EQ(base::PLATFORM_FILE_OK,
 227             AsyncFileTestHelper::Copy(file_system_context(),
 228                                       Path(from_file), Path(to_file1)));
 229
 230   context.reset(NewContext());
 231   ASSERT_EQ(base::PLATFORM_FILE_OK,
 232             AsyncFileTestHelper::Copy(file_system_context(),
 233                                       Path(from_file), Path(to_file2)));
 234
 235   EXPECT_TRUE(FileExists(from_file));
 236   EXPECT_EQ(1020, GetSize(from_file));
 237   EXPECT_TRUE(FileExists(to_file1));
 238   EXPECT_EQ(1020, GetSize(to_file1));
 239   EXPECT_TRUE(FileExists(to_file2));
 240   EXPECT_EQ(1020, GetSize(to_file2));
 241 }
 242
 243 TEST_F(LocalFileUtilTest, CopyDirectory) {
 244   const char *from_dir = "fromdir";
 245   const char *from_file = "fromdir/fromfile";
 246   const char *to_dir = "todir";
 247   const char *to_file = "todir/fromfile";
 248   bool created;
 249   scoped_ptr<FileSystemOperationContext> context;
 250
 251   context.reset(NewContext());
 252   ASSERT_EQ(base::PLATFORM_FILE_OK,
 253       FileUtil()->CreateDirectory(context.get(), Path(from_dir), false, false));
 254   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
 255   ASSERT_TRUE(created);
 256
 257   context.reset(NewContext());
 258   ASSERT_EQ(base::PLATFORM_FILE_OK,
 259       FileUtil()->Truncate(context.get(), Path(from_file), 1020));
 260
 261   EXPECT_TRUE(DirectoryExists(from_dir));
 262   EXPECT_TRUE(FileExists(from_file));
 263   EXPECT_EQ(1020, GetSize(from_file));
 264   EXPECT_FALSE(DirectoryExists(to_dir));
 265
 266   context.reset(NewContext());
 267   ASSERT_EQ(base::PLATFORM_FILE_OK,
 268             AsyncFileTestHelper::Copy(file_system_context(),
 269                                       Path(from_dir), Path(to_dir)));
 270
 271   EXPECT_TRUE(DirectoryExists(from_dir));
 272   EXPECT_TRUE(FileExists(from_file));
 273   EXPECT_EQ(1020, GetSize(from_file));
 274   EXPECT_TRUE(DirectoryExists(to_dir));
 275   EXPECT_TRUE(FileExists(to_file));
 276   EXPECT_EQ(1020, GetSize(to_file));
 277 }
 278
 279 TEST_F(LocalFileUtilTest, MoveFile) {
 280   const char *from_file = "fromfile";
 281   const char *to_file = "tofile";
 282   bool created;
 283   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
 284   ASSERT_TRUE(created);
 285   scoped_ptr<FileSystemOperationContext> context;
 286
 287   context.reset(NewContext());
 288   ASSERT_EQ(base::PLATFORM_FILE_OK,
 289       FileUtil()->Truncate(context.get(), Path(from_file), 1020));
 290
 291   EXPECT_TRUE(FileExists(from_file));
 292   EXPECT_EQ(1020, GetSize(from_file));
 293
 294   context.reset(NewContext());
 295   ASSERT_EQ(base::PLATFORM_FILE_OK,
 296             AsyncFileTestHelper::Move(file_system_context(),
 297                                       Path(from_file), Path(to_file)));
 298
 299   EXPECT_FALSE(FileExists(from_file));
 300   EXPECT_TRUE(FileExists(to_file));
 301   EXPECT_EQ(1020, GetSize(to_file));
 302 }
 303
 304 TEST_F(LocalFileUtilTest, MoveDirectory) {
 305   const char *from_dir = "fromdir";
 306   const char *from_file = "fromdir/fromfile";
 307   const char *to_dir = "todir";
 308   const char *to_file = "todir/fromfile";
 309   bool created;
 310   scoped_ptr<FileSystemOperationContext> context;
 311
 312   context.reset(NewContext());
 313   ASSERT_EQ(base::PLATFORM_FILE_OK,
 314       FileUtil()->CreateDirectory(context.get(), Path(from_dir), false, false));
 315   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
 316   ASSERT_TRUE(created);
 317
 318   context.reset(NewContext());
 319   ASSERT_EQ(base::PLATFORM_FILE_OK,
 320       FileUtil()->Truncate(context.get(), Path(from_file), 1020));
 321
 322   EXPECT_TRUE(DirectoryExists(from_dir));
 323   EXPECT_TRUE(FileExists(from_file));
 324   EXPECT_EQ(1020, GetSize(from_file));
 325   EXPECT_FALSE(DirectoryExists(to_dir));
 326
 327   context.reset(NewContext());
 328   ASSERT_EQ(base::PLATFORM_FILE_OK,
 329             AsyncFileTestHelper::Move(file_system_context(),
 330                                       Path(from_dir), Path(to_dir)));
 331
 332   EXPECT_FALSE(DirectoryExists(from_dir));
 333   EXPECT_TRUE(DirectoryExists(to_dir));
 334   EXPECT_TRUE(FileExists(to_file));
 335   EXPECT_EQ(1020, GetSize(to_file));
 336 }
 337
 338 }  // namespace fileapi