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.
7 #include "base/files/file.h"
8 #include "base/files/file_path.h"
9 #include "base/json/json_reader.h"
10 #include "base/memory/scoped_ptr.h"
11 #include "base/memory/scoped_vector.h"
12 #include "base/values.h"
13 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
14 #include "chrome/common/extensions/api/file_system_provider.h"
15 #include "chrome/common/extensions/api/file_system_provider_internal.h"
16 #include "extensions/browser/event_router.h"
17 #include "testing/gtest/include/gtest/gtest.h"
18 #include "webkit/browser/fileapi/async_file_util.h"
21 namespace file_system_provider
{
22 namespace operations
{
25 const char kExtensionId
[] = "mbflcebpggnecokmikipoihdbecnjfoj";
26 const char kFileSystemId
[] = "testing-file-system";
27 const char kMimeType
[] = "text/plain";
28 const int kRequestId
= 2;
29 const base::FilePath::CharType kDirectoryPath
[] = "/directory";
31 // Fake event dispatcher implementation with extra logging capability. Acts as
32 // a providing extension end-point.
33 class LoggingDispatchEventImpl
{
35 explicit LoggingDispatchEventImpl(bool dispatch_reply
)
36 : dispatch_reply_(dispatch_reply
) {}
37 virtual ~LoggingDispatchEventImpl() {}
39 bool OnDispatchEventImpl(scoped_ptr
<extensions::Event
> event
) {
40 events_
.push_back(event
->DeepCopy());
41 return dispatch_reply_
;
44 ScopedVector
<extensions::Event
>& events() { return events_
; }
47 ScopedVector
<extensions::Event
> events_
;
50 DISALLOW_COPY_AND_ASSIGN(LoggingDispatchEventImpl
);
53 // Callback invocation logger. Acts as a fileapi end-point.
54 class CallbackLogger
{
58 Event(const EntryMetadata
& metadata
, base::File::Error result
)
59 : metadata_(metadata
), result_(result
) {}
62 const EntryMetadata
& metadata() { return metadata_
; }
63 base::File::Error
result() { return result_
; }
66 EntryMetadata metadata_
;
67 base::File::Error result_
;
69 DISALLOW_COPY_AND_ASSIGN(Event
);
73 virtual ~CallbackLogger() {}
75 void OnGetMetadata(const EntryMetadata
& metadata
, base::File::Error result
) {
76 events_
.push_back(new Event(metadata
, result
));
79 ScopedVector
<Event
>& events() { return events_
; }
82 ScopedVector
<Event
> events_
;
85 DISALLOW_COPY_AND_ASSIGN(CallbackLogger
);
90 class FileSystemProviderOperationsGetMetadataTest
: public testing::Test
{
92 FileSystemProviderOperationsGetMetadataTest() {}
93 virtual ~FileSystemProviderOperationsGetMetadataTest() {}
95 virtual void SetUp() OVERRIDE
{
97 ProvidedFileSystemInfo(kExtensionId
,
99 "" /* file_system_name */,
100 base::FilePath() /* mount_path */);
103 ProvidedFileSystemInfo file_system_info_
;
106 TEST_F(FileSystemProviderOperationsGetMetadataTest
, Execute
) {
107 LoggingDispatchEventImpl
dispatcher(true /* dispatch_reply */);
108 CallbackLogger callback_logger
;
110 GetMetadata
get_metadata(NULL
,
112 base::FilePath::FromUTF8Unsafe(kDirectoryPath
),
113 base::Bind(&CallbackLogger::OnGetMetadata
,
114 base::Unretained(&callback_logger
)));
115 get_metadata
.SetDispatchEventImplForTesting(
116 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl
,
117 base::Unretained(&dispatcher
)));
119 EXPECT_TRUE(get_metadata
.Execute(kRequestId
));
121 ASSERT_EQ(1u, dispatcher
.events().size());
122 extensions::Event
* event
= dispatcher
.events()[0];
124 extensions::api::file_system_provider::OnGetMetadataRequested::kEventName
,
126 base::ListValue
* event_args
= event
->event_args
.get();
127 ASSERT_EQ(1u, event_args
->GetSize());
129 base::DictionaryValue
* options
= NULL
;
130 ASSERT_TRUE(event_args
->GetDictionary(0, &options
));
132 std::string event_file_system_id
;
133 EXPECT_TRUE(options
->GetString("fileSystemId", &event_file_system_id
));
134 EXPECT_EQ(kFileSystemId
, event_file_system_id
);
136 int event_request_id
= -1;
137 EXPECT_TRUE(options
->GetInteger("requestId", &event_request_id
));
138 EXPECT_EQ(kRequestId
, event_request_id
);
140 std::string event_entry_path
;
141 EXPECT_TRUE(options
->GetString("entryPath", &event_entry_path
));
142 EXPECT_EQ(kDirectoryPath
, event_entry_path
);
145 TEST_F(FileSystemProviderOperationsGetMetadataTest
, Execute_NoListener
) {
146 LoggingDispatchEventImpl
dispatcher(false /* dispatch_reply */);
147 CallbackLogger callback_logger
;
149 GetMetadata
get_metadata(NULL
,
151 base::FilePath::FromUTF8Unsafe(kDirectoryPath
),
152 base::Bind(&CallbackLogger::OnGetMetadata
,
153 base::Unretained(&callback_logger
)));
154 get_metadata
.SetDispatchEventImplForTesting(
155 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl
,
156 base::Unretained(&dispatcher
)));
158 EXPECT_FALSE(get_metadata
.Execute(kRequestId
));
161 TEST_F(FileSystemProviderOperationsGetMetadataTest
, OnSuccess
) {
162 using extensions::api::file_system_provider_internal::
163 GetMetadataRequestedSuccess::Params
;
165 LoggingDispatchEventImpl
dispatcher(true /* dispatch_reply */);
166 CallbackLogger callback_logger
;
168 GetMetadata
get_metadata(NULL
,
170 base::FilePath::FromUTF8Unsafe(kDirectoryPath
),
171 base::Bind(&CallbackLogger::OnGetMetadata
,
172 base::Unretained(&callback_logger
)));
173 get_metadata
.SetDispatchEventImplForTesting(
174 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl
,
175 base::Unretained(&dispatcher
)));
177 EXPECT_TRUE(get_metadata
.Execute(kRequestId
));
179 // Sample input as JSON. Keep in sync with file_system_provider_api.idl.
180 // As for now, it is impossible to create *::Params class directly, not from
182 const std::string input
=
184 " \"testing-file-system\",\n" // kFileSystemId
185 " 2,\n" // kRequestId
187 " \"isDirectory\": false,\n"
188 " \"name\": \"blueberries.txt\",\n"
190 " \"modificationTime\": {\n"
191 " \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n"
193 " \"mimeType\": \"text/plain\"\n" // kMimeType
195 " 0\n" // execution_time
199 std::string json_error_msg
;
200 scoped_ptr
<base::Value
> value(base::JSONReader::ReadAndReturnError(
201 input
, base::JSON_PARSE_RFC
, &json_error_code
, &json_error_msg
));
202 ASSERT_TRUE(value
.get()) << json_error_msg
;
204 base::ListValue
* value_as_list
;
205 ASSERT_TRUE(value
->GetAsList(&value_as_list
));
206 scoped_ptr
<Params
> params(Params::Create(*value_as_list
));
207 ASSERT_TRUE(params
.get());
208 scoped_ptr
<RequestValue
> request_value(
209 RequestValue::CreateForGetMetadataSuccess(params
.Pass()));
210 ASSERT_TRUE(request_value
.get());
212 const bool has_more
= false;
213 get_metadata
.OnSuccess(kRequestId
, request_value
.Pass(), has_more
);
215 ASSERT_EQ(1u, callback_logger
.events().size());
216 CallbackLogger::Event
* event
= callback_logger
.events()[0];
217 EXPECT_EQ(base::File::FILE_OK
, event
->result());
219 const EntryMetadata
& metadata
= event
->metadata();
220 EXPECT_FALSE(metadata
.is_directory
);
221 EXPECT_EQ(4096, metadata
.size
);
222 base::Time expected_time
;
224 base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014", &expected_time
));
225 EXPECT_EQ(expected_time
, metadata
.modification_time
);
226 EXPECT_EQ(kMimeType
, metadata
.mime_type
);
229 TEST_F(FileSystemProviderOperationsGetMetadataTest
, OnError
) {
230 LoggingDispatchEventImpl
dispatcher(true /* dispatch_reply */);
231 CallbackLogger callback_logger
;
233 GetMetadata
get_metadata(NULL
,
235 base::FilePath::FromUTF8Unsafe(kDirectoryPath
),
236 base::Bind(&CallbackLogger::OnGetMetadata
,
237 base::Unretained(&callback_logger
)));
238 get_metadata
.SetDispatchEventImplForTesting(
239 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl
,
240 base::Unretained(&dispatcher
)));
242 EXPECT_TRUE(get_metadata
.Execute(kRequestId
));
244 get_metadata
.OnError(kRequestId
,
245 scoped_ptr
<RequestValue
>(new RequestValue()),
246 base::File::FILE_ERROR_TOO_MANY_OPENED
);
248 ASSERT_EQ(1u, callback_logger
.events().size());
249 CallbackLogger::Event
* event
= callback_logger
.events()[0];
250 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED
, event
->result());
253 } // namespace operations
254 } // namespace file_system_provider
255 } // namespace chromeos