drive: Introduce kInitialChangestamp to DriveResourceMetadataTest

chrome/browser/chromeos/drive/drive_resource_metadata_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/drive_resource_metadata.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 12 matching lines @@
 
 namespace drive {
 namespace {
 
 // See drive.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
 const char kTestRootResourceId[] = "test_root";
 
+// The initial changestamp of the resource metadata used in
+// DriveResourceMetadataTest.
+const int64 kInitialChangestamp = 100;

[hashimoto, 2013/03/12 05:07:54]

"initial" seems a bit confusing, it sounds like something similar to "default".
(i.e. 0 for integer values)
How about using another term like "example" or "test"?

[satorux1, 2013/03/12 05:12:01]

Sounds reasonable. Changed it to kTestChangestamp.

+
 // Copies result from GetChildDirectoriesCallback.
 void CopyResultFromGetChildDirectoriesCallback(
     std::set<base::FilePath>* out_child_directories,
     const std::set<base::FilePath>& in_child_directories) {
   *out_child_directories = in_child_directories;
 }
 
 // Copies result from GetChangestampCallback.
 void CopyResultFromGetChangestampCallback(
     int64* out_changestamp, int64 in_changestamp) {
@@ skipping 77 matching lines @@
       resource_metadata, sequence_id++, false, "resource_id:dir2"));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir2"));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir2"));
 
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir3"));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir3"));
+
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  resource_metadata->SetLargestChangestamp(
+      kInitialChangestamp,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback,
+                 &error));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
 }
 
 // static
 DriveEntryProto DriveResourceMetadataTest::CreateDriveEntryProto(
     int sequence_id,
     bool is_directory,
     const std::string& parent_resource_id) {
   DriveEntryProto entry_proto;
   const std::string sequence_id_str = base::IntToString(sequence_id);
   const std::string title = (is_directory ? "dir" : "file") + sequence_id_str;
   const std::string resource_id = "resource_id:" + title;
   entry_proto.set_title(title);
   entry_proto.set_resource_id(resource_id);
   entry_proto.set_parent_resource_id(parent_resource_id);
 
   PlatformFileInfoProto* file_info = entry_proto.mutable_file_info();
   file_info->set_is_directory(is_directory);
 
   if (!is_directory) {
     DriveFileSpecificInfo* file_specific_info =
         entry_proto.mutable_file_specific_info();
     file_info->set_size(sequence_id * 1024);
     file_specific_info->set_file_md5(std::string("md5:") + title);
+  } else {
+    DriveDirectorySpecificInfo* directory_specific_info =
+        entry_proto.mutable_directory_specific_info();
+    directory_specific_info->set_changestamp(kInitialChangestamp);
   }
   return entry_proto;
 }
 
 bool DriveResourceMetadataTest::AddDriveEntryProto(
     DriveResourceMetadataInterface* resource_metadata,
     int sequence_id,
     bool is_directory,
     const std::string& parent_resource_id) {
   DriveEntryProto entry_proto = CreateDriveEntryProto(sequence_id,
@@ skipping 611 matching lines @@
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("file9", entry_proto->base_name());
 }
 
 TEST_F(DriveResourceMetadataTest, RefreshDirectory_EmtpyMap) {
   base::FilePath kDirectoryPath(FILE_PATH_LITERAL("drive/dir1"));
-  const int64 kChangestamp = 123;
+  const int64 kNewChangestamp = kInitialChangestamp + 1;
 
   // Read the directory.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProtoVector> entries;
   resource_metadata_->ReadDirectoryByPath(
       base::FilePath(kDirectoryPath),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   // "file4", "file5", "dir3" should exist in drive/dir1.
   ASSERT_EQ(3U, entries->size());
   std::vector<std::string> base_names = GetSortedBaseNames(*entries);
   EXPECT_EQ("dir3", base_names[0]);
   EXPECT_EQ("file4", base_names[1]);
   EXPECT_EQ("file5", base_names[2]);
 
   // Get the directory.
   scoped_ptr<DriveEntryProto> dir1_proto;
   resource_metadata_->GetEntryInfoByPath(
       kDirectoryPath,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &dir1_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(dir1_proto.get());
-  // The changestamp should be initially zero.
-  EXPECT_EQ(0, dir1_proto->directory_specific_info().changestamp());
+  // The changestamp should be initially kInitialChangestamp.
+  EXPECT_EQ(kInitialChangestamp,
+            dir1_proto->directory_specific_info().changestamp());
 
   // Update the directory with an empty map.
   base::FilePath file_path;
   DriveEntryProtoMap entry_map;
   resource_metadata_->RefreshDirectory(
-      DirectoryFetchInfo(dir1_proto->resource_id(), kChangestamp),
+      DirectoryFetchInfo(dir1_proto->resource_id(), kNewChangestamp),
       entry_map,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error,
                  &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kDirectoryPath, file_path);
 
   // Get the directory again.
   resource_metadata_->GetEntryInfoByPath(
       kDirectoryPath,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &dir1_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(dir1_proto.get());
   // The new changestamp should be set.
-  EXPECT_EQ(kChangestamp, dir1_proto->directory_specific_info().changestamp());
+  EXPECT_EQ(kNewChangestamp,
+            dir1_proto->directory_specific_info().changestamp());
 
   // Read the directory again.
   resource_metadata_->ReadDirectoryByPath(
       base::FilePath(kDirectoryPath),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   // "file4", "file5" should be gone now, as RefreshDirectory() was called
   // with an empty map. "dir3" should still remain, as RefreshDirectory()
   // does not touch directories at this moment. TODO(satorux):
   // RefreshDirectory() should update directories too. crbug.com/178348
   ASSERT_EQ(1U, entries->size());
   base_names = GetSortedBaseNames(*entries);
   EXPECT_EQ("dir3", base_names[0]);
 }
 
 TEST_F(DriveResourceMetadataTest, RefreshDirectory_NonEmptyMap) {
   base::FilePath kDirectoryPath(FILE_PATH_LITERAL("drive/dir1"));
-  const int64 kChangestamp = 123;
+  const int64 kNewChangestamp = kInitialChangestamp + 1;
 
   // Read the directory.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProtoVector> entries;
   resource_metadata_->ReadDirectoryByPath(
       base::FilePath(kDirectoryPath),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   // "file4", "file5", "dir3" should exist in drive/dir1.
   ASSERT_EQ(3U, entries->size());
   std::vector<std::string> base_names = GetSortedBaseNames(*entries);
   EXPECT_EQ("dir3", base_names[0]);
   EXPECT_EQ("file4", base_names[1]);
   EXPECT_EQ("file5", base_names[2]);
 
   // Get the directory.
   scoped_ptr<DriveEntryProto> dir1_proto;
   resource_metadata_->GetEntryInfoByPath(
       kDirectoryPath,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &dir1_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(dir1_proto.get());
-  // The changestamp should be initially zero.
-  EXPECT_EQ(0, dir1_proto->directory_specific_info().changestamp());
+  // The changestamp should be initially kInitialChangestamp.
+  EXPECT_EQ(kInitialChangestamp,
+            dir1_proto->directory_specific_info().changestamp());
 
   // Create a map with a new file.
   DriveEntryProto new_file;
   new_file.set_title("new_file");
   new_file.set_resource_id("new_resource_id");
   new_file.set_parent_resource_id(dir1_proto->resource_id());
   DriveEntryProtoMap entry_map;
   entry_map["new_resource_id"] = new_file;
 
   // Update the directory with the map.
   base::FilePath file_path;
   resource_metadata_->RefreshDirectory(
-      DirectoryFetchInfo(dir1_proto->resource_id(), kChangestamp),
+      DirectoryFetchInfo(dir1_proto->resource_id(), kNewChangestamp),
       entry_map,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error,
                  &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kDirectoryPath, file_path);
 
   // Get the directory again.
   resource_metadata_->GetEntryInfoByPath(
       kDirectoryPath,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &dir1_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(dir1_proto.get());
   // The new changestamp should be set.
-  EXPECT_EQ(kChangestamp, dir1_proto->directory_specific_info().changestamp());
+  EXPECT_EQ(kNewChangestamp,
+            dir1_proto->directory_specific_info().changestamp());
 
   // Read the directory again.
   resource_metadata_->ReadDirectoryByPath(
       base::FilePath(kDirectoryPath),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   // "file4", "file5" should be gone now, and "new_file" should now be added.
@@ skipping 162 matching lines @@
       base::FilePath::FromUTF8Unsafe("drive"),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   EXPECT_TRUE(entries->empty());
 }
 
 TEST_F(DriveResourceMetadataTest, PerDirectoryChangestamp) {
-  const int kChangestamp = 123;
+  const int kNewChangestamp = kInitialChangestamp + 1;
   const char kSubDirectoryResourceId[] = "sub-directory-id";
 
   DriveRootDirectoryProto proto;
   proto.set_version(kProtoVersion);
-  proto.set_largest_changestamp(kChangestamp);
+  proto.set_largest_changestamp(kNewChangestamp);
 
   // Set up the root directory.
   DriveDirectoryProto* root = proto.mutable_drive_directory();
   DriveEntryProto* root_entry = root->mutable_drive_entry();
   root_entry->mutable_file_info()->set_is_directory(true);
   root_entry->set_resource_id(kTestRootResourceId);
   root_entry->set_title("drive");
   // Add a sub directory.
   DriveDirectoryProto* directory = root->add_child_directories();
   DriveEntryProto* directory_entry = directory->mutable_drive_entry();
@@ skipping 13 matching lines @@
 
   // Confirm that the root directory contains the changestamp.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry_proto;
   resource_metadata.GetEntryInfoByPath(
       base::FilePath::FromUTF8Unsafe("drive"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
-  EXPECT_EQ(kChangestamp, entry_proto->directory_specific_info().changestamp());
+  EXPECT_EQ(kNewChangestamp,
+            entry_proto->directory_specific_info().changestamp());
 
   // Confirm that the sub directory contains the changestamp.
   resource_metadata.GetEntryInfoByPath(
       base::FilePath::FromUTF8Unsafe("drive/directory"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
-  EXPECT_EQ(kChangestamp, entry_proto->directory_specific_info().changestamp());
+  EXPECT_EQ(kNewChangestamp,
+            entry_proto->directory_specific_info().changestamp());
 
   // Save the current metadata to a string as serialized proto.
   std::string new_serialized_proto;
   resource_metadata.SerializeToString(&new_serialized_proto);
   // Read the proto to see if per-directory changestamps were properly saved.
   DriveRootDirectoryProto new_proto;
   ASSERT_TRUE(new_proto.ParseFromString(new_serialized_proto));
 
   // Confirm that the root directory contains the changestamp.
   const DriveDirectoryProto& root_proto = new_proto.drive_directory();
-  EXPECT_EQ(kChangestamp,
+  EXPECT_EQ(kNewChangestamp,
             root_proto.drive_entry().directory_specific_info().changestamp());
 
   // Confirm that the sub directory contains the changestamp.
   ASSERT_EQ(1, new_proto.drive_directory().child_directories_size());
   const DriveDirectoryProto& dir_proto = root_proto.child_directories(0);
-  EXPECT_EQ(kChangestamp,
+  EXPECT_EQ(kNewChangestamp,
             dir_proto.drive_entry().directory_specific_info().changestamp());
 
 }
 
 }  // namespace drive