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
22namespace chromeos {
23namespace file_system_provider {
24namespace operations {
25namespace {
26
27const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
28const char kFileSystemId[] = "testing-file-system";
29const int kRequestId = 2;
30const base::FilePath::CharType kDirectoryPath[] = "/kitty/and/puppy/happy";
31
32}  // namespace
33
34class 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
51TEST_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
89TEST_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
106TEST_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
130TEST_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
153TEST_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