drive: Add DownloadOperationTest

chrome/browser/chromeos/drive/file_system_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/drive/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"

[kinaba, 2013/05/30 07:23:07]

not used anymore.

[hashimoto, 2013/05/30 07:48:19]

Good catch, done.

 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
@@ skipping 185 matching lines @@
                                      const std::string& md5,
                                      FileCacheEntry* cache_entry) {
     bool result = false;
     cache_->GetCacheEntryOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(&result, cache_entry));
     google_apis::test_util::RunBlockingPoolTask();
     return result;
   }
 
-  // Returns true if the cache entry exists for the given resource ID and MD5.
-  bool CacheEntryExists(const std::string& resource_id,
-                        const std::string& md5) {
-    FileCacheEntry cache_entry;
-    return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
-  }
-
   // Flag for specifying the timestamp of the test filesystem cache.
   enum SetUpTestFileSystemParam {
     USE_OLD_TIMESTAMP,
     USE_SERVER_TIMESTAMP,
   };
 
   // Sets up a filesystem with directories: drive/root, drive/root/Dir1,
   // drive/root/Dir1/SubDir2 and files drive/root/File1, drive/root/Dir1/File2,
   // drive/root/Dir1/SubDir2/File3. If |use_up_to_date_timestamp| is true, sets
   // the changestamp to 654321, equal to that of "account_metadata.json" test
@@ skipping 104 matching lines @@
     google_apis::test_util::RunBlockingPoolTask();
     if (error != FILE_ERROR_OK)
       return false;
 
     // Recreate resource metadata.
     SetUpResourceMetadataAndFileSystem();
 
     return true;
   }
 
-  // Verifies that |file_path| is a valid JSON file for the hosted document
-  // associated with |entry| (i.e. |url| and |resource_id| match).
-  void VerifyHostedDocumentJSONFile(const ResourceEntry& entry,
-                                    const base::FilePath& file_path) {
-    std::string error;
-    JSONFileValueSerializer serializer(file_path);
-    scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
-    ASSERT_TRUE(value) << "Parse error " << file_path.value() << ": " << error;
-    DictionaryValue* dict_value = NULL;
-    ASSERT_TRUE(value->GetAsDictionary(&dict_value));
-
-    std::string alternate_url, resource_id;
-    EXPECT_TRUE(dict_value->GetString("url", &alternate_url));
-    EXPECT_TRUE(dict_value->GetString("resource_id", &resource_id));
-
-    EXPECT_EQ(entry.file_specific_info().alternate_url(), alternate_url);
-    EXPECT_EQ(entry.resource_id(), resource_id);
-  }
-
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
 
   scoped_ptr<internal::FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<FileSystem> file_system_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<internal::ResourceMetadata, test_util::DestroyHelperForTests>
@@ skipping 641 matching lines @@
       remote_src_file_path,
       local_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry);
