Support contents upload on FakeDriveService

chrome/browser/drive/fake_drive_service_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/drive/fake_drive_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/md5.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_requests.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 1607 matching lines @@
   fake_service_.InitiateUploadExistingFile(
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       "text/plain",
       13,
       "file:2_file_resource_id",
       "\"HhMOFgxXHit7ImBr\"",
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  EXPECT_EQ(GURL("https://2_file_link_resumable_create_media?mode=existing"),
-            upload_location);
+  EXPECT_TRUE(upload_location.is_valid());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
@@ skipping 52 matching lines @@
       base::FilePath(),
       test_util::CreateCopyResultCallback(&response, &entry),
       ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, response.code);
   EXPECT_FALSE(entry.get());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) {
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  base::FilePath local_file_path =
+      temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt"));
+  std::string contents("hogefugapiyo");
+  ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
+
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       "text/plain",
-      15,
+      contents.size(),
       "file:2_file_resource_id",
       "\"HhMOFgxXHit7ImBr\"",
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> entry;
   std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       upload_location,
-      0, 13, 15, "text/plain",
-      base::FilePath(),
+      0, contents.size() / 2, contents.size(), "text/plain",
+      local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(13, upload_progress_values.back().first);
+  EXPECT_GE(static_cast<int64>(contents.size() / 2),
+            upload_progress_values.back().first);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       upload_location,
-      13, 15, 15, "text/plain",
-      base::FilePath(),
+      contents.size() / 2, contents.size(), contents.size(), "text/plain",
+      local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, response.code);
   EXPECT_TRUE(entry.get());
-  EXPECT_EQ(15L, entry->file_size());
+  EXPECT_EQ(static_cast<int64>(contents.size()),
+            entry->file_size());
   EXPECT_TRUE(Exists(entry->resource_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(2, upload_progress_values.back().first);
+  EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
+            upload_progress_values.back().first);
+  EXPECT_EQ(base::MD5String(contents), entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  base::FilePath local_file_path =
+      temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo"));
+  std::string contents("hogefugapiyo");
+  ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
+
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       "test/foo",
-      15,
+      contents.size(),
       "folder:1_folder_resource_id",
       "new file.foo",
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> entry;
   std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       upload_location,
-      0, 13, 15, "test/foo",
-      base::FilePath(),
+      0, contents.size() / 2, contents.size(), "test/foo",
+      local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(13, upload_progress_values.back().first);
+  EXPECT_GE(static_cast<int64>(contents.size() / 2),
+            upload_progress_values.back().first);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       upload_location,
-      13, 15, 15, "test/foo",
-      base::FilePath(),
+      contents.size() / 2, contents.size(), contents.size(), "test/foo",
+      local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, response.code);
   EXPECT_TRUE(entry.get());
-  EXPECT_EQ(15L, entry->file_size());
+  EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size());
   EXPECT_TRUE(Exists(entry->resource_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(2, upload_progress_values.back().first);
+  EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
+            upload_progress_values.back().first);
+  EXPECT_EQ(base::MD5String(contents), entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(kContentType, resource_entry->content_mime_type());
   EXPECT_EQ(static_cast<int64>(kContentData.size()),
             resource_entry->file_size());
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ(kTitle, resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(),
                         fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
+  EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectoryOnEmptyFileSystem) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/empty_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(kContentType, resource_entry->content_mime_type());
   EXPECT_EQ(static_cast<int64>(kContentData.size()),
             resource_entry->file_size());
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ(kTitle, resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(),
                         fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
+  EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
@@ skipping 18 matching lines @@
   EXPECT_TRUE(resource_entry->is_file());
   EXPECT_EQ(kContentType, resource_entry->content_mime_type());
   EXPECT_EQ(static_cast<int64>(kContentData.size()),
             resource_entry->file_size());
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ(kTitle, resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
+  EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonexistingDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
   const std::string kParentResourceId = "folder:nonexisting_resource_id";
@@ skipping 68 matching lines @@
             resource_entry->file_size());
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ(kTitle, resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(),
                         fake_service_.GetRootResourceId()));
   ASSERT_EQ(1U, resource_entry->labels().size());
   EXPECT_EQ("shared-with-me", resource_entry->labels()[0]);
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
+  EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5());
 }
 
 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kResourceId = "file:2_file_resource_id";
   base::Time time;
   ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time));
 
@@ skipping 47 matching lines @@
       test_util::CreateCopyResultCallback(&error, &resource_entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(resource_entry);
 }
 
 }  // namespace
 
 }  // namespace drive