| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 #include <vector> | |
| 7 | |
| 8 #include "base/files/file.h" | |
| 9 #include "base/files/file_path.h" | |
| 10 #include "base/files/scoped_temp_dir.h" | |
| 11 #include "base/memory/scoped_ptr.h" | |
| 12 #include "base/memory/weak_ptr.h" | |
| 13 #include "base/platform_file.h" | |
| 14 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_fi
le_util.h" | |
| 15 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h" | |
| 16 #include "chrome/test/base/testing_profile.h" | |
| 17 #include "content/public/test/test_browser_thread_bundle.h" | |
| 18 #include "content/public/test/test_file_system_context.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 #include "webkit/browser/fileapi/async_file_util.h" | |
| 21 #include "webkit/browser/fileapi/file_system_context.h" | |
| 22 #include "webkit/browser/fileapi/file_system_url.h" | |
| 23 #include "webkit/common/blob/shareable_file_reference.h" | |
| 24 | |
| 25 namespace chromeos { | |
| 26 namespace file_system_provider { | |
| 27 namespace { | |
| 28 | |
| 29 // Logs callbacks invocations on the tested operations. | |
| 30 // TODO(mtomasz): Store and verify more arguments, once the operations return | |
| 31 // anything else than just an error. | |
| 32 class EventLogger { | |
| 33 public: | |
| 34 EventLogger() : weak_ptr_factory_(this) {} | |
| 35 virtual ~EventLogger() {} | |
| 36 | |
| 37 void OnStatus(base::File::Error error) { | |
| 38 error_.reset(new base::File::Error(error)); | |
| 39 } | |
| 40 | |
| 41 void OnCreateOrOpen(base::File::Error error, | |
| 42 base::PassPlatformFile platform_file, | |
| 43 const base::Closure& on_close_callback) { | |
| 44 error_.reset(new base::File::Error(error)); | |
| 45 } | |
| 46 | |
| 47 void OnEnsureFileExists(base::File::Error error, bool created) { | |
| 48 error_.reset(new base::File::Error(error)); | |
| 49 } | |
| 50 | |
| 51 void OnGetFileInfo(base::File::Error error, | |
| 52 const base::File::Info& file_info) { | |
| 53 error_.reset(new base::File::Error(error)); | |
| 54 } | |
| 55 | |
| 56 void OnReadDirectory(base::File::Error error, | |
| 57 const fileapi::AsyncFileUtil::EntryList& file_list, | |
| 58 bool has_more) { | |
| 59 error_.reset(new base::File::Error(error)); | |
| 60 } | |
| 61 | |
| 62 void OnCreateSnapshotFile( | |
| 63 base::File::Error error, | |
| 64 const base::File::Info& file_info, | |
| 65 const base::FilePath& platform_path, | |
| 66 const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) { | |
| 67 error_.reset(new base::File::Error(error)); | |
| 68 } | |
| 69 | |
| 70 void OnCopyFileProgress(int64 size) {} | |
| 71 | |
| 72 base::WeakPtr<EventLogger> GetWeakPtr() { | |
| 73 return weak_ptr_factory_.GetWeakPtr(); | |
| 74 } | |
| 75 | |
| 76 base::File::Error* error() { return error_.get(); } | |
| 77 | |
| 78 private: | |
| 79 scoped_ptr<base::File::Error> error_; | |
| 80 base::WeakPtrFactory<EventLogger> weak_ptr_factory_; | |
| 81 | |
| 82 DISALLOW_COPY_AND_ASSIGN(EventLogger); | |
| 83 }; | |
| 84 | |
| 85 // Creates a FileSystemURL for tests. | |
| 86 fileapi::FileSystemURL CreateFileSystemURL(Profile* profile, | |
| 87 const base::FilePath& file_path) { | |
| 88 const std::string kExtensionId = "mbflcebpggnecokmikipoihdbecnjfoj"; | |
| 89 const int kFileSystemId = 1; | |
| 90 const std::string origin = std::string("chrome-extension://") + kExtensionId; | |
| 91 const base::FilePath mount_path = | |
| 92 util::GetMountPointPath(profile, kExtensionId, kFileSystemId); | |
| 93 return fileapi::FileSystemURL::CreateForTest(GURL(origin), | |
| 94 fileapi::kFileSystemTypeProvided, | |
| 95 mount_path.Append(file_path)); | |
| 96 } | |
| 97 | |
| 98 } // namespace | |
| 99 | |
| 100 // Tests in this file are very lightweight and just test integration between | |
| 101 // AsyncFileUtil and ProvideFileSystemInterface. Currently it tests if not | |
| 102 // implemented operations return a correct error code. For not allowed | |
| 103 // operations it is FILE_ERROR_SECURITY, and for not implemented the error is | |
| 104 // FILE_ERROR_NOT_FOUND. | |
| 105 class FileSystemProviderProviderAsyncFileUtilTest : public testing::Test { | |
| 106 protected: | |
| 107 FileSystemProviderProviderAsyncFileUtilTest() {} | |
| 108 virtual ~FileSystemProviderProviderAsyncFileUtilTest() {} | |
| 109 | |
| 110 virtual void SetUp() OVERRIDE { | |
| 111 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); | |
| 112 profile_.reset(new TestingProfile); | |
| 113 async_file_util_.reset(new internal::ProviderAsyncFileUtil); | |
| 114 file_system_context_ = | |
| 115 content::CreateFileSystemContextForTesting(NULL, data_dir_.path()); | |
| 116 file_url_ = CreateFileSystemURL( | |
| 117 profile_.get(), base::FilePath::FromUTF8Unsafe("hello/world.txt")); | |
| 118 directory_url_ = CreateFileSystemURL( | |
| 119 profile_.get(), base::FilePath::FromUTF8Unsafe("hello")); | |
| 120 root_url_ = CreateFileSystemURL(profile_.get(), base::FilePath()); | |
| 121 LOG(ERROR) << file_url_.DebugString(); | |
| 122 } | |
| 123 | |
| 124 scoped_ptr<fileapi::FileSystemOperationContext> CreateOperationContext() { | |
| 125 return make_scoped_ptr( | |
| 126 new fileapi::FileSystemOperationContext(file_system_context_.get())); | |
| 127 } | |
| 128 | |
| 129 content::TestBrowserThreadBundle thread_bundle_; | |
| 130 base::ScopedTempDir data_dir_; | |
| 131 scoped_ptr<TestingProfile> profile_; | |
| 132 scoped_ptr<fileapi::AsyncFileUtil> async_file_util_; | |
| 133 scoped_refptr<fileapi::FileSystemContext> file_system_context_; | |
| 134 fileapi::FileSystemURL file_url_; | |
| 135 fileapi::FileSystemURL directory_url_; | |
| 136 fileapi::FileSystemURL root_url_; | |
| 137 }; | |
| 138 | |
| 139 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateOrOpen_Create) { | |
| 140 EventLogger logger; | |
| 141 | |
| 142 async_file_util_->CreateOrOpen( | |
| 143 CreateOperationContext(), | |
| 144 file_url_, | |
| 145 base::PLATFORM_FILE_CREATE, | |
| 146 base::Bind(&EventLogger::OnCreateOrOpen, logger.GetWeakPtr())); | |
| 147 | |
| 148 ASSERT_TRUE(logger.error()); | |
| 149 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 150 } | |
| 151 | |
| 152 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateOrOpen_CreateAlways) { | |
| 153 EventLogger logger; | |
| 154 | |
| 155 async_file_util_->CreateOrOpen( | |
| 156 CreateOperationContext(), | |
| 157 file_url_, | |
| 158 base::PLATFORM_FILE_CREATE_ALWAYS, | |
| 159 base::Bind(&EventLogger::OnCreateOrOpen, logger.GetWeakPtr())); | |
| 160 | |
| 161 ASSERT_TRUE(logger.error()); | |
| 162 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 163 } | |
| 164 | |
| 165 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateOrOpen_OpenAlways) { | |
| 166 EventLogger logger; | |
| 167 | |
| 168 async_file_util_->CreateOrOpen( | |
| 169 CreateOperationContext(), | |
| 170 file_url_, | |
| 171 base::PLATFORM_FILE_OPEN_ALWAYS, | |
| 172 base::Bind(&EventLogger::OnCreateOrOpen, logger.GetWeakPtr())); | |
| 173 | |
| 174 ASSERT_TRUE(logger.error()); | |
| 175 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 176 } | |
| 177 | |
| 178 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, | |
| 179 CreateOrOpen_OpenTruncated) { | |
| 180 EventLogger logger; | |
| 181 | |
| 182 async_file_util_->CreateOrOpen( | |
| 183 CreateOperationContext(), | |
| 184 file_url_, | |
| 185 base::PLATFORM_FILE_OPEN_TRUNCATED, | |
| 186 base::Bind(&EventLogger::OnCreateOrOpen, logger.GetWeakPtr())); | |
| 187 | |
| 188 ASSERT_TRUE(logger.error()); | |
| 189 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 190 } | |
| 191 | |
| 192 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateOrOpen_Open) { | |
| 193 EventLogger logger; | |
| 194 | |
| 195 async_file_util_->CreateOrOpen( | |
| 196 CreateOperationContext(), | |
| 197 file_url_, | |
| 198 base::PLATFORM_FILE_OPEN, | |
| 199 base::Bind(&EventLogger::OnCreateOrOpen, logger.GetWeakPtr())); | |
| 200 | |
| 201 ASSERT_TRUE(logger.error()); | |
| 202 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error()); | |
| 203 } | |
| 204 | |
| 205 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, EnsureFileExists) { | |
| 206 EventLogger logger; | |
| 207 | |
| 208 async_file_util_->EnsureFileExists( | |
| 209 CreateOperationContext(), | |
| 210 file_url_, | |
| 211 base::Bind(&EventLogger::OnEnsureFileExists, logger.GetWeakPtr())); | |
| 212 | |
| 213 ASSERT_TRUE(logger.error()); | |
| 214 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 215 } | |
| 216 | |
| 217 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateDirectory) { | |
| 218 EventLogger logger; | |
| 219 | |
| 220 async_file_util_->CreateDirectory( | |
| 221 CreateOperationContext(), | |
| 222 directory_url_, | |
| 223 false, // exclusive | |
| 224 false, // recursive | |
| 225 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 226 | |
| 227 ASSERT_TRUE(logger.error()); | |
| 228 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 229 } | |
| 230 | |
| 231 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, GetFileInfo) { | |
| 232 EventLogger logger; | |
| 233 | |
| 234 async_file_util_->GetFileInfo( | |
| 235 CreateOperationContext(), | |
| 236 file_url_, | |
| 237 base::Bind(&EventLogger::OnGetFileInfo, logger.GetWeakPtr())); | |
| 238 | |
| 239 ASSERT_TRUE(logger.error()); | |
| 240 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error()); | |
| 241 } | |
| 242 | |
| 243 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, ReadDirectory) { | |
| 244 EventLogger logger; | |
| 245 | |
| 246 async_file_util_->ReadDirectory( | |
| 247 CreateOperationContext(), | |
| 248 root_url_, | |
| 249 base::Bind(&EventLogger::OnReadDirectory, logger.GetWeakPtr())); | |
| 250 | |
| 251 ASSERT_TRUE(logger.error()); | |
| 252 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error()); | |
| 253 } | |
| 254 | |
| 255 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, Touch) { | |
| 256 EventLogger logger; | |
| 257 | |
| 258 async_file_util_->CreateDirectory( | |
| 259 CreateOperationContext(), | |
| 260 file_url_, | |
| 261 false, // exclusive | |
| 262 false, // recursive | |
| 263 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 264 | |
| 265 ASSERT_TRUE(logger.error()); | |
| 266 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 267 } | |
| 268 | |
| 269 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, Truncate) { | |
| 270 EventLogger logger; | |
| 271 | |
| 272 async_file_util_->Truncate( | |
| 273 CreateOperationContext(), | |
| 274 file_url_, | |
| 275 0, // length | |
| 276 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 277 | |
| 278 ASSERT_TRUE(logger.error()); | |
| 279 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 280 } | |
| 281 | |
| 282 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CopyFileLocal) { | |
| 283 EventLogger logger; | |
| 284 | |
| 285 async_file_util_->CopyFileLocal( | |
| 286 CreateOperationContext(), | |
| 287 file_url_, // src_url | |
| 288 file_url_, // dst_url | |
| 289 fileapi::FileSystemOperation::OPTION_NONE, | |
| 290 base::Bind(&EventLogger::OnCopyFileProgress, logger.GetWeakPtr()), | |
| 291 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 292 | |
| 293 ASSERT_TRUE(logger.error()); | |
| 294 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 295 } | |
| 296 | |
| 297 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, MoveFileLocal) { | |
| 298 EventLogger logger; | |
| 299 | |
| 300 async_file_util_->MoveFileLocal( | |
| 301 CreateOperationContext(), | |
| 302 file_url_, // src_url | |
| 303 file_url_, // dst_url | |
| 304 fileapi::FileSystemOperation::OPTION_NONE, | |
| 305 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 306 | |
| 307 ASSERT_TRUE(logger.error()); | |
| 308 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 309 } | |
| 310 | |
| 311 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CopyInForeignFile) { | |
| 312 EventLogger logger; | |
| 313 | |
| 314 async_file_util_->CopyInForeignFile( | |
| 315 CreateOperationContext(), | |
| 316 base::FilePath(), // src_file_path | |
| 317 file_url_, // dst_url | |
| 318 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 319 | |
| 320 ASSERT_TRUE(logger.error()); | |
| 321 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 322 } | |
| 323 | |
| 324 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, DeleteFile) { | |
| 325 EventLogger logger; | |
| 326 | |
| 327 async_file_util_->DeleteFile( | |
| 328 CreateOperationContext(), | |
| 329 file_url_, | |
| 330 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 331 | |
| 332 ASSERT_TRUE(logger.error()); | |
| 333 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 334 } | |
| 335 | |
| 336 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, DeleteDirectory) { | |
| 337 EventLogger logger; | |
| 338 | |
| 339 async_file_util_->DeleteDirectory( | |
| 340 CreateOperationContext(), | |
| 341 directory_url_, | |
| 342 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 343 | |
| 344 ASSERT_TRUE(logger.error()); | |
| 345 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 346 } | |
| 347 | |
| 348 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, DeleteRecursively) { | |
| 349 EventLogger logger; | |
| 350 | |
| 351 async_file_util_->DeleteRecursively( | |
| 352 CreateOperationContext(), | |
| 353 directory_url_, | |
| 354 base::Bind(&EventLogger::OnStatus, logger.GetWeakPtr())); | |
| 355 | |
| 356 ASSERT_TRUE(logger.error()); | |
| 357 EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error()); | |
| 358 } | |
| 359 | |
| 360 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateSnapshotFile) { | |
| 361 EventLogger logger; | |
| 362 | |
| 363 async_file_util_->CreateSnapshotFile( | |
| 364 CreateOperationContext(), | |
| 365 file_url_, | |
| 366 base::Bind(&EventLogger::OnCreateSnapshotFile, logger.GetWeakPtr())); | |
| 367 | |
| 368 ASSERT_TRUE(logger.error()); | |
| 369 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error()); | |
| 370 } | |
| 371 | |
| 372 } // namespace file_system_provider | |
| 373 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 240483008:
Revert of [fsp] Add an initial AsyncFileUtil. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src