Home | History | Annotate | Download | only in operations 
      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/create_directory.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/memory/scoped_ptr.h"
     13 #include "base/memory/scoped_vector.h"
     14 #include "chrome/browser/chromeos/file_system_provider/operations/test_util.h"
     15 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
     16 #include "chrome/common/extensions/api/file_system_provider.h"
     17 #include "chrome/common/extensions/api/file_system_provider_internal.h"
     18 #include "extensions/browser/event_router.h"
     19 #include "storage/browser/fileapi/async_file_util.h"
     20 #include "testing/gtest/include/gtest/gtest.h"
     21 
     22 namespace chromeos {
     23 namespace file_system_provider {
     24 namespace operations {
     25 namespace {
     26 
     27 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
     28 const char kFileSystemId[] = "testing-file-system";
     29 const int kRequestId = 2;
     30 const base::FilePath::CharType kDirectoryPath[] = "/kitty/and/puppy/happy";
     31 
     32 }  // namespace
     33 
     34 class FileSystemProviderOperationsCreateDirectoryTest : public testing::Test {
     35  protected:
     36   FileSystemProviderOperationsCreateDirectoryTest() {}
     37   virtual ~FileSystemProviderOperationsCreateDirectoryTest() {}
     38 
     39   virtual void SetUp() OVERRIDE {
     40     file_system_info_ =
     41         ProvidedFileSystemInfo(kExtensionId,
     42                                kFileSystemId,
     43                                "" /* file_system_name */,
     44                                true /* writable */,
     45                                base::FilePath() /* mount_path */);
     46   }
     47 
     48   ProvidedFileSystemInfo file_system_info_;
     49 };
     50 
     51 TEST_F(FileSystemProviderOperationsCreateDirectoryTest, Execute) {
     52   using extensions::api::file_system_provider::CreateDirectoryRequestedOptions;
     53 
     54   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
     55   util::StatusCallbackLog callback_log;
     56 
     57   CreateDirectory create_directory(
     58       NULL,
     59       file_system_info_,
     60       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
     61       true /* recursive */,
     62       base::Bind(&util::LogStatusCallback, &callback_log));
     63   create_directory.SetDispatchEventImplForTesting(
     64       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
     65                  base::Unretained(&dispatcher)));
     66 
     67   EXPECT_TRUE(create_directory.Execute(kRequestId));
     68 
     69   ASSERT_EQ(1u, dispatcher.events().size());
     70   extensions::Event* event = dispatcher.events()[0];
     71   EXPECT_EQ(extensions::api::file_system_provider::OnCreateDirectoryRequested::
     72                 kEventName,
     73             event->event_name);
     74   base::ListValue* event_args = event->event_args.get();
     75   ASSERT_EQ(1u, event_args->GetSize());
     76 
     77   const base::DictionaryValue* options_as_value = NULL;
     78   ASSERT_TRUE(event_args->GetDictionary(0, &options_as_value));
     79 
     80   CreateDirectoryRequestedOptions options;
     81   ASSERT_TRUE(
     82       CreateDirectoryRequestedOptions::Populate(*options_as_value, &options));
     83   EXPECT_EQ(kFileSystemId, options.file_system_id);
     84   EXPECT_EQ(kRequestId, options.request_id);
     85   EXPECT_EQ(kDirectoryPath, options.directory_path);
     86   EXPECT_TRUE(options.recursive);
     87 }
     88 
     89 TEST_F(FileSystemProviderOperationsCreateDirectoryTest, Execute_NoListener) {
     90   util::LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */);
     91   util::StatusCallbackLog callback_log;
     92 
     93   CreateDirectory create_directory(
     94       NULL,
     95       file_system_info_,
     96       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
     97       true /* recursive */,
     98       base::Bind(&util::LogStatusCallback, &callback_log));
     99   create_directory.SetDispatchEventImplForTesting(
    100       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
    101                  base::Unretained(&dispatcher)));
    102 
    103   EXPECT_FALSE(create_directory.Execute(kRequestId));
    104 }
    105 
    106 TEST_F(FileSystemProviderOperationsCreateDirectoryTest, Execute_ReadOnly) {
    107   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
    108   util::StatusCallbackLog callback_log;
    109 
    110   const ProvidedFileSystemInfo read_only_file_system_info(
    111       kExtensionId,
    112       kFileSystemId,
    113       "" /* file_system_name */,
    114       false /* writable */,
    115       base::FilePath() /* mount_path */);
    116 
    117   CreateDirectory create_directory(
    118       NULL,
    119       read_only_file_system_info,
    120       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
    121       true /* recursive */,
    122       base::Bind(&util::LogStatusCallback, &callback_log));
    123   create_directory.SetDispatchEventImplForTesting(
    124       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
    125                  base::Unretained(&dispatcher)));
    126 
    127   EXPECT_FALSE(create_directory.Execute(kRequestId));
    128 }
    129 
    130 TEST_F(FileSystemProviderOperationsCreateDirectoryTest, OnSuccess) {
    131   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
    132   util::StatusCallbackLog callback_log;
    133 
    134   CreateDirectory create_directory(
    135       NULL,
    136       file_system_info_,
    137       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
    138       true /* recursive */,
    139       base::Bind(&util::LogStatusCallback, &callback_log));
    140   create_directory.SetDispatchEventImplForTesting(
    141       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
    142                  base::Unretained(&dispatcher)));
    143 
    144   EXPECT_TRUE(create_directory.Execute(kRequestId));
    145 
    146   create_directory.OnSuccess(kRequestId,
    147                              scoped_ptr<RequestValue>(new RequestValue()),
    148                              false /* has_more */);
    149   ASSERT_EQ(1u, callback_log.size());
    150   EXPECT_EQ(base::File::FILE_OK, callback_log[0]);
    151 }
    152 
    153 TEST_F(FileSystemProviderOperationsCreateDirectoryTest, OnError) {
    154   util::LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
    155   util::StatusCallbackLog callback_log;
    156 
    157   CreateDirectory create_directory(
    158       NULL,
    159       file_system_info_,
    160       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
    161       true /* recursive */,
    162       base::Bind(&util::LogStatusCallback, &callback_log));
    163   create_directory.SetDispatchEventImplForTesting(
    164       base::Bind(&util::LoggingDispatchEventImpl::OnDispatchEventImpl,
    165                  base::Unretained(&dispatcher)));
    166 
    167   EXPECT_TRUE(create_directory.Execute(kRequestId));
    168 
    169   create_directory.OnError(kRequestId,
    170                            scoped_ptr<RequestValue>(new RequestValue()),
    171                            base::File::FILE_ERROR_TOO_MANY_OPENED);
    172   ASSERT_EQ(1u, callback_log.size());
    173   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, callback_log[0]);
    174 }
    175 
    176 }  // namespace operations
    177 }  // namespace file_system_provider
    178 }  // namespace chromeos
    179