-  VerifyHostedDocumentJSONFile(*entry, local_dest_file_path);
+  EXPECT_EQ(GURL(entry->file_specific_info().alternate_url()),
+            util::ReadUrlFromGDocFile(local_dest_file_path));
+  EXPECT_EQ(entry->resource_id(),
+            util::ReadResourceIdFromGDocFile(local_dest_file_path));
 }
 
 TEST_F(FileSystemTest, CopyNotExistingFile) {
   base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
@@ skipping 116 matching lines @@
   error = FILE_ERROR_FAILED;
   EXPECT_CALL(*mock_cache_observer_,
               OnCacheUnpinned(entry->resource_id(),
                               entry->file_specific_info().file_md5())).Times(1);
   file_system_->Unpin(file_path,
                       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
-TEST_F(FileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  // The transfered file is cached and the change of "offline available"
-  // attribute is notified.
-  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-  const int64 file_size = entry->file_info().size();
-
-  // Pretend we have enough space.
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      file_size + internal::kMinFreeSpace);
-
-  FileError error = FILE_ERROR_FAILED;
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
-
-  // Verify that readable permission is set.
-  int permission = 0;
-  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_path, &permission));
-  EXPECT_EQ(file_util::FILE_PERMISSION_READ_BY_USER |
-            file_util::FILE_PERMISSION_WRITE_BY_USER |
-            file_util::FILE_PERMISSION_READ_BY_GROUP |
-            file_util::FILE_PERMISSION_READ_BY_OTHERS, permission);
-}
-
-TEST_F(FileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-
-  // Pretend we have no space at all.
-  fake_free_disk_space_getter_->set_fake_free_disk_space(0);
-
-  FileError error = FILE_ERROR_OK;
-  base::FilePath file_path;
-  scoped_ptr<ResourceEntry> entry;
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
-}
-
-TEST_F(FileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  // The transfered file is cached and the change of "offline available"
-  // attribute is notified.
-  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-  const int64 file_size = entry->file_info().size();
-
-  // Pretend we have no space first (checked before downloading a file),
-  // but then start reporting we have space. This is to emulate that
-  // the disk space was freed up by removing temporary files.
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      file_size + internal::kMinFreeSpace);
-  fake_free_disk_space_getter_->set_fake_free_disk_space(0);
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      file_size + internal::kMinFreeSpace);
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      file_size + internal::kMinFreeSpace);
-
-  // Store something of the file size in the temporary cache directory.
-  const std::string content(file_size, 'x');
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  const base::FilePath tmp_file =
-      temp_dir.path().AppendASCII("something.txt");
-  ASSERT_TRUE(google_apis::test_util::WriteStringToFile(tmp_file, content));
-
-  FileError error = FILE_ERROR_FAILED;
-  cache_->StoreOnUIThread(
-      "<resource_id>", "<md5>", tmp_file,
-      internal::FileCache::FILE_OPERATION_COPY,
-      google_apis::test_util::CreateCopyResultCallback(&error));
-  google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
-
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
-
-  // The cache entry should be removed in order to free up space.
-  ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
-}
-
-TEST_F(FileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-  const int64 file_size = entry->file_info().size();
-
-  // Pretend we have enough space first (checked before downloading a file),
-  // but then start reporting we have not enough space. This is to emulate that
-  // the disk space becomes full after the file is downloaded for some reason
-  // (ex. the actual file was larger than the expected size).
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      file_size + internal::kMinFreeSpace);
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      internal::kMinFreeSpace - 1);
-  fake_free_disk_space_getter_->set_fake_free_disk_space(
-      internal::kMinFreeSpace - 1);
-
-  FileError error = FILE_ERROR_OK;
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
-}
-
-TEST_F(FileSystemTest, GetFileByPath_FromCache) {
-  fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
-
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-
-  // Store something as cached version of this file.
-  FileError error = FILE_ERROR_OK;
-  cache_->StoreOnUIThread(
-      entry->resource_id(),
-      entry->file_specific_info().file_md5(),
-      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
-      internal::FileCache::FILE_OPERATION_COPY,
-      google_apis::test_util::CreateCopyResultCallback(&error));
-  google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(FILE_ERROR_OK, error);
-
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
-}
-
-TEST_F(FileSystemTest, GetFileByPath_HostedDocument) {
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL(
-      "drive/root/Document 1 excludeDir-test.gdoc"));
-  scoped_ptr<ResourceEntry> src_entry =
-      GetResourceEntryByPathSync(file_in_root);
-  ASSERT_TRUE(src_entry);
-
-  FileError error = FILE_ERROR_FAILED;
-  base::FilePath file_path;
-  scoped_ptr<ResourceEntry> entry;
-  file_system_->GetFileByPath(file_in_root,
-                              google_apis::test_util::CreateCopyResultCallback(
-                                  &error, &file_path, &entry));
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_TRUE(entry->file_specific_info().is_hosted_document());
-  EXPECT_FALSE(file_path.empty());
-
-  ASSERT_TRUE(src_entry);
-  VerifyHostedDocumentJSONFile(*src_entry, file_path);
-}
-
-TEST_F(FileSystemTest, GetFileByResourceId) {
-  fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
-
-  // The transfered file is cached and the change of "offline available"
-  // attribute is notified.
-  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
-
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-  std::string resource_id = entry->resource_id();
-
-  FileError error = FILE_ERROR_OK;
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByResourceId(
-      resource_id,
-      ClientContext(USER_INITIATED),
-      google_apis::test_util::CreateCopyResultCallback(
-          &error, &file_path, &entry),
-      google_apis::GetContentCallback());
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
-}
-
-TEST_F(FileSystemTest, GetFileContentByPath) {
-  fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
-
-  // The transfered file is cached and the change of "offline available"
-  // attribute is notified.
-  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
-
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-
-  {
-    FileError initialized_error = FILE_ERROR_FAILED;
-    scoped_ptr<ResourceEntry> entry;
-    base::FilePath local_path;
-    base::Closure cancel_download;
-    google_apis::test_util::TestGetContentCallback get_content_callback;
-
-    FileError completion_error = FILE_ERROR_FAILED;
-
-    file_system_->GetFileContentByPath(
-        file_in_root,
-        google_apis::test_util::CreateCopyResultCallback(
-            &initialized_error, &entry, &local_path, &cancel_download),
-        get_content_callback.callback(),
-        google_apis::test_util::CreateCopyResultCallback(&completion_error));
-    google_apis::test_util::RunBlockingPoolTask();
-
-    // For the first time, file is downloaded from the remote server.
-    // In this case, |local_path| is empty while |cancel_download| is not.
-    EXPECT_EQ(FILE_ERROR_OK, initialized_error);
-    ASSERT_TRUE(entry);
-    ASSERT_TRUE(local_path.empty());
-    EXPECT_TRUE(!cancel_download.is_null());
-    // Content is available through the second callback argument.
-    EXPECT_EQ(static_cast<size_t>(entry->file_info().size()),
-              get_content_callback.GetConcatenatedData().size());
-    EXPECT_EQ(FILE_ERROR_OK, completion_error);
-  }
-
-  {
-    FileError initialized_error = FILE_ERROR_FAILED;
-    scoped_ptr<ResourceEntry> entry;
-    base::FilePath local_path;
-    base::Closure cancel_download;
-    google_apis::test_util::TestGetContentCallback get_content_callback;
-
-    FileError completion_error = FILE_ERROR_FAILED;
-
-    file_system_->GetFileContentByPath(
-        file_in_root,
-        google_apis::test_util::CreateCopyResultCallback(
-            &initialized_error, &entry, &local_path, &cancel_download),
-        get_content_callback.callback(),
-        google_apis::test_util::CreateCopyResultCallback(&completion_error));
-    google_apis::test_util::RunBlockingPoolTask();
-
-    // Try second download. In this case, the file should be cached, so
-    // |local_path| should not be empty while |cancel_download| is empty.
-    EXPECT_EQ(FILE_ERROR_OK, initialized_error);
-    ASSERT_TRUE(entry);
-    ASSERT_TRUE(!local_path.empty());
-    EXPECT_TRUE(cancel_download.is_null());
-    // The content is available from the cache file.
-    EXPECT_TRUE(get_content_callback.data().empty());
-    int64 local_file_size = 0;
-    file_util::GetFileSize(local_path, &local_file_size);
-    EXPECT_EQ(entry->file_info().size(), local_file_size);
-    EXPECT_EQ(FILE_ERROR_OK, completion_error);
-  }
-}
-
-TEST_F(FileSystemTest, GetFileByResourceId_FromCache) {
-  fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
-
-  ASSERT_TRUE(LoadRootFeedDocument());
-
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
-  scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
-
-  // Store something as cached version of this file.
-  FileError error = FILE_ERROR_FAILED;
-  cache_->StoreOnUIThread(
-      entry->resource_id(),
-      entry->file_specific_info().file_md5(),
-      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
-      internal::FileCache::FILE_OPERATION_COPY,
-      google_apis::test_util::CreateCopyResultCallback(&error));
-  google_apis::test_util::RunBlockingPoolTask();
-  EXPECT_EQ(FILE_ERROR_OK, error);
-
-  // The file is obtained from the cache.
-  // Hence the downloading should work even if the drive service is offline.
-  fake_drive_service_->set_offline(true);
-
-  std::string resource_id = entry->resource_id();
-  base::FilePath file_path;
-  entry.reset();
-  file_system_->GetFileByResourceId(
-      resource_id,
-      ClientContext(USER_INITIATED),
-      google_apis::test_util::CreateCopyResultCallback(
-          &error, &file_path, &entry),
-      google_apis::GetContentCallback());
-  google_apis::test_util::RunBlockingPoolTask();
-
-  EXPECT_EQ(FILE_ERROR_OK, error);
-  ASSERT_TRUE(entry);
-  EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
-}
-
 TEST_F(FileSystemTest, GetAvailableSpace) {
   FileError error = FILE_ERROR_OK;
   int64 bytes_total;
   int64 bytes_used;
   file_system_->GetAvailableSpace(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &bytes_total, &bytes_used));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), bytes_used);
   EXPECT_EQ(GG_LONGLONG(9876543210), bytes_total);
@@ skipping 157 matching lines @@
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 }   // namespace drive