| 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/cleanup_task.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <set> | |
| 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/offliner_policy.h" | |
| 14 #include "components/offline_pages/background/request_coordinator.h" | |
| 15 #include "components/offline_pages/background/request_coordinator_event_logger.h
" | |
| 16 #include "components/offline_pages/background/request_notifier.h" | |
| 17 #include "components/offline_pages/background/request_queue_in_memory_store.h" | |
| 18 #include "components/offline_pages/background/request_queue_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 namespace { | |
| 25 // Data for request 1. | |
| 26 const int64_t kRequestId1 = 17; | |
| 27 const GURL kUrl1("https://google.com"); | |
| 28 const ClientId kClientId1("bookmark", "1234"); | |
| 29 // Data for request 2. | |
| 30 const int64_t kRequestId2 = 42; | |
| 31 const GURL kUrl2("http://nytimes.com"); | |
| 32 const ClientId kClientId2("bookmark", "5678"); | |
| 33 const bool kUserRequested = true; | |
| 34 | |
| 35 // Default request | |
| 36 const SavePageRequest kEmptyRequest(0UL, | |
| 37 GURL(""), | |
| 38 ClientId("", ""), | |
| 39 base::Time(), | |
| 40 true); | |
| 41 } // namespace | |
| 42 | |
| 43 // TODO: Refactor this stub class into its own file, use in Pick Request Task | |
| 44 // Test too. | |
| 45 // Helper class needed by the CleanupTask | |
| 46 class RequestNotifierStub : public RequestNotifier { | |
| 47 public: | |
| 48 RequestNotifierStub() | |
| 49 : last_expired_request_(kEmptyRequest), total_expired_requests_(0) {} | |
| 50 | |
| 51 void NotifyAdded(const SavePageRequest& request) override {} | |
| 52 void NotifyChanged(const SavePageRequest& request) override {} | |
| 53 | |
| 54 void NotifyCompleted(const SavePageRequest& request, | |
| 55 BackgroundSavePageResult status) override { | |
| 56 last_expired_request_ = request; | |
| 57 last_request_expiration_status_ = status; | |
| 58 total_expired_requests_++; | |
| 59 } | |
| 60 | |
| 61 const SavePageRequest& last_expired_request() { | |
| 62 return last_expired_request_; | |
| 63 } | |
| 64 | |
| 65 RequestCoordinator::BackgroundSavePageResult | |
| 66 last_request_expiration_status() { | |
| 67 return last_request_expiration_status_; | |
| 68 } | |
| 69 | |
| 70 int32_t total_expired_requests() { return total_expired_requests_; } | |
| 71 | |
| 72 private: | |
| 73 BackgroundSavePageResult last_request_expiration_status_; | |
| 74 SavePageRequest last_expired_request_; | |
| 75 int32_t total_expired_requests_; | |
| 76 }; | |
| 77 | |
| 78 class CleanupTaskTest : public testing::Test { | |
| 79 public: | |
| 80 CleanupTaskTest(); | |
| 81 | |
| 82 ~CleanupTaskTest() override; | |
| 83 | |
| 84 void SetUp() override; | |
| 85 | |
| 86 void PumpLoop(); | |
| 87 | |
| 88 void AddRequestDone(ItemActionStatus status); | |
| 89 | |
| 90 void GetRequestsCallback( | |
| 91 bool success, | |
| 92 std::vector<std::unique_ptr<SavePageRequest>> requests); | |
| 93 | |
| 94 void QueueRequests(const SavePageRequest& request1, | |
| 95 const SavePageRequest& request2); | |
| 96 | |
| 97 // Reset the factory and the task using the current policy. | |
| 98 void MakeFactoryAndTask(); | |
| 99 | |
| 100 RequestNotifierStub* GetNotifier() { return notifier_.get(); } | |
| 101 | |
| 102 CleanupTask* task() { return task_.get(); } | |
| 103 RequestQueueStore* store() { return store_.get(); } | |
| 104 OfflinerPolicy* policy() { return policy_.get(); } | |
| 105 std::vector<std::unique_ptr<SavePageRequest>>& found_requests() { | |
| 106 return found_requests_; | |
| 107 } | |
| 108 | |
| 109 protected: | |
| 110 void InitializeStoreDone(bool success); | |
| 111 | |
| 112 std::unique_ptr<RequestQueueStore> store_; | |
| 113 std::unique_ptr<RequestNotifierStub> notifier_; | |
| 114 std::unique_ptr<SavePageRequest> last_picked_; | |
| 115 std::unique_ptr<OfflinerPolicy> policy_; | |
| 116 RequestCoordinatorEventLogger event_logger_; | |
| 117 std::unique_ptr<CleanupTaskFactory> factory_; | |
| 118 std::unique_ptr<CleanupTask> task_; | |
| 119 std::vector<std::unique_ptr<SavePageRequest>> found_requests_; | |
| 120 | |
| 121 private: | |
| 122 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| 123 base::ThreadTaskRunnerHandle task_runner_handle_; | |
| 124 }; | |
| 125 | |
| 126 CleanupTaskTest::CleanupTaskTest() | |
| 127 : task_runner_(new base::TestSimpleTaskRunner), | |
| 128 task_runner_handle_(task_runner_) {} | |
| 129 | |
| 130 CleanupTaskTest::~CleanupTaskTest() {} | |
| 131 | |
| 132 void CleanupTaskTest::SetUp() { | |
| 133 DeviceConditions conditions; | |
| 134 store_.reset(new RequestQueueInMemoryStore()); | |
| 135 policy_.reset(new OfflinerPolicy()); | |
| 136 notifier_.reset(new RequestNotifierStub()); | |
| 137 MakeFactoryAndTask(); | |
| 138 | |
| 139 store_->Initialize(base::Bind(&CleanupTaskTest::InitializeStoreDone, | |
| 140 base::Unretained(this))); | |
| 141 PumpLoop(); | |
| 142 } | |
| 143 | |
| 144 void CleanupTaskTest::PumpLoop() { | |
| 145 task_runner_->RunUntilIdle(); | |
| 146 } | |
| 147 | |
| 148 void CleanupTaskTest::AddRequestDone(ItemActionStatus status) { | |
| 149 ASSERT_EQ(ItemActionStatus::SUCCESS, status); | |
| 150 } | |
| 151 | |
| 152 void CleanupTaskTest::GetRequestsCallback( | |
| 153 bool success, | |
| 154 std::vector<std::unique_ptr<SavePageRequest>> requests) { | |
| 155 found_requests_ = std::move(requests); | |
| 156 } | |
| 157 | |
| 158 // Test helper to queue the two given requests. | |
| 159 void CleanupTaskTest::QueueRequests(const SavePageRequest& request1, | |
| 160 const SavePageRequest& request2) { | |
| 161 DeviceConditions conditions; | |
| 162 std::set<int64_t> disabled_requests; | |
| 163 // Add test requests on the Queue. | |
| 164 store_->AddRequest(request1, base::Bind(&CleanupTaskTest::AddRequestDone, | |
| 165 base::Unretained(this))); | |
| 166 store_->AddRequest(request2, base::Bind(&CleanupTaskTest::AddRequestDone, | |
| 167 base::Unretained(this))); | |
| 168 | |
| 169 // Pump the loop to give the async queue the opportunity to do the adds. | |
| 170 PumpLoop(); | |
| 171 } | |
| 172 | |
| 173 void CleanupTaskTest::MakeFactoryAndTask() { | |
| 174 factory_.reset( | |
| 175 new CleanupTaskFactory(policy_.get(), notifier_.get(), &event_logger_)); | |
| 176 DeviceConditions conditions; | |
| 177 task_ = factory_->CreateCleanupTask(store_.get()); | |
| 178 } | |
| 179 | |
| 180 void CleanupTaskTest::InitializeStoreDone(bool success) { | |
| 181 ASSERT_TRUE(success); | |
| 182 } | |
| 183 | |
| 184 TEST_F(CleanupTaskTest, CleanupExpiredRequest) { | |
| 185 base::Time creation_time = base::Time::Now(); | |
| 186 base::Time expired_time = | |
| 187 creation_time - base::TimeDelta::FromSeconds( | |
| 188 policy()->GetRequestExpirationTimeInSeconds() + 10); | |
| 189 // Request2 will be expired, request1 will be current. | |
| 190 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 191 kUserRequested); | |
| 192 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, expired_time, | |
| 193 kUserRequested); | |
| 194 QueueRequests(request1, request2); | |
| 195 | |
| 196 // Initiate cleanup. | |
| 197 task()->Run(); | |
| 198 PumpLoop(); | |
| 199 | |
| 200 // See what is left in the queue, should be just the other request. | |
| 201 store()->GetRequests(base::Bind(&CleanupTaskTest::GetRequestsCallback, | |
| 202 base::Unretained(this))); | |
| 203 PumpLoop(); | |
| 204 EXPECT_EQ(1UL, found_requests().size()); | |
| 205 EXPECT_EQ(kRequestId1, found_requests().at(0)->request_id()); | |
| 206 } | |
| 207 | |
| 208 TEST_F(CleanupTaskTest, CleanupStartCountExceededRequest) { | |
| 209 base::Time creation_time = base::Time::Now(); | |
| 210 // Request2 will have an exceeded start count. | |
| 211 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 212 kUserRequested); | |
| 213 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 214 kUserRequested); | |
| 215 request2.set_started_attempt_count(policy()->GetMaxStartedTries()); | |
| 216 QueueRequests(request1, request2); | |
| 217 | |
| 218 // Initiate cleanup. | |
| 219 task()->Run(); | |
| 220 PumpLoop(); | |
| 221 | |
| 222 // See what is left in the queue, should be just the other request. | |
| 223 store()->GetRequests(base::Bind(&CleanupTaskTest::GetRequestsCallback, | |
| 224 base::Unretained(this))); | |
| 225 PumpLoop(); | |
| 226 EXPECT_EQ(1UL, found_requests().size()); | |
| 227 EXPECT_EQ(kRequestId1, found_requests().at(0)->request_id()); | |
| 228 } | |
| 229 | |
| 230 TEST_F(CleanupTaskTest, CleanupCompletionCountExceededRequest) { | |
| 231 base::Time creation_time = base::Time::Now(); | |
| 232 // Request2 will have an exceeded completion count. | |
| 233 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 234 kUserRequested); | |
| 235 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 236 kUserRequested); | |
| 237 request2.set_completed_attempt_count(policy()->GetMaxCompletedTries()); | |
| 238 QueueRequests(request1, request2); | |
| 239 | |
| 240 // Initiate cleanup. | |
| 241 task()->Run(); | |
| 242 PumpLoop(); | |
| 243 | |
| 244 // See what is left in the queue, should be just the other request. | |
| 245 store()->GetRequests(base::Bind(&CleanupTaskTest::GetRequestsCallback, | |
| 246 base::Unretained(this))); | |
| 247 PumpLoop(); | |
| 248 EXPECT_EQ(1UL, found_requests().size()); | |
| 249 EXPECT_EQ(kRequestId1, found_requests().at(0)->request_id()); | |
| 250 } | |
| 251 | |
| 252 TEST_F(CleanupTaskTest, IgnoreRequestInProgress) { | |
| 253 base::Time creation_time = base::Time::Now(); | |
| 254 // Both requests will have an exceeded completion count. | |
| 255 // The first request will be marked as started. | |
| 256 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 257 kUserRequested); | |
| 258 request1.set_completed_attempt_count(policy()->GetMaxCompletedTries()); | |
| 259 request1.MarkAttemptStarted(creation_time); | |
| 260 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 261 kUserRequested); | |
| 262 request2.set_completed_attempt_count(policy()->GetMaxCompletedTries()); | |
| 263 QueueRequests(request1, request2); | |
| 264 | |
| 265 // Initiate cleanup. | |
| 266 task()->Run(); | |
| 267 PumpLoop(); | |
| 268 | |
| 269 // See what is left in the queue, request1 should be left in the queue even | |
| 270 // though it is expired because it was listed as in-progress while cleaning. | |
| 271 // Request2 should have been cleaned out of the queue. | |
| 272 store()->GetRequests(base::Bind(&CleanupTaskTest::GetRequestsCallback, | |
| 273 base::Unretained(this))); | |
| 274 PumpLoop(); | |
| 275 EXPECT_EQ(1UL, found_requests().size()); | |
| 276 EXPECT_EQ(kRequestId1, found_requests().at(0)->request_id()); | |
| 277 } | |
| 278 | |
| 279 } // namespace offline_pages | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2489443002:
Move all components/offline_pages/ files into component/offline_pages/core (Closed)
