OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 | 6 |
7 #include "base/files/file.h" | 7 #include "base/files/file.h" |
8 #include "base/files/file_path.h" | 8 #include "base/files/file_path.h" |
9 #include "base/json/json_reader.h" | 9 #include "base/json/json_reader.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
11 #include "base/memory/scoped_vector.h" | 11 #include "base/memory/scoped_vector.h" |
12 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h
" | 12 #include "chrome/browser/chromeos/file_system_provider/operations/read_directory
.h" |
13 #include "chrome/common/extensions/api/file_system_provider.h" | 13 #include "chrome/common/extensions/api/file_system_provider.h" |
14 #include "chrome/common/extensions/api/file_system_provider_internal.h" | 14 #include "chrome/common/extensions/api/file_system_provider_internal.h" |
15 #include "extensions/browser/event_router.h" | 15 #include "extensions/browser/event_router.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "webkit/browser/fileapi/async_file_util.h" | 17 #include "webkit/browser/fileapi/async_file_util.h" |
18 | 18 |
19 namespace chromeos { | 19 namespace chromeos { |
20 namespace file_system_provider { | 20 namespace file_system_provider { |
21 namespace operations { | 21 namespace operations { |
22 namespace { | 22 namespace { |
(...skipping 23 matching lines...) Expand all Loading... |
46 bool dispatch_reply_; | 46 bool dispatch_reply_; |
47 | 47 |
48 DISALLOW_COPY_AND_ASSIGN(LoggingDispatchEventImpl); | 48 DISALLOW_COPY_AND_ASSIGN(LoggingDispatchEventImpl); |
49 }; | 49 }; |
50 | 50 |
51 // Callback invocation logger. Acts as a fileapi end-point. | 51 // Callback invocation logger. Acts as a fileapi end-point. |
52 class CallbackLogger { | 52 class CallbackLogger { |
53 public: | 53 public: |
54 class Event { | 54 class Event { |
55 public: | 55 public: |
56 Event(base::File::Error result, const base::File::Info& file_info) | 56 Event(base::File::Error result, |
57 : result_(result), file_info_(file_info) {} | 57 const fileapi::AsyncFileUtil::EntryList& entry_list, |
| 58 bool has_more) |
| 59 : result_(result), entry_list_(entry_list), has_more_(has_more) {} |
58 virtual ~Event() {} | 60 virtual ~Event() {} |
59 | 61 |
60 base::File::Error result() { return result_; } | 62 base::File::Error result() { return result_; } |
61 const base::File::Info& file_info() { return file_info_; } | 63 const fileapi::AsyncFileUtil::EntryList& entry_list() { |
| 64 return entry_list_; |
| 65 } |
| 66 bool has_more() { return has_more_; } |
62 | 67 |
63 private: | 68 private: |
64 base::File::Error result_; | 69 base::File::Error result_; |
65 base::File::Info file_info_; | 70 fileapi::AsyncFileUtil::EntryList entry_list_; |
| 71 bool has_more_; |
66 | 72 |
67 DISALLOW_COPY_AND_ASSIGN(Event); | 73 DISALLOW_COPY_AND_ASSIGN(Event); |
68 }; | 74 }; |
69 | 75 |
70 CallbackLogger() : weak_ptr_factory_(this) {} | 76 CallbackLogger() : weak_ptr_factory_(this) {} |
71 virtual ~CallbackLogger() {} | 77 virtual ~CallbackLogger() {} |
72 | 78 |
73 void OnGetMetadata(base::File::Error result, | 79 void OnReadDirectory(base::File::Error result, |
74 const base::File::Info& file_info) { | 80 const fileapi::AsyncFileUtil::EntryList& entry_list, |
75 events_.push_back(new Event(result, file_info)); | 81 bool has_more) { |
| 82 events_.push_back(new Event(result, entry_list, has_more)); |
76 } | 83 } |
77 | 84 |
78 ScopedVector<Event>& events() { return events_; } | 85 ScopedVector<Event>& events() { return events_; } |
79 | 86 |
80 base::WeakPtr<CallbackLogger> GetWeakPtr() { | 87 base::WeakPtr<CallbackLogger> GetWeakPtr() { |
81 return weak_ptr_factory_.GetWeakPtr(); | 88 return weak_ptr_factory_.GetWeakPtr(); |
82 } | 89 } |
83 | 90 |
84 private: | 91 private: |
85 ScopedVector<Event> events_; | 92 ScopedVector<Event> events_; |
86 bool dispatch_reply_; | 93 bool dispatch_reply_; |
87 base::WeakPtrFactory<CallbackLogger> weak_ptr_factory_; | 94 base::WeakPtrFactory<CallbackLogger> weak_ptr_factory_; |
88 | 95 |
89 DISALLOW_COPY_AND_ASSIGN(CallbackLogger); | 96 DISALLOW_COPY_AND_ASSIGN(CallbackLogger); |
90 }; | 97 }; |
91 | 98 |
92 } // namespace | 99 } // namespace |
93 | 100 |
94 class FileSystemProviderOperationsGetMetadataTest : public testing::Test { | 101 class FileSystemProviderOperationsReadDirectoryTest : public testing::Test { |
95 protected: | 102 protected: |
96 FileSystemProviderOperationsGetMetadataTest() {} | 103 FileSystemProviderOperationsReadDirectoryTest() {} |
97 virtual ~FileSystemProviderOperationsGetMetadataTest() {} | 104 virtual ~FileSystemProviderOperationsReadDirectoryTest() {} |
98 | 105 |
99 virtual void SetUp() OVERRIDE { | 106 virtual void SetUp() OVERRIDE { |
100 file_system_info_ = | 107 file_system_info_ = |
101 ProvidedFileSystemInfo(kExtensionId, | 108 ProvidedFileSystemInfo(kExtensionId, |
102 kFileSystemId, | 109 kFileSystemId, |
103 "" /* file_system_name */, | 110 "" /* file_system_name */, |
104 base::FilePath() /* mount_path */); | 111 base::FilePath() /* mount_path */); |
105 } | 112 } |
106 | 113 |
107 ProvidedFileSystemInfo file_system_info_; | 114 ProvidedFileSystemInfo file_system_info_; |
108 }; | 115 }; |
109 | 116 |
110 TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute) { | 117 TEST_F(FileSystemProviderOperationsReadDirectoryTest, Execute) { |
111 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); | 118 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); |
112 CallbackLogger callback_logger; | 119 CallbackLogger callback_logger; |
113 | 120 |
114 GetMetadata get_metadata( | 121 ReadDirectory read_directory(NULL, |
115 NULL, | 122 file_system_info_, |
116 file_system_info_, | 123 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
117 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 124 base::Bind(&CallbackLogger::OnReadDirectory, |
118 base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr())); | 125 callback_logger.GetWeakPtr())); |
119 get_metadata.SetDispatchEventImplForTesting( | 126 read_directory.SetDispatchEventImplForTesting( |
120 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, | 127 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, |
121 base::Unretained(&dispatcher))); | 128 base::Unretained(&dispatcher))); |
122 | 129 |
123 EXPECT_TRUE(get_metadata.Execute(kRequestId)); | 130 EXPECT_TRUE(read_directory.Execute(kRequestId)); |
124 | 131 |
125 ASSERT_EQ(1u, dispatcher.events().size()); | 132 ASSERT_EQ(1u, dispatcher.events().size()); |
126 extensions::Event* event = dispatcher.events()[0]; | 133 extensions::Event* event = dispatcher.events()[0]; |
127 EXPECT_EQ( | 134 EXPECT_EQ(extensions::api::file_system_provider::OnReadDirectoryRequested:: |
128 extensions::api::file_system_provider::OnGetMetadataRequested::kEventName, | 135 kEventName, |
129 event->event_name); | 136 event->event_name); |
130 base::ListValue* event_args = event->event_args.get(); | 137 base::ListValue* event_args = event->event_args.get(); |
131 ASSERT_EQ(3u, event_args->GetSize()); | 138 ASSERT_EQ(3u, event_args->GetSize()); |
132 | 139 |
133 int event_file_system_id = -1; | 140 int event_file_system_id = -1; |
134 EXPECT_TRUE(event_args->GetInteger(0, &event_file_system_id)); | 141 EXPECT_TRUE(event_args->GetInteger(0, &event_file_system_id)); |
135 EXPECT_EQ(kFileSystemId, event_file_system_id); | 142 EXPECT_EQ(kFileSystemId, event_file_system_id); |
136 | 143 |
137 int event_request_id = -1; | 144 int event_request_id = -1; |
138 EXPECT_TRUE(event_args->GetInteger(1, &event_request_id)); | 145 EXPECT_TRUE(event_args->GetInteger(1, &event_request_id)); |
139 EXPECT_EQ(kRequestId, event_request_id); | 146 EXPECT_EQ(kRequestId, event_request_id); |
140 | 147 |
141 std::string event_directory_path; | 148 std::string event_directory_path; |
142 EXPECT_TRUE(event_args->GetString(2, &event_directory_path)); | 149 EXPECT_TRUE(event_args->GetString(2, &event_directory_path)); |
143 EXPECT_EQ(kDirectoryPath, event_directory_path); | 150 EXPECT_EQ(kDirectoryPath, event_directory_path); |
144 } | 151 } |
145 | 152 |
146 TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute_NoListener) { | 153 TEST_F(FileSystemProviderOperationsReadDirectoryTest, Execute_NoListener) { |
147 LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */); | 154 LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */); |
148 CallbackLogger callback_logger; | 155 CallbackLogger callback_logger; |
149 | 156 |
150 GetMetadata get_metadata( | 157 ReadDirectory read_directory(NULL, |
151 NULL, | 158 file_system_info_, |
152 file_system_info_, | 159 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
153 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 160 base::Bind(&CallbackLogger::OnReadDirectory, |
154 base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr())); | 161 callback_logger.GetWeakPtr())); |
155 get_metadata.SetDispatchEventImplForTesting( | 162 read_directory.SetDispatchEventImplForTesting( |
156 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, | 163 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, |
157 base::Unretained(&dispatcher))); | 164 base::Unretained(&dispatcher))); |
158 | 165 |
159 EXPECT_FALSE(get_metadata.Execute(kRequestId)); | 166 EXPECT_FALSE(read_directory.Execute(kRequestId)); |
160 } | 167 } |
161 | 168 |
162 TEST_F(FileSystemProviderOperationsGetMetadataTest, OnSuccess) { | 169 TEST_F(FileSystemProviderOperationsReadDirectoryTest, OnSuccess) { |
163 using extensions::api::file_system_provider::EntryMetadata; | 170 using extensions::api::file_system_provider::EntryMetadata; |
164 using extensions::api::file_system_provider_internal:: | 171 using extensions::api::file_system_provider_internal:: |
165 GetMetadataRequestedSuccess::Params; | 172 ReadDirectoryRequestedSuccess::Params; |
166 | 173 |
167 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); | 174 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); |
168 CallbackLogger callback_logger; | 175 CallbackLogger callback_logger; |
169 | 176 |
170 GetMetadata get_metadata( | 177 ReadDirectory read_directory(NULL, |
171 NULL, | 178 file_system_info_, |
172 file_system_info_, | 179 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
173 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 180 base::Bind(&CallbackLogger::OnReadDirectory, |
174 base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr())); | 181 callback_logger.GetWeakPtr())); |
175 get_metadata.SetDispatchEventImplForTesting( | 182 read_directory.SetDispatchEventImplForTesting( |
176 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, | 183 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, |
177 base::Unretained(&dispatcher))); | 184 base::Unretained(&dispatcher))); |
178 | 185 |
179 EXPECT_TRUE(get_metadata.Execute(kRequestId)); | 186 EXPECT_TRUE(read_directory.Execute(kRequestId)); |
180 | 187 |
181 // Sample input as JSON. Keep in sync with file_system_provider_api.idl. | 188 // Sample input as JSON. Keep in sync with file_system_provider_api.idl. |
182 // As for now, it is impossible to create *::Params class directly, not from | 189 // As for now, it is impossible to create *::Params class directly, not from |
183 // base::Value. | 190 // base::Value. |
184 const std::string input = | 191 const std::string input = |
185 "[\n" | 192 "[\n" |
186 " 1,\n" // kFileSystemId | 193 " 1,\n" // kFileSystemId |
187 " 2,\n" // kRequestId | 194 " 2,\n" // kRequestId |
188 " {\n" | 195 " [\n" |
189 " \"isDirectory\": false,\n" | 196 " {\n" |
190 " \"name\": \"blueberries.txt\",\n" | 197 " \"isDirectory\": false,\n" |
191 " \"size\": 4096,\n" | 198 " \"name\": \"blueberries.txt\",\n" |
192 " \"modificationTime\": {\n" | 199 " \"size\": 4096,\n" |
193 " \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n" | 200 " \"modificationTime\": {\n" |
| 201 " \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n" |
| 202 " }\n" |
194 " }\n" | 203 " }\n" |
195 " }\n" | 204 " ],\n" |
| 205 " false\n" // has_next |
196 "]\n"; | 206 "]\n"; |
197 | 207 |
198 int json_error_code; | 208 int json_error_code; |
199 std::string json_error_msg; | 209 std::string json_error_msg; |
200 scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError( | 210 scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError( |
201 input, base::JSON_PARSE_RFC, &json_error_code, &json_error_msg)); | 211 input, base::JSON_PARSE_RFC, &json_error_code, &json_error_msg)); |
202 ASSERT_TRUE(value.get()) << json_error_msg; | 212 ASSERT_TRUE(value.get()) << json_error_msg; |
203 | 213 |
204 base::ListValue* value_as_list; | 214 base::ListValue* value_as_list; |
205 ASSERT_TRUE(value->GetAsList(&value_as_list)); | 215 ASSERT_TRUE(value->GetAsList(&value_as_list)); |
206 scoped_ptr<Params> params(Params::Create(*value_as_list)); | 216 scoped_ptr<Params> params(Params::Create(*value_as_list)); |
207 ASSERT_TRUE(params.get()); | 217 ASSERT_TRUE(params.get()); |
208 scoped_ptr<RequestValue> request_value( | 218 scoped_ptr<RequestValue> request_value( |
209 RequestValue::CreateForGetMetadataSuccess(params.Pass())); | 219 RequestValue::CreateForReadDirectorySuccess(params.Pass())); |
210 ASSERT_TRUE(request_value.get()); | 220 ASSERT_TRUE(request_value.get()); |
211 | 221 |
212 const bool has_next = false; | 222 const bool has_next = false; |
213 get_metadata.OnSuccess(kRequestId, request_value.Pass(), has_next); | 223 read_directory.OnSuccess(kRequestId, request_value.Pass(), has_next); |
214 | 224 |
215 ASSERT_EQ(1u, callback_logger.events().size()); | 225 ASSERT_EQ(1u, callback_logger.events().size()); |
216 CallbackLogger::Event* event = callback_logger.events()[0]; | 226 CallbackLogger::Event* event = callback_logger.events()[0]; |
217 EXPECT_EQ(base::File::FILE_OK, event->result()); | 227 EXPECT_EQ(base::File::FILE_OK, event->result()); |
218 | 228 |
219 const base::File::Info& file_info = event->file_info(); | 229 ASSERT_EQ(1u, event->entry_list().size()); |
220 EXPECT_FALSE(file_info.is_directory); | 230 const fileapi::DirectoryEntry entry = event->entry_list()[0]; |
221 EXPECT_EQ(4096, file_info.size); | 231 EXPECT_FALSE(entry.is_directory); |
| 232 EXPECT_EQ("blueberries.txt", entry.name); |
| 233 EXPECT_EQ(4096, entry.size); |
222 base::Time expected_time; | 234 base::Time expected_time; |
223 EXPECT_TRUE( | 235 EXPECT_TRUE( |
224 base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014", &expected_time)); | 236 base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014", &expected_time)); |
225 EXPECT_EQ(expected_time, file_info.last_modified); | 237 EXPECT_EQ(expected_time, entry.last_modified_time); |
226 } | 238 } |
227 | 239 |
228 TEST_F(FileSystemProviderOperationsGetMetadataTest, OnError) { | 240 TEST_F(FileSystemProviderOperationsReadDirectoryTest, OnError) { |
229 using extensions::api::file_system_provider::EntryMetadata; | 241 using extensions::api::file_system_provider::EntryMetadata; |
230 using extensions::api::file_system_provider_internal:: | 242 using extensions::api::file_system_provider_internal:: |
231 GetMetadataRequestedError::Params; | 243 ReadDirectoryRequestedSuccess::Params; |
232 | 244 |
233 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); | 245 LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */); |
234 CallbackLogger callback_logger; | 246 CallbackLogger callback_logger; |
235 | 247 |
236 GetMetadata get_metadata( | 248 ReadDirectory read_directory(NULL, |
237 NULL, | 249 file_system_info_, |
238 file_system_info_, | 250 base::FilePath::FromUTF8Unsafe(kDirectoryPath), |
239 base::FilePath::FromUTF8Unsafe(kDirectoryPath), | 251 base::Bind(&CallbackLogger::OnReadDirectory, |
240 base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr())); | 252 callback_logger.GetWeakPtr())); |
241 get_metadata.SetDispatchEventImplForTesting( | 253 read_directory.SetDispatchEventImplForTesting( |
242 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, | 254 base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl, |
243 base::Unretained(&dispatcher))); | 255 base::Unretained(&dispatcher))); |
244 | 256 |
245 EXPECT_TRUE(get_metadata.Execute(kRequestId)); | 257 EXPECT_TRUE(read_directory.Execute(kRequestId)); |
246 | 258 |
247 get_metadata.OnError(kRequestId, base::File::FILE_ERROR_TOO_MANY_OPENED); | 259 read_directory.OnError(kRequestId, base::File::FILE_ERROR_TOO_MANY_OPENED); |
248 | 260 |
249 ASSERT_EQ(1u, callback_logger.events().size()); | 261 ASSERT_EQ(1u, callback_logger.events().size()); |
250 CallbackLogger::Event* event = callback_logger.events()[0]; | 262 CallbackLogger::Event* event = callback_logger.events()[0]; |
251 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, event->result()); | 263 EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, event->result()); |
| 264 ASSERT_EQ(0u, event->entry_list().size()); |
252 } | 265 } |
253 | 266 |
254 } // namespace operations | 267 } // namespace operations |
255 } // namespace file_system_provider | 268 } // namespace file_system_provider |
256 } // namespace chromeos | 269 } // namespace chromeos |
OLD | NEW |