| OLD | NEW |
|---|
| (Empty) |
| 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 "chrome/browser/chromeos/drive/fake_drive_file_system.h" | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/message_loop.h" | |
| 9 #include "chrome/browser/chromeos/drive/file_system_util.h" | |
| 10 #include "chrome/browser/google_apis/fake_drive_service.h" | |
| 11 #include "chrome/browser/google_apis/test_util.h" | |
| 12 #include "content/public/browser/browser_thread.h" | |
| 13 #include "content/public/test/test_browser_thread.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 | |
| 16 namespace drive { | |
| 17 namespace test_util { | |
| 18 | |
| 19 class FakeDriveFileSystemTest : public ::testing::Test { | |
| 20 protected: | |
| 21 FakeDriveFileSystemTest() | |
| 22 : ui_thread_(content::BrowserThread::UI, &message_loop_) { | |
| 23 } | |
| 24 | |
| 25 virtual void SetUp() OVERRIDE { | |
| 26 // Initialize FakeDriveService. | |
| 27 fake_drive_service_.reset(new google_apis::FakeDriveService); | |
| 28 fake_drive_service_->LoadResourceListForWapi( | |
| 29 "chromeos/gdata/root_feed.json"); | |
| 30 fake_drive_service_->LoadAccountMetadataForWapi( | |
| 31 "chromeos/gdata/account_metadata.json"); | |
| 32 fake_drive_service_->LoadAppListForDriveApi("chromeos/drive/applist.json"); | |
| 33 | |
| 34 // Create a testee instance. | |
| 35 fake_drive_file_system_.reset( | |
| 36 new FakeDriveFileSystem(fake_drive_service_.get())); | |
| 37 ASSERT_TRUE(fake_drive_file_system_->InitializeForTesting()); | |
| 38 } | |
| 39 | |
| 40 MessageLoopForUI message_loop_; | |
| 41 content::TestBrowserThread ui_thread_; | |
| 42 | |
| 43 scoped_ptr<google_apis::FakeDriveService> fake_drive_service_; | |
| 44 scoped_ptr<FakeDriveFileSystem> fake_drive_file_system_; | |
| 45 }; | |
| 46 | |
| 47 TEST_F(FakeDriveFileSystemTest, GetEntryInfoByResourceId) { | |
| 48 FileError error = FILE_ERROR_FAILED; | |
| 49 scoped_ptr<DriveEntryProto> entry; | |
| 50 base::FilePath file_path; | |
| 51 | |
| 52 fake_drive_file_system_->GetEntryInfoByResourceId( | |
| 53 "folder:sub_dir_folder_resource_id", | |
| 54 google_apis::test_util::CreateCopyResultCallback( | |
| 55 &error, &file_path, &entry)); | |
| 56 google_apis::test_util::RunBlockingPoolTask(); | |
| 57 | |
| 58 ASSERT_EQ(FILE_ERROR_OK, error); | |
| 59 EXPECT_EQ( | |
| 60 util::GetDriveMyDriveRootPath().AppendASCII( | |
| 61 "Directory 1/Sub Directory Folder"), | |
| 62 file_path); | |
| 63 EXPECT_TRUE(entry); // Just make sure something is returned. | |
| 64 } | |
| 65 | |
| 66 TEST_F(FakeDriveFileSystemTest, | |
| 67 GetEntryInfoByResourceId_PathCompatibleWithGetEntryInfoByPath) { | |
| 68 const std::string document_resource_id = "document:5_document_resource_id"; | |
| 69 | |
| 70 FileError error = FILE_ERROR_FAILED; | |
| 71 scoped_ptr<DriveEntryProto> entry; | |
| 72 base::FilePath file_path; | |
| 73 | |
| 74 // Get entry info by resource id. | |
| 75 fake_drive_file_system_->GetEntryInfoByResourceId( | |
| 76 document_resource_id, | |
| 77 google_apis::test_util::CreateCopyResultCallback( | |
| 78 &error, &file_path, &entry)); | |
| 79 google_apis::test_util::RunBlockingPoolTask(); | |
| 80 | |
| 81 ASSERT_EQ(FILE_ERROR_OK, error); | |
| 82 ASSERT_TRUE(entry); | |
| 83 EXPECT_TRUE(entry->file_specific_info().is_hosted_document()); | |
| 84 | |
| 85 // Get entry info by path given by GetEntryInfoByResourceId. | |
| 86 error = FILE_ERROR_FAILED; | |
| 87 entry.reset(); | |
| 88 fake_drive_file_system_->GetEntryInfoByPath( | |
| 89 file_path, | |
| 90 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); | |
| 91 google_apis::test_util::RunBlockingPoolTask(); | |
| 92 | |
| 93 ASSERT_EQ(FILE_ERROR_OK, error); | |
| 94 ASSERT_TRUE(entry); | |
| 95 EXPECT_EQ(document_resource_id, entry->resource_id()); | |
| 96 } | |
| 97 | |
| 98 TEST_F(FakeDriveFileSystemTest, GetFileContentByPath) { | |
| 99 FileError initialize_error = FILE_ERROR_FAILED; | |
| 100 scoped_ptr<DriveEntryProto> entry_proto; | |
| 101 base::FilePath cache_file_path; | |
| 102 base::Closure cancel_download; | |
| 103 google_apis::test_util::TestGetContentCallback get_content_callback; | |
| 104 FileError completion_error = FILE_ERROR_FAILED; | |
| 105 | |
| 106 const base::FilePath kDriveFile = | |
| 107 util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt"); | |
| 108 | |
| 109 // For the first time, the file should be downloaded from the service. | |
| 110 fake_drive_file_system_->GetFileContentByPath( | |
| 111 kDriveFile, | |
| 112 google_apis::test_util::CreateCopyResultCallback( | |
| 113 &initialize_error, &entry_proto, &cache_file_path, &cancel_download), | |
| 114 get_content_callback.callback(), | |
| 115 google_apis::test_util::CreateCopyResultCallback(&completion_error)); | |
| 116 google_apis::test_util::RunBlockingPoolTask(); | |
| 117 | |
| 118 EXPECT_EQ(FILE_ERROR_OK, initialize_error); | |
| 119 EXPECT_TRUE(entry_proto); | |
| 120 | |
| 121 // No cache file is available yet. | |
| 122 EXPECT_TRUE(cache_file_path.empty()); | |
| 123 | |
| 124 // The download should be happened so the |get_content_callback| | |
| 125 // should have the actual data. | |
| 126 std::string content = get_content_callback.GetConcatenatedData(); | |
| 127 EXPECT_EQ(10U, content.size()); | |
| 128 EXPECT_EQ(FILE_ERROR_OK, completion_error); | |
| 129 | |
| 130 initialize_error = FILE_ERROR_FAILED; | |
| 131 entry_proto.reset(); | |
| 132 get_content_callback.mutable_data()->clear(); | |
| 133 completion_error = FILE_ERROR_FAILED; | |
| 134 | |
| 135 // For the second time, the cache file should be found. | |
| 136 fake_drive_file_system_->GetFileContentByPath( | |
| 137 kDriveFile, | |
| 138 google_apis::test_util::CreateCopyResultCallback( | |
| 139 &initialize_error, &entry_proto, &cache_file_path, &cancel_download), | |
| 140 get_content_callback.callback(), | |
| 141 google_apis::test_util::CreateCopyResultCallback(&completion_error)); | |
| 142 google_apis::test_util::RunBlockingPoolTask(); | |
| 143 | |
| 144 EXPECT_EQ(FILE_ERROR_OK, initialize_error); | |
| 145 EXPECT_TRUE(entry_proto); | |
| 146 | |
| 147 // Cache file should be available. | |
| 148 ASSERT_FALSE(cache_file_path.empty()); | |
| 149 | |
| 150 // There should be a cache file so no data should be downloaded. | |
| 151 EXPECT_TRUE(get_content_callback.data().empty()); | |
| 152 EXPECT_EQ(FILE_ERROR_OK, completion_error); | |
| 153 | |
| 154 // Make sure the cached file's content. | |
| 155 std::string cache_file_content; | |
| 156 ASSERT_TRUE( | |
| 157 file_util::ReadFileToString(cache_file_path, &cache_file_content)); | |
| 158 EXPECT_EQ(content, cache_file_content); | |
| 159 } | |
| 160 | |
| 161 TEST_F(FakeDriveFileSystemTest, GetFileContentByPath_Directory) { | |
| 162 FileError initialize_error = FILE_ERROR_FAILED; | |
| 163 scoped_ptr<DriveEntryProto> entry_proto; | |
| 164 base::FilePath cache_file_path; | |
| 165 google_apis::test_util::TestGetContentCallback get_content_callback; | |
| 166 FileError completion_error = FILE_ERROR_FAILED; | |
| 167 base::Closure cancel_download; | |
| 168 | |
| 169 fake_drive_file_system_->GetFileContentByPath( | |
| 170 util::GetDriveMyDriveRootPath(), | |
| 171 google_apis::test_util::CreateCopyResultCallback( | |
| 172 &initialize_error, &entry_proto, &cache_file_path, &cancel_download), | |
| 173 get_content_callback.callback(), | |
| 174 google_apis::test_util::CreateCopyResultCallback(&completion_error)); | |
| 175 google_apis::test_util::RunBlockingPoolTask(); | |
| 176 | |
| 177 EXPECT_EQ(FILE_ERROR_NOT_A_FILE, completion_error); | |
| 178 } | |
| 179 | |
| 180 TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath) { | |
| 181 FileError error = FILE_ERROR_FAILED; | |
| 182 scoped_ptr<DriveEntryProto> entry; | |
| 183 fake_drive_file_system_->GetEntryInfoByPath( | |
| 184 util::GetDriveMyDriveRootPath().AppendASCII( | |
| 185 "Directory 1/Sub Directory Folder"), | |
| 186 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); | |
| 187 google_apis::test_util::RunBlockingPoolTask(); | |
| 188 | |
| 189 ASSERT_EQ(FILE_ERROR_OK, error); | |
| 190 ASSERT_TRUE(entry); | |
| 191 EXPECT_EQ("folder:sub_dir_folder_resource_id", entry->resource_id()); | |
| 192 } | |
| 193 | |
| 194 TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath_Root) { | |
| 195 FileError error = FILE_ERROR_FAILED; | |
| 196 scoped_ptr<DriveEntryProto> entry; | |
| 197 fake_drive_file_system_->GetEntryInfoByPath( | |
| 198 util::GetDriveMyDriveRootPath(), | |
| 199 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); | |
| 200 google_apis::test_util::RunBlockingPoolTask(); | |
| 201 | |
| 202 ASSERT_EQ(FILE_ERROR_OK, error); | |
| 203 ASSERT_TRUE(entry); | |
| 204 EXPECT_TRUE(entry->file_info().is_directory()); | |
| 205 EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id()); | |
| 206 EXPECT_EQ(util::kDriveMyDriveRootDirName, entry->title()); | |
| 207 } | |
| 208 | |
| 209 TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath_Invalid) { | |
| 210 FileError error = FILE_ERROR_FAILED; | |
| 211 scoped_ptr<DriveEntryProto> entry; | |
| 212 fake_drive_file_system_->GetEntryInfoByPath( | |
| 213 util::GetDriveMyDriveRootPath().AppendASCII("Invalid File Name"), | |
| 214 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); | |
| 215 google_apis::test_util::RunBlockingPoolTask(); | |
| 216 | |
| 217 ASSERT_EQ(FILE_ERROR_NOT_FOUND, error); | |
| 218 ASSERT_FALSE(entry); | |
| 219 } | |
| 220 | |
| 221 } // namespace test_util | |
| 222 } // namespace drive | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 14755002:
drive: Drop "Drive" from FakeDriveFileSystem and MockDriveFileSystem (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src