[Offline pages] Extracting AddRequest method in RequestQueueStore

components/offline_pages/background/request_queue_store_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/offline_pages/background/request_queue_store.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 18 matching lines @@
 const ClientId kClientId("bookmark", "1234");
 const ClientId kClientId2("async", "5678");
 const bool kUserRequested = true;
 
 enum class LastResult {
   kNone,
   kFalse,
   kTrue,
 };
 
-bool operator==(const SavePageRequest& lhs, const SavePageRequest& rhs) {
-  return lhs.request_id() == rhs.request_id() && lhs.url() == rhs.url() &&
-         lhs.client_id() == rhs.client_id() &&
-         lhs.creation_time() == rhs.creation_time() &&
-         lhs.activation_time() == rhs.activation_time() &&
-         lhs.started_attempt_count() == rhs.started_attempt_count() &&
-         lhs.completed_attempt_count() == rhs.completed_attempt_count() &&
-         lhs.last_attempt_time() == rhs.last_attempt_time() &&
-         lhs.request_state() == rhs.request_state();
-}
-
 }  // namespace
 
 // Class that serves as a base for testing different implementations of the
 // |RequestQueueStore|. Specific implementations extend the templatized version
 // of this class and provide appropriate store factory.
 class RequestQueueStoreTestBase : public testing::Test {
  public:
   RequestQueueStoreTestBase();
 
   // Test overrides.
   void TearDown() override;
 
   void PumpLoop();
   void ClearResults();
 
   // Callback used for get requests.
   void GetRequestsDone(bool result,
                        std::vector<std::unique_ptr<SavePageRequest>> requests);
   // Callback used for add/update request.
   void AddOrUpdateDone(UpdateStatus result);
+  void AddRequestDone(ItemActionStatus status);
   void UpdateMultipleRequestsDone(
       const RequestQueue::UpdateMultipleRequestResults& results,
       std::vector<std::unique_ptr<SavePageRequest>> requests);
   // Callback used for remove requests.
   void RemoveDone(const RequestQueue::UpdateMultipleRequestResults& results,
                   std::vector<std::unique_ptr<SavePageRequest>> requests);
   // Callback used for reset.
   void ResetDone(bool result);
 
   LastResult last_result() const { return last_result_; }
   UpdateStatus last_update_status() const { return last_update_status_; }
   const RequestQueue::UpdateMultipleRequestResults&
   last_multiple_update_results() const {
     return last_multiple_update_results_;
   }
   const RequestQueue::UpdateMultipleRequestResults& last_remove_results()
       const {
     return last_remove_results_;
   }
   const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
+  ItemActionStatus last_add_status() const { return last_add_status_; }
 
  protected:
   base::ScopedTempDir temp_directory_;
 
  private:
   LastResult last_result_;
   UpdateStatus last_update_status_;
+  ItemActionStatus last_add_status_;
   RequestQueue::UpdateMultipleRequestResults last_multiple_update_results_;
   RequestQueue::UpdateMultipleRequestResults last_remove_results_;
   std::vector<std::unique_ptr<SavePageRequest>> last_requests_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
 };
 
 RequestQueueStoreTestBase::RequestQueueStoreTestBase()
     : last_result_(LastResult::kNone),
       last_update_status_(UpdateStatus::FAILED),
+      last_add_status_(ItemActionStatus::NOT_FOUND),
       task_runner_(new base::TestSimpleTaskRunner),
       task_runner_handle_(task_runner_) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 }
 
 void RequestQueueStoreTestBase::TearDown() {
   // Wait for all the pieces of the store to delete itself properly.
   PumpLoop();
 }
 
 void RequestQueueStoreTestBase::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestQueueStoreTestBase::ClearResults() {
   last_result_ = LastResult::kNone;
   last_update_status_ = UpdateStatus::FAILED;
+  last_add_status_ = ItemActionStatus::NOT_FOUND;
   last_remove_results_.clear();
   last_requests_.clear();
 }
 
 void RequestQueueStoreTestBase::GetRequestsDone(
     bool result,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_result_ = result ? LastResult::kTrue : LastResult::kFalse;
   last_requests_ = std::move(requests);
 }
 
 void RequestQueueStoreTestBase::AddOrUpdateDone(UpdateStatus status) {
   last_update_status_ = status;
 }
 
+void RequestQueueStoreTestBase::AddRequestDone(ItemActionStatus status) {
+  last_add_status_ = status;
+}
+
 void RequestQueueStoreTestBase::UpdateMultipleRequestsDone(
     const RequestQueue::UpdateMultipleRequestResults& results,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_multiple_update_results_ = results;
   last_requests_ = std::move(requests);
 }
 
 void RequestQueueStoreTestBase::RemoveDone(
     const RequestQueue::UpdateMultipleRequestResults& results,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
@@ skipping 66 matching lines @@
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_TRUE(this->last_requests().empty());
 }
 
 TYPED_TEST(RequestQueueStoreTest, AddRequest) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest request(
       kRequestId, kUrl, kClientId, creation_time, kUserRequested);
 
