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 111 matching lines @@
 }
 
 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());
-}
-
 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) {
   HashPrefixMap prefix_map;
   EXPECT_EQ(APPLY_UPDATE_SUCCESS,
@@ skipping 390 matching lines @@
             store.MergeUpdate(prefix_map_old, prefix_map_additions,
                               &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) {

[Nathan Parker, 2016/10/11 20:29:42]

How about a test for when a write fails (like, permission denied or some such)?
And is there any test to verify that a ApplyUpdate() (full/partial) calls
WriteToDisk correctly?

[vakh (use Gerrit instead), 2016/10/11 21:50:39]

Done.

-  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");
+  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_EQ(WRITE_SUCCESS,
-            V4Store(task_runner_, store_path_).WriteToDisk(std::move(lur)));
+            write_store.WriteToDisk(GetUrlMalwareId(), Checksum()));
 
   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());

[Nathan Parker, 2016/10/11 20:29:42]

This should verify the store id too, ya?

[vakh (use Gerrit instead), 2016/10/11 21:50:39]

I realized that there's no need to set the list_id since we never use it. The
store file is read as a set of hash prefixes. The store is never aware of which
list it represents. The DB is aware of that, but it manages that by using unique
filenames for each store.

   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");
+  V4Store write_store(task_runner_, store_path_);
+  write_store.hash_prefix_map_[5] = "abcdef";
+  write_store.state_ = "test_client_state";
   EXPECT_EQ(WRITE_SUCCESS,
-            V4Store(task_runner_, store_path_).WriteToDisk(std::move(lur)));
+            write_store.WriteToDisk(GetUrlMalwareId(), Checksum()));
 
   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 217 matching lines @@
   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());
 }
 
 }  // namespace safe_browsing