Small: Serialize the store's hash_prefix_map_ to file in WriteToDisk()

components/safe_browsing_db/v4_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 "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 108 matching lines @@
   WriteFileFormatProtoToFile(0x600D71FE, 9);
   EXPECT_EQ(HASH_PREFIX_INFO_MISSING_FAILURE,
             V4Store(task_runner_, store_path_).ReadFromDisk());
 }
 
 TEST_F(V4StoreTest, TestReadFromNoHashPrefixesFile) {
   ListUpdateResponse list_update_response;
   list_update_response.set_platform_type(LINUX_PLATFORM);
   list_update_response.set_response_type(ListUpdateResponse::FULL_UPDATE);
   WriteFileFormatProtoToFile(0x600D71FE, 9, &list_update_response);
-  EXPECT_EQ(READ_SUCCESS, V4Store(task_runner_, store_path_).ReadFromDisk());
-}
-
-TEST_F(V4StoreTest, TestWriteNoResponseType) {
-  EXPECT_EQ(INVALID_RESPONSE_TYPE_FAILURE,
-            V4Store(task_runner_, store_path_)
-                .WriteToDisk(base::WrapUnique(new ListUpdateResponse)));
-}
-
-TEST_F(V4StoreTest, TestWritePartialResponseType) {
-  std::unique_ptr<ListUpdateResponse> list_update_response(
-      new ListUpdateResponse);
-  list_update_response->set_response_type(ListUpdateResponse::PARTIAL_UPDATE);
-  EXPECT_EQ(INVALID_RESPONSE_TYPE_FAILURE,
-            V4Store(task_runner_, store_path_)
-                .WriteToDisk(std::move(list_update_response)));
-}
-
-TEST_F(V4StoreTest, TestWriteFullResponseType) {
-  std::unique_ptr<ListUpdateResponse> list_update_response(
-      new ListUpdateResponse);
-  list_update_response->set_response_type(ListUpdateResponse::FULL_UPDATE);
-  list_update_response->set_new_client_state("test_client_state");
-  EXPECT_EQ(WRITE_SUCCESS, V4Store(task_runner_, store_path_)
-                               .WriteToDisk(std::move(list_update_response)));
-
-  V4Store read_store(task_runner_, store_path_);
-  EXPECT_EQ(READ_SUCCESS, read_store.ReadFromDisk());
-  EXPECT_EQ("test_client_state", read_store.state_);
-  EXPECT_TRUE(read_store.hash_prefix_map_.empty());
+  V4Store store(task_runner_, store_path_);
+  EXPECT_EQ(READ_SUCCESS, store.ReadFromDisk());
+  EXPECT_TRUE(store.hash_prefix_map_.empty());
 }
 
 TEST_F(V4StoreTest, TestAddUnlumpedHashesWithInvalidAddition) {
   HashPrefixMap prefix_map;
   EXPECT_EQ(ADDITIONS_SIZE_UNEXPECTED_FAILURE,
             V4Store::AddUnlumpedHashes(5, "a", &prefix_map));
   EXPECT_TRUE(prefix_map.empty());
 }
 
 TEST_F(V4StoreTest, TestAddUnlumpedHashesWithEmptyString) {
@@ skipping 393 matching lines @@
                               &raw_removals, expected_checksum));
 
   const HashPrefixMap& prefix_map = store.hash_prefix_map_;
   // The size is 2 since we reserve space anyway.
   EXPECT_EQ(2u, prefix_map.size());
   EXPECT_EQ("2222aaaa", prefix_map.at(4));
   EXPECT_EQ("1111133333bbbbb", prefix_map.at(5));
 }
 
 TEST_F(V4StoreTest, TestReadFullResponseWithValidHashPrefixMap) {
-  std::unique_ptr<ListUpdateResponse> lur(new ListUpdateResponse);
-  lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
-  lur->set_new_client_state("test_client_state");
-  lur->set_platform_type(WINDOWS_PLATFORM);
-  lur->set_threat_entry_type(URL);
-  lur->set_threat_type(MALWARE_THREAT);
-  ThreatEntrySet* additions = lur->add_additions();
-  additions->set_compression_type(RAW);
-  additions->mutable_raw_hashes()->set_prefix_size(5);
-  additions->mutable_raw_hashes()->set_raw_hashes("00000abcde");
-  additions = lur->add_additions();
-  additions->set_compression_type(RAW);
-  additions->mutable_raw_hashes()->set_prefix_size(4);
-  additions->mutable_raw_hashes()->set_raw_hashes("00000abc");
-  EXPECT_EQ(WRITE_SUCCESS,
-            V4Store(task_runner_, store_path_).WriteToDisk(std::move(lur)));
+  V4Store write_store(task_runner_, store_path_);
+  write_store.hash_prefix_map_[4] = "00000abc";
+  write_store.hash_prefix_map_[5] = "00000abcde";
+  write_store.state_ = "test_client_state";
+  EXPECT_FALSE(base::PathExists(write_store.store_path_));
+  EXPECT_EQ(WRITE_SUCCESS, write_store.WriteToDisk(Checksum()));
+  EXPECT_TRUE(base::PathExists(write_store.store_path_));
 
   V4Store read_store (task_runner_, store_path_);
   EXPECT_EQ(READ_SUCCESS, read_store.ReadFromDisk());
   EXPECT_EQ("test_client_state", read_store.state_);
   ASSERT_EQ(2u, read_store.hash_prefix_map_.size());
   EXPECT_EQ("00000abc", read_store.hash_prefix_map_[4]);
   EXPECT_EQ("00000abcde", read_store.hash_prefix_map_[5]);
 }
 
 // This tests fails to read the prefix map from the disk because the file on
 // disk is invalid. The hash prefixes string is 6 bytes long, but the prefix
 // size is 5 so the parser isn't able to split the hash prefixes list
 // completely.
 TEST_F(V4StoreTest, TestReadFullResponseWithInvalidHashPrefixMap) {
-  std::unique_ptr<ListUpdateResponse> lur(new ListUpdateResponse);
-  lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
-  lur->set_new_client_state("test_client_state");
-  lur->set_platform_type(WINDOWS_PLATFORM);
-  lur->set_threat_entry_type(URL);
-  lur->set_threat_type(MALWARE_THREAT);
-  ThreatEntrySet* additions = lur->add_additions();
-  additions->set_compression_type(RAW);
-  additions->mutable_raw_hashes()->set_prefix_size(5);
-  additions->mutable_raw_hashes()->set_raw_hashes("abcdef");
-  EXPECT_EQ(WRITE_SUCCESS,
-            V4Store(task_runner_, store_path_).WriteToDisk(std::move(lur)));
+  V4Store write_store(task_runner_, store_path_);
+  write_store.hash_prefix_map_[5] = "abcdef";
+  write_store.state_ = "test_client_state";
+  EXPECT_FALSE(base::PathExists(write_store.store_path_));
+  EXPECT_EQ(WRITE_SUCCESS, write_store.WriteToDisk(Checksum()));
+  EXPECT_TRUE(base::PathExists(write_store.store_path_));
 
   V4Store read_store(task_runner_, store_path_);
   EXPECT_EQ(HASH_PREFIX_MAP_GENERATION_FAILURE, read_store.ReadFromDisk());
   EXPECT_TRUE(read_store.state_.empty());
   EXPECT_TRUE(read_store.hash_prefix_map_.empty());
 }
 
 TEST_F(V4StoreTest, TestHashPrefixExistsAtTheBeginning) {
   HashPrefixes hash_prefixes = "abcdebbbbbccccc";
   HashPrefix hash_prefix = "abcde";
@@ skipping 147 matching lines @@
   RiceDeltaEncoding* rice_indices = removal->mutable_rice_indices();
   rice_indices->set_first_value(0);
   rice_indices->set_num_entries(2);
   rice_indices->set_rice_parameter(2);
   rice_indices->set_encoded_data("\x16");
 
   bool called_back = false;
   UpdatedStoreReadyCallback store_ready_callback =
       base::Bind(&V4StoreTest::UpdatedStoreReadyAfterRiceRemovals,
                  base::Unretained(this), &called_back);
+  EXPECT_FALSE(base::PathExists(store.store_path_));
   store.ApplyUpdate(std::move(lur), task_runner_, store_ready_callback);
+  EXPECT_TRUE(base::PathExists(store.store_path_));
+
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // This ensures that the callback was called.
   EXPECT_TRUE(called_back);
 }
 
 TEST_F(V4StoreTest, TestMergeUpdatesFailsChecksum) {
   // Proof of checksum mismatch using python:
   // >>> import hashlib
@@ skipping 15 matching lines @@
   // First the case of checksum not matching after reading from disk.
   ListUpdateResponse list_update_response;
   list_update_response.set_new_client_state("test_client_state");
   list_update_response.set_platform_type(LINUX_PLATFORM);
   list_update_response.set_response_type(ListUpdateResponse::FULL_UPDATE);
   list_update_response.mutable_checksum()->set_sha256(
       std::string(crypto::kSHA256Length, 0));
   WriteFileFormatProtoToFile(0x600D71FE, 9, &list_update_response);
   V4Store store(task_runner_, store_path_);
   EXPECT_TRUE(store.expected_checksum_.empty());
-
   EXPECT_EQ(READ_SUCCESS, store.ReadFromDisk());
   EXPECT_TRUE(!store.expected_checksum_.empty());
   EXPECT_EQ("test_client_state", store.state());
 
   EXPECT_FALSE(store.VerifyChecksum());
 
   // Now the case of checksum matching after reading from disk.
   // Proof of checksum mismatch using python:
   // >>> import hashlib
   // >>> m = hashlib.sha256()
@@ skipping 14 matching lines @@
   V4Store another_store(task_runner_, store_path_);
   EXPECT_TRUE(another_store.expected_checksum_.empty());
 
   EXPECT_EQ(READ_SUCCESS, another_store.ReadFromDisk());
   EXPECT_TRUE(!another_store.expected_checksum_.empty());
   EXPECT_EQ("test_client_state", another_store.state());
 
   EXPECT_TRUE(another_store.VerifyChecksum());
 }
 
+TEST_F(V4StoreTest, WriteToDiskFails) {
+  // Pass the directory name as file name so that when the code tries to rename
+  // the temp store file to |store_path_| it fails.
+  EXPECT_EQ(UNABLE_TO_RENAME_FAILURE,
+            V4Store(task_runner_, temp_dir_.GetPath()).WriteToDisk(Checksum()));
+}
+
 }  // namespace safe_browsing