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