drive: Add test for ChangeListLoader::LoadIfNeeded with non empty DirectoryFetchInfo

chrome/browser/chromeos/drive/change_list_loader_unittest.cc

 // Copyright 2013 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/change_list_loader.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
@@ skipping 48 matching lines @@
 
  private:
   ChangeListLoader* loader_;
   std::set<base::FilePath> changed_directories_;
   int load_from_server_complete_count_;
   int initial_load_complete_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChangeListLoaderObserver);
 };
 
+class TestDriveService : public FakeDriveService {
+ public:
+  TestDriveService() : never_return_all_resource_list_(false),
+                       blocked_call_count_(0) {}
+
+  void set_never_return_all_resource_list(bool value) {
+    never_return_all_resource_list_ = value;
+  }
+
+  int blocked_call_count() const { return blocked_call_count_; }
+
+  // FakeDriveService override.
+  virtual google_apis::CancelCallback GetAllResourceList(
+      const google_apis::GetResourceListCallback& callback) OVERRIDE {
+    if (never_return_all_resource_list_) {
+      ++blocked_call_count_;
+      return google_apis::CancelCallback();
+    }
+    return FakeDriveService::GetAllResourceList(callback);
+  }
+
+ private:
+  // GetAllResourceList never returns result when this is set to true.
+  // Used to emulate the real server's slowness.
+  bool never_return_all_resource_list_;
+
+  int blocked_call_count_;  // Number of blocked method calls.
+};
+
 class ChangeListLoaderTest : public testing::Test {
  protected:
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     pref_service_.reset(new TestingPrefServiceSimple);
     test_util::RegisterDrivePrefs(pref_service_->registry());
 
-    drive_service_.reset(new FakeDriveService);
+    drive_service_.reset(new TestDriveService);
     ASSERT_TRUE(drive_service_->LoadResourceListForWapi(
         "gdata/root_feed.json"));
     ASSERT_TRUE(drive_service_->LoadAccountMetadataForWapi(
         "gdata/account_metadata.json"));
 
     scheduler_.reset(new JobScheduler(pref_service_.get(),
                                       drive_service_.get(),
                                       base::MessageLoopProxy::current().get()));
     metadata_storage_.reset(new ResourceMetadataStorage(
         temp_dir_.path(), base::MessageLoopProxy::current().get()));
@@ skipping 27 matching lines @@
         false,  // shared_with_me
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(google_apis::HTTP_CREATED, error);
     return entry.Pass();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
   scoped_ptr<TestingPrefServiceSimple> pref_service_;
-  scoped_ptr<FakeDriveService> drive_service_;
+  scoped_ptr<TestDriveService> drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<ResourceMetadataStorage,
              test_util::DestroyHelperForTests> metadata_storage_;
   scoped_ptr<ResourceMetadata, test_util::DestroyHelperForTests> metadata_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<ChangeListLoader> change_list_loader_;
 };
 
 TEST_F(ChangeListLoaderTest, LoadIfNeeded) {
   EXPECT_FALSE(change_list_loader_->IsRefreshing());
@@ skipping 82 matching lines @@
   EXPECT_EQ(1U, observer.changed_directories().count(
       util::GetDriveMyDriveRootPath()));
 
   base::FilePath file_path =
       util::GetDriveMyDriveRootPath().AppendASCII(gdata_entry->title());
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryByPath(file_path, &entry));
 }
 
+TEST_F(ChangeListLoaderTest, LoadIfNeeded_MyDrive) {
+  // Emulate the slowness of GetAllResourceList().
+  drive_service_->set_never_return_all_resource_list(true);
+
+  // Load grand root.
+  FileError error = FILE_ERROR_FAILED;
+  change_list_loader_->LoadIfNeeded(
+      DirectoryFetchInfo(util::kDriveGrandRootSpecialResourceId, 0),
+      google_apis::test_util::CreateCopyResultCallback(&error));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+
+  // GetAllResourceList() was called.
+  EXPECT_EQ(1, drive_service_->blocked_call_count());
+
+  // My Drive is present in the local metadata, but its child is not.
+  ResourceEntry entry;
+  EXPECT_EQ(FILE_ERROR_OK,
+            metadata_->GetResourceEntryByPath(util::GetDriveMyDriveRootPath(),
+                                              &entry));
+  const int mydrive_changestamp = entry.directory_specific_info().changestamp();

[kinaba, 2013/07/25 08:48:39]

changestamp should be int64

[hashimoto, 2013/07/25 09:32:10]

Good catch.
Done.

+
+  base::FilePath file_path =
+      util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
+  EXPECT_EQ(FILE_ERROR_NOT_FOUND,
+            metadata_->GetResourceEntryByPath(file_path, &entry));
+
+  // Load My Drive.
+  change_list_loader_->LoadIfNeeded(
+      DirectoryFetchInfo(drive_service_->GetRootResourceId(),
+                         mydrive_changestamp),
+      google_apis::test_util::CreateCopyResultCallback(&error));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+
+  // Now the file is present.
+  EXPECT_EQ(FILE_ERROR_OK,
+            metadata_->GetResourceEntryByPath(file_path, &entry));
+}
+
+TEST_F(ChangeListLoaderTest, LoadIfNeeded_NewDirectories) {
+  // Make local metadata up to date.
+  FileError error = FILE_ERROR_FAILED;
+  change_list_loader_->LoadIfNeeded(
+      DirectoryFetchInfo(),
+      google_apis::test_util::CreateCopyResultCallback(&error));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+
+  // Add a new file.
+  scoped_ptr<google_apis::ResourceEntry> file = AddNewFile("New File");
+  ASSERT_TRUE(file);
+
+  // Emulate the slowness of GetAllResourceList().
+  drive_service_->set_never_return_all_resource_list(true);
+
+  // Enter refreshing state.
+  FileError check_for_updates_error = FILE_ERROR_FAILED;
+  change_list_loader_->CheckForUpdates(
+      google_apis::test_util::CreateCopyResultCallback(
+          &check_for_updates_error));
+  EXPECT_TRUE(change_list_loader_->IsRefreshing());
+
+  // Load My Drive.
+  change_list_loader_->LoadIfNeeded(
+      DirectoryFetchInfo(drive_service_->GetRootResourceId(),
+                         metadata_->GetLargestChangestamp()),
+      google_apis::test_util::CreateCopyResultCallback(&error));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+
+  // The new file is present in the local metadata.
+  base::FilePath file_path =
+      util::GetDriveMyDriveRootPath().AppendASCII(file->title());
+  ResourceEntry entry;
+  EXPECT_EQ(FILE_ERROR_OK,
+            metadata_->GetResourceEntryByPath(file_path, &entry));
+}
+
 TEST_F(ChangeListLoaderTest, CheckForUpdates) {
   // CheckForUpdates() results in no-op before load.
   FileError check_for_updates_error = FILE_ERROR_FAILED;
   change_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(
           &check_for_updates_error));
   EXPECT_FALSE(change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_FAILED,
             check_for_updates_error);  // Callback was not run.
@@ skipping 49 matching lines @@
   // The new file is found in the local metadata.
   base::FilePath new_file_path =
       util::GetDriveMyDriveRootPath().AppendASCII(gdata_entry->title());
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryByPath(new_file_path, &entry));
 }
 
 }  // namespace internal
 }  // namespace drive