chrome/browser/safe_browsing/incident_reporting/state_store_unittest.cc

   1 // Copyright 2015 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 "chrome/browser/safe_browsing/incident_reporting/state_store.h"
   6
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/json/json_file_value_serializer.h"
   9 #include "base/macros.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/test/test_simple_task_runner.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/prefs/browser_prefs.h"
  16 #include "chrome/browser/prefs/pref_service_syncable.h"
  17 #include "chrome/browser/prefs/pref_service_syncable_factory.h"
  18 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
  19 #include "chrome/common/pref_names.h"
  20 #include "chrome/test/base/testing_browser_process.h"
  21 #include "chrome/test/base/testing_profile.h"
  22 #include "chrome/test/base/testing_profile_manager.h"
  23 #include "components/pref_registry/pref_registry_syncable.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 namespace safe_browsing {
  27
  28 // A test fixture with a testing profile that writes its user prefs to a json
  29 // file.
  30 class StateStoreTest : public ::testing::Test {
  31  protected:
  32   struct TestData {
  33     IncidentType type;
  34     const char* key;
  35     uint32_t digest;
  36   };
  37
  38   StateStoreTest()
  39       : profile_(nullptr),
  40         task_runner_(new base::TestSimpleTaskRunner()),
  41         thread_task_runner_handle_(task_runner_),
  42         profile_manager_(TestingBrowserProcess::GetGlobal()) {}
  43
  44   void SetUp() override {
  45     testing::Test::SetUp();
  46     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  47     ASSERT_TRUE(profile_manager_.SetUp());
  48     CreateProfile();
  49   }
  50
  51   void DeleteProfile() {
  52     if (profile_) {
  53       profile_ = nullptr;
  54       profile_manager_.DeleteTestingProfile(kProfileName_);
  55     }
  56   }
  57
  58   // Removes the safebrowsing.incidents_sent preference from the profile's pref
  59   // store.
  60   void TrimPref() {
  61     ASSERT_EQ(nullptr, profile_);
  62     scoped_ptr<base::Value> prefs(JSONFileValueDeserializer(GetPrefsPath())
  63                                       .Deserialize(nullptr, nullptr));
  64     ASSERT_NE(nullptr, prefs.get());
  65     base::DictionaryValue* dict = nullptr;
  66     ASSERT_TRUE(prefs->GetAsDictionary(&dict));
  67     ASSERT_TRUE(dict->Remove(prefs::kSafeBrowsingIncidentsSent, nullptr));
  68     ASSERT_TRUE(JSONFileValueSerializer(GetPrefsPath()).Serialize(*dict));
  69   }
  70
  71   void CreateProfile() {
  72     ASSERT_EQ(nullptr, profile_);
  73     // Create the testing profile with a file-backed user pref store.
  74     PrefServiceSyncableFactory factory;
  75     factory.SetUserPrefsFile(GetPrefsPath(), task_runner_.get());
  76     user_prefs::PrefRegistrySyncable* pref_registry =
  77         new user_prefs::PrefRegistrySyncable();
  78     chrome::RegisterUserProfilePrefs(pref_registry);
  79     profile_ = profile_manager_.CreateTestingProfile(
  80         kProfileName_, factory.CreateSyncable(pref_registry).Pass(),
  81         base::UTF8ToUTF16(kProfileName_), 0, std::string(),
  82         TestingProfile::TestingFactories());
  83   }
  84
  85   static const char kProfileName_[];
  86   static const TestData kTestData_[];
  87   TestingProfile* profile_;
  88   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
  89
  90  private:
  91   base::FilePath GetPrefsPath() {
  92     return temp_dir_.path().AppendASCII("prefs");
  93   }
  94
  95   base::ScopedTempDir temp_dir_;
  96   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
  97   TestingProfileManager profile_manager_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(StateStoreTest);
 100 };
 101
 102 // static
 103 const char StateStoreTest::kProfileName_[] = "test_profile";
 104 const StateStoreTest::TestData StateStoreTest::kTestData_[] = {
 105     {IncidentType::TRACKED_PREFERENCE, "tp_one", 1},
 106     {IncidentType::TRACKED_PREFERENCE, "tp_two", 2},
 107     {IncidentType::TRACKED_PREFERENCE, "tp_three", 3},
 108     {IncidentType::BINARY_INTEGRITY, "bi", 0},
 109     {IncidentType::BLACKLIST_LOAD, "bl", 0x47},
 110 };
 111
 112 TEST_F(StateStoreTest, MarkAsAndHasBeenReported) {
 113   StateStore state_store(profile_);
 114
 115   for (const auto& data : kTestData_)
 116     ASSERT_FALSE(state_store.HasBeenReported(data.type, data.key, data.digest));
 117
 118   {
 119     StateStore::Transaction transaction(&state_store);
 120     for (const auto& data : kTestData_) {
 121       transaction.MarkAsReported(data.type, data.key, data.digest);
 122       ASSERT_TRUE(
 123           state_store.HasBeenReported(data.type, data.key, data.digest));
 124     }
 125   }
 126
 127   for (const auto& data : kTestData_)
 128     ASSERT_TRUE(state_store.HasBeenReported(data.type, data.key, data.digest));
 129 }
 130
 131 TEST_F(StateStoreTest, ClearForType) {
 132   StateStore state_store(profile_);
 133
 134   {
 135     StateStore::Transaction transaction(&state_store);
 136     for (const auto& data : kTestData_)
 137       transaction.MarkAsReported(data.type, data.key, data.digest);
 138   }
 139
 140   for (const auto& data : kTestData_)
 141     ASSERT_TRUE(state_store.HasBeenReported(data.type, data.key, data.digest));
 142
 143   const IncidentType removed_type = IncidentType::TRACKED_PREFERENCE;
 144   StateStore::Transaction(&state_store).ClearForType(removed_type);
 145
 146   for (const auto& data : kTestData_) {
 147     if (data.type == removed_type) {
 148       ASSERT_FALSE(
 149           state_store.HasBeenReported(data.type, data.key, data.digest));
 150     } else {
 151       ASSERT_TRUE(
 152           state_store.HasBeenReported(data.type, data.key, data.digest));
 153     }
 154   }
 155 }
 156
 157 TEST_F(StateStoreTest, Persistence) {
 158   // Write some state to the store.
 159   {
 160     StateStore state_store(profile_);
 161     StateStore::Transaction transaction(&state_store);
 162     for (const auto& data : kTestData_)
 163       transaction.MarkAsReported(data.type, data.key, data.digest);
 164   }
 165
 166   // Run tasks to write prefs out to the JsonPrefStore.
 167   task_runner_->RunUntilIdle();
 168
 169   // Delete the profile.
 170   DeleteProfile();
 171
 172   // Recreate the profile.
 173   CreateProfile();
 174
 175   // Verify that the state survived.
 176   StateStore state_store(profile_);
 177   for (const auto& data : kTestData_)
 178     ASSERT_TRUE(state_store.HasBeenReported(data.type, data.key, data.digest));
 179 }
 180
 181 TEST_F(StateStoreTest, PersistenceWithStoreDelete) {
 182   // Write some state to the store.
 183   {
 184     StateStore state_store(profile_);
 185     StateStore::Transaction transaction(&state_store);
 186     for (const auto& data : kTestData_)
 187       transaction.MarkAsReported(data.type, data.key, data.digest);
 188   }
 189
 190   // Run tasks to write prefs out to the JsonPrefStore.
 191   task_runner_->RunUntilIdle();
 192
 193   // Delete the profile.
 194   DeleteProfile();
 195
 196   // Delete the state pref.
 197   TrimPref();
 198
 199   // Recreate the profile.
 200   CreateProfile();
 201
 202   // Verify that the state did not survive.
 203   StateStore state_store(profile_);
 204   for (const auto& data : kTestData_)
 205     ASSERT_FALSE(state_store.HasBeenReported(data.type, data.key, data.digest));
 206 }
 207
 208 }  // namespace safe_browsing