components/drive/team_drive_change_list_loader_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2018 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 <memory>

 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/drive/chromeos/drive_file_util.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/file_cache.h"
 #include "components/drive/chromeos/loader_controller.h"
 #include "components/drive/chromeos/resource_metadata.h"
 #include "components/drive/chromeos/team_drive_change_list_loader.h"
 #include "components/drive/event_logger.h"
 #include "components/drive/file_change.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/job_scheduler.h"
 #include "components/drive/resource_metadata_storage.h"
 #include "components/drive/service/fake_drive_service.h"
 #include "components/drive/service/test_util.h"
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "services/network/test/test_network_connection_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace drive {
 namespace internal {

 namespace {

 constexpr char kTeamDriveId[] = "team_drive_id";
 constexpr char kTeamDriveName[] = "team_drive_name";
 constexpr char kTestStartPageToken[] = "1";

 class TestChangeListLoaderObserver : public ChangeListLoaderObserver {
  public:
   TestChangeListLoaderObserver()
       : load_from_server_complete_count_(0), initial_load_complete_count_(0) {}

   ~TestChangeListLoaderObserver() override = default;

   const FileChange& changed_files() const { return changed_files_; }
   void clear_changed_files() { changed_files_.ClearForTest(); }

   int load_from_server_complete_count() const {
     return load_from_server_complete_count_;
   }
   int initial_load_complete_count() const {
     return initial_load_complete_count_;
   }

   // ChageListObserver overrides:
   void OnFileChanged(const FileChange& changed_files) override {
     changed_files_.Apply(changed_files);
   }
   void OnLoadFromServerComplete() override {
     ++load_from_server_complete_count_;
   }
   void OnInitialLoadComplete() override { ++initial_load_complete_count_; }

  private:
   FileChange changed_files_;
   int load_from_server_complete_count_;
   int initial_load_complete_count_;

   DISALLOW_COPY_AND_ASSIGN(TestChangeListLoaderObserver);
 };

 }  // namespace

 class TeamDriveChangeListLoaderTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());

     pref_service_ = std::make_unique<TestingPrefServiceSimple>();
     test_util::RegisterDrivePrefs(pref_service_->registry());

     logger_ = std::make_unique<EventLogger>();

     drive_service_ = std::make_unique<FakeDriveService>();
     ASSERT_TRUE(test_util::SetUpTeamDriveTestEntries(
         drive_service_.get(), kTeamDriveId, kTeamDriveName));

     network::TestNetworkConnectionTracker::GetInstance()->SetConnectionType(
         network::mojom::ConnectionType::CONNECTION_WIFI);
     scheduler_ = std::make_unique<JobScheduler>(
         pref_service_.get(), logger_.get(), drive_service_.get(),
         network::TestNetworkConnectionTracker::GetInstance(),
         base::ThreadTaskRunnerHandle::Get().get(), nullptr);
     metadata_storage_.reset(new ResourceMetadataStorage(
         temp_dir_.GetPath(), base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_TRUE(metadata_storage_->Initialize());

     cache_.reset(new FileCache(metadata_storage_.get(), temp_dir_.GetPath(),
                                base::ThreadTaskRunnerHandle::Get().get(),
                                nullptr /* free_disk_space_getter */));
     ASSERT_TRUE(cache_->Initialize());

     metadata_.reset(
         new ResourceMetadata(metadata_storage_.get(), cache_.get(),
                              base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());

     loader_controller_ = std::make_unique<LoaderController>();
     base::FilePath root_entry_path =
         util::GetDriveTeamDrivesRootPath().Append(kTeamDriveName);

     team_drive_change_list_loader_ =
         std::make_unique<TeamDriveChangeListLoader>(
             kTeamDriveId, root_entry_path, logger_.get(),
             base::ThreadTaskRunnerHandle::Get().get(), metadata_.get(),
             scheduler_.get(), loader_controller_.get());

     change_list_loader_observer_ =
         std::make_unique<TestChangeListLoaderObserver>();
     team_drive_change_list_loader_->AddChangeListLoaderObserver(
         change_list_loader_observer_.get());
   }

   // Adds a team drive entry to ResourceMetadata
   void AddTeamDriveEntry(const std::string& id,
                          const std::string& name,
                          const std::string& start_page_token) {
     std::string root_local_id;
     ASSERT_EQ(FILE_ERROR_OK,
               metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
                                      &root_local_id));

     std::string local_id;
     ASSERT_EQ(FILE_ERROR_OK, metadata_->AddEntry(
                                  CreateDirectoryEntryWithResourceId(
                                      name, id, root_local_id, start_page_token),
                                  &local_id));
   }

   // Creates a ResourceEntry for a directory with explicitly set resource_id.
   ResourceEntry CreateDirectoryEntryWithResourceId(
       const std::string& title,
       const std::string& resource_id,
       const std::string& parent_local_id,
       const std::string& start_page_token) {
     ResourceEntry entry;
     entry.set_title(title);
     entry.set_resource_id(resource_id);
     entry.set_parent_local_id(parent_local_id);
     entry.mutable_file_info()->set_is_directory(true);
     entry.mutable_directory_specific_info()->set_start_page_token(
         start_page_token);
     return entry;
   }

   // Adds a new file to the root directory of the service.
   std::unique_ptr<google_apis::FileResource> AddNewFile(
       const std::string& title,
       const std::string& parent_resource_id) {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_FILE_ERROR;
     std::unique_ptr<google_apis::FileResource> entry;
     drive_service_->AddNewFile(
         "text/plain", "content text", parent_resource_id, title,
         false,  // shared_with_me
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(google_apis::HTTP_CREATED, error);
     return entry;
   }

   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
   std::unique_ptr<TestingPrefServiceSimple> pref_service_;
   std::unique_ptr<EventLogger> logger_;
   std::unique_ptr<FakeDriveService> drive_service_;
   std::unique_ptr<JobScheduler> scheduler_;
   std::unique_ptr<ResourceMetadataStorage, test_util::DestroyHelperForTests>
       metadata_storage_;
   std::unique_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   std::unique_ptr<ResourceMetadata, test_util::DestroyHelperForTests> metadata_;
   std::unique_ptr<LoaderController> loader_controller_;
   std::unique_ptr<TeamDriveChangeListLoader> team_drive_change_list_loader_;
   std::unique_ptr<TestChangeListLoaderObserver> change_list_loader_observer_;
 };

 // When loading, if the local resource metadata contains a start page token then
 // we do not load from the server, just use local metadata.
 TEST_F(TeamDriveChangeListLoaderTest, MetadataRefresh) {
   AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, kTestStartPageToken);
   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());

   FileError error = FILE_ERROR_FAILED;
   team_drive_change_list_loader_->LoadIfNeeded(
       google_apis::test_util::CreateCopyResultCallback(&error));
   EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);

   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   EXPECT_EQ(1, drive_service_->start_page_token_load_count());
   EXPECT_EQ(0, drive_service_->change_list_load_count());
 }

 // Trigger a full load, by setting the start page token of the team drive in
 // resource metadata to an empty string.
 TEST_F(TeamDriveChangeListLoaderTest, FullLoad) {
   AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, std::string());
   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());

   FileError error = FILE_ERROR_FAILED;
   team_drive_change_list_loader_->LoadIfNeeded(
       google_apis::test_util::CreateCopyResultCallback(&error));
   EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);

   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   EXPECT_EQ(1, drive_service_->start_page_token_load_count());
   EXPECT_EQ(1, drive_service_->file_list_load_count());
   EXPECT_EQ(0, drive_service_->change_list_load_count());
   EXPECT_EQ(1, change_list_loader_observer_->initial_load_complete_count());
   EXPECT_EQ(1, change_list_loader_observer_->load_from_server_complete_count());
   EXPECT_TRUE(change_list_loader_observer_->changed_files().empty());

   base::FilePath file_path = util::GetDriveTeamDrivesRootPath()
                                  .AppendASCII(kTeamDriveName)
                                  .AppendASCII("File 1.txt");
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryByPath(file_path, &entry));
 }

 // CheckForUpdates will trigger a full and delta load from the server
 TEST_F(TeamDriveChangeListLoaderTest, CheckForUpdates) {
   AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, std::string());

   // CheckForUpdates() results in no-op before load.
   FileError error = FILE_ERROR_FAILED;
   team_drive_change_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_FAILED, error);

   EXPECT_EQ(0, drive_service_->file_list_load_count());
   EXPECT_EQ(0, drive_service_->start_page_token_load_count());

   // Start initial load.
   FileError load_error = FILE_ERROR_FAILED;
   team_drive_change_list_loader_->LoadIfNeeded(
       google_apis::test_util::CreateCopyResultCallback(&load_error));
   EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();

   std::string start_page_token;
   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   EXPECT_EQ(FILE_ERROR_OK, load_error);
   EXPECT_EQ(FILE_ERROR_OK,
             internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
                                         &start_page_token));
   EXPECT_FALSE(start_page_token.empty());
   EXPECT_EQ(1, drive_service_->file_list_load_count());

   std::string previous_start_page_token = start_page_token;
   // CheckForUpdates() results in no update.
   FileError check_for_updates_error = FILE_ERROR_FAILED;
   team_drive_change_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(
           &check_for_updates_error));
   EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   EXPECT_EQ(FILE_ERROR_OK,
             internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
                                         &start_page_token));
   EXPECT_EQ(previous_start_page_token, start_page_token);

   // Add a file to the service.
   std::unique_ptr<google_apis::FileResource> gdata_entry =
       AddNewFile("New File", kTeamDriveId);
   ASSERT_TRUE(gdata_entry);

   // CheckForUpdates() results in update.
   change_list_loader_observer_->clear_changed_files();
   team_drive_change_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(
           &check_for_updates_error));
   EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
   base::RunLoop().RunUntilIdle();

   EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
   EXPECT_EQ(FILE_ERROR_OK,
             internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
                                         &start_page_token));
   EXPECT_NE(previous_start_page_token, start_page_token);
   EXPECT_EQ(2, change_list_loader_observer_->load_from_server_complete_count());

   base::FilePath team_drive_path =
       util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName);
   EXPECT_TRUE(change_list_loader_observer_->changed_files().CountDirectory(
       team_drive_path));

   // The new file is found in the local metadata.
   base::FilePath new_file_path =
       team_drive_path.AppendASCII(gdata_entry->title());
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryByPath(new_file_path, &entry));
 }

 }  // namespace internal
 }  // namespace drive
	// Copyright 2018 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 <memory>

	#include "base/command_line.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "components/drive/chromeos/drive_file_util.h"
	#include "components/drive/chromeos/drive_test_util.h"
	#include "components/drive/chromeos/file_cache.h"
	#include "components/drive/chromeos/loader_controller.h"
	#include "components/drive/chromeos/resource_metadata.h"
	#include "components/drive/chromeos/team_drive_change_list_loader.h"
	#include "components/drive/event_logger.h"
	#include "components/drive/file_change.h"
	#include "components/drive/file_system_core_util.h"
	#include "components/drive/job_scheduler.h"
	#include "components/drive/resource_metadata_storage.h"
	#include "components/drive/service/fake_drive_service.h"
	#include "components/drive/service/test_util.h"
	#include "components/prefs/testing_pref_service.h"
	#include "content/public/test/test_browser_thread_bundle.h"
	#include "services/network/test/test_network_connection_tracker.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace drive {
	namespace internal {

	namespace {

	constexpr char kTeamDriveId[] = "team_drive_id";
	constexpr char kTeamDriveName[] = "team_drive_name";
	constexpr char kTestStartPageToken[] = "1";

	class TestChangeListLoaderObserver : public ChangeListLoaderObserver {
	public:
	TestChangeListLoaderObserver()
	: load_from_server_complete_count_(0), initial_load_complete_count_(0) {}

	~TestChangeListLoaderObserver() override = default;

	const FileChange& changed_files() const { return changed_files_; }
	void clear_changed_files() { changed_files_.ClearForTest(); }

	int load_from_server_complete_count() const {
	return load_from_server_complete_count_;
	}
	int initial_load_complete_count() const {
	return initial_load_complete_count_;
	}

	// ChageListObserver overrides:
	void OnFileChanged(const FileChange& changed_files) override {
	changed_files_.Apply(changed_files);
	}
	void OnLoadFromServerComplete() override {
	++load_from_server_complete_count_;
	}
	void OnInitialLoadComplete() override { ++initial_load_complete_count_; }

	private:
	FileChange changed_files_;
	int load_from_server_complete_count_;
	int initial_load_complete_count_;

	DISALLOW_COPY_AND_ASSIGN(TestChangeListLoaderObserver);
	};

	} // namespace

	class TeamDriveChangeListLoaderTest : public testing::Test {
	protected:
	void SetUp() override {
	ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());

	pref_service_ = std::make_unique<TestingPrefServiceSimple>();
	test_util::RegisterDrivePrefs(pref_service_->registry());

	logger_ = std::make_unique<EventLogger>();

	drive_service_ = std::make_unique<FakeDriveService>();
	ASSERT_TRUE(test_util::SetUpTeamDriveTestEntries(
	drive_service_.get(), kTeamDriveId, kTeamDriveName));

	network::TestNetworkConnectionTracker::GetInstance()->SetConnectionType(
	network::mojom::ConnectionType::CONNECTION_WIFI);
	scheduler_ = std::make_unique<JobScheduler>(
	pref_service_.get(), logger_.get(), drive_service_.get(),
	network::TestNetworkConnectionTracker::GetInstance(),
	base::ThreadTaskRunnerHandle::Get().get(), nullptr);
	metadata_storage_.reset(new ResourceMetadataStorage(
	temp_dir_.GetPath(), base::ThreadTaskRunnerHandle::Get().get()));
	ASSERT_TRUE(metadata_storage_->Initialize());

	cache_.reset(new FileCache(metadata_storage_.get(), temp_dir_.GetPath(),
	base::ThreadTaskRunnerHandle::Get().get(),
	nullptr /* free_disk_space_getter */));
	ASSERT_TRUE(cache_->Initialize());

	metadata_.reset(
	new ResourceMetadata(metadata_storage_.get(), cache_.get(),
	base::ThreadTaskRunnerHandle::Get().get()));
	ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());

	loader_controller_ = std::make_unique<LoaderController>();
	base::FilePath root_entry_path =
	util::GetDriveTeamDrivesRootPath().Append(kTeamDriveName);

	team_drive_change_list_loader_ =
	std::make_unique<TeamDriveChangeListLoader>(
	kTeamDriveId, root_entry_path, logger_.get(),
	base::ThreadTaskRunnerHandle::Get().get(), metadata_.get(),
	scheduler_.get(), loader_controller_.get());

	change_list_loader_observer_ =
	std::make_unique<TestChangeListLoaderObserver>();
	team_drive_change_list_loader_->AddChangeListLoaderObserver(
	change_list_loader_observer_.get());
	}

	// Adds a team drive entry to ResourceMetadata
	void AddTeamDriveEntry(const std::string& id,
	const std::string& name,
	const std::string& start_page_token) {
	std::string root_local_id;
	ASSERT_EQ(FILE_ERROR_OK,
	metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
	&root_local_id));

	std::string local_id;
	ASSERT_EQ(FILE_ERROR_OK, metadata_->AddEntry(
	CreateDirectoryEntryWithResourceId(
	name, id, root_local_id, start_page_token),
	&local_id));
	}

	// Creates a ResourceEntry for a directory with explicitly set resource_id.
	ResourceEntry CreateDirectoryEntryWithResourceId(
	const std::string& title,
	const std::string& resource_id,
	const std::string& parent_local_id,
	const std::string& start_page_token) {
	ResourceEntry entry;
	entry.set_title(title);
	entry.set_resource_id(resource_id);
	entry.set_parent_local_id(parent_local_id);
	entry.mutable_file_info()->set_is_directory(true);
	entry.mutable_directory_specific_info()->set_start_page_token(
	start_page_token);
	return entry;
	}

	// Adds a new file to the root directory of the service.
	std::unique_ptr<google_apis::FileResource> AddNewFile(
	const std::string& title,
	const std::string& parent_resource_id) {
	google_apis::DriveApiErrorCode error = google_apis::DRIVE_FILE_ERROR;
	std::unique_ptr<google_apis::FileResource> entry;
	drive_service_->AddNewFile(
	"text/plain", "content text", parent_resource_id, title,
	false, // shared_with_me
	google_apis::test_util::CreateCopyResultCallback(&error, &entry));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(google_apis::HTTP_CREATED, error);
	return entry;
	}

	content::TestBrowserThreadBundle thread_bundle_;
	base::ScopedTempDir temp_dir_;
	std::unique_ptr<TestingPrefServiceSimple> pref_service_;
	std::unique_ptr<EventLogger> logger_;
	std::unique_ptr<FakeDriveService> drive_service_;
	std::unique_ptr<JobScheduler> scheduler_;
	std::unique_ptr<ResourceMetadataStorage, test_util::DestroyHelperForTests>
	metadata_storage_;
	std::unique_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
	std::unique_ptr<ResourceMetadata, test_util::DestroyHelperForTests> metadata_;
	std::unique_ptr<LoaderController> loader_controller_;
	std::unique_ptr<TeamDriveChangeListLoader> team_drive_change_list_loader_;
	std::unique_ptr<TestChangeListLoaderObserver> change_list_loader_observer_;
	};

	// When loading, if the local resource metadata contains a start page token then
	// we do not load from the server, just use local metadata.
	TEST_F(TeamDriveChangeListLoaderTest, MetadataRefresh) {
	AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, kTestStartPageToken);
	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());

	FileError error = FILE_ERROR_FAILED;
	team_drive_change_list_loader_->LoadIfNeeded(
	google_apis::test_util::CreateCopyResultCallback(&error));
	EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);

	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	EXPECT_EQ(1, drive_service_->start_page_token_load_count());
	EXPECT_EQ(0, drive_service_->change_list_load_count());
	}

	// Trigger a full load, by setting the start page token of the team drive in
	// resource metadata to an empty string.
	TEST_F(TeamDriveChangeListLoaderTest, FullLoad) {
	AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, std::string());
	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());

	FileError error = FILE_ERROR_FAILED;
	team_drive_change_list_loader_->LoadIfNeeded(
	google_apis::test_util::CreateCopyResultCallback(&error));
	EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);

	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	EXPECT_EQ(1, drive_service_->start_page_token_load_count());
	EXPECT_EQ(1, drive_service_->file_list_load_count());
	EXPECT_EQ(0, drive_service_->change_list_load_count());
	EXPECT_EQ(1, change_list_loader_observer_->initial_load_complete_count());
	EXPECT_EQ(1, change_list_loader_observer_->load_from_server_complete_count());
	EXPECT_TRUE(change_list_loader_observer_->changed_files().empty());

	base::FilePath file_path = util::GetDriveTeamDrivesRootPath()
	.AppendASCII(kTeamDriveName)
	.AppendASCII("File 1.txt");
	ResourceEntry entry;
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(file_path, &entry));
	}

	// CheckForUpdates will trigger a full and delta load from the server
	TEST_F(TeamDriveChangeListLoaderTest, CheckForUpdates) {
	AddTeamDriveEntry(kTeamDriveId, kTeamDriveName, std::string());

	// CheckForUpdates() results in no-op before load.
	FileError error = FILE_ERROR_FAILED;
	team_drive_change_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_FAILED, error);

	EXPECT_EQ(0, drive_service_->file_list_load_count());
	EXPECT_EQ(0, drive_service_->start_page_token_load_count());

	// Start initial load.
	FileError load_error = FILE_ERROR_FAILED;
	team_drive_change_list_loader_->LoadIfNeeded(
	google_apis::test_util::CreateCopyResultCallback(&load_error));
	EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();

	std::string start_page_token;
	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	EXPECT_EQ(FILE_ERROR_OK, load_error);
	EXPECT_EQ(FILE_ERROR_OK,
	internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
	&start_page_token));
	EXPECT_FALSE(start_page_token.empty());
	EXPECT_EQ(1, drive_service_->file_list_load_count());

	std::string previous_start_page_token = start_page_token;
	// CheckForUpdates() results in no update.
	FileError check_for_updates_error = FILE_ERROR_FAILED;
	team_drive_change_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(
	&check_for_updates_error));
	EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();
	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	EXPECT_EQ(FILE_ERROR_OK,
	internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
	&start_page_token));
	EXPECT_EQ(previous_start_page_token, start_page_token);

	// Add a file to the service.
	std::unique_ptr<google_apis::FileResource> gdata_entry =
	AddNewFile("New File", kTeamDriveId);
	ASSERT_TRUE(gdata_entry);

	// CheckForUpdates() results in update.
	change_list_loader_observer_->clear_changed_files();
	team_drive_change_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(
	&check_for_updates_error));
	EXPECT_TRUE(team_drive_change_list_loader_->IsRefreshing());
	base::RunLoop().RunUntilIdle();

	EXPECT_FALSE(team_drive_change_list_loader_->IsRefreshing());
	EXPECT_EQ(FILE_ERROR_OK,
	internal::GetStartPageToken(metadata_.get(), kTeamDriveId,
	&start_page_token));
	EXPECT_NE(previous_start_page_token, start_page_token);
	EXPECT_EQ(2, change_list_loader_observer_->load_from_server_complete_count());

	base::FilePath team_drive_path =
	util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName);
	EXPECT_TRUE(change_list_loader_observer_->changed_files().CountDirectory(
	team_drive_path));

	// The new file is found in the local metadata.
	base::FilePath new_file_path =
	team_drive_path.AppendASCII(gdata_entry->title());
	ResourceEntry entry;
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(new_file_path, &entry));
	}

	} // namespace internal
	} // namespace drive