-  store->AddOrUpdateRequest(
-      request, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                          base::Unretained(this)));
-  ASSERT_EQ(UpdateStatus::FAILED, this->last_update_status());
+  store->AddRequest(request,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
+  ASSERT_EQ(ItemActionStatus::NOT_FOUND, this->last_add_status());
   this->PumpLoop();
-  ASSERT_EQ(UpdateStatus::UPDATED, this->last_update_status());
+  ASSERT_EQ(ItemActionStatus::SUCCESS, this->last_add_status());
 
   // Verifying get reqeust results after a request was added.
   this->ClearResults();
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
-  ASSERT_TRUE(request == *(this->last_requests()[0]));
+  ASSERT_EQ(request, *(this->last_requests()[0].get()));
+
+  // Verify it is not possible to add the same request twice.
+  this->ClearResults();
+  store->AddRequest(request,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
+  ASSERT_EQ(ItemActionStatus::NOT_FOUND, this->last_add_status());
+  this->PumpLoop();
+  ASSERT_EQ(ItemActionStatus::ALREADY_EXISTS, this->last_add_status());
+
+  // Check that there is still only one item in the store.
+  this->ClearResults();
+  store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
+                                base::Unretained(this)));
+  ASSERT_EQ(LastResult::kNone, this->last_result());
+  this->PumpLoop();
+  ASSERT_EQ(LastResult::kTrue, this->last_result());
+  ASSERT_EQ(1ul, this->last_requests().size());
 }
 
 TYPED_TEST(RequestQueueStoreTest, UpdateRequest) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest original_request(
       kRequestId, kUrl, kClientId, creation_time, kUserRequested);
-  store->AddOrUpdateRequest(
-      original_request, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                                   base::Unretained(this)));
+  store->AddRequest(original_request,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   base::Time new_creation_time =
       creation_time + base::TimeDelta::FromMinutes(1);
   base::Time activation_time = creation_time + base::TimeDelta::FromHours(6);
   SavePageRequest updated_request(kRequestId, kUrl, kClientId,
                                   new_creation_time, activation_time,
                                   kUserRequested);
   store->AddOrUpdateRequest(
       updated_request, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
                                   base::Unretained(this)));
   ASSERT_EQ(UpdateStatus::FAILED, this->last_update_status());
   this->PumpLoop();
   ASSERT_EQ(UpdateStatus::UPDATED, this->last_update_status());
 
   // Verifying get reqeust results after a request was updated.
   this->ClearResults();
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
-  ASSERT_TRUE(updated_request == *(this->last_requests()[0].get()));
+  ASSERT_EQ(updated_request, *(this->last_requests()[0].get()));
 }
 
 TYPED_TEST(RequestQueueStoreTest, RemoveRequests) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest request1(kRequestId, kUrl, kClientId, creation_time,
                            kUserRequested);
-  store->AddOrUpdateRequest(
-      request1, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                           base::Unretained(this)));
+  store->AddRequest(request1,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time,
                            kUserRequested);
-  store->AddOrUpdateRequest(
-      request2, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                           base::Unretained(this)));
+  store->AddRequest(request2,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   std::vector<int64_t> request_ids{kRequestId, kRequestId2};
   store->RemoveRequests(request_ids,
                         base::Bind(&RequestQueueStoreTestBase::RemoveDone,
                                    base::Unretained(this)));
   ASSERT_EQ(0ul, this->last_remove_results().size());
   this->PumpLoop();
   ASSERT_EQ(2ul, this->last_remove_results().size());
@@ skipping 28 matching lines @@
   ASSERT_EQ(0UL, this->last_requests().size());
 }
 
 TYPED_TEST(RequestQueueStoreTest, PauseAndResumeRequest) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
 
   // Create request and add it to the queue.
   SavePageRequest request1(kRequestId, kUrl, kClientId, creation_time,
                            kUserRequested);
-  store->AddOrUpdateRequest(
-      request1, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                           base::Unretained(this)));
+  store->AddRequest(request1,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   // Pause a request.
   std::vector<int64_t> request_ids{kRequestId};
   store->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::PAUSED,
       base::Bind(&RequestQueueStoreTestBase::UpdateMultipleRequestsDone,
                  base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
@@ skipping 44 matching lines @@
   ASSERT_EQ(SavePageRequest::RequestState::AVAILABLE,
             this->last_requests().at(0)->request_state());
   this->ClearResults();
 }
 
 TYPED_TEST(RequestQueueStoreTest, ResetStore) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest original_request(
       kRequestId, kUrl, kClientId, creation_time, kUserRequested);
-  store->AddOrUpdateRequest(
-      original_request, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                                   base::Unretained(this)));
+  store->AddRequest(original_request,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   store->Reset(base::Bind(&RequestQueueStoreTestBase::ResetDone,
                           base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   this->ClearResults();
 
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_TRUE(this->last_requests().empty());
 }
 
 class RequestQueueStoreSQLTest
     : public RequestQueueStoreTest<RequestQueueStoreSQLFactory> {};
 
 // Makes sure that persistent DB is actually persisting requests across store
 // restarts.
 TEST_F(RequestQueueStoreSQLTest, SaveCloseReopenRead) {
   std::unique_ptr<RequestQueueStore> store(BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest original_request(
       kRequestId, kUrl, kClientId, creation_time, kUserRequested);
-  store->AddOrUpdateRequest(
-      original_request, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
-                                   base::Unretained(this)));
+  store->AddRequest(original_request,
+                    base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
+                               base::Unretained(this)));
   PumpLoop();
   ClearResults();
 
   // Resets the store, using the same temp directory. The contents should be
   // intact. First reset is done separately to release DB lock.
   store.reset();
   store = BuildStore();
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
   ASSERT_TRUE(original_request == *(this->last_requests().at(0).get()));
 }
 
 }  // offline_pages