OLD | NEW |
| (Empty) |
1 // Copyright 2016 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 "components/offline_pages/background/request_queue.h" | |
6 | |
7 #include <memory> | |
8 #include <utility> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/test/test_simple_task_runner.h" | |
12 #include "base/threading/thread_task_runner_handle.h" | |
13 #include "components/offline_pages/background/device_conditions.h" | |
14 #include "components/offline_pages/background/offliner_policy.h" | |
15 #include "components/offline_pages/background/request_coordinator.h" | |
16 #include "components/offline_pages/background/request_coordinator_event_logger.h
" | |
17 #include "components/offline_pages/background/request_notifier.h" | |
18 #include "components/offline_pages/background/request_queue_in_memory_store.h" | |
19 #include "components/offline_pages/background/save_page_request.h" | |
20 #include "testing/gtest/include/gtest/gtest.h" | |
21 | |
22 namespace offline_pages { | |
23 | |
24 using AddRequestResult = AddRequestResult; | |
25 using GetRequestsResult = GetRequestsResult; | |
26 using UpdateRequestResult = UpdateRequestResult; | |
27 | |
28 namespace { | |
29 // Data for request 1. | |
30 const int64_t kRequestId = 42; | |
31 const GURL kUrl("http://example.com"); | |
32 const ClientId kClientId("bookmark", "1234"); | |
33 // Data for request 2. | |
34 const int64_t kRequestId2 = 77; | |
35 const GURL kUrl2("http://test.com"); | |
36 const ClientId kClientId2("bookmark", "567"); | |
37 const bool kUserRequested = true; | |
38 const int64_t kRequestId3 = 99; | |
39 const int kOneWeekInSeconds = 7 * 24 * 60 * 60; | |
40 | |
41 // Default request | |
42 const SavePageRequest kEmptyRequest(0UL, | |
43 GURL(""), | |
44 ClientId("", ""), | |
45 base::Time(), | |
46 true); | |
47 | |
48 } // namespace | |
49 | |
50 // Helper class needed by the PickRequestTask | |
51 class RequestNotifierStub : public RequestNotifier { | |
52 public: | |
53 RequestNotifierStub() | |
54 : last_expired_request_(kEmptyRequest), total_expired_requests_(0) {} | |
55 | |
56 void NotifyAdded(const SavePageRequest& request) override {} | |
57 void NotifyChanged(const SavePageRequest& request) override {} | |
58 | |
59 void NotifyCompleted(const SavePageRequest& request, | |
60 BackgroundSavePageResult status) override { | |
61 last_expired_request_ = request; | |
62 last_request_expiration_status_ = status; | |
63 total_expired_requests_++; | |
64 } | |
65 | |
66 const SavePageRequest& last_expired_request() { | |
67 return last_expired_request_; | |
68 } | |
69 | |
70 RequestCoordinator::BackgroundSavePageResult | |
71 last_request_expiration_status() { | |
72 return last_request_expiration_status_; | |
73 } | |
74 | |
75 int32_t total_expired_requests() { return total_expired_requests_; } | |
76 | |
77 private: | |
78 BackgroundSavePageResult last_request_expiration_status_; | |
79 SavePageRequest last_expired_request_; | |
80 int32_t total_expired_requests_; | |
81 }; | |
82 | |
83 // TODO(fgorski): Add tests for store failures in add/remove/get. | |
84 class RequestQueueTest : public testing::Test { | |
85 public: | |
86 RequestQueueTest(); | |
87 ~RequestQueueTest() override; | |
88 | |
89 // Test overrides. | |
90 void SetUp() override; | |
91 | |
92 void PumpLoop(); | |
93 | |
94 // Callback for adding requests. | |
95 void AddRequestDone(AddRequestResult result, const SavePageRequest& request); | |
96 // Callback for getting requests. | |
97 void GetRequestsDone(GetRequestsResult result, | |
98 std::vector<std::unique_ptr<SavePageRequest>> requests); | |
99 | |
100 void UpdateRequestDone(UpdateRequestResult result); | |
101 void UpdateRequestsDone(std::unique_ptr<UpdateRequestsResult> result); | |
102 | |
103 void ClearResults(); | |
104 | |
105 RequestQueue* queue() { return queue_.get(); } | |
106 | |
107 AddRequestResult last_add_result() const { return last_add_result_; } | |
108 SavePageRequest* last_added_request() { | |
109 return last_added_request_.get(); | |
110 } | |
111 | |
112 UpdateRequestResult last_update_result() const { return last_update_result_; } | |
113 | |
114 GetRequestsResult last_get_requests_result() const { | |
115 return last_get_requests_result_; | |
116 } | |
117 | |
118 const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const { | |
119 return last_requests_; | |
120 } | |
121 | |
122 UpdateRequestsResult* update_requests_result() const { | |
123 return update_requests_result_.get(); | |
124 } | |
125 | |
126 void RequestPickedCallback(const SavePageRequest& request) {} | |
127 void RequestNotPickedCallback(bool non_user_requested_tasks_remain) {} | |
128 | |
129 private: | |
130 AddRequestResult last_add_result_; | |
131 std::unique_ptr<SavePageRequest> last_added_request_; | |
132 std::unique_ptr<UpdateRequestsResult> update_requests_result_; | |
133 UpdateRequestResult last_update_result_; | |
134 | |
135 GetRequestsResult last_get_requests_result_; | |
136 std::vector<std::unique_ptr<SavePageRequest>> last_requests_; | |
137 | |
138 std::unique_ptr<RequestQueue> queue_; | |
139 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
140 base::ThreadTaskRunnerHandle task_runner_handle_; | |
141 }; | |
142 | |
143 RequestQueueTest::RequestQueueTest() | |
144 : last_add_result_(AddRequestResult::STORE_FAILURE), | |
145 last_update_result_(UpdateRequestResult::STORE_FAILURE), | |
146 last_get_requests_result_(GetRequestsResult::STORE_FAILURE), | |
147 task_runner_(new base::TestSimpleTaskRunner), | |
148 task_runner_handle_(task_runner_) {} | |
149 | |
150 RequestQueueTest::~RequestQueueTest() {} | |
151 | |
152 void RequestQueueTest::SetUp() { | |
153 std::unique_ptr<RequestQueueInMemoryStore> store( | |
154 new RequestQueueInMemoryStore()); | |
155 queue_.reset(new RequestQueue(std::move(store))); | |
156 } | |
157 | |
158 void RequestQueueTest::PumpLoop() { | |
159 task_runner_->RunUntilIdle(); | |
160 } | |
161 | |
162 void RequestQueueTest::AddRequestDone(AddRequestResult result, | |
163 const SavePageRequest& request) { | |
164 last_add_result_ = result; | |
165 last_added_request_.reset(new SavePageRequest(request)); | |
166 } | |
167 | |
168 void RequestQueueTest::GetRequestsDone( | |
169 GetRequestsResult result, | |
170 std::vector<std::unique_ptr<SavePageRequest>> requests) { | |
171 last_get_requests_result_ = result; | |
172 last_requests_ = std::move(requests); | |
173 } | |
174 | |
175 void RequestQueueTest::UpdateRequestDone(UpdateRequestResult result) { | |
176 last_update_result_ = result; | |
177 } | |
178 | |
179 void RequestQueueTest::UpdateRequestsDone( | |
180 std::unique_ptr<UpdateRequestsResult> result) { | |
181 update_requests_result_ = std::move(result); | |
182 } | |
183 | |
184 void RequestQueueTest::ClearResults() { | |
185 last_add_result_ = AddRequestResult::STORE_FAILURE; | |
186 last_update_result_ = UpdateRequestResult::STORE_FAILURE; | |
187 last_get_requests_result_ = GetRequestsResult::STORE_FAILURE; | |
188 last_added_request_.reset(nullptr); | |
189 update_requests_result_.reset(nullptr); | |
190 last_requests_.clear(); | |
191 } | |
192 | |
193 TEST_F(RequestQueueTest, GetRequestsEmpty) { | |
194 queue()->GetRequests( | |
195 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
196 PumpLoop(); | |
197 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
198 ASSERT_EQ(0ul, last_requests().size()); | |
199 } | |
200 | |
201 TEST_F(RequestQueueTest, AddRequest) { | |
202 base::Time creation_time = base::Time::Now(); | |
203 SavePageRequest request( | |
204 kRequestId, kUrl, kClientId, creation_time, kUserRequested); | |
205 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
206 base::Unretained(this))); | |
207 PumpLoop(); | |
208 ASSERT_EQ(AddRequestResult::SUCCESS, last_add_result()); | |
209 ASSERT_TRUE(last_added_request()); | |
210 ASSERT_EQ(kRequestId, last_added_request()->request_id()); | |
211 | |
212 queue()->GetRequests( | |
213 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
214 PumpLoop(); | |
215 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
216 ASSERT_EQ(1ul, last_requests().size()); | |
217 } | |
218 | |
219 TEST_F(RequestQueueTest, RemoveRequest) { | |
220 base::Time creation_time = base::Time::Now(); | |
221 SavePageRequest request( | |
222 kRequestId, kUrl, kClientId, creation_time, kUserRequested); | |
223 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
224 base::Unretained(this))); | |
225 PumpLoop(); | |
226 ASSERT_EQ(kRequestId, last_added_request()->request_id()); | |
227 | |
228 std::vector<int64_t> remove_requests{kRequestId}; | |
229 queue()->RemoveRequests(remove_requests, | |
230 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
231 base::Unretained(this))); | |
232 PumpLoop(); | |
233 EXPECT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
234 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
235 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
236 update_requests_result()->item_statuses.at(0).second); | |
237 EXPECT_EQ(1UL, update_requests_result()->updated_items.size()); | |
238 EXPECT_EQ(request, update_requests_result()->updated_items.at(0)); | |
239 | |
240 queue()->GetRequests( | |
241 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
242 PumpLoop(); | |
243 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
244 ASSERT_EQ(0ul, last_requests().size()); | |
245 } | |
246 | |
247 TEST_F(RequestQueueTest, RemoveSeveralRequests) { | |
248 base::Time creation_time = base::Time::Now(); | |
249 SavePageRequest request(kRequestId, kUrl, kClientId, creation_time, | |
250 kUserRequested); | |
251 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
252 base::Unretained(this))); | |
253 PumpLoop(); | |
254 ASSERT_EQ(kRequestId, last_added_request()->request_id()); | |
255 | |
256 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
257 kUserRequested); | |
258 queue()->AddRequest(request2, base::Bind(&RequestQueueTest::AddRequestDone, | |
259 base::Unretained(this))); | |
260 PumpLoop(); | |
261 ASSERT_EQ(kRequestId2, last_added_request()->request_id()); | |
262 | |
263 std::vector<int64_t> remove_requests; | |
264 remove_requests.push_back(kRequestId); | |
265 remove_requests.push_back(kRequestId2); | |
266 remove_requests.push_back(kRequestId3); | |
267 queue()->RemoveRequests(remove_requests, | |
268 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
269 base::Unretained(this))); | |
270 PumpLoop(); | |
271 ASSERT_EQ(3ul, update_requests_result()->item_statuses.size()); | |
272 ASSERT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
273 ASSERT_EQ(ItemActionStatus::SUCCESS, | |
274 update_requests_result()->item_statuses.at(0).second); | |
275 ASSERT_EQ(kRequestId2, update_requests_result()->item_statuses.at(1).first); | |
276 ASSERT_EQ(ItemActionStatus::SUCCESS, | |
277 update_requests_result()->item_statuses.at(1).second); | |
278 ASSERT_EQ(kRequestId3, update_requests_result()->item_statuses.at(2).first); | |
279 ASSERT_EQ(ItemActionStatus::NOT_FOUND, | |
280 update_requests_result()->item_statuses.at(2).second); | |
281 EXPECT_EQ(2UL, update_requests_result()->updated_items.size()); | |
282 EXPECT_EQ(request, update_requests_result()->updated_items.at(0)); | |
283 EXPECT_EQ(request2, update_requests_result()->updated_items.at(1)); | |
284 | |
285 queue()->GetRequests( | |
286 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
287 PumpLoop(); | |
288 | |
289 // Verify both requests are no longer in the queue. | |
290 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
291 ASSERT_EQ(0ul, last_requests().size()); | |
292 } | |
293 | |
294 TEST_F(RequestQueueTest, PauseAndResume) { | |
295 base::Time creation_time = base::Time::Now(); | |
296 SavePageRequest request(kRequestId, kUrl, kClientId, creation_time, | |
297 kUserRequested); | |
298 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
299 base::Unretained(this))); | |
300 PumpLoop(); | |
301 ASSERT_EQ(kRequestId, last_added_request()->request_id()); | |
302 | |
303 queue()->GetRequests( | |
304 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
305 PumpLoop(); | |
306 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
307 ASSERT_EQ(1ul, last_requests().size()); | |
308 | |
309 std::vector<int64_t> request_ids; | |
310 request_ids.push_back(kRequestId); | |
311 | |
312 // Pause the request. | |
313 queue()->ChangeRequestsState(request_ids, | |
314 SavePageRequest::RequestState::PAUSED, | |
315 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
316 base::Unretained(this))); | |
317 PumpLoop(); | |
318 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
319 ASSERT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
320 ASSERT_EQ(ItemActionStatus::SUCCESS, | |
321 update_requests_result()->item_statuses.at(0).second); | |
322 ASSERT_EQ(1ul, update_requests_result()->updated_items.size()); | |
323 ASSERT_EQ(SavePageRequest::RequestState::PAUSED, | |
324 update_requests_result()->updated_items.at(0).request_state()); | |
325 | |
326 queue()->GetRequests( | |
327 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
328 PumpLoop(); | |
329 | |
330 // Verify the request is paused. | |
331 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
332 ASSERT_EQ(1ul, last_requests().size()); | |
333 ASSERT_EQ(SavePageRequest::RequestState::PAUSED, | |
334 last_requests().at(0)->request_state()); | |
335 | |
336 // Resume the request. | |
337 queue()->ChangeRequestsState(request_ids, | |
338 SavePageRequest::RequestState::AVAILABLE, | |
339 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
340 base::Unretained(this))); | |
341 PumpLoop(); | |
342 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
343 ASSERT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
344 ASSERT_EQ(ItemActionStatus::SUCCESS, | |
345 update_requests_result()->item_statuses.at(0).second); | |
346 ASSERT_EQ(1ul, update_requests_result()->updated_items.size()); | |
347 ASSERT_EQ(SavePageRequest::RequestState::AVAILABLE, | |
348 update_requests_result()->updated_items.at(0).request_state()); | |
349 | |
350 queue()->GetRequests( | |
351 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
352 PumpLoop(); | |
353 | |
354 // Verify the request is no longer paused. | |
355 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
356 ASSERT_EQ(1ul, last_requests().size()); | |
357 ASSERT_EQ(SavePageRequest::RequestState::AVAILABLE, | |
358 last_requests().at(0)->request_state()); | |
359 } | |
360 | |
361 // A longer test populating the request queue with more than one item, properly | |
362 // listing multiple items and removing the right item. | |
363 TEST_F(RequestQueueTest, MultipleRequestsAddGetRemove) { | |
364 base::Time creation_time = base::Time::Now(); | |
365 SavePageRequest request1( | |
366 kRequestId, kUrl, kClientId, creation_time, kUserRequested); | |
367 queue()->AddRequest(request1, base::Bind(&RequestQueueTest::AddRequestDone, | |
368 base::Unretained(this))); | |
369 PumpLoop(); | |
370 ASSERT_EQ(request1.request_id(), last_added_request()->request_id()); | |
371 SavePageRequest request2( | |
372 kRequestId2, kUrl2, kClientId2, creation_time, kUserRequested); | |
373 queue()->AddRequest(request2, base::Bind(&RequestQueueTest::AddRequestDone, | |
374 base::Unretained(this))); | |
375 PumpLoop(); | |
376 ASSERT_EQ(request2.request_id(), last_added_request()->request_id()); | |
377 | |
378 queue()->GetRequests( | |
379 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
380 PumpLoop(); | |
381 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
382 ASSERT_EQ(2ul, last_requests().size()); | |
383 | |
384 std::vector<int64_t> remove_requests; | |
385 remove_requests.push_back(request1.request_id()); | |
386 queue()->RemoveRequests(remove_requests, | |
387 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
388 base::Unretained(this))); | |
389 PumpLoop(); | |
390 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
391 ASSERT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
392 ASSERT_EQ(ItemActionStatus::SUCCESS, | |
393 update_requests_result()->item_statuses.at(0).second); | |
394 | |
395 queue()->GetRequests( | |
396 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
397 PumpLoop(); | |
398 ASSERT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
399 ASSERT_EQ(1ul, last_requests().size()); | |
400 ASSERT_EQ(request2.request_id(), last_requests().at(0)->request_id()); | |
401 } | |
402 | |
403 TEST_F(RequestQueueTest, MarkAttemptStarted) { | |
404 // First add a request. Retry count will be set to 0. | |
405 base::Time creation_time = base::Time::Now(); | |
406 SavePageRequest request(kRequestId, kUrl, kClientId, creation_time, | |
407 kUserRequested); | |
408 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
409 base::Unretained(this))); | |
410 PumpLoop(); | |
411 | |
412 base::Time before_time = base::Time::Now(); | |
413 // Update the request, ensure it succeeded. | |
414 queue()->MarkAttemptStarted(kRequestId, | |
415 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
416 base::Unretained(this))); | |
417 PumpLoop(); | |
418 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
419 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
420 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
421 update_requests_result()->item_statuses.at(0).second); | |
422 EXPECT_EQ(1UL, update_requests_result()->updated_items.size()); | |
423 EXPECT_LE(before_time, | |
424 update_requests_result()->updated_items.at(0).last_attempt_time()); | |
425 EXPECT_GE(base::Time::Now(), | |
426 update_requests_result()->updated_items.at(0).last_attempt_time()); | |
427 EXPECT_EQ( | |
428 1, update_requests_result()->updated_items.at(0).started_attempt_count()); | |
429 EXPECT_EQ(SavePageRequest::RequestState::OFFLINING, | |
430 update_requests_result()->updated_items.at(0).request_state()); | |
431 | |
432 queue()->GetRequests( | |
433 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
434 PumpLoop(); | |
435 EXPECT_EQ(GetRequestsResult::SUCCESS, last_get_requests_result()); | |
436 ASSERT_EQ(1ul, last_requests().size()); | |
437 EXPECT_EQ(update_requests_result()->updated_items.at(0), | |
438 *last_requests().at(0)); | |
439 } | |
440 | |
441 TEST_F(RequestQueueTest, MarkAttempStartedRequestNotPresent) { | |
442 // First add a request. Retry count will be set to 0. | |
443 base::Time creation_time = base::Time::Now(); | |
444 // This request is never put into the queue. | |
445 SavePageRequest request1(kRequestId, kUrl, kClientId, creation_time, | |
446 kUserRequested); | |
447 | |
448 queue()->MarkAttemptStarted(kRequestId, | |
449 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
450 base::Unretained(this))); | |
451 PumpLoop(); | |
452 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
453 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
454 EXPECT_EQ(ItemActionStatus::NOT_FOUND, | |
455 update_requests_result()->item_statuses.at(0).second); | |
456 EXPECT_EQ(0ul, update_requests_result()->updated_items.size()); | |
457 } | |
458 | |
459 TEST_F(RequestQueueTest, MarkAttemptAborted) { | |
460 base::Time creation_time = base::Time::Now(); | |
461 SavePageRequest request(kRequestId, kUrl, kClientId, creation_time, | |
462 kUserRequested); | |
463 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
464 base::Unretained(this))); | |
465 PumpLoop(); | |
466 | |
467 // Start request. | |
468 queue()->MarkAttemptStarted(kRequestId, | |
469 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
470 base::Unretained(this))); | |
471 PumpLoop(); | |
472 ClearResults(); | |
473 | |
474 queue()->MarkAttemptAborted(kRequestId, | |
475 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
476 base::Unretained(this))); | |
477 PumpLoop(); | |
478 | |
479 ASSERT_TRUE(update_requests_result()); | |
480 EXPECT_EQ(1UL, update_requests_result()->item_statuses.size()); | |
481 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
482 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
483 update_requests_result()->item_statuses.at(0).second); | |
484 EXPECT_EQ(1UL, update_requests_result()->updated_items.size()); | |
485 EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE, | |
486 update_requests_result()->updated_items.at(0).request_state()); | |
487 } | |
488 | |
489 TEST_F(RequestQueueTest, MarkAttemptAbortedRequestNotPresent) { | |
490 // First add a request. Retry count will be set to 0. | |
491 base::Time creation_time = base::Time::Now(); | |
492 // This request is never put into the queue. | |
493 SavePageRequest request1(kRequestId, kUrl, kClientId, creation_time, | |
494 kUserRequested); | |
495 | |
496 queue()->MarkAttemptAborted(kRequestId, | |
497 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
498 base::Unretained(this))); | |
499 PumpLoop(); | |
500 ASSERT_EQ(1ul, update_requests_result()->item_statuses.size()); | |
501 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
502 EXPECT_EQ(ItemActionStatus::NOT_FOUND, | |
503 update_requests_result()->item_statuses.at(0).second); | |
504 EXPECT_EQ(0ul, update_requests_result()->updated_items.size()); | |
505 } | |
506 | |
507 TEST_F(RequestQueueTest, MarkAttemptCompleted) { | |
508 base::Time creation_time = base::Time::Now(); | |
509 SavePageRequest request(kRequestId, kUrl, kClientId, creation_time, | |
510 kUserRequested); | |
511 queue()->AddRequest(request, base::Bind(&RequestQueueTest::AddRequestDone, | |
512 base::Unretained(this))); | |
513 PumpLoop(); | |
514 | |
515 // Start request. | |
516 queue()->MarkAttemptStarted(kRequestId, | |
517 base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
518 base::Unretained(this))); | |
519 PumpLoop(); | |
520 ClearResults(); | |
521 | |
522 queue()->MarkAttemptCompleted( | |
523 kRequestId, base::Bind(&RequestQueueTest::UpdateRequestsDone, | |
524 base::Unretained(this))); | |
525 PumpLoop(); | |
526 | |
527 ASSERT_TRUE(update_requests_result()); | |
528 EXPECT_EQ(1UL, update_requests_result()->item_statuses.size()); | |
529 EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first); | |
530 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
531 update_requests_result()->item_statuses.at(0).second); | |
532 EXPECT_EQ(1UL, update_requests_result()->updated_items.size()); | |
533 EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE, | |
534 update_requests_result()->updated_items.at(0).request_state()); | |
535 } | |
536 | |
537 // Request expiration is detected during the call to pick a request, which | |
538 // is why this test calls PickNextRequest(). | |
539 TEST_F(RequestQueueTest, CleanStaleRequests) { | |
540 // Create a request that is already expired. | |
541 base::Time creation_time = | |
542 base::Time::Now() - base::TimeDelta::FromSeconds(2 * kOneWeekInSeconds); | |
543 | |
544 SavePageRequest original_request(kRequestId, kUrl, kClientId, creation_time, | |
545 kUserRequested); | |
546 queue()->AddRequest( | |
547 original_request, | |
548 base::Bind(&RequestQueueTest::AddRequestDone, base::Unretained(this))); | |
549 this->PumpLoop(); | |
550 this->ClearResults(); | |
551 | |
552 // Set up a picker factory pointing to our fake notifier. | |
553 OfflinerPolicy policy; | |
554 RequestNotifierStub notifier; | |
555 RequestCoordinatorEventLogger event_logger; | |
556 std::unique_ptr<PickRequestTaskFactory> picker_factory( | |
557 new PickRequestTaskFactory(&policy, ¬ifier, &event_logger)); | |
558 queue()->SetPickerFactory(std::move(picker_factory)); | |
559 | |
560 // Do a pick and clean operation, which will remove stale entries. | |
561 DeviceConditions conditions; | |
562 std::set<int64_t> disabled_list; | |
563 queue()->PickNextRequest( | |
564 base::Bind(&RequestQueueTest::RequestPickedCallback, | |
565 base::Unretained(this)), | |
566 base::Bind(&RequestQueueTest::RequestNotPickedCallback, | |
567 base::Unretained(this)), | |
568 conditions, disabled_list); | |
569 | |
570 this->PumpLoop(); | |
571 | |
572 // Notifier should have been notified that the request was removed. | |
573 ASSERT_EQ(notifier.last_expired_request().request_id(), kRequestId); | |
574 ASSERT_EQ(notifier.last_request_expiration_status(), | |
575 RequestNotifier::BackgroundSavePageResult::EXPIRED); | |
576 | |
577 // Doing a get should show no entries left in the queue since the expired | |
578 // request has been removed. | |
579 queue()->GetRequests( | |
580 base::Bind(&RequestQueueTest::GetRequestsDone, base::Unretained(this))); | |
581 this->PumpLoop(); | |
582 ASSERT_EQ(GetRequestsResult::SUCCESS, this->last_get_requests_result()); | |
583 ASSERT_TRUE(this->last_requests().empty()); | |
584 } | |
585 | |
586 } // namespace offline_pages | |
OLD | NEW |