Database support for 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 <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"
 #include "chrome/browser/chromeos/gdata/gdata_test_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 gdata {
-
 namespace {
 
 // See gdata.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
+// Add a directory to |parent| and return that directory. The name and
+// resource_id are determined by the incrementing counter |sequence_id|.
+GDataDirectory* AddDirectory(GDataDirectory* parent,
+                             GDataDirectoryService* directory_service,
+                             int sequence_id) {
+  GDataDirectory* dir = new GDataDirectory(parent, directory_service);
+  const std::string dir_name = "dir" + base::IntToString(sequence_id);
+  const std::string resource_id = std::string("dir_resource_id:") +
+                                  dir_name;
+  dir->set_title(dir_name);
+  dir->set_resource_id(resource_id);
+  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  directory_service->AddEntryToDirectory(
+      parent->GetFilePath(),
+      dir,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_OK, error);
+  return dir;
+}
+
+// Add a file to |parent| and return that file. The name and
+// resource_id are determined by the incrementing counter |sequence_id|.
+GDataFile* AddFile(GDataDirectory* parent,
+                   GDataDirectoryService* directory_service,
+                   int sequence_id) {
+  GDataFile* file = new GDataFile(parent, directory_service);
+  const std::string title = "file" + base::IntToString(sequence_id);
+  const std::string resource_id = std::string("file_resource_id:") +
+                                  title;
+  file->set_title(title);
+  file->set_resource_id(resource_id);
+  file->set_file_md5(std::string("file_md5:") + title);
+  GDataFileError error = GDATA_FILE_ERROR_FAILED;
+  directory_service->AddEntryToDirectory(
+      parent->GetFilePath(),
+      file,
+      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_OK, error);
+  return file;
+}
+
+// Creates the following files/directories
+// drive/dir1/
+// drive/dir2/
+// drive/dir1/dir3/
+// drive/dir1/file4
+// drive/dir1/file5
+// drive/dir2/file6
+// drive/dir2/file7
+// drive/dir2/file8
+// drive/dir1/dir3/file9
+// drive/dir1/dir3/file10
+void InitDirectoryService(GDataDirectoryService* directory_service) {
+  int sequence_id = 1;
+  GDataDirectory* dir1 = AddDirectory(directory_service->root(),
+      directory_service, sequence_id++);
+  GDataDirectory* dir2 = AddDirectory(directory_service->root(),
+      directory_service, sequence_id++);
+  GDataDirectory* dir3 = AddDirectory(dir1, directory_service, sequence_id++);
+
+  AddFile(dir1, directory_service, sequence_id++);
+  AddFile(dir1, directory_service, sequence_id++);
+
+  AddFile(dir2, directory_service, sequence_id++);
+  AddFile(dir2, directory_service, sequence_id++);
+  AddFile(dir2, directory_service, sequence_id++);
+
+  AddFile(dir3, directory_service, sequence_id++);
+  AddFile(dir3, directory_service, sequence_id++);
+}
+
+// Find directory by path.
+GDataDirectory* FindDirectory(GDataDirectoryService* directory_service,
+                              const char* path) {
+  return directory_service->FindEntryByPathSync(
+      FilePath(path))->AsGDataDirectory();
+}
+
+// Find file by path.
+GDataFile* FindFile(GDataDirectoryService* directory_service,
+                    const char* path) {
+  return directory_service->FindEntryByPathSync(FilePath(path))->AsGDataFile();
+}
+
+// Verify that the recreated directory service matches what we created in
+// InitDirectoryService.
+void VerifyDirectoryService(GDataDirectoryService* directory_service) {
+  ASSERT_TRUE(directory_service->root());
+
+  GDataDirectory* dir1 = FindDirectory(directory_service, "drive/dir1");
+  ASSERT_TRUE(dir1);
+  GDataDirectory* dir2 = FindDirectory(directory_service, "drive/dir2");
+  ASSERT_TRUE(dir2);
+  GDataDirectory* dir3 = FindDirectory(directory_service, "drive/dir1/dir3");
+  ASSERT_TRUE(dir3);
+
+  GDataFile* file4 = FindFile(directory_service, "drive/dir1/file4");
+  ASSERT_TRUE(file4);
+  EXPECT_EQ(file4->parent(), dir1);
+
+  GDataFile* file5 = FindFile(directory_service, "drive/dir1/file5");
+  ASSERT_TRUE(file5);
+  EXPECT_EQ(file5->parent(), dir1);
+
+  GDataFile* file6 = FindFile(directory_service, "drive/dir2/file6");
+  ASSERT_TRUE(file6);
+  EXPECT_EQ(file6->parent(), dir2);
+
+  GDataFile* file7 = FindFile(directory_service, "drive/dir2/file7");
+  ASSERT_TRUE(file7);
+  EXPECT_EQ(file7->parent(), dir2);
+
+  GDataFile* file8 = FindFile(directory_service, "drive/dir2/file8");
+  ASSERT_TRUE(file8);
+  EXPECT_EQ(file8->parent(), dir2);
+
+  GDataFile* file9 = FindFile(directory_service, "drive/dir1/dir3/file9");
+  ASSERT_TRUE(file9);
+  EXPECT_EQ(file9->parent(), dir3);
+
+  GDataFile* file10 = FindFile(directory_service, "drive/dir1/dir3/file10");
+  ASSERT_TRUE(file10);
+  EXPECT_EQ(file10->parent(), dir3);
+
+  EXPECT_EQ(dir1, directory_service->GetEntryByResourceId(
+      "dir_resource_id:dir1"));
+  EXPECT_EQ(dir2, directory_service->GetEntryByResourceId(
+      "dir_resource_id:dir2"));
+  EXPECT_EQ(dir3, directory_service->GetEntryByResourceId(
+      "dir_resource_id:dir3"));
+  EXPECT_EQ(file4, directory_service->GetEntryByResourceId(
+      "file_resource_id:file4"));
+  EXPECT_EQ(file5, directory_service->GetEntryByResourceId(
+      "file_resource_id:file5"));
+  EXPECT_EQ(file6, directory_service->GetEntryByResourceId(
+      "file_resource_id:file6"));
+  EXPECT_EQ(file7, directory_service->GetEntryByResourceId(
+      "file_resource_id:file7"));
+  EXPECT_EQ(file8, directory_service->GetEntryByResourceId(
+      "file_resource_id:file8"));
+  EXPECT_EQ(file9, directory_service->GetEntryByResourceId(
+      "file_resource_id:file9"));
+  EXPECT_EQ(file10, directory_service->GetEntryByResourceId(
+      "file_resource_id:file10"));
+}
+
+// Callback for GDataDirectoryService::InitFromDB.
+void InitFromDBCallback(GDataFileError expected_error,
+                        GDataFileError actual_error) {
+  EXPECT_EQ(expected_error, actual_error);
+}
+
 }  // namespace
 
 TEST(GDataEntryTest, FromProto_DetectBadUploadUrl) {
   GDataEntryProto proto;
   proto.set_title("test.txt");
 
   GDataEntry entry(NULL, NULL);
   // This should fail as the upload URL is empty.
   ASSERT_FALSE(entry.FromProto(proto));
 
@@ skipping 236 matching lines @@
 
 TEST(GDataRootDirectoryTest, 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) {
+  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"));
+  // InitFromDB should fail with GDATA_FILE_ERROR_NOT_FOUND since the db
+  // doesn't exist.
+  directory_service.InitFromDB(db_path, blocking_task_runner,
+      base::Bind(&InitFromDBCallback, GDATA_FILE_ERROR_NOT_FOUND));
+  test_util::RunBlockingPoolTask();
+  InitDirectoryService(&directory_service);
+
+  // Write the filesystem to db.
+  directory_service.SaveToDB();
+  test_util::RunBlockingPoolTask();
+
+  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