chrome/browser/supervised_user/supervised_user_whitelist_service_unittest.cc

   1 // Copyright 2014 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 <map>
   6 #include <set>
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/path_service.h"
  14 #include "base/prefs/scoped_user_pref_update.h"
  15 #include "base/run_loop.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "chrome/browser/component_updater/supervised_user_whitelist_installer.h"
  19 #include "chrome/browser/supervised_user/supervised_user_site_list.h"
  20 #include "chrome/browser/supervised_user/supervised_user_whitelist_service.h"
  21 #include "chrome/common/chrome_paths.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "chrome/test/base/testing_profile.h"
  24 #include "content/public/test/test_browser_thread_bundle.h"
  25 #include "sync/api/sync_change.h"
  26 #include "sync/api/sync_error_factory.h"
  27 #include "sync/protocol/sync.pb.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29
  30 namespace {
  31
  32 const char kClientId[] = "client-id";
  33
  34 class MockSupervisedUserWhitelistInstaller
  35     : public component_updater::SupervisedUserWhitelistInstaller {
  36  public:
  37   MockSupervisedUserWhitelistInstaller() {}
  38   ~MockSupervisedUserWhitelistInstaller() override {}
  39
  40   const std::set<std::string>& registered_whitelists() {
  41     return registered_whitelists_;
  42   }
  43
  44   void NotifyWhitelistReady(const std::string& crx_id,
  45                             const base::FilePath& path) {
  46     for (const auto& callback : ready_callbacks_)
  47       callback.Run(crx_id, path);
  48   }
  49
  50   // SupervisedUserWhitelistInstaller implementation:
  51   void RegisterComponents() override {}
  52
  53   void Subscribe(const WhitelistReadyCallback& callback) override {
  54     ready_callbacks_.push_back(callback);
  55   }
  56
  57   void RegisterWhitelist(const std::string& client_id,
  58                          const std::string& crx_id,
  59                          const std::string& name) override {
  60     EXPECT_EQ(kClientId, client_id);
  61     EXPECT_FALSE(WhitelistIsRegistered(crx_id)) << crx_id;
  62     registered_whitelists_.insert(crx_id);
  63   }
  64
  65   void UnregisterWhitelist(const std::string& client_id,
  66                            const std::string& crx_id) override {
  67     EXPECT_EQ(kClientId, client_id);
  68     EXPECT_TRUE(WhitelistIsRegistered(crx_id)) << crx_id;
  69     registered_whitelists_.erase(crx_id);
  70   }
  71
  72  private:
  73   bool WhitelistIsRegistered(const std::string& crx_id) {
  74     return registered_whitelists_.count(crx_id) > 0;
  75   }
  76
  77   std::set<std::string> registered_whitelists_;
  78   std::vector<WhitelistReadyCallback> ready_callbacks_;
  79 };
  80
  81 }  // namespace
  82
  83 class SupervisedUserWhitelistServiceTest : public testing::Test {
  84  public:
  85   SupervisedUserWhitelistServiceTest()
  86       : installer_(new MockSupervisedUserWhitelistInstaller),
  87         service_(new SupervisedUserWhitelistService(profile_.GetPrefs(),
  88                                                     installer_.get(),
  89                                                     kClientId)) {
  90     service_->AddSiteListsChangedCallback(
  91         base::Bind(&SupervisedUserWhitelistServiceTest::OnSiteListsChanged,
  92                    base::Unretained(this)));
  93     SupervisedUserSiteList::SetLoadInProcessForTesting(true);
  94   }
  95
  96   ~SupervisedUserWhitelistServiceTest() override {
  97     SupervisedUserSiteList::SetLoadInProcessForTesting(false);
  98   }
  99
 100  protected:
 101   void PrepareInitialStateAndPreferences() {
 102     // Create two whitelists.
 103     DictionaryPrefUpdate update(profile_.GetPrefs(),
 104                                 prefs::kSupervisedUserWhitelists);
 105     base::DictionaryValue* dict = update.Get();
 106
 107     scoped_ptr<base::DictionaryValue> whitelist_dict(new base::DictionaryValue);
 108     whitelist_dict->SetString("name", "Whitelist A");
 109     dict->Set("aaaa", whitelist_dict.release());
 110
 111     whitelist_dict.reset(new base::DictionaryValue);
 112     whitelist_dict->SetString("name", "Whitelist B");
 113     dict->Set("bbbb", whitelist_dict.release());
 114
 115     installer_->RegisterWhitelist(kClientId, "aaaa", "Whitelist A");
 116     installer_->RegisterWhitelist(kClientId, "bbbb", "Whitelist B");
 117   }
 118
 119   void CheckFinalStateAndPreferences() {
 120     EXPECT_EQ(2u, installer_->registered_whitelists().size());
 121     EXPECT_EQ(1u, installer_->registered_whitelists().count("bbbb"));
 122     EXPECT_EQ(1u, installer_->registered_whitelists().count("cccc"));
 123
 124     const base::DictionaryValue* dict =
 125         profile_.GetPrefs()->GetDictionary(prefs::kSupervisedUserWhitelists);
 126     EXPECT_EQ(2u, dict->size());
 127     const base::DictionaryValue* whitelist_dict = nullptr;
 128     ASSERT_TRUE(dict->GetDictionary("bbbb", &whitelist_dict));
 129     std::string name;
 130     ASSERT_TRUE(whitelist_dict->GetString("name", &name));
 131     EXPECT_EQ("Whitelist B New", name);
 132     ASSERT_TRUE(dict->GetDictionary("cccc", &whitelist_dict));
 133     ASSERT_TRUE(whitelist_dict->GetString("name", &name));
 134     EXPECT_EQ("Whitelist C", name);
 135   }
 136
 137   const sync_pb::ManagedUserWhitelistSpecifics* FindWhitelist(
 138       const syncer::SyncDataList& data_list,
 139       const std::string& id) {
 140     for (const syncer::SyncData& data : data_list) {
 141       const sync_pb::ManagedUserWhitelistSpecifics& whitelist =
 142           data.GetSpecifics().managed_user_whitelist();
 143       if (whitelist.id() == id)
 144         return &whitelist;
 145     }
 146     return nullptr;
 147   }
 148
 149   void OnSiteListsChanged(
 150       const std::vector<scoped_refptr<SupervisedUserSiteList>>& site_lists) {
 151     site_lists_ = site_lists;
 152     if (!site_lists_changed_callback_.is_null())
 153       site_lists_changed_callback_.Run();
 154   }
 155
 156   content::TestBrowserThreadBundle thread_bundle_;
 157   TestingProfile profile_;
 158
 159   scoped_ptr<MockSupervisedUserWhitelistInstaller> installer_;
 160   scoped_ptr<SupervisedUserWhitelistService> service_;
 161
 162   std::vector<scoped_refptr<SupervisedUserSiteList>> site_lists_;
 163   base::Closure site_lists_changed_callback_;
 164 };
 165
 166 TEST_F(SupervisedUserWhitelistServiceTest, MergeEmpty) {
 167   service_->Init();
 168
 169   syncer::SyncMergeResult result = service_->MergeDataAndStartSyncing(
 170       syncer::SUPERVISED_USER_WHITELISTS, syncer::SyncDataList(),
 171       scoped_ptr<syncer::SyncChangeProcessor>(),
 172       scoped_ptr<syncer::SyncErrorFactory>());
 173   EXPECT_FALSE(result.error().IsSet());
 174   EXPECT_EQ(0, result.num_items_added());
 175   EXPECT_EQ(0, result.num_items_modified());
 176   EXPECT_EQ(0, result.num_items_deleted());
 177   EXPECT_EQ(0, result.num_items_before_association());
 178   EXPECT_EQ(0, result.num_items_after_association());
 179
 180   EXPECT_EQ(0u, installer_->registered_whitelists().size());
 181 }
 182
 183 TEST_F(SupervisedUserWhitelistServiceTest, MergeExisting) {
 184   PrepareInitialStateAndPreferences();
 185
 186   // Initialize the service. The whitelists should not be ready yet.
 187   service_->Init();
 188   EXPECT_EQ(0u, site_lists_.size());
 189
 190   // Notify that whitelist A is ready.
 191   base::RunLoop run_loop;
 192   site_lists_changed_callback_ = run_loop.QuitClosure();
 193   base::FilePath test_data_dir;
 194   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
 195   base::FilePath whitelist_path =
 196       test_data_dir.AppendASCII("whitelists/content_pack/site_list.json");
 197   installer_->NotifyWhitelistReady("aaaa", whitelist_path);
 198   run_loop.Run();
 199
 200   ASSERT_EQ(1u, site_lists_.size());
 201   const std::vector<SupervisedUserSiteList::Site>& sites =
 202       site_lists_[0]->sites();
 203   EXPECT_EQ(3u, sites.size());
 204   EXPECT_EQ("YouTube", base::UTF16ToUTF8(sites[0].name));
 205
 206   // Do the initial merge. One item should be added (whitelist C), one should be
 207   // modified (whitelist B), and one item should be removed (whitelist A).
 208   syncer::SyncDataList initial_data;
 209   initial_data.push_back(
 210       SupervisedUserWhitelistService::CreateWhitelistSyncData(
 211           "bbbb", "Whitelist B New"));
 212   initial_data.push_back(
 213       SupervisedUserWhitelistService::CreateWhitelistSyncData(
 214           "cccc", "Whitelist C"));
 215   syncer::SyncMergeResult result = service_->MergeDataAndStartSyncing(
 216       syncer::SUPERVISED_USER_WHITELISTS, initial_data,
 217       scoped_ptr<syncer::SyncChangeProcessor>(),
 218       scoped_ptr<syncer::SyncErrorFactory>());
 219   EXPECT_FALSE(result.error().IsSet());
 220   EXPECT_EQ(1, result.num_items_added());
 221   EXPECT_EQ(1, result.num_items_modified());
 222   EXPECT_EQ(1, result.num_items_deleted());
 223   EXPECT_EQ(2, result.num_items_before_association());
 224   EXPECT_EQ(2, result.num_items_after_association());
 225
 226   // Whitelist A (which was previously ready) should be removed now, and
 227   // whitelist B was never ready.
 228   EXPECT_EQ(0u, site_lists_.size());
 229
 230   CheckFinalStateAndPreferences();
 231 }
 232
 233 TEST_F(SupervisedUserWhitelistServiceTest, ApplyChanges) {
 234   PrepareInitialStateAndPreferences();
 235
 236   service_->Init();
 237
 238   // Process some changes.
 239   syncer::SyncChangeList changes;
 240   changes.push_back(syncer::SyncChange(
 241       FROM_HERE, syncer::SyncChange::ACTION_ADD,
 242       SupervisedUserWhitelistService::CreateWhitelistSyncData(
 243           "cccc", "Whitelist C")));
 244   changes.push_back(syncer::SyncChange(
 245       FROM_HERE, syncer::SyncChange::ACTION_UPDATE,
 246       SupervisedUserWhitelistService::CreateWhitelistSyncData(
 247           "bbbb", "Whitelist B New")));
 248   changes.push_back(syncer::SyncChange(
 249       FROM_HERE, syncer::SyncChange::ACTION_DELETE,
 250       SupervisedUserWhitelistService::CreateWhitelistSyncData(
 251           "aaaa", "Ignored")));
 252   syncer::SyncError error = service_->ProcessSyncChanges(FROM_HERE, changes);
 253   EXPECT_FALSE(error.IsSet());
 254
 255   EXPECT_EQ(0u, site_lists_.size());
 256
 257   // If whitelist A now becomes ready, it should be ignored.
 258   installer_->NotifyWhitelistReady(
 259       "aaaa", base::FilePath(FILE_PATH_LITERAL("/path/to/aaaa")));
 260   EXPECT_EQ(0u, site_lists_.size());
 261
 262   CheckFinalStateAndPreferences();
 263 }
 264
 265 TEST_F(SupervisedUserWhitelistServiceTest, GetAllSyncData) {
 266   PrepareInitialStateAndPreferences();
 267
 268   syncer::SyncDataList sync_data =
 269       service_->GetAllSyncData(syncer::SUPERVISED_USER_WHITELISTS);
 270   ASSERT_EQ(2u, sync_data.size());
 271   const sync_pb::ManagedUserWhitelistSpecifics* whitelist =
 272       FindWhitelist(sync_data, "aaaa");
 273   ASSERT_TRUE(whitelist);
 274   EXPECT_EQ("Whitelist A", whitelist->name());
 275   whitelist = FindWhitelist(sync_data, "bbbb");
 276   ASSERT_TRUE(whitelist);
 277   EXPECT_EQ("Whitelist B", whitelist->name());
 278 }