chrome/browser/chromeos/drive/file_system/get_file_for_saving_operation_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/drive/file_system/get_file_for_saving_operation.h"
   6
   7 #include "base/callback.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/file_util.h"
  10 #include "base/run_loop.h"
  11 #include "base/task_runner_util.h"
  12 #include "chrome/browser/chromeos/drive/drive.pb.h"
  13 #include "chrome/browser/chromeos/drive/file_change.h"
  14 #include "chrome/browser/chromeos/drive/file_errors.h"
  15 #include "chrome/browser/chromeos/drive/file_system/operation_test_base.h"
  16 #include "chrome/browser/chromeos/drive/file_write_watcher.h"
  17 #include "chrome/browser/chromeos/drive/job_scheduler.h"
  18 #include "content/public/test/test_utils.h"
  19 #include "google_apis/drive/test_util.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace drive {
  23 namespace file_system {
  24
  25 namespace {
  26
  27 // If OnCacheFileUploadNeededByOperation is called, records the local ID and
  28 // calls |quit_closure|.
  29 class TestDelegate : public OperationDelegate {
  30  public:
  31   void set_quit_closure(const base::Closure& quit_closure) {
  32     quit_closure_ = quit_closure;
  33   }
  34
  35   const std::string& updated_local_id() const {
  36     return updated_local_id_;
  37   }
  38
  39   // OperationDelegate overrides.
  40   void OnEntryUpdatedByOperation(const ClientContext& /* context */,
  41                                  const std::string& local_id) override {
  42     updated_local_id_ = local_id;
  43     if (!quit_closure_.is_null())
  44       quit_closure_.Run();
  45   }
  46
  47  private:
  48   std::string updated_local_id_;
  49   base::Closure quit_closure_;
  50 };
  51
  52 }  // namespace
  53
  54 class GetFileForSavingOperationTest : public OperationTestBase {
  55  protected:
  56   // FileWriteWatcher requires TYPE_IO message loop to run.
  57   GetFileForSavingOperationTest()
  58       : OperationTestBase(content::TestBrowserThreadBundle::IO_MAINLOOP) {
  59   }
  60
  61   void SetUp() override {
  62     OperationTestBase::SetUp();
  63
  64     operation_.reset(new GetFileForSavingOperation(
  65         logger(), blocking_task_runner(), &delegate_, scheduler(), metadata(),
  66         cache(), temp_dir()));
  67     operation_->file_write_watcher_for_testing()->DisableDelayForTesting();
  68   }
  69
  70   TestDelegate delegate_;
  71   scoped_ptr<GetFileForSavingOperation> operation_;
  72 };
  73
  74 TEST_F(GetFileForSavingOperationTest, GetFileForSaving_Exist) {
  75   base::FilePath drive_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
  76   ResourceEntry src_entry;
  77   ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(drive_path, &src_entry));
  78
  79   // Run the operation.
  80   FileError error = FILE_ERROR_FAILED;
  81   scoped_ptr<ResourceEntry> entry;
  82   base::FilePath local_path;
  83   operation_->GetFileForSaving(
  84       drive_path,
  85       google_apis::test_util::CreateCopyResultCallback(
  86           &error, &local_path, &entry));
  87   content::RunAllBlockingPoolTasksUntilIdle();
  88
  89   // Checks that the file is retrieved.
  90   EXPECT_EQ(FILE_ERROR_OK, error);
  91   ASSERT_TRUE(entry);
  92   EXPECT_EQ(src_entry.resource_id(), entry->resource_id());
  93
  94   // Checks that it presents in cache and marked dirty.
  95   EXPECT_TRUE(entry->file_specific_info().cache_state().is_present());
  96   EXPECT_TRUE(entry->file_specific_info().cache_state().is_dirty());
  97
  98   // Write something to the cache and checks that the event is reported.
  99   {
 100     base::RunLoop run_loop;
 101     delegate_.set_quit_closure(run_loop.QuitClosure());
 102     google_apis::test_util::WriteStringToFile(local_path, "hello");
 103     run_loop.Run();
 104     EXPECT_EQ(GetLocalId(drive_path), delegate_.updated_local_id());
 105   }
 106 }
 107
 108 TEST_F(GetFileForSavingOperationTest, GetFileForSaving_NotExist) {
 109   base::FilePath drive_path(FILE_PATH_LITERAL("drive/root/NotExist.txt"));
 110   ResourceEntry src_entry;
 111   ASSERT_EQ(FILE_ERROR_NOT_FOUND,
 112             GetLocalResourceEntry(drive_path, &src_entry));
 113
 114   // Run the operation.
 115   FileError error = FILE_ERROR_FAILED;
 116   scoped_ptr<ResourceEntry> entry;
 117   base::FilePath local_path;
 118   operation_->GetFileForSaving(
 119       drive_path,
 120       google_apis::test_util::CreateCopyResultCallback(
 121           &error, &local_path, &entry));
 122   content::RunAllBlockingPoolTasksUntilIdle();
 123
 124   // Checks that the file is created and retrieved.
 125   EXPECT_EQ(FILE_ERROR_OK, error);
 126   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(drive_path, &src_entry));
 127   int64 size = -1;
 128   EXPECT_TRUE(base::GetFileSize(local_path, &size));
 129   EXPECT_EQ(0, size);
 130 }
 131
 132 TEST_F(GetFileForSavingOperationTest, GetFileForSaving_Directory) {
 133   base::FilePath drive_path(FILE_PATH_LITERAL("drive/root/Directory 1"));
 134   ResourceEntry src_entry;
 135   ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(drive_path, &src_entry));
 136   ASSERT_TRUE(src_entry.file_info().is_directory());
 137
 138   // Run the operation.
 139   FileError error = FILE_ERROR_FAILED;
 140   scoped_ptr<ResourceEntry> entry;
 141   base::FilePath local_path;
 142   operation_->GetFileForSaving(
 143       drive_path,
 144       google_apis::test_util::CreateCopyResultCallback(
 145           &error, &local_path, &entry));
 146   content::RunAllBlockingPoolTasksUntilIdle();
 147
 148   // Checks that an error is returned.
 149   EXPECT_EQ(FILE_ERROR_EXISTS, error);
 150 }
 151
 152 }  // namespace file_system
 153 }  // namespace drive