chrome/browser/chromeos/file_system_provider/operations/write_file_unittest.cc

   1 // Copyright 2014 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/file_system_provider/operations/write_file.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/files/file.h"
  11 #include "base/files/file_path.h"
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "base/values.h"
  17 #include "chrome/browser/chromeos/file_system_provider/operations/test_util.h"
  18 #include "chrome/common/extensions/api/file_system_provider.h"
  19 #include "chrome/common/extensions/api/file_system_provider_internal.h"
  20 #include "extensions/browser/event_router.h"
  21 #include "net/base/io_buffer.h"
  22 #include "storage/browser/fileapi/async_file_util.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace chromeos {
  26 namespace file_system_provider {
  27 namespace operations {
  28 namespace {
  29
  30 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
  31 const char kFileSystemId[] = "testing-file-system";
  32 const int kRequestId = 2;
  33 const int kFileHandle = 3;
  34 const char kWriteData[] = "Welcome to my world!";
  35 const int kOffset = 10;
  36
  37 }  // namespace
  38
  39 class FileSystemProviderOperationsWriteFileTest : public testing::Test {
  40  protected:
  41   FileSystemProviderOperationsWriteFileTest() {}
  42   ~FileSystemProviderOperationsWriteFileTest() override {}
  43
  44   void SetUp() override {
  45     MountOptions mount_options(kFileSystemId, "" /* display_name */);
  46     mount_options.writable = true;
  47     file_system_info_ =
  48         ProvidedFileSystemInfo(kExtensionId, mount_options, base::FilePath());
  49     io_buffer_ = make_scoped_refptr(new net::StringIOBuffer(kWriteData));
  50   }
  51
  52   ProvidedFileSystemInfo file_system_info_;
  53   scoped_refptr<net::StringIOBuffer> io_buffer_;
  54 };
  55
  56 TEST_F(FileSystemProviderOperationsWriteFileTest, Execute) {
  57   using extensions::api::file_system_provider::WriteFileRequestedOptions;
  58
  59   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
  60   util::StatusCallbackLog callback_log;
  61
  62   WriteFile write_file(NULL,
  63                        file_system_info_,
  64                        kFileHandle,
  65                        io_buffer_.get(),
  66                        kOffset,
  67                        io_buffer_->size(),
  68                        base::Bind(&util::LogStatusCallback, &callback_log));
  69   write_file.SetDispatchEventImplForTesting(
  70       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
  71                  base::Unretained(&dispatcher)));
  72
  73   EXPECT_TRUE(write_file.Execute(kRequestId));
  74
  75   ASSERT_EQ(1u, dispatcher.events().size());
  76   extensions::Event* event = dispatcher.events()[0];
  77   EXPECT_EQ(
  78       extensions::api::file_system_provider::OnWriteFileRequested::kEventName,
  79       event->event_name);
  80   base::ListValue* event_args = event->event_args.get();
  81   ASSERT_EQ(1u, event_args->GetSize());
  82
  83   const base::DictionaryValue* options_as_value = NULL;
  84   ASSERT_TRUE(event_args->GetDictionary(0, &options_as_value));
  85
  86   WriteFileRequestedOptions options;
  87   ASSERT_TRUE(WriteFileRequestedOptions::Populate(*options_as_value, &options));
  88   EXPECT_EQ(kFileSystemId, options.file_system_id);
  89   EXPECT_EQ(kRequestId, options.request_id);
  90   EXPECT_EQ(kFileHandle, options.open_request_id);
  91   EXPECT_EQ(kOffset, static_cast<double>(options.offset));
  92   std::string write_data(kWriteData);
  93   EXPECT_EQ(std::vector<char>(write_data.begin(), write_data.end()),
  94             options.data);
  95 }
  96
  97 TEST_F(FileSystemProviderOperationsWriteFileTest, Execute_NoListener) {
  98   util::LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */);
  99   util::StatusCallbackLog callback_log;
 100
 101   WriteFile write_file(NULL,
 102                        file_system_info_,
 103                        kFileHandle,
 104                        io_buffer_.get(),
 105                        kOffset,
 106                        io_buffer_->size(),
 107                        base::Bind(&util::LogStatusCallback, &callback_log));
 108   write_file.SetDispatchEventImplForTesting(
 109       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
 110                  base::Unretained(&dispatcher)));
 111
 112   EXPECT_FALSE(write_file.Execute(kRequestId));
 113 }
 114
 115 TEST_F(FileSystemProviderOperationsWriteFileTest, Execute_ReadOnly) {
 116   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 117   util::StatusCallbackLog callback_log;
 118
 119   const ProvidedFileSystemInfo read_only_file_system_info(
 120       kExtensionId,
 121       MountOptions(kFileSystemId, "" /* display_name */),
 122       base::FilePath() /* mount_path */);
 123
 124   WriteFile write_file(NULL,
 125                        read_only_file_system_info,
 126                        kFileHandle,
 127                        io_buffer_.get(),
 128                        kOffset,
 129                        io_buffer_->size(),
 130                        base::Bind(&util::LogStatusCallback, &callback_log));
 131   write_file.SetDispatchEventImplForTesting(
 132       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
 133                  base::Unretained(&dispatcher)));
 134
 135   EXPECT_FALSE(write_file.Execute(kRequestId));
 136 }
 137
 138 TEST_F(FileSystemProviderOperationsWriteFileTest, OnSuccess) {
 139   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 140   util::StatusCallbackLog callback_log;
 141
 142   WriteFile write_file(NULL,
 143                        file_system_info_,
 144                        kFileHandle,
 145                        io_buffer_.get(),
 146                        kOffset,
 147                        io_buffer_->size(),
 148                        base::Bind(&util::LogStatusCallback, &callback_log));
 149   write_file.SetDispatchEventImplForTesting(
 150       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
 151                  base::Unretained(&dispatcher)));
 152
 153   EXPECT_TRUE(write_file.Execute(kRequestId));
 154
 155   write_file.OnSuccess(kRequestId,
 156                        scoped_ptr<RequestValue>(new RequestValue()),
 157                        false /* has_more */);
 158   ASSERT_EQ(1u, callback_log.size());
 159   EXPECT_EQ(base::File::FILE_OK, callback_log[0]);
 160 }
 161
 162 TEST_F(FileSystemProviderOperationsWriteFileTest, OnError) {
 163   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
 164   util::StatusCallbackLog callback_log;
 165
 166   WriteFile write_file(NULL,
 167                        file_system_info_,
 168                        kFileHandle,
 169                        io_buffer_.get(),
 170                        kOffset,
 171                        io_buffer_->size(),
 172                        base::Bind(&util::LogStatusCallback, &callback_log));
 173   write_file.SetDispatchEventImplForTesting(
 174       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
 175                  base::Unretained(&dispatcher)));
 176
 177   EXPECT_TRUE(write_file.Execute(kRequestId));
 178
 179   write_file.OnError(kRequestId,
 180                      scoped_ptr<RequestValue>(new RequestValue()),
 181                      base::File::FILE_ERROR_TOO_MANY_OPENED);
 182
 183   ASSERT_EQ(1u, callback_log.size());
 184   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, callback_log[0]);
 185 }
 186
 187 }  // namespace operations
 188 }  // namespace file_system_provider
 189 }  // namespace chromeos