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/bind.h" | 7 #include "base/bind.h" |
8 #include "base/files/file.h" | 8 #include "base/files/file.h" |
9 #include "base/files/file_path.h" | 9 #include "base/files/file_path.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 "base/memory/weak_ptr.h" | 12 #include "base/memory/weak_ptr.h" |
13 #include "base/values.h" | 13 #include "base/values.h" |
14 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" | 14 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 namespace chromeos { | 17 namespace chromeos { |
18 namespace file_system_provider { | 18 namespace file_system_provider { |
19 namespace { | 19 namespace { |
20 | 20 |
21 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; | |
22 const int kFileSystemId = 1; | |
23 | |
24 // Logs calls of the success and error callbacks on requests. | 21 // Logs calls of the success and error callbacks on requests. |
25 class EventLogger { | 22 class EventLogger { |
26 public: | 23 public: |
27 class SuccessEvent { | 24 class SuccessEvent { |
28 public: | 25 public: |
29 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) | 26 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) |
30 : result_(result.Pass()), has_next_(has_next) {} | 27 : result_(result.Pass()), has_next_(has_next) {} |
31 ~SuccessEvent() {} | 28 ~SuccessEvent() {} |
32 | 29 |
33 base::DictionaryValue* result() { return result_.get(); } | 30 base::DictionaryValue* result() { return result_.get(); } |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
84 request_manager_.reset(new RequestManager()); | 81 request_manager_.reset(new RequestManager()); |
85 } | 82 } |
86 | 83 |
87 scoped_ptr<RequestManager> request_manager_; | 84 scoped_ptr<RequestManager> request_manager_; |
88 }; | 85 }; |
89 | 86 |
90 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { | 87 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { |
91 EventLogger logger; | 88 EventLogger logger; |
92 | 89 |
93 int request_id = request_manager_->CreateRequest( | 90 int request_id = request_manager_->CreateRequest( |
94 kExtensionId, | |
95 kFileSystemId, | |
96 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 91 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
97 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 92 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
98 | 93 |
99 EXPECT_EQ(1, request_id); | 94 EXPECT_EQ(1, request_id); |
100 EXPECT_EQ(0u, logger.success_events().size()); | 95 EXPECT_EQ(0u, logger.success_events().size()); |
101 EXPECT_EQ(0u, logger.error_events().size()); | 96 EXPECT_EQ(0u, logger.error_events().size()); |
102 | 97 |
103 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); | 98 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); |
104 const bool has_next = false; | 99 const bool has_next = false; |
105 response->SetString("path", "i-like-vanilla"); | 100 response->SetString("path", "i-like-vanilla"); |
106 | 101 |
107 bool result = request_manager_->FulfillRequest( | 102 bool result = |
108 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); | 103 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
109 EXPECT_TRUE(result); | 104 EXPECT_TRUE(result); |
110 | 105 |
111 // Validate if the callback has correct arguments. | 106 // Validate if the callback has correct arguments. |
112 ASSERT_EQ(1u, logger.success_events().size()); | 107 ASSERT_EQ(1u, logger.success_events().size()); |
113 EXPECT_EQ(0u, logger.error_events().size()); | 108 EXPECT_EQ(0u, logger.error_events().size()); |
114 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 109 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
115 ASSERT_TRUE(event->result()); | 110 ASSERT_TRUE(event->result()); |
116 std::string response_test_string; | 111 std::string response_test_string; |
117 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); | 112 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); |
118 EXPECT_EQ("i-like-vanilla", response_test_string); | 113 EXPECT_EQ("i-like-vanilla", response_test_string); |
119 EXPECT_EQ(has_next, event->has_next()); | 114 EXPECT_EQ(has_next, event->has_next()); |
120 | 115 |
121 // Confirm, that the request is removed. Basically, fulfilling again for the | 116 // Confirm, that the request is removed. Basically, fulfilling again for the |
122 // same request, should fail. | 117 // same request, should fail. |
123 { | 118 { |
124 scoped_ptr<base::DictionaryValue> response; | 119 scoped_ptr<base::DictionaryValue> response; |
125 bool retry = request_manager_->FulfillRequest( | 120 bool retry = |
126 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); | 121 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
127 EXPECT_FALSE(retry); | 122 EXPECT_FALSE(retry); |
128 } | 123 } |
129 | 124 |
130 // Rejecting should also fail. | 125 // Rejecting should also fail. |
131 { | 126 { |
132 bool retry = request_manager_->RejectRequest( | 127 bool retry = request_manager_->RejectRequest(request_id, |
133 kExtensionId, kFileSystemId, request_id, base::File::FILE_ERROR_FAILED); | 128 base::File::FILE_ERROR_FAILED); |
134 EXPECT_FALSE(retry); | 129 EXPECT_FALSE(retry); |
135 } | 130 } |
136 } | 131 } |
137 | 132 |
138 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { | 133 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { |
139 EventLogger logger; | 134 EventLogger logger; |
140 | 135 |
141 int request_id = request_manager_->CreateRequest( | 136 int request_id = request_manager_->CreateRequest( |
142 kExtensionId, | |
143 kFileSystemId, | |
144 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 137 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
145 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 138 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
146 | 139 |
147 EXPECT_EQ(1, request_id); | 140 EXPECT_EQ(1, request_id); |
148 EXPECT_EQ(0u, logger.success_events().size()); | 141 EXPECT_EQ(0u, logger.success_events().size()); |
149 EXPECT_EQ(0u, logger.error_events().size()); | 142 EXPECT_EQ(0u, logger.error_events().size()); |
150 | 143 |
151 scoped_ptr<base::DictionaryValue> response; | 144 scoped_ptr<base::DictionaryValue> response; |
152 const bool has_next = true; | 145 const bool has_next = true; |
153 | 146 |
154 bool result = request_manager_->FulfillRequest( | 147 bool result = |
155 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); | 148 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
156 EXPECT_TRUE(result); | 149 EXPECT_TRUE(result); |
157 | 150 |
158 // Validate if the callback has correct arguments. | 151 // Validate if the callback has correct arguments. |
159 ASSERT_EQ(1u, logger.success_events().size()); | 152 ASSERT_EQ(1u, logger.success_events().size()); |
160 EXPECT_EQ(0u, logger.error_events().size()); | 153 EXPECT_EQ(0u, logger.error_events().size()); |
161 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 154 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
162 EXPECT_FALSE(event->result()); | 155 EXPECT_FALSE(event->result()); |
163 EXPECT_EQ(has_next, event->has_next()); | 156 EXPECT_EQ(has_next, event->has_next()); |
164 | 157 |
165 // Confirm, that the request is not removed (since it has has_next == true). | 158 // Confirm, that the request is not removed (since it has has_next == true). |
166 // Basically, fulfilling again for the same request, should not fail. | 159 // Basically, fulfilling again for the same request, should not fail. |
167 { | 160 { |
168 bool new_has_next = false; | 161 bool new_has_next = false; |
169 bool retry = request_manager_->FulfillRequest( | 162 bool retry = request_manager_->FulfillRequest( |
170 kExtensionId, kFileSystemId, request_id, response.Pass(), new_has_next); | 163 request_id, response.Pass(), new_has_next); |
171 EXPECT_TRUE(retry); | 164 EXPECT_TRUE(retry); |
172 } | 165 } |
173 | 166 |
174 // Since |new_has_next| is false, then the request should be removed. To check | 167 // Since |new_has_next| is false, then the request should be removed. To check |
175 // it, try to fulfill again, what should fail. | 168 // it, try to fulfill again, what should fail. |
176 { | 169 { |
177 bool new_has_next = false; | 170 bool new_has_next = false; |
178 bool retry = request_manager_->FulfillRequest( | 171 bool retry = request_manager_->FulfillRequest( |
179 kExtensionId, kFileSystemId, request_id, response.Pass(), new_has_next); | 172 request_id, response.Pass(), new_has_next); |
180 EXPECT_FALSE(retry); | 173 EXPECT_FALSE(retry); |
181 } | 174 } |
182 } | 175 } |
183 | 176 |
184 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { | 177 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { |
185 EventLogger logger; | 178 EventLogger logger; |
186 | 179 |
187 int request_id = request_manager_->CreateRequest( | 180 int request_id = request_manager_->CreateRequest( |
188 kExtensionId, | |
189 kFileSystemId, | |
190 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 181 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
191 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 182 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
192 | 183 |
193 EXPECT_EQ(1, request_id); | 184 EXPECT_EQ(1, request_id); |
194 EXPECT_EQ(0u, logger.success_events().size()); | 185 EXPECT_EQ(0u, logger.success_events().size()); |
195 EXPECT_EQ(0u, logger.error_events().size()); | 186 EXPECT_EQ(0u, logger.error_events().size()); |
196 | 187 |
197 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 188 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
198 bool result = request_manager_->RejectRequest( | 189 bool result = request_manager_->RejectRequest(request_id, error); |
199 kExtensionId, kFileSystemId, request_id, error); | |
200 EXPECT_TRUE(result); | 190 EXPECT_TRUE(result); |
201 | 191 |
202 // Validate if the callback has correct arguments. | 192 // Validate if the callback has correct arguments. |
203 ASSERT_EQ(1u, logger.error_events().size()); | 193 ASSERT_EQ(1u, logger.error_events().size()); |
204 EXPECT_EQ(0u, logger.success_events().size()); | 194 EXPECT_EQ(0u, logger.success_events().size()); |
205 EventLogger::ErrorEvent* event = logger.error_events()[0]; | 195 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
206 EXPECT_EQ(error, event->error()); | 196 EXPECT_EQ(error, event->error()); |
207 | 197 |
208 // Confirm, that the request is removed. Basically, fulfilling again for the | 198 // Confirm, that the request is removed. Basically, fulfilling again for the |
209 // same request, should fail. | 199 // same request, should fail. |
210 { | 200 { |
211 scoped_ptr<base::DictionaryValue> response; | 201 scoped_ptr<base::DictionaryValue> response; |
212 bool has_next = false; | 202 bool has_next = false; |
213 bool retry = request_manager_->FulfillRequest( | 203 bool retry = |
214 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); | 204 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
215 EXPECT_FALSE(retry); | 205 EXPECT_FALSE(retry); |
216 } | 206 } |
217 | 207 |
218 // Rejecting should also fail. | 208 // Rejecting should also fail. |
219 { | 209 { |
220 bool retry = request_manager_->RejectRequest( | 210 bool retry = request_manager_->RejectRequest(request_id, error); |
221 kExtensionId, kFileSystemId, request_id, error); | |
222 EXPECT_FALSE(retry); | 211 EXPECT_FALSE(retry); |
223 } | 212 } |
224 } | 213 } |
225 | 214 |
226 TEST_F(FileSystemProviderRequestManagerTest, | 215 TEST_F(FileSystemProviderRequestManagerTest, |
227 CreateAndFulfillWithWrongRequestId) { | 216 CreateAndFulfillWithWrongRequestId) { |
228 EventLogger logger; | 217 EventLogger logger; |
229 | 218 |
230 int request_id = request_manager_->CreateRequest( | 219 int request_id = request_manager_->CreateRequest( |
231 kExtensionId, | |
232 kFileSystemId, | |
233 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 220 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
234 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 221 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
235 | 222 |
236 EXPECT_EQ(1, request_id); | 223 EXPECT_EQ(1, request_id); |
237 EXPECT_EQ(0u, logger.success_events().size()); | 224 EXPECT_EQ(0u, logger.success_events().size()); |
238 EXPECT_EQ(0u, logger.error_events().size()); | 225 EXPECT_EQ(0u, logger.error_events().size()); |
239 | 226 |
240 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 227 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
241 bool result = request_manager_->RejectRequest( | 228 bool result = request_manager_->RejectRequest(request_id + 1, error); |
242 kExtensionId, kFileSystemId, request_id + 1, error); | |
243 EXPECT_FALSE(result); | 229 EXPECT_FALSE(result); |
244 | 230 |
245 // Callbacks should not be called. | 231 // Callbacks should not be called. |
246 EXPECT_EQ(0u, logger.error_events().size()); | 232 EXPECT_EQ(0u, logger.error_events().size()); |
247 EXPECT_EQ(0u, logger.success_events().size()); | 233 EXPECT_EQ(0u, logger.success_events().size()); |
248 | 234 |
249 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 235 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
250 { | 236 { |
251 bool retry = request_manager_->RejectRequest( | 237 bool retry = request_manager_->RejectRequest(request_id, error); |
252 kExtensionId, kFileSystemId, request_id, error); | |
253 EXPECT_TRUE(retry); | 238 EXPECT_TRUE(retry); |
254 } | 239 } |
255 } | 240 } |
256 | 241 |
257 TEST_F(FileSystemProviderRequestManagerTest, | 242 TEST_F(FileSystemProviderRequestManagerTest, |
258 CreateAndRejectWithWrongRequestId) { | 243 CreateAndRejectWithWrongRequestId) { |
259 EventLogger logger; | 244 EventLogger logger; |
260 | 245 |
261 int request_id = request_manager_->CreateRequest( | 246 int request_id = request_manager_->CreateRequest( |
262 kExtensionId, | |
263 kFileSystemId, | |
264 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 247 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
265 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 248 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
266 | 249 |
267 EXPECT_EQ(1, request_id); | 250 EXPECT_EQ(1, request_id); |
268 EXPECT_EQ(0u, logger.success_events().size()); | 251 EXPECT_EQ(0u, logger.success_events().size()); |
269 EXPECT_EQ(0u, logger.error_events().size()); | 252 EXPECT_EQ(0u, logger.error_events().size()); |
270 | 253 |
271 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 254 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
272 bool result = request_manager_->RejectRequest( | 255 bool result = request_manager_->RejectRequest(request_id + 1, error); |
273 kExtensionId, kFileSystemId, request_id + 1, error); | |
274 EXPECT_FALSE(result); | 256 EXPECT_FALSE(result); |
275 | 257 |
276 // Callbacks should not be called. | 258 // Callbacks should not be called. |
277 EXPECT_EQ(0u, logger.error_events().size()); | 259 EXPECT_EQ(0u, logger.error_events().size()); |
278 EXPECT_EQ(0u, logger.success_events().size()); | 260 EXPECT_EQ(0u, logger.success_events().size()); |
279 | 261 |
280 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 262 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
281 { | 263 { |
282 bool retry = request_manager_->RejectRequest( | 264 bool retry = request_manager_->RejectRequest(request_id, error); |
283 kExtensionId, kFileSystemId, request_id, error); | |
284 EXPECT_TRUE(retry); | 265 EXPECT_TRUE(retry); |
285 } | 266 } |
286 } | 267 } |
287 | |
288 TEST_F(FileSystemProviderRequestManagerTest, | |
289 CreateAndFulfillWithUnownedRequestId) { | |
290 EventLogger logger; | |
291 | |
292 int request_id = request_manager_->CreateRequest( | |
293 kExtensionId, | |
294 kFileSystemId, | |
295 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | |
296 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | |
297 EXPECT_EQ(1, request_id); | |
298 | |
299 scoped_ptr<base::DictionaryValue> response; | |
300 const bool has_next = false; | |
301 | |
302 bool result = request_manager_->FulfillRequest(kExtensionId, | |
303 2, // file_system_id | |
304 request_id, | |
305 response.Pass(), | |
306 has_next); | |
307 EXPECT_FALSE(result); | |
308 | |
309 // Callbacks should not be called. | |
310 EXPECT_EQ(0u, logger.error_events().size()); | |
311 EXPECT_EQ(0u, logger.success_events().size()); | |
312 | |
313 // Confirm, that the request hasn't been removed, by fulfilling it again, but | |
314 // with a correct file system. | |
315 { | |
316 bool retry = request_manager_->FulfillRequest( | |
317 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); | |
318 EXPECT_TRUE(retry); | |
319 } | |
320 } | |
321 | 268 |
322 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { | 269 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { |
323 EventLogger logger; | 270 EventLogger logger; |
324 | 271 |
325 int first_request_id = request_manager_->CreateRequest( | 272 int first_request_id = request_manager_->CreateRequest( |
326 kExtensionId, | |
327 kFileSystemId, | |
328 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 273 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
329 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 274 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
330 | 275 |
331 int second_request_id = request_manager_->CreateRequest( | 276 int second_request_id = request_manager_->CreateRequest( |
332 kExtensionId, | |
333 kFileSystemId, | |
334 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 277 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
335 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 278 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
336 | 279 |
337 EXPECT_EQ(1, first_request_id); | 280 EXPECT_EQ(1, first_request_id); |
338 EXPECT_EQ(2, second_request_id); | 281 EXPECT_EQ(2, second_request_id); |
339 } | 282 } |
340 | 283 |
| 284 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) { |
| 285 EventLogger logger; |
| 286 |
| 287 { |
| 288 RequestManager request_manager; |
| 289 int request_id = request_manager.CreateRequest( |
| 290 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
| 291 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
| 292 |
| 293 EXPECT_EQ(1, request_id); |
| 294 EXPECT_EQ(0u, logger.success_events().size()); |
| 295 EXPECT_EQ(0u, logger.error_events().size()); |
| 296 } |
| 297 |
| 298 // All active requests should be aborted in the destructor of RequestManager. |
| 299 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
| 300 ASSERT_EQ(1u, logger.error_events().size()); |
| 301 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); |
| 302 |
| 303 EXPECT_EQ(0u, logger.success_events().size()); |
| 304 } |
| 305 |
341 } // namespace file_system_provider | 306 } // namespace file_system_provider |
342 } // namespace chromeos | 307 } // namespace chromeos |
OLD | NEW |