Set root resource ID upon full feed update.

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>
 
 #include "base/sequenced_task_runner.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_files.h"
 #include "chrome/browser/chromeos/drive/drive_test_util.h"
+#include "chrome/browser/google_apis/gdata_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace {
 
+// The root directory resource ID for WAPI.
+// TODO(haruki): Make Drive API equivalent work. http://crbug.com/157114
+const char kTestRootDirectoryResourceId[] = "folder:fakeroot";

[satorux1, 2012/10/23 08:06:26]

I guess we don't need this. What's wrong with using
kWAPIRootDirectoryResourceId?

[kochi, 2012/10/23 08:21:21]

The idea is that we should not assume that the root
resource id is constant "folder:fakeroot".

If we give "folder:root", some tests ran just fine, while
if I turn on --enable-drive-v2-api it failed immediately.
So using a different ID is useful.

I would also like to change drive_file_system_unittest.cc
as well to use the different constant.

+
 // See drive.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
 // Callback for DriveResourceMetadata::InitFromDB.
 void InitFromDBCallback(DriveFileError expected_error,
                         DriveFileError actual_error) {
   EXPECT_EQ(expected_error, actual_error);
 }
 
@@ skipping 40 matching lines @@
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
 };
 
 DriveResourceMetadataTest::DriveResourceMetadataTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   Init();
 }
 
 void DriveResourceMetadataTest::Init() {
+  resource_metadata_.InitializeRootEntry(kTestRootDirectoryResourceId);
+
   int sequence_id = 1;
   DriveDirectory* dir1 = AddDirectory(resource_metadata_.root(), sequence_id++);
   DriveDirectory* dir2 = AddDirectory(resource_metadata_.root(), sequence_id++);
   DriveDirectory* dir3 = AddDirectory(dir1, sequence_id++);
 
   AddFile(dir1, sequence_id++);
   AddFile(dir1, sequence_id++);
 
   AddFile(dir2, sequence_id++);
   AddFile(dir2, sequence_id++);
@@ skipping 29 matching lines @@
 
   return file.release();
 }
 
 TEST_F(DriveResourceMetadataTest, VersionCheck) {
   // Set up the root directory.
   DriveRootDirectoryProto proto;
   DriveEntryProto* mutable_entry =
       proto.mutable_drive_directory()->mutable_drive_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
-  mutable_entry->set_resource_id(kDriveRootDirectoryResourceId);
+  mutable_entry->set_resource_id(kTestRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
   mutable_entry->set_title("drive");
 
   DriveResourceMetadata resource_metadata;
+  resource_metadata.InitializeRootEntry(kTestRootDirectoryResourceId);
 
   std::string serialized_proto;
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is emtpy.
   ASSERT_FALSE(resource_metadata.ParseFromString(serialized_proto));
 
   // Set an older version, and serialize.
   proto.set_version(kProtoVersion - 1);
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is older.
   ASSERT_FALSE(resource_metadata.ParseFromString(serialized_proto));
 
   // Set the current version, and serialize.
   proto.set_version(kProtoVersion);
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should succeed as the version matches the current number.
   ASSERT_TRUE(resource_metadata.ParseFromString(serialized_proto));
 
   // Set a newer version, and serialize.
   proto.set_version(kProtoVersion + 1);
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is newer.
   ASSERT_FALSE(resource_metadata.ParseFromString(serialized_proto));
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryByResourceId_RootDirectory) {
   DriveResourceMetadata resource_metadata;
+  resource_metadata.InitializeRootEntry(kTestRootDirectoryResourceId);
+  EXPECT_EQ(kTestRootDirectoryResourceId,
+            resource_metadata.root_resource_id());
   // Look up the root directory by its resource ID.
   DriveEntry* entry = resource_metadata.GetEntryByResourceId(
-      kDriveRootDirectoryResourceId);
+      resource_metadata.root_resource_id());
   ASSERT_TRUE(entry);
-  EXPECT_EQ(kDriveRootDirectoryResourceId, entry->resource_id());
+  EXPECT_EQ(kTestRootDirectoryResourceId, entry->resource_id());
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId) {
   // Confirm that an existing file is found.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
   resource_metadata_.GetEntryInfoByResourceId(
       "file_resource_id:file4",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
@@ skipping 170 matching lines @@
   resource_metadata_.SaveToDB();
   google_apis::test_util::RunBlockingPoolTask();
 
   // InitFromDB should fail with DRIVE_FILE_ERROR_IN_USE.
   resource_metadata_.InitFromDB(db_path, blocking_task_runner,
       base::Bind(&InitFromDBCallback, DRIVE_FILE_ERROR_IN_USE));
   google_apis::test_util::RunBlockingPoolTask();
 
   // InitFromDB should succeed.
   DriveResourceMetadata test_resource_metadata;
+  test_resource_metadata.InitializeRootEntry(kTestRootDirectoryResourceId);
   test_resource_metadata.InitFromDB(db_path, blocking_task_runner,
       base::Bind(&InitFromDBCallback, DRIVE_FILE_OK));
   google_apis::test_util::RunBlockingPoolTask();
 
   // Verify by checking for drive/dir2, which should have 3 children.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProtoVector> entries;
   test_resource_metadata.ReadDirectoryByPath(
       FilePath::FromUTF8Unsafe("drive/dir2"),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
@@ skipping 71 matching lines @@
   // Remove unknown resource_id using RemoveEntryFromParent.
   resource_metadata_.RemoveEntryFromParent(
       "foo",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
           &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   // Try removing root. This should fail.
   resource_metadata_.RemoveEntryFromParent(
-      kDriveRootDirectoryResourceId,
+      resource_metadata_.root_resource_id(),
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
           &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_ACCESS_DENIED, error);
 }
 
 TEST_F(DriveResourceMetadataTest, MoveEntryToDirectory) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
@@ skipping 126 matching lines @@
       FilePath::FromUTF8Unsafe("drive/dir2/file11"),
       "file11",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
   EXPECT_EQ(FilePath(), drive_file_path);
 }
 
 }  // namespace drive