components/drive/team_drive_list_loader_unittest.cc - chromium/src - 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/files/scoped_temp_dir.h"
 #include "components/drive/chromeos/change_list_loader.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/loader_controller.h"
 #include "components/drive/chromeos/resource_metadata.h"
 #include "components/drive/chromeos/team_drive_list_loader.h"
 #include "components/drive/event_logger.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/job_scheduler.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 "google_apis/drive/test_util.h"
 #include "services/network/test/test_network_connection_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace drive {
 namespace internal {

 namespace {

 constexpr char kTestStartPageToken[] = "123456";

 class TestTeamDriveListObserver : public TeamDriveListObserver {
  public:
   ~TestTeamDriveListObserver() override = default;

   void OnTeamDriveListLoaded(
       const std::vector<TeamDrive>& team_drives_list,
       const std::vector<TeamDrive>& added_team_drives,
       const std::vector<TeamDrive>& removed_team_drives) override {
     team_drives_list_ = team_drives_list;
     added_team_drives_ = added_team_drives;
     removed_team_drives_ = removed_team_drives;
   }

   const std::vector<TeamDrive>& team_drives_list() const {
     return team_drives_list_;
   }

   const std::vector<TeamDrive>& added_team_drives() const {
     return added_team_drives_;
   }

   const std::vector<TeamDrive>& removed_team_drives() const {
     return removed_team_drives_;
   }

  private:
   std::vector<TeamDrive> team_drives_list_;
   std::vector<TeamDrive> added_team_drives_;
   std::vector<TeamDrive> removed_team_drives_;
 };

 }  // namespace

 class TeamDriveListLoaderTest : 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::SetUpTestEntries(drive_service_.get()));
     drive_service_->set_default_max_results(2);

     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>();
     team_drive_list_loader_ = std::make_unique<TeamDriveListLoader>(
         logger_.get(), base::ThreadTaskRunnerHandle::Get().get(),
         metadata_.get(), scheduler_.get(), loader_controller_.get());

     team_drive_list_observer_ = std::make_unique<TestTeamDriveListObserver>();
     team_drive_list_loader_->AddObserver(team_drive_list_observer_.get());
   }

   // 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) {
     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(
         kTestStartPageToken);
     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<TeamDriveListLoader> team_drive_list_loader_;
   std::unique_ptr<TestTeamDriveListObserver> team_drive_list_observer_;
 };

 // Tests that if there are no team drives on the server, we will not add
 // and team drives to local metadata.
 TEST_F(TeamDriveListLoaderTest, NoTeamDrives) {
   // Tests the response if there are no team drives loaded.
   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->LoadIfNeeded(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_TRUE(team_drive_list_observer_->team_drives_list().empty());
   EXPECT_TRUE(team_drive_list_observer_->added_team_drives().empty());
   EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

   ResourceEntryVector entries;
   EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
                                util::GetDriveTeamDrivesRootPath(), &entries));
   EXPECT_TRUE(entries.empty());
 }

 // Tests if there is one team drive on the server we will add it to the local
 // metadata.
 TEST_F(TeamDriveListLoaderTest, OneTeamDrive) {
   constexpr char kTeamDriveId1[] = "the1stTeamDriveId";
   constexpr char kTeamDriveName1[] = "The First Team Drive";
   drive_service_->AddTeamDrive(kTeamDriveId1, kTeamDriveName1);

   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_EQ(1UL, team_drive_list_observer_->team_drives_list().size());
   EXPECT_EQ(1UL, team_drive_list_observer_->added_team_drives().size());
   EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

   ResourceEntryVector entries;
   EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
                                util::GetDriveTeamDrivesRootPath(), &entries));
   EXPECT_EQ(1UL, entries.size());

   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK,
             metadata_->GetResourceEntryByPath(
                 util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName1),
                 &entry));

   const base::FilePath& team_drive_path =
       team_drive_list_observer_->team_drives_list().front().team_drive_path();
   EXPECT_EQ(team_drive_path,
             util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName1));
 }

 TEST_F(TeamDriveListLoaderTest, NotmalizedTeamDriveName) {
   constexpr char kTeamDriveId1[] = "the1stTeamDriveId";
   constexpr char kTeamDriveName1[] = "A / Strange / Team / Drive / Name";
   constexpr char kTeamDriveNormalized1[] = "A _ Strange _ Team _ Drive _ Name";
   drive_service_->AddTeamDrive(kTeamDriveId1, kTeamDriveName1);

   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_EQ(1UL, team_drive_list_observer_->team_drives_list().size());
   EXPECT_EQ(1UL, team_drive_list_observer_->added_team_drives().size());
   EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

   ResourceEntryVector entries;
   EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
                                util::GetDriveTeamDrivesRootPath(), &entries));
   EXPECT_EQ(1UL, entries.size());

   ResourceEntry entry;
   EXPECT_EQ(
       FILE_ERROR_OK,
       metadata_->GetResourceEntryByPath(
           util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1),
           &entry));

   {
     const base::FilePath& team_drive_path =
         team_drive_list_observer_->team_drives_list().front().team_drive_path();
     EXPECT_EQ(team_drive_path,
               util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1));
   }
   {
     const base::FilePath& team_drive_path =
         team_drive_list_observer_->added_team_drives()
             .front()
             .team_drive_path();
     EXPECT_EQ(team_drive_path,
               util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1));
   }
 }

 // Tests if there are multiple team drives on the server, we will add them all
 // to local metadata.
 TEST_F(TeamDriveListLoaderTest, MultipleTeamDrive) {
   const std::vector<std::pair<std::string, std::string>> team_drives = {
       {"the1stTeamDriveId", "The First Team Drive"},
       {"the2ndTeamDriveId", "The Second Team Drive"},
       {"the3rdTeamDriveId", "The Third Team Drive"},
       {"the4thTeamDriveId", "The Forth Team Drive"},
   };

   for (const auto& drive : team_drives) {
     drive_service_->AddTeamDrive(drive.first, drive.second);
   }

   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_EQ(team_drives.size(),
             team_drive_list_observer_->team_drives_list().size());
   EXPECT_EQ(team_drives.size(),
             team_drive_list_observer_->added_team_drives().size());
   EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

   ResourceEntryVector entries;
   EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
                                util::GetDriveTeamDrivesRootPath(), &entries));
   EXPECT_EQ(team_drives.size(), entries.size());

   ResourceEntry entry;

   for (const auto& drive : team_drives) {
     EXPECT_EQ(FILE_ERROR_OK,
               metadata_->GetResourceEntryByPath(
                   util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
                   &entry));
     EXPECT_EQ(drive.first, entry.resource_id());
     EXPECT_EQ(drive.second, entry.base_name());
     EXPECT_TRUE(entry.file_info().is_directory());
     EXPECT_EQ("", entry.directory_specific_info().start_page_token());
   }
 }

 // Tests that is we have existing team drives in local metadata, and we add
 // new team drives from the server, that we retain the pre-existing local
 // metadata.
 TEST_F(TeamDriveListLoaderTest, RetainExistingMetadata) {
   const std::vector<std::pair<std::string, std::string>> new_team_drives = {
       {"the3rdTeamDriveId", "The Third Team Drive"},
       {"the4thTeamDriveId", "The Forth Team Drive"},
   };

   const std::vector<std::pair<std::string, std::string>> old_team_drives = {
       {"the1stTeamDriveId", "The First Team Drive"},
       {"the2ndTeamDriveId", "The Second Team Drive"},
   };

   for (const auto& drive : old_team_drives) {
     drive_service_->AddTeamDrive(drive.first, drive.second);
   }

   for (const auto& drive : new_team_drives) {
     drive_service_->AddTeamDrive(drive.first, drive.second);
   }

   std::string root_local_id;
   ASSERT_EQ(FILE_ERROR_OK,
             metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
                                    &root_local_id));

   for (const auto& drive : old_team_drives) {
     std::string local_id;
     ASSERT_EQ(FILE_ERROR_OK,
               metadata_->AddEntry(CreateDirectoryEntryWithResourceId(
                                       drive.second, drive.first, root_local_id),
                                   &local_id));
   }

   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_EQ(old_team_drives.size() + new_team_drives.size(),
             team_drive_list_observer_->team_drives_list().size());
   EXPECT_EQ(new_team_drives.size(),
             team_drive_list_observer_->added_team_drives().size());
   EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

   ResourceEntryVector entries;
   EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
                                util::GetDriveTeamDrivesRootPath(), &entries));
   EXPECT_EQ(new_team_drives.size() + old_team_drives.size(), entries.size());

   ResourceEntry entry;
   for (const auto& drive : new_team_drives) {
     EXPECT_EQ(FILE_ERROR_OK,
               metadata_->GetResourceEntryByPath(
                   util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
                   &entry));
     EXPECT_EQ(drive.first, entry.resource_id());
     EXPECT_EQ(drive.second, entry.base_name());
     EXPECT_TRUE(entry.file_info().is_directory());
     EXPECT_EQ("", entry.directory_specific_info().start_page_token());
   }

   for (const auto& drive : old_team_drives) {
     EXPECT_EQ(FILE_ERROR_OK,
               metadata_->GetResourceEntryByPath(
                   util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
                   &entry));
     EXPECT_EQ(drive.first, entry.resource_id());
     EXPECT_EQ(drive.second, entry.base_name());
     EXPECT_TRUE(entry.file_info().is_directory());
     EXPECT_EQ(kTestStartPageToken,
               entry.directory_specific_info().start_page_token());
   }
 }

 // Tests that if we we had team drives stored locally that are no longer on the
 // server that we deleted them correctly.
 TEST_F(TeamDriveListLoaderTest, RemoveMissingTeamDriveFromMetadata) {
   const std::vector<std::pair<std::string, std::string>> old_team_drives = {
       {"the1stTeamDriveId", "The First Team Drive"},
       {"the2ndTeamDriveId", "The Second Team Drive"},
   };

   std::string root_local_id;
   ASSERT_EQ(FILE_ERROR_OK,
             metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
                                    &root_local_id));

   for (const auto& drive : old_team_drives) {
     std::string local_id;
     ASSERT_EQ(FILE_ERROR_OK,
               metadata_->AddEntry(CreateDirectoryEntryWithResourceId(
                                       drive.second, drive.first, root_local_id),
                                   &local_id));
   }

   FileError error = FILE_ERROR_FAILED;
   team_drive_list_loader_->CheckForUpdates(
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

   EXPECT_TRUE(team_drive_list_observer_->team_drives_list().empty());
   EXPECT_TRUE(team_drive_list_observer_->added_team_drives().empty());
   EXPECT_EQ(old_team_drives.size(),
             team_drive_list_observer_->removed_team_drives().size());

   ResourceEntry entry;
   for (const auto& drive : old_team_drives) {
     EXPECT_EQ(FILE_ERROR_NOT_FOUND,
               metadata_->GetResourceEntryByPath(
                   util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
                   &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/files/scoped_temp_dir.h"
	#include "components/drive/chromeos/change_list_loader.h"
	#include "components/drive/chromeos/drive_test_util.h"
	#include "components/drive/chromeos/loader_controller.h"
	#include "components/drive/chromeos/resource_metadata.h"
	#include "components/drive/chromeos/team_drive_list_loader.h"
	#include "components/drive/event_logger.h"
	#include "components/drive/file_system_core_util.h"
	#include "components/drive/job_scheduler.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 "google_apis/drive/test_util.h"
	#include "services/network/test/test_network_connection_tracker.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace drive {
	namespace internal {

	namespace {

	constexpr char kTestStartPageToken[] = "123456";

	class TestTeamDriveListObserver : public TeamDriveListObserver {
	public:
	~TestTeamDriveListObserver() override = default;

	void OnTeamDriveListLoaded(
	const std::vector<TeamDrive>& team_drives_list,
	const std::vector<TeamDrive>& added_team_drives,
	const std::vector<TeamDrive>& removed_team_drives) override {
	team_drives_list_ = team_drives_list;
	added_team_drives_ = added_team_drives;
	removed_team_drives_ = removed_team_drives;
	}

	const std::vector<TeamDrive>& team_drives_list() const {
	return team_drives_list_;
	}

	const std::vector<TeamDrive>& added_team_drives() const {
	return added_team_drives_;
	}

	const std::vector<TeamDrive>& removed_team_drives() const {
	return removed_team_drives_;
	}

	private:
	std::vector<TeamDrive> team_drives_list_;
	std::vector<TeamDrive> added_team_drives_;
	std::vector<TeamDrive> removed_team_drives_;
	};

	} // namespace

	class TeamDriveListLoaderTest : 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::SetUpTestEntries(drive_service_.get()));
	drive_service_->set_default_max_results(2);

	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>();
	team_drive_list_loader_ = std::make_unique<TeamDriveListLoader>(
	logger_.get(), base::ThreadTaskRunnerHandle::Get().get(),
	metadata_.get(), scheduler_.get(), loader_controller_.get());

	team_drive_list_observer_ = std::make_unique<TestTeamDriveListObserver>();
	team_drive_list_loader_->AddObserver(team_drive_list_observer_.get());
	}

	// 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) {
	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(
	kTestStartPageToken);
	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<TeamDriveListLoader> team_drive_list_loader_;
	std::unique_ptr<TestTeamDriveListObserver> team_drive_list_observer_;
	};

	// Tests that if there are no team drives on the server, we will not add
	// and team drives to local metadata.
	TEST_F(TeamDriveListLoaderTest, NoTeamDrives) {
	// Tests the response if there are no team drives loaded.
	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->LoadIfNeeded(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_TRUE(team_drive_list_observer_->team_drives_list().empty());
	EXPECT_TRUE(team_drive_list_observer_->added_team_drives().empty());
	EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

	ResourceEntryVector entries;
	EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
	util::GetDriveTeamDrivesRootPath(), &entries));
	EXPECT_TRUE(entries.empty());
	}

	// Tests if there is one team drive on the server we will add it to the local
	// metadata.
	TEST_F(TeamDriveListLoaderTest, OneTeamDrive) {
	constexpr char kTeamDriveId1[] = "the1stTeamDriveId";
	constexpr char kTeamDriveName1[] = "The First Team Drive";
	drive_service_->AddTeamDrive(kTeamDriveId1, kTeamDriveName1);

	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_EQ(1UL, team_drive_list_observer_->team_drives_list().size());
	EXPECT_EQ(1UL, team_drive_list_observer_->added_team_drives().size());
	EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

	ResourceEntryVector entries;
	EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
	util::GetDriveTeamDrivesRootPath(), &entries));
	EXPECT_EQ(1UL, entries.size());

	ResourceEntry entry;
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName1),
	&entry));

	const base::FilePath& team_drive_path =
	team_drive_list_observer_->team_drives_list().front().team_drive_path();
	EXPECT_EQ(team_drive_path,
	util::GetDriveTeamDrivesRootPath().AppendASCII(kTeamDriveName1));
	}

	TEST_F(TeamDriveListLoaderTest, NotmalizedTeamDriveName) {
	constexpr char kTeamDriveId1[] = "the1stTeamDriveId";
	constexpr char kTeamDriveName1[] = "A / Strange / Team / Drive / Name";
	constexpr char kTeamDriveNormalized1[] = "A _ Strange _ Team _ Drive _ Name";
	drive_service_->AddTeamDrive(kTeamDriveId1, kTeamDriveName1);

	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_EQ(1UL, team_drive_list_observer_->team_drives_list().size());
	EXPECT_EQ(1UL, team_drive_list_observer_->added_team_drives().size());
	EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

	ResourceEntryVector entries;
	EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
	util::GetDriveTeamDrivesRootPath(), &entries));
	EXPECT_EQ(1UL, entries.size());

	ResourceEntry entry;
	EXPECT_EQ(
	FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1),
	&entry));

	{
	const base::FilePath& team_drive_path =
	team_drive_list_observer_->team_drives_list().front().team_drive_path();
	EXPECT_EQ(team_drive_path,
	util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1));
	}
	{
	const base::FilePath& team_drive_path =
	team_drive_list_observer_->added_team_drives()
	.front()
	.team_drive_path();
	EXPECT_EQ(team_drive_path,
	util::GetDriveTeamDrivesRootPath().Append(kTeamDriveNormalized1));
	}
	}

	// Tests if there are multiple team drives on the server, we will add them all
	// to local metadata.
	TEST_F(TeamDriveListLoaderTest, MultipleTeamDrive) {
	const std::vector<std::pair<std::string, std::string>> team_drives = {
	{"the1stTeamDriveId", "The First Team Drive"},
	{"the2ndTeamDriveId", "The Second Team Drive"},
	{"the3rdTeamDriveId", "The Third Team Drive"},
	{"the4thTeamDriveId", "The Forth Team Drive"},
	};

	for (const auto& drive : team_drives) {
	drive_service_->AddTeamDrive(drive.first, drive.second);
	}

	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_EQ(team_drives.size(),
	team_drive_list_observer_->team_drives_list().size());
	EXPECT_EQ(team_drives.size(),
	team_drive_list_observer_->added_team_drives().size());
	EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

	ResourceEntryVector entries;
	EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
	util::GetDriveTeamDrivesRootPath(), &entries));
	EXPECT_EQ(team_drives.size(), entries.size());

	ResourceEntry entry;

	for (const auto& drive : team_drives) {
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
	&entry));
	EXPECT_EQ(drive.first, entry.resource_id());
	EXPECT_EQ(drive.second, entry.base_name());
	EXPECT_TRUE(entry.file_info().is_directory());
	EXPECT_EQ("", entry.directory_specific_info().start_page_token());
	}
	}

	// Tests that is we have existing team drives in local metadata, and we add
	// new team drives from the server, that we retain the pre-existing local
	// metadata.
	TEST_F(TeamDriveListLoaderTest, RetainExistingMetadata) {
	const std::vector<std::pair<std::string, std::string>> new_team_drives = {
	{"the3rdTeamDriveId", "The Third Team Drive"},
	{"the4thTeamDriveId", "The Forth Team Drive"},
	};

	const std::vector<std::pair<std::string, std::string>> old_team_drives = {
	{"the1stTeamDriveId", "The First Team Drive"},
	{"the2ndTeamDriveId", "The Second Team Drive"},
	};

	for (const auto& drive : old_team_drives) {
	drive_service_->AddTeamDrive(drive.first, drive.second);
	}

	for (const auto& drive : new_team_drives) {
	drive_service_->AddTeamDrive(drive.first, drive.second);
	}

	std::string root_local_id;
	ASSERT_EQ(FILE_ERROR_OK,
	metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
	&root_local_id));

	for (const auto& drive : old_team_drives) {
	std::string local_id;
	ASSERT_EQ(FILE_ERROR_OK,
	metadata_->AddEntry(CreateDirectoryEntryWithResourceId(
	drive.second, drive.first, root_local_id),
	&local_id));
	}

	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_EQ(old_team_drives.size() + new_team_drives.size(),
	team_drive_list_observer_->team_drives_list().size());
	EXPECT_EQ(new_team_drives.size(),
	team_drive_list_observer_->added_team_drives().size());
	EXPECT_TRUE(team_drive_list_observer_->removed_team_drives().empty());

	ResourceEntryVector entries;
	EXPECT_EQ(FILE_ERROR_OK, metadata_->ReadDirectoryByPath(
	util::GetDriveTeamDrivesRootPath(), &entries));
	EXPECT_EQ(new_team_drives.size() + old_team_drives.size(), entries.size());

	ResourceEntry entry;
	for (const auto& drive : new_team_drives) {
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
	&entry));
	EXPECT_EQ(drive.first, entry.resource_id());
	EXPECT_EQ(drive.second, entry.base_name());
	EXPECT_TRUE(entry.file_info().is_directory());
	EXPECT_EQ("", entry.directory_specific_info().start_page_token());
	}

	for (const auto& drive : old_team_drives) {
	EXPECT_EQ(FILE_ERROR_OK,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
	&entry));
	EXPECT_EQ(drive.first, entry.resource_id());
	EXPECT_EQ(drive.second, entry.base_name());
	EXPECT_TRUE(entry.file_info().is_directory());
	EXPECT_EQ(kTestStartPageToken,
	entry.directory_specific_info().start_page_token());
	}
	}

	// Tests that if we we had team drives stored locally that are no longer on the
	// server that we deleted them correctly.
	TEST_F(TeamDriveListLoaderTest, RemoveMissingTeamDriveFromMetadata) {
	const std::vector<std::pair<std::string, std::string>> old_team_drives = {
	{"the1stTeamDriveId", "The First Team Drive"},
	{"the2ndTeamDriveId", "The Second Team Drive"},
	};

	std::string root_local_id;
	ASSERT_EQ(FILE_ERROR_OK,
	metadata_->GetIdByPath(util::GetDriveTeamDrivesRootPath(),
	&root_local_id));

	for (const auto& drive : old_team_drives) {
	std::string local_id;
	ASSERT_EQ(FILE_ERROR_OK,
	metadata_->AddEntry(CreateDirectoryEntryWithResourceId(
	drive.second, drive.first, root_local_id),
	&local_id));
	}

	FileError error = FILE_ERROR_FAILED;
	team_drive_list_loader_->CheckForUpdates(
	google_apis::test_util::CreateCopyResultCallback(&error));
	base::RunLoop().RunUntilIdle();
	EXPECT_EQ(FILE_ERROR_OK, error);
	EXPECT_EQ(1, drive_service_->team_drive_list_load_count());

	EXPECT_TRUE(team_drive_list_observer_->team_drives_list().empty());
	EXPECT_TRUE(team_drive_list_observer_->added_team_drives().empty());
	EXPECT_EQ(old_team_drives.size(),
	team_drive_list_observer_->removed_team_drives().size());

	ResourceEntry entry;
	for (const auto& drive : old_team_drives) {
	EXPECT_EQ(FILE_ERROR_NOT_FOUND,
	metadata_->GetResourceEntryByPath(
	util::GetDriveTeamDrivesRootPath().AppendASCII(drive.second),
	&entry));
	}
	}

	} // namespace internal
	} // namespace drive