chrome/browser/supervised_user/supervised_user_settings_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 "base/bind.h"
   6 #include "base/callback.h"
   7 #include "base/json/json_reader.h"
   8 #include "base/prefs/testing_pref_store.h"
   9 #include "base/strings/string_util.h"
  10 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
  11 #include "sync/api/fake_sync_change_processor.h"
  12 #include "sync/api/sync_change.h"
  13 #include "sync/api/sync_change_processor_wrapper_for_test.h"
  14 #include "sync/api/sync_error_factory_mock.h"
  15 #include "sync/protocol/sync.pb.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace {
  19
  20 class MockSyncErrorFactory : public syncer::SyncErrorFactory {
  21  public:
  22   explicit MockSyncErrorFactory(syncer::ModelType type);
  23   virtual ~MockSyncErrorFactory();
  24
  25   // SyncErrorFactory implementation:
  26   virtual syncer::SyncError CreateAndUploadError(
  27       const tracked_objects::Location& location,
  28       const std::string& message) override;
  29
  30  private:
  31   syncer::ModelType type_;
  32
  33   DISALLOW_COPY_AND_ASSIGN(MockSyncErrorFactory);
  34 };
  35
  36 MockSyncErrorFactory::MockSyncErrorFactory(syncer::ModelType type)
  37     : type_(type) {}
  38
  39 MockSyncErrorFactory::~MockSyncErrorFactory() {}
  40
  41 syncer::SyncError MockSyncErrorFactory::CreateAndUploadError(
  42     const tracked_objects::Location& location,
  43     const std::string& message) {
  44   return syncer::SyncError(location,
  45                            syncer::SyncError::DATATYPE_ERROR,
  46                            message,
  47                            type_);
  48 }
  49
  50 }  // namespace
  51
  52 const char kAtomicItemName[] = "X-Wombat";
  53 const char kSettingsName[] = "TestingSetting";
  54 const char kSettingsValue[] = "SettingsValue";
  55 const char kSplitItemName[] = "X-SuperMoosePowers";
  56
  57 class SupervisedUserSettingsServiceTest : public ::testing::Test {
  58  protected:
  59   SupervisedUserSettingsServiceTest() {}
  60   virtual ~SupervisedUserSettingsServiceTest() {}
  61
  62   scoped_ptr<syncer::SyncChangeProcessor> CreateSyncProcessor() {
  63     sync_processor_.reset(new syncer::FakeSyncChangeProcessor);
  64     return scoped_ptr<syncer::SyncChangeProcessor>(
  65         new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
  66   }
  67
  68   void StartSyncing(const syncer::SyncDataList& initial_sync_data) {
  69     scoped_ptr<syncer::SyncErrorFactory> error_handler(
  70         new MockSyncErrorFactory(syncer::SUPERVISED_USER_SETTINGS));
  71     syncer::SyncMergeResult result = settings_service_.MergeDataAndStartSyncing(
  72         syncer::SUPERVISED_USER_SETTINGS,
  73         initial_sync_data,
  74         CreateSyncProcessor(),
  75         error_handler.Pass());
  76     EXPECT_FALSE(result.error().IsSet());
  77   }
  78
  79   void UploadSplitItem(const std::string& key, const std::string& value) {
  80     split_items_.SetStringWithoutPathExpansion(key, value);
  81     settings_service_.UploadItem(
  82         SupervisedUserSettingsService::MakeSplitSettingKey(kSplitItemName,
  83                                                            key),
  84         scoped_ptr<base::Value>(new base::StringValue(value)));
  85   }
  86
  87   void UploadAtomicItem(const std::string& value) {
  88     atomic_setting_value_.reset(new base::StringValue(value));
  89     settings_service_.UploadItem(
  90         kAtomicItemName,
  91         scoped_ptr<base::Value>(new base::StringValue(value)));
  92   }
  93
  94   void VerifySyncDataItem(syncer::SyncData sync_data) {
  95     const sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
  96         sync_data.GetSpecifics().managed_user_setting();
  97     base::Value* expected_value = NULL;
  98     if (supervised_user_setting.name() == kAtomicItemName) {
  99       expected_value = atomic_setting_value_.get();
 100     } else {
 101       EXPECT_TRUE(StartsWithASCII(supervised_user_setting.name(),
 102                                   std::string(kSplitItemName) + ':',
 103                                   true));
 104       std::string key =
 105           supervised_user_setting.name().substr(strlen(kSplitItemName) + 1);
 106       EXPECT_TRUE(split_items_.GetWithoutPathExpansion(key, &expected_value));
 107     }
 108
 109     scoped_ptr<base::Value> value(
 110         base::JSONReader::Read(supervised_user_setting.value()));
 111     EXPECT_TRUE(expected_value->Equals(value.get()));
 112   }
 113
 114   void OnNewSettingsAvailable(const base::DictionaryValue* settings) {
 115     if (!settings)
 116       settings_.reset();
 117     else
 118       settings_.reset(settings->DeepCopy());
 119   }
 120
 121   // testing::Test overrides:
 122   virtual void SetUp() override {
 123     TestingPrefStore* pref_store = new TestingPrefStore;
 124     settings_service_.Init(pref_store);
 125     settings_service_.Subscribe(
 126         base::Bind(&SupervisedUserSettingsServiceTest::OnNewSettingsAvailable,
 127                    base::Unretained(this)));
 128     pref_store->SetInitializationCompleted();
 129     ASSERT_FALSE(settings_);
 130     settings_service_.SetActive(true);
 131     ASSERT_TRUE(settings_);
 132   }
 133
 134   virtual void TearDown() override {
 135     settings_service_.Shutdown();
 136   }
 137
 138   base::DictionaryValue split_items_;
 139   scoped_ptr<base::Value> atomic_setting_value_;
 140   SupervisedUserSettingsService settings_service_;
 141   scoped_ptr<base::DictionaryValue> settings_;
 142
 143   scoped_ptr<syncer::FakeSyncChangeProcessor> sync_processor_;
 144 };
 145
 146 TEST_F(SupervisedUserSettingsServiceTest, ProcessAtomicSetting) {
 147   StartSyncing(syncer::SyncDataList());
 148   ASSERT_TRUE(settings_);
 149   const base::Value* value = NULL;
 150   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 151
 152   settings_.reset();
 153   syncer::SyncData data =
 154       SupervisedUserSettingsService::CreateSyncDataForSetting(
 155           kSettingsName, base::StringValue(kSettingsValue));
 156   syncer::SyncChangeList change_list;
 157   change_list.push_back(
 158       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD, data));
 159   syncer::SyncError error =
 160       settings_service_.ProcessSyncChanges(FROM_HERE, change_list);
 161   EXPECT_FALSE(error.IsSet()) << error.ToString();
 162   ASSERT_TRUE(settings_);
 163   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 164   std::string string_value;
 165   EXPECT_TRUE(value->GetAsString(&string_value));
 166   EXPECT_EQ(kSettingsValue, string_value);
 167 }
 168
 169 TEST_F(SupervisedUserSettingsServiceTest, ProcessSplitSetting) {
 170   StartSyncing(syncer::SyncDataList());
 171   ASSERT_TRUE(settings_);
 172   const base::Value* value = NULL;
 173   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 174
 175   base::DictionaryValue dict;
 176   dict.SetString("foo", "bar");
 177   dict.SetBoolean("awesomesauce", true);
 178   dict.SetInteger("eaudecologne", 4711);
 179
 180   settings_.reset();
 181   syncer::SyncChangeList change_list;
 182   for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
 183     syncer::SyncData data =
 184         SupervisedUserSettingsService::CreateSyncDataForSetting(
 185             SupervisedUserSettingsService::MakeSplitSettingKey(kSettingsName,
 186                                                                it.key()),
 187             it.value());
 188     change_list.push_back(
 189         syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD, data));
 190   }
 191   syncer::SyncError error =
 192       settings_service_.ProcessSyncChanges(FROM_HERE, change_list);
 193   EXPECT_FALSE(error.IsSet()) << error.ToString();
 194   ASSERT_TRUE(settings_);
 195   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 196   const base::DictionaryValue* dict_value = NULL;
 197   ASSERT_TRUE(value->GetAsDictionary(&dict_value));
 198   EXPECT_TRUE(dict_value->Equals(&dict));
 199 }
 200
 201 TEST_F(SupervisedUserSettingsServiceTest, SetLocalSetting) {
 202   const base::Value* value = NULL;
 203   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 204
 205   settings_.reset();
 206   settings_service_.SetLocalSettingForTesting(
 207       kSettingsName,
 208       scoped_ptr<base::Value>(new base::StringValue(kSettingsValue)));
 209   ASSERT_TRUE(settings_);
 210   ASSERT_TRUE(settings_->GetWithoutPathExpansion(kSettingsName, &value));
 211   std::string string_value;
 212   EXPECT_TRUE(value->GetAsString(&string_value));
 213   EXPECT_EQ(kSettingsValue, string_value);
 214 }
 215
 216 TEST_F(SupervisedUserSettingsServiceTest, UploadItem) {
 217   UploadSplitItem("foo", "bar");
 218   UploadSplitItem("blurp", "baz");
 219   UploadAtomicItem("hurdle");
 220
 221   // Uploading should produce changes when we start syncing.
 222   StartSyncing(syncer::SyncDataList());
 223   ASSERT_EQ(3u, sync_processor_->changes().size());
 224   for (const syncer::SyncChange& sync_change : sync_processor_->changes()) {
 225     ASSERT_TRUE(sync_change.IsValid());
 226     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_change.change_type());
 227     VerifySyncDataItem(sync_change.sync_data());
 228   }
 229
 230   // It should also show up in local Sync data.
 231   syncer::SyncDataList sync_data =
 232       settings_service_.GetAllSyncData(syncer::SUPERVISED_USER_SETTINGS);
 233   EXPECT_EQ(3u, sync_data.size());
 234   for (const syncer::SyncData& sync_data_item : sync_data)
 235     VerifySyncDataItem(sync_data_item);
 236
 237   // Uploading after we have started syncing should work too.
 238   sync_processor_->changes().clear();
 239   UploadSplitItem("froodle", "narf");
 240   ASSERT_EQ(1u, sync_processor_->changes().size());
 241   syncer::SyncChange change = sync_processor_->changes()[0];
 242   ASSERT_TRUE(change.IsValid());
 243   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
 244   VerifySyncDataItem(change.sync_data());
 245
 246   sync_data = settings_service_.GetAllSyncData(
 247       syncer::SUPERVISED_USER_SETTINGS);
 248   EXPECT_EQ(4u, sync_data.size());
 249   for (const syncer::SyncData& sync_data_item : sync_data)
 250     VerifySyncDataItem(sync_data_item);
 251
 252   // Uploading an item with a previously seen key should create an UPDATE
 253   // action.
 254   sync_processor_->changes().clear();
 255   UploadSplitItem("blurp", "snarl");
 256   ASSERT_EQ(1u, sync_processor_->changes().size());
 257   change = sync_processor_->changes()[0];
 258   ASSERT_TRUE(change.IsValid());
 259   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
 260   VerifySyncDataItem(change.sync_data());
 261
 262   sync_data = settings_service_.GetAllSyncData(
 263       syncer::SUPERVISED_USER_SETTINGS);
 264   EXPECT_EQ(4u, sync_data.size());
 265   for (const syncer::SyncData& sync_data_item : sync_data)
 266     VerifySyncDataItem(sync_data_item);
 267
 268   sync_processor_->changes().clear();
 269   UploadAtomicItem("fjord");
 270   ASSERT_EQ(1u, sync_processor_->changes().size());
 271   change = sync_processor_->changes()[0];
 272   ASSERT_TRUE(change.IsValid());
 273   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
 274   VerifySyncDataItem(change.sync_data());
 275
 276   sync_data = settings_service_.GetAllSyncData(
 277       syncer::SUPERVISED_USER_SETTINGS);
 278   EXPECT_EQ(4u, sync_data.size());
 279   for (const syncer::SyncData& sync_data_item : sync_data)
 280     VerifySyncDataItem(sync_data_item);
 281
 282   // The uploaded items should not show up as settings.
 283   const base::Value* value = NULL;
 284   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kAtomicItemName, &value));
 285   EXPECT_FALSE(settings_->GetWithoutPathExpansion(kSplitItemName, &value));
 286
 287   // Restarting sync should not create any new changes.
 288   settings_service_.StopSyncing(syncer::SUPERVISED_USER_SETTINGS);
 289   StartSyncing(sync_data);
 290   ASSERT_EQ(0u, sync_processor_->changes().size());
 291 }