OLD | NEW |
---|---|
(Empty) | |
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 <string> | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/files/file.h" | |
9 #include "base/files/file_path.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/memory/scoped_vector.h" | |
12 #include "base/memory/weak_ptr.h" | |
13 #include "base/values.h" | |
14 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" | |
15 #include "testing/gtest/include/gtest/gtest.h" | |
16 | |
17 namespace chromeos { | |
18 namespace file_system_provider { | |
19 namespace { | |
20 | |
21 static const std::string kExtensionId = "mbflcebpggnecokmikipoihdbecnjfoj"; | |
hashimoto
2014/03/25 10:57:48
nit: No need to have const. You are already in the
kinaba
2014/03/25 11:14:51
I think hashimoto meant no need for static.
std::
mtomasz
2014/03/26 00:52:34
Done.
mtomasz
2014/03/26 00:52:34
Done.
hashimoto
2014/03/26 01:07:56
oops, right, indeed.
| |
22 static const int kFileSystemId = 1; | |
23 static const std::string kFileSystemName = "Camera Pictures"; | |
24 static const base::FilePath::CharType kMountPath[] = FILE_PATH_LITERAL( | |
25 "/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash"); | |
26 | |
27 class EventLogger { | |
28 public: | |
29 class SuccessEvent { | |
30 public: | |
31 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) | |
32 : result_(result.Pass()), has_next_(has_next) {} | |
33 ~SuccessEvent() {}; | |
kinaba
2014/03/25 11:14:51
semicolon not necessary.
mtomasz
2014/03/26 00:52:34
Done.
| |
34 | |
35 base::DictionaryValue* result() { return result_.get(); } | |
36 bool has_next() { return has_next_; } | |
37 | |
38 private: | |
39 scoped_ptr<base::DictionaryValue> result_; | |
40 bool has_next_; | |
41 }; | |
42 | |
43 class ErrorEvent { | |
44 public: | |
45 explicit ErrorEvent(base::File::Error error) : error_(error) {} | |
46 ~ErrorEvent() {}; | |
kinaba
2014/03/25 11:14:51
Drop semicolon
mtomasz
2014/03/26 00:52:34
Done.
| |
47 | |
48 base::File::Error error() { return error_; } | |
49 | |
50 private: | |
51 base::File::Error error_; | |
52 }; | |
53 | |
54 EventLogger() : weak_ptr_factory_(this) {} | |
55 virtual ~EventLogger() {} | |
56 | |
57 void OnSuccess(scoped_ptr<base::DictionaryValue> result, bool has_next) { | |
58 success_events_.push_back(new SuccessEvent(result.Pass(), has_next)); | |
59 } | |
60 | |
61 void OnError(base::File::Error error) { | |
62 error_events_.push_back(new ErrorEvent(error)); | |
63 } | |
64 | |
65 ScopedVector<SuccessEvent>& success_events() { return success_events_; } | |
66 ScopedVector<ErrorEvent>& error_events() { return error_events_; } | |
67 | |
68 base::WeakPtr<EventLogger> GetWeakPtr() { | |
69 return weak_ptr_factory_.GetWeakPtr(); | |
70 } | |
71 | |
72 private: | |
73 ScopedVector<SuccessEvent> success_events_; | |
74 ScopedVector<ErrorEvent> error_events_; | |
75 base::WeakPtrFactory<EventLogger> weak_ptr_factory_; | |
76 }; | |
77 | |
78 } // namespace | |
79 | |
80 class FileSystemProviderRequestManagerTest : public testing::Test { | |
81 protected: | |
82 FileSystemProviderRequestManagerTest() {} | |
83 virtual ~FileSystemProviderRequestManagerTest() {} | |
84 | |
85 virtual void SetUp() OVERRIDE { | |
86 request_manager_.reset(new RequestManager()); | |
87 | |
88 // Configure the testing file system. | |
89 file_system = ProvidedFileSystem(kExtensionId, | |
90 kFileSystemId, | |
91 kFileSystemName, | |
92 base::FilePath(kMountPath)); | |
93 } | |
94 | |
95 scoped_ptr<RequestManager> request_manager_; | |
96 ProvidedFileSystem file_system; | |
97 }; | |
98 | |
99 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { | |
100 EventLogger logger; | |
101 | |
102 int request_id = request_manager_->CreateRequest( | |
103 file_system, | |
104 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
105 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
106 | |
107 EXPECT_EQ(1, request_id); | |
108 EXPECT_EQ(0u, logger.success_events().size()); | |
109 EXPECT_EQ(0u, logger.error_events().size()); | |
110 | |
111 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); | |
112 const bool has_next = false; | |
113 response->SetString("path", "i-like-vanilla"); | |
114 | |
115 bool result = request_manager_->FulfillRequest( | |
116 file_system, request_id, response.Pass(), has_next); | |
117 EXPECT_TRUE(result); | |
118 | |
119 // Validate if the callback has correct arguments. | |
120 ASSERT_EQ(1u, logger.success_events().size()); | |
121 EXPECT_EQ(0u, logger.error_events().size()); | |
122 EventLogger::SuccessEvent* event = logger.success_events()[0]; | |
123 ASSERT_TRUE(event->result()); | |
124 std::string response_test_string; | |
125 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); | |
126 EXPECT_EQ("i-like-vanilla", response_test_string); | |
127 EXPECT_EQ(has_next, event->has_next()); | |
128 | |
129 // Confirm, that the request is removed. Basically, fulfilling again for the | |
130 // same request, should fail. | |
131 { | |
132 bool retry = request_manager_->FulfillRequest( | |
133 file_system, request_id, response.Pass(), has_next); | |
134 EXPECT_FALSE(retry); | |
135 } | |
136 | |
137 // Rejecting should also fail. | |
138 { | |
139 bool retry = request_manager_->RejectRequest( | |
140 file_system, request_id, base::File::FILE_ERROR_FAILED); | |
141 EXPECT_FALSE(retry); | |
142 } | |
143 } | |
144 | |
145 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { | |
146 EventLogger logger; | |
147 | |
148 int request_id = request_manager_->CreateRequest( | |
149 file_system, | |
150 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
151 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
152 | |
153 EXPECT_EQ(1, request_id); | |
154 EXPECT_EQ(0u, logger.success_events().size()); | |
155 EXPECT_EQ(0u, logger.error_events().size()); | |
156 | |
157 scoped_ptr<base::DictionaryValue> response; | |
158 const bool has_next = true; | |
159 | |
160 bool result = request_manager_->FulfillRequest( | |
161 file_system, request_id, response.Pass(), has_next); | |
162 EXPECT_TRUE(result); | |
163 | |
164 // Validate if the callback has correct arguments. | |
165 ASSERT_EQ(1u, logger.success_events().size()); | |
166 EXPECT_EQ(0u, logger.error_events().size()); | |
167 EventLogger::SuccessEvent* event = logger.success_events()[0]; | |
168 ASSERT_FALSE(event->result()); | |
hashimoto
2014/03/25 10:57:48
nit: I think this can be EXPECT.
Why don't you all
mtomasz
2014/03/26 00:52:34
Done.
| |
169 EXPECT_EQ(has_next, event->has_next()); | |
170 | |
171 // Confirm, that the request is not removed (since it has has_next == true). | |
172 // Basically, fulfilling again for the same request, should not fail. | |
173 { | |
174 bool new_has_next = false; | |
175 bool retry = request_manager_->FulfillRequest( | |
176 file_system, request_id, response.Pass(), new_has_next); | |
177 EXPECT_TRUE(retry); | |
178 } | |
179 | |
180 // Since |new_has_next| is false, then the request should be removed. To check | |
181 // it, try to fulfill again, what should fail. | |
182 { | |
183 bool new_has_next = false; | |
184 bool retry = request_manager_->FulfillRequest( | |
185 file_system, request_id, response.Pass(), new_has_next); | |
186 EXPECT_FALSE(retry); | |
187 } | |
188 } | |
189 | |
190 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { | |
191 EventLogger logger; | |
192 | |
193 int request_id = request_manager_->CreateRequest( | |
194 file_system, | |
195 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
196 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
197 | |
198 EXPECT_EQ(1, request_id); | |
199 EXPECT_EQ(0u, logger.success_events().size()); | |
200 EXPECT_EQ(0u, logger.error_events().size()); | |
201 | |
202 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | |
203 bool result = request_manager_->RejectRequest(file_system, request_id, error); | |
204 EXPECT_TRUE(result); | |
205 | |
206 // Validate if the callback has correct arguments. | |
207 ASSERT_EQ(1u, logger.error_events().size()); | |
208 EXPECT_EQ(0u, logger.success_events().size()); | |
209 EventLogger::ErrorEvent* event = logger.error_events()[0]; | |
210 EXPECT_EQ(error, event->error()); | |
211 | |
212 // Confirm, that the request is removed. Basically, fulfilling again for the | |
213 // same request, should fail. | |
214 { | |
215 scoped_ptr<base::DictionaryValue> response; | |
216 bool has_next = false; | |
217 bool retry = request_manager_->FulfillRequest( | |
218 file_system, request_id, response.Pass(), has_next); | |
219 EXPECT_FALSE(retry); | |
220 } | |
221 | |
222 // Rejecting should also fail. | |
223 { | |
224 bool retry = | |
225 request_manager_->RejectRequest(file_system, request_id, error); | |
226 EXPECT_FALSE(retry); | |
227 } | |
228 } | |
229 | |
230 TEST_F(FileSystemProviderRequestManagerTest, | |
231 CreateAndFulfillWithWrongRequestId) { | |
232 EventLogger logger; | |
233 | |
234 int request_id = request_manager_->CreateRequest( | |
235 file_system, | |
236 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
237 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
238 | |
239 EXPECT_EQ(1, request_id); | |
240 EXPECT_EQ(0u, logger.success_events().size()); | |
241 EXPECT_EQ(0u, logger.error_events().size()); | |
242 | |
243 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | |
244 bool result = | |
245 request_manager_->RejectRequest(file_system, request_id + 1, error); | |
246 EXPECT_FALSE(result); | |
247 | |
248 // Callbacks should not be called. | |
249 ASSERT_EQ(0u, logger.error_events().size()); | |
hashimoto
2014/03/25 10:57:48
nit: This can be EXPECT?
mtomasz
2014/03/26 00:52:34
Done.
| |
250 EXPECT_EQ(0u, logger.success_events().size()); | |
251 | |
252 // Confirm, that the request hasn't been removed, by rejecting it correctly. | |
253 { | |
254 bool retry = | |
255 request_manager_->RejectRequest(file_system, request_id, error); | |
256 EXPECT_TRUE(retry); | |
257 } | |
258 } | |
259 | |
260 TEST_F(FileSystemProviderRequestManagerTest, | |
261 CreateAndRejectWithWrongRequestId) { | |
262 EventLogger logger; | |
263 | |
264 int request_id = request_manager_->CreateRequest( | |
265 file_system, | |
266 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
267 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
268 | |
269 EXPECT_EQ(1, request_id); | |
270 EXPECT_EQ(0u, logger.success_events().size()); | |
271 EXPECT_EQ(0u, logger.error_events().size()); | |
272 | |
273 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | |
274 bool result = | |
275 request_manager_->RejectRequest(file_system, request_id + 1, error); | |
276 EXPECT_FALSE(result); | |
277 | |
278 // Callbacks should not be called. | |
279 ASSERT_EQ(0u, logger.error_events().size()); | |
hashimoto
2014/03/25 10:57:48
nit: This can be EXPECT?
mtomasz
2014/03/26 00:52:34
Done.
| |
280 EXPECT_EQ(0u, logger.success_events().size()); | |
281 | |
282 // Confirm, that the request hasn't been removed, by rejecting it correctly. | |
283 { | |
284 bool retry = | |
285 request_manager_->RejectRequest(file_system, request_id, error); | |
286 EXPECT_TRUE(retry); | |
287 } | |
288 } | |
289 | |
290 TEST_F(FileSystemProviderRequestManagerTest, | |
291 CreateAndFulfillWithUnownedRequestId) { | |
292 EventLogger logger; | |
293 | |
294 int request_id = request_manager_->CreateRequest( | |
295 file_system, | |
296 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
297 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
298 EXPECT_EQ(1, request_id); | |
299 | |
300 // Create another file system, which has just a different fiel system id | |
301 // (1 -> 2). | |
302 ProvidedFileSystem another_file_system( | |
303 kExtensionId, | |
304 2, // file_system_id | |
305 "Music", | |
306 base::FilePath( | |
kinaba
2014/03/25 11:14:51
base::FilePath::FromUTF8Unsafe (or FILE_PATH_LITER
mtomasz
2014/03/26 00:52:34
Done.
| |
307 "/provided/mbflcebpggnecokmikipoihdbecnjfoj-2-testing_profile-hash")); | |
308 | |
309 scoped_ptr<base::DictionaryValue> response; | |
310 const bool has_next = false; | |
311 | |
312 bool result = request_manager_->FulfillRequest( | |
313 another_file_system, request_id, response.Pass(), has_next); | |
314 EXPECT_FALSE(result); | |
315 | |
316 // Callbacks should not be called. | |
317 ASSERT_EQ(0u, logger.error_events().size()); | |
hashimoto
2014/03/25 10:57:48
nit: This can be EXPECT?
mtomasz
2014/03/26 00:52:34
Done.
| |
318 EXPECT_EQ(0u, logger.success_events().size()); | |
319 | |
320 // Confirm, that the request hasn't been removed, by fulfilling it again, but | |
321 // with a correct file system. | |
322 { | |
323 bool retry = request_manager_->FulfillRequest( | |
324 file_system, request_id, response.Pass(), has_next); | |
325 EXPECT_TRUE(retry); | |
326 } | |
327 } | |
328 | |
329 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { | |
330 EventLogger logger; | |
331 | |
332 int first_request_id = request_manager_->CreateRequest( | |
333 file_system, | |
334 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
335 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
336 | |
337 int second_request_id = request_manager_->CreateRequest( | |
338 file_system, | |
339 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
340 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
341 | |
342 EXPECT_EQ(1, first_request_id); | |
343 EXPECT_EQ(2, second_request_id); | |
344 } | |
345 | |
346 } // namespace file_system_provider | |
347 } // namespace chromeos | |
OLD | NEW |