gdata: Add GetEntryInfoByPath() and ReadDirectoryByPath() to GDataDirectoryService

chrome/browser/chromeos/gdata/gdata_files_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/gdata/gdata_files.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/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_cache.h"
@@ skipping 174 matching lines @@
   ASSERT_FALSE(entry.FromProto(proto));
 
   // Set a upload URL.
   proto.set_upload_url(kResumableEditMediaUrl);
 
   // This should succeed as the upload URL is set.
   ASSERT_TRUE(entry.FromProto(proto));
   EXPECT_EQ(kResumableEditMediaUrl, entry.upload_url().spec());
 }
 
-TEST(GDataRootDirectoryTest, VersionCheck) {
+TEST(GDataDirectoryServiceTest, VersionCheck) {
   // Set up the root directory.
   GDataRootDirectoryProto proto;
   GDataEntryProto* mutable_entry =
       proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
   mutable_entry->set_title("drive");
 
   GDataDirectoryService directory_service;
@@ skipping 15 matching lines @@
   // This should succeed as the version matches the current number.
   ASSERT_TRUE(directory_service.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(directory_service.ParseFromString(serialized_proto));
 }
 
-TEST(GDataRootDirectoryTest, ParseFromString_DetectBadTitle) {
+TEST(GDataDirectoryServiceTest, ParseFromString_DetectBadTitle) {
   GDataRootDirectoryProto proto;
   proto.set_version(kProtoVersion);
 
   GDataEntryProto* mutable_entry =
       proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
 
   std::string serialized_proto;
@@ skipping 17 matching lines @@
 
   // Setting the title to kGDataRootDirectory.
   mutable_entry->set_title(kGDataRootDirectory);
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
 
   // This should succeed as the title is kGDataRootDirectory.
   ASSERT_TRUE(directory_service.ParseFromString(serialized_proto));
   ASSERT_EQ(kGDataRootDirectory, root->title());
 }
 
-TEST(GDataRootDirectoryTest, ParseFromString_DetectBadResourceID) {
+TEST(GDataDirectoryServiceTest, ParseFromString_DetectBadResourceID) {
   GDataRootDirectoryProto proto;
   proto.set_version(kProtoVersion);
 
   GDataEntryProto* mutable_entry =
       proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_title(kGDataRootDirectory);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
 
   std::string serialized_proto;
@@ skipping 11 matching lines @@
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
 
   // This should succeed as the resource ID is correct.
   ASSERT_TRUE(directory_service.ParseFromString(serialized_proto));
   EXPECT_EQ(kGDataRootDirectoryResourceId, root->resource_id());
 }
 
 // We have a similar test in FromProto_DetectBadUploadUrl, but the test here
 // is to ensure that an error in GDataFile::FromProto() is properly
 // propagated to GDataRootDirectory::ParseFromString().
-TEST(GDataRootDirectoryTest, ParseFromString_DetectNoUploadUrl) {
+TEST(GDataDirectoryServiceTest, ParseFromString_DetectNoUploadUrl) {
   // Set up the root directory properly.
   GDataRootDirectoryProto root_directory_proto;
   root_directory_proto.set_version(kProtoVersion);
 
   GDataEntryProto* mutable_entry =
       root_directory_proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_title(kGDataRootDirectory);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
@@ skipping 46 matching lines @@
   ASSERT_TRUE(root_directory_proto.SerializeToString(&serialized_proto));
   ASSERT_TRUE(directory_service.ParseFromString(serialized_proto));
   // No file should be added to the root directory.
   ASSERT_TRUE(root->child_files().empty());
   // Two directories ("empty", "dir") should be added to the root directory.
   ASSERT_EQ(2U, root->child_directories().size());
   // The origin should change to FROM_CACHE because we loaded from the cache.
   ASSERT_EQ(FROM_CACHE, directory_service.origin());
 }
 
-TEST(GDataRootDirectoryTest, RefreshFile) {
+TEST(GDataDirectoryServiceTest, RefreshFile) {
   MessageLoopForUI message_loop;
   GDataDirectoryService directory_service;
   GDataDirectory* root(directory_service.root());
   // Add a directory to the file system.
   GDataDirectory* directory_entry = new GDataDirectory(root,
                                                        &directory_service);
   directory_entry->set_resource_id("folder:directory_resource_id");
   directory_entry->set_title("directory");
   directory_entry->SetBaseNameFromTitle();
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
@@ skipping 35 matching lines @@
 
   // Let's try refreshing file that didn't prviously exist.
   GDataFile* non_existent_entry = new GDataFile(NULL, &directory_service);
   non_existent_entry->set_resource_id("file:does_not_exist");
   directory_service.RefreshFile(
       scoped_ptr<GDataFile>(non_existent_entry).Pass());
   // File with non existent resource id should not be added.
   EXPECT_FALSE(directory_service.GetEntryByResourceId("file:does_not_exist"));
 }
 
-TEST(GDataRootDirectoryTest, GetEntryByResourceId_RootDirectory) {
+TEST(GDataDirectoryServiceTest, GetEntryByResourceId_RootDirectory) {
   GDataDirectoryService directory_service;
   // Look up the root directory by its resource ID.
   GDataEntry* entry = directory_service.GetEntryByResourceId(
       kGDataRootDirectoryResourceId);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kGDataRootDirectoryResourceId, entry->resource_id());
 }
 
-TEST(GDataRootDirectoryTest, DBTest) {
+TEST(GDataDirectoryServiceTest, GetEntryInfoByPath) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
+  GDataDirectoryService directory_service;
+  InitDirectoryService(&directory_service);
+
+  // Confirm that an existing file is found.
+  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  scoped_ptr<GDataEntryProto> entry_proto;
+  directory_service.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/file4"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("file4", entry_proto->base_name());
+
+  // Confirm that a non existing file is not found.
+  error = GDATA_FILE_ERROR_FAILED;
+  entry_proto.reset();
+  directory_service.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/non_existing"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, error);
+  EXPECT_FALSE(entry_proto.get());
+}
+
+TEST(GDataDirectoryServiceTest, ReadDirectoryByPath) {
+  MessageLoopForUI message_loop;
+  content::TestBrowserThread ui_thread(content::BrowserThread::UI,
+                                       &message_loop);
+  GDataDirectoryService directory_service;
+  InitDirectoryService(&directory_service);
+
+  // Confirm that an existing directory is found.
+  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  scoped_ptr<GDataEntryProtoVector> entries;
+  directory_service.ReadDirectoryByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1"),
+      base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
+                 &error, &entries));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_OK, error);
+  ASSERT_TRUE(entries.get());
+  ASSERT_EQ(3U, entries->size());
+
+  // The order is not guaranteed so we should sort the base names.
+  std::vector<std::string> base_names;
+  for (size_t i = 0; i < 3; ++i)
+    base_names.push_back(entries->at(i).base_name());
+  std::sort(base_names.begin(), base_names.end());
+
+  EXPECT_EQ("dir3", base_names[0]);
+  EXPECT_EQ("file4", base_names[1]);
+  EXPECT_EQ("file5", base_names[2]);
+
+  // Confirm that a non existing directory is not found.
+  error = GDATA_FILE_ERROR_FAILED;
+  entries.reset();
+  directory_service.ReadDirectoryByPath(
+      FilePath::FromUTF8Unsafe("drive/non_existing"),
+      base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
+                 &error, &entries));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, error);
+  EXPECT_FALSE(entries.get());
+
+  // Confirm that reading a file results in GDATA_FILE_ERROR_NOT_A_DIRECTORY.
+  error = GDATA_FILE_ERROR_FAILED;
+  entries.reset();
+  directory_service.ReadDirectoryByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/file4"),
+      base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
+                 &error, &entries));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_ERROR_NOT_A_DIRECTORY, error);
+  EXPECT_FALSE(entries.get());
+}
+
+TEST(GDataDirectoryServiceTest, DBTest) {
+  MessageLoopForUI message_loop;
+  content::TestBrowserThread ui_thread(content::BrowserThread::UI,
+                                       &message_loop);
 
   scoped_ptr<TestingProfile> profile(new TestingProfile);
   scoped_refptr<base::SequencedWorkerPool> pool =
       content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
       pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
   GDataDirectoryService directory_service;
   FilePath db_path(GDataCache::GetCacheRootPath(profile.get()).
       AppendASCII("meta").AppendASCII("resource_metadata.db"));
@@ skipping 11 matching lines @@
   GDataDirectoryService directory_service2;
   // InitFromDB should succeed with GDATA_FILE_OK as the db now exists.
   directory_service2.InitFromDB(db_path, blocking_task_runner,
       base::Bind(&InitFromDBCallback, GDATA_FILE_OK));
   test_util::RunBlockingPoolTask();
 
   VerifyDirectoryService(&directory_service2);
 }
 
 }  // namespace gdata