text: // 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/callback_helpers.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"
  #include "chrome/browser/chromeos/drive/change_list_loader_observer.h"
  #include "chrome/browser/chromeos/drive/file_cache.h"
  #include "chrome/browser/chromeos/drive/file_change.h"
  #include "chrome/browser/chromeos/drive/file_system_util.h"
  #include "chrome/browser/chromeos/drive/job_scheduler.h"
  #include "chrome/browser/chromeos/drive/resource_metadata.h"
  #include "chrome/browser/chromeos/drive/test_util.h"
  #include "chrome/browser/drive/event_logger.h"
  #include "chrome/browser/drive/fake_drive_service.h"
  #include "chrome/browser/drive/test_util.h"
  #include "content/public/test/test_browser_thread_bundle.h"
  #include "google_apis/drive/drive_api_parser.h"
  #include "google_apis/drive/test_util.h"
  #include "testing/gtest/include/gtest/gtest.h"
  
  namespace drive {
  namespace internal {
  
  class TestChangeListLoaderObserver : public ChangeListLoaderObserver {
   public:
    explicit TestChangeListLoaderObserver(ChangeListLoader* loader)
        : loader_(loader),
          load_from_server_complete_count_(0),
          initial_load_complete_count_(0) {
      loader_->AddObserver(this);
    }
  
    virtual ~TestChangeListLoaderObserver() {
      loader_->RemoveObserver(this);
    }
  
    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:
    virtual void OnFileChanged(const FileChange& changed_files) OVERRIDE {
      changed_files_.Apply(changed_files);
    }
    virtual void OnLoadFromServerComplete() OVERRIDE {
      ++load_from_server_complete_count_;
    }
    virtual void OnInitialLoadComplete() OVERRIDE {
      ++initial_load_complete_count_;
    }
  
   private:
    ChangeListLoader* loader_;
    FileChange changed_files_;
    int load_from_server_complete_count_;
    int initial_load_complete_count_;
  
    DISALLOW_COPY_AND_ASSIGN(TestChangeListLoaderObserver);
  };
  
  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());
  
      logger_.reset(new EventLogger);
  
      drive_service_.reset(new FakeDriveService);
      ASSERT_TRUE(test_util::SetUpTestEntries(drive_service_.get()));
  
      scheduler_.reset(new JobScheduler(pref_service_.get(),
                                        logger_.get(),
                                        drive_service_.get(),
                                        base::MessageLoopProxy::current().get()));
      metadata_storage_.reset(new ResourceMetadataStorage(
          temp_dir_.path(), base::MessageLoopProxy::current().get()));
      ASSERT_TRUE(metadata_storage_->Initialize());
  
      cache_.reset(new FileCache(metadata_storage_.get(),
                                 temp_dir_.path(),
                                 base::MessageLoopProxy::current().get(),
                                 NULL /* free_disk_space_getter */));
      ASSERT_TRUE(cache_->Initialize());
  
      metadata_.reset(new ResourceMetadata(
          metadata_storage_.get(), cache_.get(),
          base::MessageLoopProxy::current().get()));
      ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());
  
      about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
      loader_controller_.reset(new LoaderController);
      change_list_loader_.reset(
          new ChangeListLoader(logger_.get(),
                               base::MessageLoopProxy::current().get(),
                               metadata_.get(),
                               scheduler_.get(),
                               about_resource_loader_.get(),
                               loader_controller_.get()));
    }
  
    // Adds a new file to the root directory of the service.
    scoped_ptr<google_apis::FileResource> AddNewFile(const std::string& title) {
      google_apis::GDataErrorCode error = google_apis::GDATA_FILE_ERROR;
      scoped_ptr<google_apis::FileResource> entry;
      drive_service_->AddNewFile(
          "text/plain",
          "content text",
          drive_service_->GetRootResourceId(),
          title,
          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<EventLogger> logger_;
    scoped_ptr<FakeDriveService> drive_service_;
    scoped_ptr<JobScheduler> scheduler_;
    scoped_ptr<ResourceMetadataStorage,
               test_util::DestroyHelperForTests> metadata_storage_;
    scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
    scoped_ptr<ResourceMetadata, test_util::DestroyHelperForTests> metadata_;
    scoped_ptr<AboutResourceLoader> about_resource_loader_;
    scoped_ptr<LoaderController> loader_controller_;
    scoped_ptr<ChangeListLoader> change_list_loader_;
  };
  
  TEST_F(ChangeListLoaderTest, AboutResourceLoader) {
    google_apis::GDataErrorCode error[6] = {};
    scoped_ptr<google_apis::AboutResource> about[6];
  
    // No resource is cached at the beginning.
    ASSERT_FALSE(about_resource_loader_->cached_about_resource());
  
    // Since no resource is cached, this "Get" should trigger the update.
    about_resource_loader_->GetAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 0, about + 0));
    // Since there is one in-flight update, the next "Get" just wait for it.
    about_resource_loader_->GetAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 1, about + 1));
  
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(google_apis::HTTP_SUCCESS, error[0]);
    EXPECT_EQ(google_apis::HTTP_SUCCESS, error[1]);
    const int64 first_changestamp = about[0]->largest_change_id();
    EXPECT_EQ(first_changestamp, about[1]->largest_change_id());
    ASSERT_TRUE(about_resource_loader_->cached_about_resource());
    EXPECT_EQ(
        first_changestamp,
        about_resource_loader_->cached_about_resource()->largest_change_id());
  
    // Increment changestamp by 1.
    AddNewFile("temp");
    // Explicitly calling UpdateAboutResource will start another API call.
    about_resource_loader_->UpdateAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 2, about + 2));
    // It again waits for the in-flight UpdateAboutResoure call, even though this
    // time there is a cached result.
    about_resource_loader_->GetAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 3, about + 3));
  
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(google_apis::HTTP_SUCCESS, error[2]);
    EXPECT_EQ(google_apis::HTTP_SUCCESS, error[3]);
    EXPECT_EQ(first_changestamp + 1, about[2]->largest_change_id());
    EXPECT_EQ(first_changestamp + 1, about[3]->largest_change_id());
    EXPECT_EQ(
        first_changestamp + 1,
        about_resource_loader_->cached_about_resource()->largest_change_id());
  
    // Increment changestamp by 1.
    AddNewFile("temp2");
    // Now no UpdateAboutResource task is running. Returns the cached result.
    about_resource_loader_->GetAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 4, about + 4));
    // Explicitly calling UpdateAboutResource will start another API call.
    about_resource_loader_->UpdateAboutResource(
        google_apis::test_util::CreateCopyResultCallback(error + 5, about + 5));
  
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(google_apis::HTTP_NO_CONTENT, error[4]);
    EXPECT_EQ(google_apis::HTTP_SUCCESS, error[5]);
    EXPECT_EQ(first_changestamp + 1, about[4]->largest_change_id());
    EXPECT_EQ(first_changestamp + 2, about[5]->largest_change_id());
    EXPECT_EQ(
        first_changestamp + 2,
        about_resource_loader_->cached_about_resource()->largest_change_id());
  
    EXPECT_EQ(3, drive_service_->about_resource_load_count());
  }
  
  TEST_F(ChangeListLoaderTest, Load) {
    EXPECT_FALSE(change_list_loader_->IsRefreshing());
  
    // Start initial load.
    TestChangeListLoaderObserver observer(change_list_loader_.get());
  
    EXPECT_EQ(0, drive_service_->about_resource_load_count());
  
    FileError error = FILE_ERROR_FAILED;
    change_list_loader_->LoadIfNeeded(
        google_apis::test_util::CreateCopyResultCallback(&error));
    EXPECT_TRUE(change_list_loader_->IsRefreshing());
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(FILE_ERROR_OK, error);
  
    EXPECT_FALSE(change_list_loader_->IsRefreshing());
    int64 changestamp = 0;
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_LT(0, changestamp);
    EXPECT_EQ(1, drive_service_->file_list_load_count());
    EXPECT_EQ(1, drive_service_->about_resource_load_count());
    EXPECT_EQ(1, observer.initial_load_complete_count());
    EXPECT_EQ(1, observer.load_from_server_complete_count());
    EXPECT_TRUE(observer.changed_files().empty());
  
    base::FilePath file_path =
        util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
    ResourceEntry entry;
    EXPECT_EQ(FILE_ERROR_OK,
              metadata_->GetResourceEntryByPath(file_path, &entry));
  }
  
  TEST_F(ChangeListLoaderTest, Load_LocalMetadataAvailable) {
    // Prepare metadata.
    FileError error = FILE_ERROR_FAILED;
    change_list_loader_->LoadIfNeeded(
        google_apis::test_util::CreateCopyResultCallback(&error));
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(FILE_ERROR_OK, error);
  
    // Reset loader.
    about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
    change_list_loader_.reset(
        new ChangeListLoader(logger_.get(),
                             base::MessageLoopProxy::current().get(),
                             metadata_.get(),
                             scheduler_.get(),
                             about_resource_loader_.get(),
                             loader_controller_.get()));
  
    // Add a file to the service.
    scoped_ptr<google_apis::FileResource> gdata_entry = AddNewFile("New File");
    ASSERT_TRUE(gdata_entry);
  
    // Start loading. Because local metadata is available, the load results in
    // returning FILE_ERROR_OK without fetching full list of resources.
    const int previous_file_list_load_count =
        drive_service_->file_list_load_count();
    TestChangeListLoaderObserver observer(change_list_loader_.get());
  
    change_list_loader_->LoadIfNeeded(
        google_apis::test_util::CreateCopyResultCallback(&error));
    EXPECT_TRUE(change_list_loader_->IsRefreshing());
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(FILE_ERROR_OK, error);
    EXPECT_EQ(previous_file_list_load_count,
              drive_service_->file_list_load_count());
    EXPECT_EQ(1, observer.initial_load_complete_count());
  
    // Update should be checked by Load().
    int64 changestamp = 0;
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_EQ(drive_service_->about_resource().largest_change_id(), changestamp);
    EXPECT_EQ(1, drive_service_->change_list_load_count());
    EXPECT_EQ(1, observer.load_from_server_complete_count());
    EXPECT_TRUE(
        observer.changed_files().CountDirectory(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, 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.
    int64 changestamp = 0;
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_EQ(0, changestamp);
    EXPECT_EQ(0, drive_service_->file_list_load_count());
    EXPECT_EQ(0, drive_service_->about_resource_load_count());
  
    // Start initial load.
    FileError load_error = FILE_ERROR_FAILED;
    change_list_loader_->LoadIfNeeded(
        google_apis::test_util::CreateCopyResultCallback(&load_error));
    EXPECT_TRUE(change_list_loader_->IsRefreshing());
  
    // CheckForUpdates() while loading.
    change_list_loader_->CheckForUpdates(
        google_apis::test_util::CreateCopyResultCallback(
            &check_for_updates_error));
  
    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(change_list_loader_->IsRefreshing());
    EXPECT_EQ(FILE_ERROR_OK, load_error);
    EXPECT_EQ(FILE_ERROR_OK, check_for_updates_error);
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_LT(0, changestamp);
    EXPECT_EQ(1, drive_service_->file_list_load_count());
  
    int64 previous_changestamp = 0;
    EXPECT_EQ(FILE_ERROR_OK,
              metadata_->GetLargestChangestamp(&previous_changestamp));
    // CheckForUpdates() results in no update.
    change_list_loader_->CheckForUpdates(
        google_apis::test_util::CreateCopyResultCallback(
            &check_for_updates_error));
    EXPECT_TRUE(change_list_loader_->IsRefreshing());
    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(change_list_loader_->IsRefreshing());
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_EQ(previous_changestamp, changestamp);
  
    // Add a file to the service.
    scoped_ptr<google_apis::FileResource> gdata_entry = AddNewFile("New File");
    ASSERT_TRUE(gdata_entry);
  
    // CheckForUpdates() results in update.
    TestChangeListLoaderObserver observer(change_list_loader_.get());
    change_list_loader_->CheckForUpdates(
        google_apis::test_util::CreateCopyResultCallback(
            &check_for_updates_error));
    EXPECT_TRUE(change_list_loader_->IsRefreshing());
    base::RunLoop().RunUntilIdle();
    EXPECT_FALSE(change_list_loader_->IsRefreshing());
    EXPECT_EQ(FILE_ERROR_OK, metadata_->GetLargestChangestamp(&changestamp));
    EXPECT_LT(previous_changestamp, changestamp);
    EXPECT_EQ(1, observer.load_from_server_complete_count());
    EXPECT_TRUE(
        observer.changed_files().CountDirectory(util::GetDriveMyDriveRootPath()));
  
    // 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));
  }
  
  TEST_F(ChangeListLoaderTest, Lock) {
    FileError error = FILE_ERROR_FAILED;
    change_list_loader_->LoadIfNeeded(
        google_apis::test_util::CreateCopyResultCallback(&error));
    base::RunLoop().RunUntilIdle();
    EXPECT_EQ(FILE_ERROR_OK, error);
  
    // Add a new file.
    scoped_ptr<google_apis::FileResource> file = AddNewFile("New File");
    ASSERT_TRUE(file);
  
    // Lock the loader.
    scoped_ptr<base::ScopedClosureRunner> lock = loader_controller_->GetLock();
  
    // Start update.
    TestChangeListLoaderObserver observer(change_list_loader_.get());
    FileError check_for_updates_error = FILE_ERROR_FAILED;
    change_list_loader_->CheckForUpdates(
        google_apis::test_util::CreateCopyResultCallback(
            &check_for_updates_error));
    base::RunLoop().RunUntilIdle();
  
    // Update is pending due to the lock.
    EXPECT_TRUE(observer.changed_files().empty());
  
    // Unlock the loader, this should resume the pending update.
    lock.reset();
    base::RunLoop().RunUntilIdle();
    EXPECT_TRUE(
        observer.changed_files().CountDirectory(util::GetDriveMyDriveRootPath()));
  }
  
  }  // namespace internal
  }  // namespace drive
  